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, 281 insertions, 0 deletions

diff --git a/base/gstiffio.c b/base/gstiffio.c
new file mode 100644
index 000000000..4d19c123e
--- /dev/null
+++ b/base/gstiffio.c
@@ -0,0 +1,281 @@
+/* Copyright (C) 2001-2012 Artifex Software, Inc.
+   All Rights Reserved.
+
+   This software is provided AS-IS with no warranty, either express or
+   implied.
+
+   This software is distributed under license and may not be copied,
+   modified or distributed except as expressly authorized under the terms
+   of the license contained in the file LICENSE in this distribution.
+
+   Refer to licensing information at http://www.artifex.com or contact
+   Artifex Software, Inc.,  7 Mt. Lassen Drive - Suite A-134, San Rafael,
+   CA  94903, U.S.A., +1(415)492-9861, for further information.
+*/
+
+
+/* TIFF hooks and stubs */
+
+#include "stdint_.h"   /* for tiff.h */
+#include "stdio_.h"
+#include "time_.h"
+#include "malloc_.h"
+#include "gstypes.h"
+#include "gscdefs.h"
+#include "gdevprn.h"
+
+#include "scommon.h"
+#include "stream.h"
+#include "strmio.h"
+
+#include "gstiffio.h"
+
+
+#define TIFF_PRINT_BUF_LENGTH 1024
+static const char tifs_msg_truncated[] = "\n*** Previous line has been truncated.\n";
+
+/* place to hold the data for our libtiff i/o hooks */
+typedef struct tifs_io_private_t
+{
+    FILE *f;
+    gx_device_printer *pdev;
+} tifs_io_private;
+
+/* libtiff i/o hooks */
+static int
+gs_tifsDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
+{
+    (void) fd;
+    (void) pbase;
+    (void) psize;
+    return (0);
+}
+
+static void
+gs_tifsDummyUnmapProc(thandle_t fd, void* base, toff_t size)
+{
+    (void) fd;
+    (void) base;
+    (void) size;
+}
+
+static size_t
+gs_tifsReadProc(thandle_t fd, void* buf, size_t size)
+{
+    tifs_io_private *tiffio = (tifs_io_private *)fd;
+    size_t size_io = (size_t) size;
+
+    if ((size_t) size_io != size) {
+        return (size_t) -1;
+    }
+    return((size_t) fread (buf, 1, size_io, tiffio->f));
+}
+
+static size_t
+gs_tifsWriteProc(thandle_t fd, void* buf, size_t size)
+{
+    tifs_io_private *tiffio = (tifs_io_private *)fd;
+    size_t size_io = (size_t) size;
+    size_t written;
+
+    if ((size_t) size_io != size) {
+        return (size_t) -1;
+    }
+    written = (size_t) fwrite (buf, 1, size_io, tiffio->f);
+    return written;
+}
+
+static uint64_t
+gs_tifsSeekProc(thandle_t fd, uint64_t off, int whence)
+{
+    tifs_io_private *tiffio = (tifs_io_private *)fd;
+    gs_offset_t off_io = (gs_offset_t) off;
+
+    if ((uint64_t) off_io != off) {
+        return (uint64_t) -1; /* this is really gross */
+    }
+    if (gp_fseek_64(tiffio->f , (gs_offset_t)off_io, whence) < 0) {
+        return (uint64_t) -1;
+    }
+    return (gp_ftell_64(tiffio->f));
+}
+
+static int
+gs_tifsCloseProc(thandle_t fd)
+{
+    tifs_io_private *tiffio = (tifs_io_private *)fd;
+    gx_device_printer *pdev = tiffio->pdev;
+    int code = fclose(tiffio->f);
+    
+    gs_free(pdev->memory, tiffio, sizeof(tifs_io_private), 1, "gs_tifsCloseProc");
+
+    return code;
+}
+
+static uint64_t
+gs_tifsSizeProc(thandle_t fd)
+{
+    tifs_io_private *tiffio = (tifs_io_private *)fd;
+    uint64_t length;
+    gs_offset_t curpos = gp_ftell_64(tiffio->f);
+
+    if (curpos < 0) {
+        return(0);
+    }
+    
+    if (gp_fseek_64(tiffio->f, (gs_offset_t)0, SEEK_END) < 0) {
+        return(0);
+    }
+    length = (uint64_t)gp_ftell_64(tiffio->f);
+    
+    if (gp_fseek_64(tiffio->f, curpos, SEEK_SET) < 0) {
+        return(0);
+    }
+    return length;
+}
+
+TIFF *
+tiff_from_filep(gx_device_printer *dev,  const char *name, FILE *filep, int big_endian, bool usebigtiff)
+{
+    char mode[5] = "w";
+    int modelen = 1;
+    TIFF *t;
+    tifs_io_private *tiffio;
+
+    if (big_endian)
+        mode[modelen++] = 'b';
+    else
+        mode[modelen++] = 'l';
+
+    if (usebigtiff)
+    /* this should never happen for libtiff < 4.0 - see tiff_put_some_params() */
+        mode[modelen++] = '8';
+
+    mode[modelen] = (char)0;
+    
+    tiffio = (tifs_io_private *)gs_malloc(dev->memory, sizeof(tifs_io_private), 1, "tiff_from_filep");
+    if (!tiffio) {
+        return NULL;
+    }
+    tiffio->f = filep;
+    tiffio->pdev = dev;
+
+    t = TIFFClientOpen(name, mode,
+        (thandle_t) tiffio, (TIFFReadWriteProc)gs_tifsReadProc,
+        (TIFFReadWriteProc)gs_tifsWriteProc, (TIFFSeekProc)gs_tifsSeekProc,
+        gs_tifsCloseProc, (TIFFSizeProc)gs_tifsSizeProc, gs_tifsDummyMapProc,
+        gs_tifsDummyUnmapProc);
+
+    return t;
+}
+
+static void
+gs_tifsWarningHandlerEx(thandle_t client_data, const char* module, const char* fmt, va_list ap)
+{
+    tifs_io_private *tiffio = (tifs_io_private *)client_data;
+    gx_device_printer *pdev = tiffio->pdev;    
+    int count;
+    char buf[TIFF_PRINT_BUF_LENGTH];
+
+    count = vsnprintf(buf, sizeof(buf), fmt, ap);
+    if (count >= sizeof(buf) || count < 0)  { /* C99 || MSVC */
+        dmlprintf1(pdev->memory, "%s", buf);
+        dmlprintf1(pdev->memory, "%s\n", tifs_msg_truncated);
+    } else {
+        dmlprintf1(pdev->memory, "%s\n", buf);
+    }
+}
+
+static void
+gs_tifsErrorHandlerEx(thandle_t client_data, const char* module, const char* fmt, va_list ap)
+{
+    tifs_io_private *tiffio = (tifs_io_private *)client_data;
+    gx_device_printer *pdev = tiffio->pdev;    
+    const char *max_size_error = "Maximum TIFF file size exceeded";
+    int count;
+    char buf[TIFF_PRINT_BUF_LENGTH];
+
+    count = vsnprintf(buf, sizeof(buf), fmt, ap);
+    if (count >= sizeof(buf) || count < 0)  { /* C99 || MSVC */
+        dmlprintf1(pdev->memory, "%s\n", buf);
+        dmlprintf1(pdev->memory, "%s", tifs_msg_truncated);
+    } else {
+        dmlprintf1(pdev->memory, "%s\n", buf);
+    }
+
+#if (TIFFLIB_VERSION >= 20111221)
+    if (!strncmp(fmt, max_size_error, strlen(max_size_error))) {
+        dmlprintf(pdev->memory, "Use -dUseBigTIFF(=true) for BigTIFF output\n");
+    }
+#endif
+}
+
+void tiff_set_handlers (void)
+{
+    (void)TIFFSetErrorHandler(NULL);
+    (void)TIFFSetWarningHandler(NULL);
+    (void)TIFFSetErrorHandlerExt(gs_tifsErrorHandlerEx);
+    (void)TIFFSetWarningHandlerExt(gs_tifsWarningHandlerEx);
+}
+
+#if SHARE_LIBTIFF == 0
+TIFF*
+TIFFFdOpen(int fd, const char* name, const char* mode)
+{
+    (void)fd;
+    (void)name;
+    (void)mode;
+
+    return(NULL);
+}
+
+TIFF*
+TIFFOpen(const char* name, const char* mode)
+{
+    (void)name;
+    (void)mode;
+    
+    return(NULL);
+}
+
+void*
+_TIFFmalloc(tmsize_t s)
+{
+    return (malloc((size_t) s));
+}
+
+void
+_TIFFfree(void* p)
+{
+    free(p);
+}
+
+void*
+_TIFFrealloc(void* p, tmsize_t s)
+{
+    return (realloc(p, (size_t) s));
+}
+
+void
+_TIFFmemset(void* p, int v, tmsize_t c)
+{
+    memset(p, v, (size_t) c);
+}
+
+void
+_TIFFmemcpy(void* d, const void* s, tmsize_t c)
+{
+    memcpy(d, s, (size_t) c);
+}
+
+int
+_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
+{
+    return (memcmp(p1, p2, (size_t) c));
+}
+
+/* We supply our own warning/error handlers when we invoke libtiff */
+TIFFErrorHandler _TIFFwarningHandler = NULL;
+TIFFErrorHandler _TIFFerrorHandler = NULL;
+
+#endif /*  SHARE_LIBTIFF == 0 */