Commit of build_consolidation branch

Squashed into one commit (see branch for details of the evolution of the
branch).

This brings gpcl6 and gxps into the Ghostscript build system, and a shared
set of graphics library object files for all the interpreters.

Also, brings the same configuration options to the pcl and xps products as we
have for Ghostscript.

1 files changed, 425 insertions, 0 deletions

diff --git a/tiff/libtiff/tif_stream.cxx b/tiff/libtiff/tif_stream.cxx
new file mode 100644
index 000000000..163447ebd
--- /dev/null
+++ b/tiff/libtiff/tif_stream.cxx
@@ -0,0 +1,425 @@
+/* $Id: tif_stream.cxx,v 1.11 2010-12-11 23:12:29 faxguy Exp $ */
+
+/*
+ * Copyright (c) 1988-1996 Sam Leffler
+ * Copyright (c) 1991-1996 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and 
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+ * 
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+ * OF THIS SOFTWARE.
+ */
+
+/*
+ * TIFF Library UNIX-specific Routines.
+ */
+#include "tiffiop.h"
+#include <iostream>
+
+#ifndef __VMS
+using namespace std;
+#endif
+
+/*
+  ISO C++ uses a 'std::streamsize' type to define counts.  This makes
+  it similar to, (but perhaps not the same as) size_t.
+
+  The std::ios::pos_type is used to represent stream positions as used
+  by tellg(), tellp(), seekg(), and seekp().  This makes it similar to
+  (but perhaps not the same as) 'off_t'.  The std::ios::streampos type
+  is used for character streams, but is documented to not be an
+  integral type anymore, so it should *not* be assigned to an integral
+  type.
+
+  The std::ios::off_type is used to specify relative offsets needed by
+  the variants of seekg() and seekp() which accept a relative offset
+  argument.
+
+  Useful prototype knowledge:
+
+  Obtain read position
+    ios::pos_type basic_istream::tellg()
+
+  Set read position
+    basic_istream& basic_istream::seekg(ios::pos_type)
+    basic_istream& basic_istream::seekg(ios::off_type, ios_base::seekdir)
+
+  Read data
+    basic_istream& istream::read(char *str, streamsize count)
+
+  Number of characters read in last unformatted read
+    streamsize istream::gcount();
+
+  Obtain write position
+    ios::pos_type basic_ostream::tellp()
+
+  Set write position
+    basic_ostream& basic_ostream::seekp(ios::pos_type)
+    basic_ostream& basic_ostream::seekp(ios::off_type, ios_base::seekdir)
+
+  Write data
+    basic_ostream& ostream::write(const char *str, streamsize count)
+*/
+
+struct tiffis_data;
+struct tiffos_data;
+
+extern "C" {
+
+	static tmsize_t _tiffosReadProc(thandle_t, void*, tmsize_t);
+	static tmsize_t _tiffisReadProc(thandle_t fd, void* buf, tmsize_t size);
+	static tmsize_t _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size);
+	static tmsize_t _tiffisWriteProc(thandle_t, void*, tmsize_t);
+	static uint64   _tiffosSeekProc(thandle_t fd, uint64 off, int whence);
+	static uint64   _tiffisSeekProc(thandle_t fd, uint64 off, int whence);
+	static uint64   _tiffosSizeProc(thandle_t fd);
+	static uint64   _tiffisSizeProc(thandle_t fd);
+	static int      _tiffosCloseProc(thandle_t fd);
+	static int      _tiffisCloseProc(thandle_t fd);
+	static int 	_tiffDummyMapProc(thandle_t , void** base, toff_t* size );
+	static void     _tiffDummyUnmapProc(thandle_t , void* base, toff_t size );
+	static TIFF*    _tiffStreamOpen(const char* name, const char* mode, void *fd);
+
+struct tiffis_data
+{
+	istream	*stream;
+        ios::pos_type start_pos;
+};
+
+struct tiffos_data
+{
+	ostream	*stream;
+	ios::pos_type start_pos;
+};
+
+static tmsize_t
+_tiffosReadProc(thandle_t, void*, tmsize_t)
+{
+        return 0;
+}
+
+static tmsize_t
+_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size)
+{
+        tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);
+
+        // Verify that type does not overflow.
+        streamsize request_size = size;
+        if (static_cast<tmsize_t>(request_size) != size)
+          return static_cast<tmsize_t>(-1);
+
+        data->stream->read((char *) buf, request_size);
+
+        return static_cast<tmsize_t>(data->stream->gcount());
+}
+
+static tmsize_t
+_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size)
+{
+	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
+	ostream		*os = data->stream;
+	ios::pos_type	pos = os->tellp();
+
+        // Verify that type does not overflow.
+        streamsize request_size = size;
+        if (static_cast<tmsize_t>(request_size) != size)
+          return static_cast<tmsize_t>(-1);
+
+	os->write(reinterpret_cast<const char *>(buf), request_size);
+
+	return static_cast<tmsize_t>(os->tellp() - pos);
+}
+
+static tmsize_t
+_tiffisWriteProc(thandle_t, void*, tmsize_t)
+{
+	return 0;
+}
+
+static uint64
+_tiffosSeekProc(thandle_t fd, uint64 off, int whence)
+{
+	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
+	ostream		*os = data->stream;
+
+	// if the stream has already failed, don't do anything
+	if( os->fail() )
+		return static_cast<uint64>(-1);
+
+	switch(whence) {
+	case SEEK_SET:
+		{
+			// Compute 64-bit offset
+			uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
+
+			// Verify that value does not overflow
+			ios::off_type offset = static_cast<ios::off_type>(new_offset);
+			if (static_cast<uint64>(offset) != new_offset)
+				return static_cast<uint64>(-1);
+			
+			os->seekp(offset, ios::beg);
+		break;
+		}
+	case SEEK_CUR:
+		{
+			// Verify that value does not overflow
+			ios::off_type offset = static_cast<ios::off_type>(off);
+			if (static_cast<uint64>(offset) != off)
+				return static_cast<uint64>(-1);
+
+			os->seekp(offset, ios::cur);
+			break;
+		}
+	case SEEK_END:
+		{
+			// Verify that value does not overflow
+			ios::off_type offset = static_cast<ios::off_type>(off);
+			if (static_cast<uint64>(offset) != off)
+				return static_cast<uint64>(-1);
+
+			os->seekp(offset, ios::end);
+			break;
+		}
+	}
+
+	// Attempt to workaround problems with seeking past the end of the
+	// stream.  ofstream doesn't have a problem with this but
+	// ostrstream/ostringstream does. In that situation, add intermediate
+	// '\0' characters.
+	if( os->fail() ) {
+#ifdef __VMS
+		int		old_state;
+#else
+		ios::iostate	old_state;
+#endif
+		ios::pos_type	origin;
+
+		old_state = os->rdstate();
+		// reset the fail bit or else tellp() won't work below
+		os->clear(os->rdstate() & ~ios::failbit);
+		switch( whence ) {
+			case SEEK_SET:
+                        default:
+				origin = data->start_pos;
+				break;
+			case SEEK_CUR:
+				origin = os->tellp();
+				break;
+			case SEEK_END:
+				os->seekp(0, ios::end);
+				origin = os->tellp();
+				break;
+		}
+		// restore original stream state
+		os->clear(old_state);	
+
+		// only do something if desired seek position is valid
+		if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) {
+			uint64	num_fill;
+
+			// clear the fail bit 
+			os->clear(os->rdstate() & ~ios::failbit);
+
+			// extend the stream to the expected size
+			os->seekp(0, ios::end);
+			num_fill = (static_cast<uint64>(origin)) + off - os->tellp();
+			for( uint64 i = 0; i < num_fill; i++ )
+				os->put('\0');
+
+			// retry the seek
+			os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg);
+		}
+	}
+
+	return static_cast<uint64>(os->tellp());
+}
+
+static uint64
+_tiffisSeekProc(thandle_t fd, uint64 off, int whence)
+{
+	tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);
+
+	switch(whence) {
+	case SEEK_SET:
+		{
+			// Compute 64-bit offset
+			uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
+			
+			// Verify that value does not overflow
+			ios::off_type offset = static_cast<ios::off_type>(new_offset);
+			if (static_cast<uint64>(offset) != new_offset)
+				return static_cast<uint64>(-1);
+
+			data->stream->seekg(offset, ios::beg);
+			break;
+		}
+	case SEEK_CUR:
+		{
+			// Verify that value does not overflow
+			ios::off_type offset = static_cast<ios::off_type>(off);
+			if (static_cast<uint64>(offset) != off)
+				return static_cast<uint64>(-1);
+
+			data->stream->seekg(offset, ios::cur);
+			break;
+		}
+	case SEEK_END:
+		{
+			// Verify that value does not overflow
+			ios::off_type offset = static_cast<ios::off_type>(off);
+			if (static_cast<uint64>(offset) != off)
+				return static_cast<uint64>(-1);
+
+			data->stream->seekg(offset, ios::end);
+			break;
+		}
+	}
+
+	return (uint64) (data->stream->tellg() - data->start_pos);
+}
+
+static uint64
+_tiffosSizeProc(thandle_t fd)
+{
+	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
+	ostream		*os = data->stream;
+	ios::pos_type	pos = os->tellp();
+	ios::pos_type	len;
+
+	os->seekp(0, ios::end);
+	len = os->tellp();
+	os->seekp(pos);
+
+	return (uint64) len;
+}
+
+static uint64
+_tiffisSizeProc(thandle_t fd)
+{
+	tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);
+	ios::pos_type	pos = data->stream->tellg();
+	ios::pos_type	len;
+
+	data->stream->seekg(0, ios::end);
+	len = data->stream->tellg();
+	data->stream->seekg(pos);
+
+	return (uint64) len;
+}
+
+static int
+_tiffosCloseProc(thandle_t fd)
+{
+	// Our stream was not allocated by us, so it shouldn't be closed by us.
+	delete reinterpret_cast<tiffos_data *>(fd);
+	return 0;
+}
+
+static int
+_tiffisCloseProc(thandle_t fd)
+{
+	// Our stream was not allocated by us, so it shouldn't be closed by us.
+	delete reinterpret_cast<tiffis_data *>(fd);
+	return 0;
+}
+
+static int
+_tiffDummyMapProc(thandle_t , void** base, toff_t* size )
+{
+	return (0);
+}
+
+static void
+_tiffDummyUnmapProc(thandle_t , void* base, toff_t size )
+{
+}
+
+/*
+ * Open a TIFF file descriptor for read/writing.
+ */
+static TIFF*
+_tiffStreamOpen(const char* name, const char* mode, void *fd)
+{
+	TIFF*	tif;
+
+	if( strchr(mode, 'w') ) {
+		tiffos_data	*data = new tiffos_data;
+		data->stream = reinterpret_cast<ostream *>(fd);
+		data->start_pos = data->stream->tellp();
+
+		// Open for writing.
+		tif = TIFFClientOpen(name, mode,
+				reinterpret_cast<thandle_t>(data),
+				_tiffosReadProc,
+                                _tiffosWriteProc,
+				_tiffosSeekProc,
+                                _tiffosCloseProc,
+				_tiffosSizeProc,
+				_tiffDummyMapProc,
+                                _tiffDummyUnmapProc);
+	} else {
+		tiffis_data	*data = new tiffis_data;
+		data->stream = reinterpret_cast<istream *>(fd);
+		data->start_pos = data->stream->tellg();
+		// Open for reading.
+		tif = TIFFClientOpen(name, mode,
+				reinterpret_cast<thandle_t>(data),
+				_tiffisReadProc,
+                                _tiffisWriteProc,
+				_tiffisSeekProc,
+                                _tiffisCloseProc,
+				_tiffisSizeProc,
+				_tiffDummyMapProc,
+                                _tiffDummyUnmapProc);
+	}
+
+	return (tif);
+}
+
+} /* extern "C" */
+
+TIFF*
+TIFFStreamOpen(const char* name, ostream *os)
+{
+	// If os is either a ostrstream or ostringstream, and has no data
+	// written to it yet, then tellp() will return -1 which will break us.
+	// We workaround this by writing out a dummy character and
+	// then seek back to the beginning.
+	if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) {
+		*os << '\0';
+		os->seekp(0);
+	}
+
+	// NB: We don't support mapped files with streams so add 'm'
+	return _tiffStreamOpen(name, "wm", os);
+}
+
+TIFF*
+TIFFStreamOpen(const char* name, istream *is)
+{
+	// NB: We don't support mapped files with streams so add 'm'
+	return _tiffStreamOpen(name, "rm", is);
+}
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
+/*
+  Local Variables:
+  mode: c
+  indent-tabs-mode: true
+  c-basic-offset: 8
+  End:
+*/