7 files changed, 465 insertions, 74 deletions

diff --git a/gs/base/gp.h b/gs/base/gp.h
index 829a782fd..1cdf34754 100644
--- a/gs/base/gp.h
+++ b/gs/base/gp.h
@@ -232,6 +232,24 @@ FILE *gp_open_scratch_file(const gs_memory_t *mem,
 /* Open a file with the given name, as a stream of uninterpreted bytes. */
 FILE *gp_fopen(const char *fname, const char *mode);
 
+/* Test whether this platform supports the sharing of file descriptors */
+int gp_can_share_fdesc(void);
+
+/* Create a self-deleting scratch file */
+FILE *gp_open_scratch_file_rm(const gs_memory_t *mem,
+                              const char        *prefix,
+                                    char         fname[gp_file_name_sizeof],
+                              const char        *mode);
+
+/* Create a second open FILE on the basis of a given one */
+FILE *gp_fdup(FILE *f, const char *mode);
+
+/* Read from a specified offset within a FILE into a buffer */
+int gp_fpread(char *buf, uint count, int64_t offset, FILE *f);
+
+/* Write to a specified offset within a FILE from a buffer */
+int gp_fpwrite(char *buf, uint count, int64_t offset, FILE *f);
+
 /* Force given file into binary mode (no eol translations, etc) */
 /* if 2nd param true, text mode if 2nd param false */
 int gp_setmode_binary(FILE * pfile, bool mode);
diff --git a/gs/base/gp_macio.c b/gs/base/gp_macio.c
index c5190d561..8452312f0 100644
--- a/gs/base/gp_macio.c
+++ b/gs/base/gp_macio.c
@@ -549,6 +549,34 @@ gp_fopen (const char * fname, const char * mode) {
 
 }
 
+int gp_can_share_fdesc(void)
+{
+    return 0;
+}
+
+FILE *gp_open_scratch_file_rm(const gs_memory_t *mem,
+                              const char        *prefix,
+                                    char         fname[gp_file_name_sizeof],
+                              const char        *mode)
+{
+    return NULL;
+}
+
+FILE *gp_fdup(FILE *f, const char *mode)
+{
+    return NULL;
+}
+
+int gp_fpread(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return -1;
+}
+
+int gp_fpwrite(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return -1;
+}
+
 FILE *
 popen (const char * fname, const char * mode ) {
         return gp_fopen (fname,  mode);
diff --git a/gs/base/gp_mswin.c b/gs/base/gp_mswin.c
index b7f5a8166..d4e33af9b 100644
--- a/gs/base/gp_mswin.c
+++ b/gs/base/gp_mswin.c
@@ -612,11 +612,12 @@ FILE *mswin_popen(const char *cmd, const char *mode)
 
 /* Create and open a scratch file with a given name prefix. */
 /* Write the actual file name at fname. */
-FILE *
-gp_open_scratch_file(const gs_memory_t *mem,
-                     const char        *prefix,
-                           char        *fname,
-                     const char        *mode)
+static FILE *
+gp_open_scratch_file_generic(const gs_memory_t *mem,
+                             const char        *prefix,
+                                   char        *fname,
+                             const char        *mode,
+                                   int          remove)
 {
     UINT n;
     DWORD l;
@@ -721,26 +722,19 @@ gp_open_scratch_file(const gs_memory_t *mem,
                 hfile = CreateFile2(uni,
                                     GENERIC_READ | GENERIC_WRITE | DELETE,
                                     FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                    CREATE_ALWAYS,
+                                    CREATE_ALWAYS | (remove ? FILE_FLAG_DELETE_ON_CLOSE : 0),
                                     NULL);
 #else
                 hfile = CreateFileW(uni,
                                     GENERIC_READ | GENERIC_WRITE | DELETE,
                                     FILE_SHARE_READ | FILE_SHARE_WRITE,
                                     NULL, CREATE_ALWAYS,
-                                    FILE_ATTRIBUTE_NORMAL /* | FILE_FLAG_DELETE_ON_CLOSE */,
+                                    FILE_ATTRIBUTE_NORMAL | (remove ? FILE_FLAG_DELETE_ON_CLOSE : 0),
                                     NULL);
 #endif
                 free(uni);
             }
 #endif
-            /*
-             * Can't apply FILE_FLAG_DELETE_ON_CLOSE due to
-             * the logics of clist_fclose. Also note that
-             * gdev_prn_render_pages requires multiple temporary files
-             * to exist simultaneousely, so that keeping all them opened
-             * may exceed available CRTL file handles.
-             */
         }
     }
     if (hfile != INVALID_HANDLE_VALUE) {
@@ -769,6 +763,24 @@ gp_open_scratch_file(const gs_memory_t *mem,
     return f;
 }
 
+FILE *
+gp_open_scratch_file(const gs_memory_t *mem,
+                     const char        *prefix,
+                           char        *fname,
+                     const char        *mode)
+{
+    return gp_open_scratch_file_generic(mem, prefix, fname, mode, 0);
+}
+
+FILE *
+gp_open_scratch_file_rm(const gs_memory_t *mem,
+                        const char        *prefix,
+                              char        *fname,
+                        const char        *mode)
+{
+    return gp_open_scratch_file_generic(mem, prefix, fname, mode, 1);
+}
+
 /* Open a file with the given name, as a stream of uninterpreted bytes. */
 FILE *
 gp_fopen(const char *fname, const char *mode)
@@ -794,6 +806,66 @@ gp_fopen(const char *fname, const char *mode)
 #endif
 }
 
+/* test whether gp_fdup is supported on this platform  */
+int gp_can_share_fdesc(void)
+{
+    return 1;
+}
+
+/* Create a second open FILE on the basis of a given one */
+FILE *gp_fdup(FILE *f, const char *mode)
+{
+    int fd = fileno(f);
+    if (fd < 0)
+        return NULL;
+
+    fd = dup(fd);
+    if (fd < 0)
+        return NULL;
+
+    return fdopen(fd, mode);
+}
+
+/* Read from a specified offset within a FILE into a buffer */
+int gp_fpread(char *buf, uint count, int64_t offset, FILE *f)
+{
+    OVERLAPPED overlapped;
+    DWORD ret;
+    HANDLE hnd = _get_osfhandle(fileno(f));
+
+    if (hnd == INVALID_HANDLE_VALUE)
+        return -1;
+
+    memset(&overlapped, 0, sizeof(OVERLAPPED));
+    overlapped.Offset = (DWORD)offset;
+    overlapped.OffsetHigh = (DWORD)(offset >> 32);
+
+    if (!ReadFile((HANDLE)hnd, buf, count, &ret, &overlapped))
+        return -1;
+
+    return ret;
+}
+
+/* Write to a specified offset within a FILE from a buffer */
+int gp_fpwrite(char *buf, uint count, int64_t offset, FILE *f)
+{
+    OVERLAPPED overlapped;
+    DWORD ret;
+    HANDLE hnd = _get_osfhandle(fileno(f));
+
+    if (hnd == INVALID_HANDLE_VALUE)
+        return -1;
+
+    memset(&overlapped, 0, sizeof(OVERLAPPED));
+    overlapped.Offset = (DWORD)offset;
+    overlapped.OffsetHigh = (DWORD)(offset >> 32);
+
+    if (!WriteFile((HANDLE)hnd, buf, count, &ret, &overlapped))
+        return -1;
+
+    return ret;
+}
+
 /* ------ Font enumeration ------ */
 
  /* This is used to query the native os for a list of font names and
diff --git a/gs/base/gp_os2fs.c b/gs/base/gp_os2fs.c
index 1de5a3336..fd033bcc2 100644
--- a/gs/base/gp_os2fs.c
+++ b/gs/base/gp_os2fs.c
@@ -262,6 +262,34 @@ gp_fopen(const char *fname, const char *mode)
     return fopen(fname, mode);
 }
 
+int gp_can_share_fdesc(void)
+{
+    return 0;
+}
+
+FILE *gp_open_scratch_file_rm(const gs_memory_t *mem,
+                              const char        *prefix,
+                                    char         fname[gp_file_name_sizeof],
+                              const char        *mode)
+{
+    return NULL;
+}
+
+FILE *gp_fdup(FILE *f, const char *mode)
+{
+    return NULL;
+}
+
+int gp_fpread(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return -1;
+}
+
+int gp_fpwrite(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return -1;
+}
+
 /* -------------- Helpers for gp_file_name_combine_generic ------------- */
 
 uint gp_file_name_root(const char *fname, uint len)
diff --git a/gs/base/gp_unifs.c b/gs/base/gp_unifs.c
index f44b3d2bc..59fc86c3d 100644
--- a/gs/base/gp_unifs.c
+++ b/gs/base/gp_unifs.c
@@ -151,6 +151,46 @@ gp_fopen(const char *fname, const char *mode)
     return fopen(fname, mode);
 }
 
+int gp_can_share_fdesc(void)
+{
+    return 1;
+}
+
+FILE *gp_open_scratch_file_rm(const gs_memory_t *mem,
+                              const char        *prefix,
+                                    char         fname[gp_file_name_sizeof],
+                              const char        *mode)
+{
+    FILE *f = gp_open_scratch_file_generic(mem, prefix, fname, mode, false);
+    /* Unlink file immediately to avoid it being left around if the program
+     * is killed. On this platform readers access temp files by cloning the
+     * FILE pointer and without accessing the file by name */
+    if (f)
+        unlink(fname);
+    return f;
+}
+
+FILE *gp_fdup(FILE *f, const char *mode)
+{
+    int fd = fileno(f);
+    if (fd < 0)
+        return NULL;
+    fd = dup(fd);
+    if (fd < 0)
+        return NULL;
+    return fdopen(fd, mode);
+}
+
+int gp_fpread(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return pread(fileno(f), buf, count, offset);
+}
+
+int gp_fpwrite(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return pwrite(fileno(f), buf, count, offset);
+}
+
 /* Set a file into binary or text mode. */
 int
 gp_setmode_binary(FILE * pfile, bool mode)
diff --git a/gs/base/gp_vms.c b/gs/base/gp_vms.c
index 689f4ca88..f3b5f6f31 100644
--- a/gs/base/gp_vms.c
+++ b/gs/base/gp_vms.c
@@ -287,6 +287,34 @@ gp_fopen(const char *fname, const char *mode)
     return fopen(fname, mode);
 }
 
+int gp_can_share_fdesc(void)
+{
+    return 0;
+}
+
+FILE *gp_open_scratch_file_rm(const gs_memory_t *mem,
+                              const char        *prefix,
+                                    char         fname[gp_file_name_sizeof],
+                              const char        *mode)
+{
+    return NULL;
+}
+
+FILE *gp_fdup(FILE *f, const char *mode)
+{
+    return NULL;
+}
+
+int gp_fpread(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return -1;
+}
+
+int gp_fpwrite(char *buf, uint count, int64_t offset, FILE *f)
+{
+    return -1;
+}
+
 /* Set a file into binary or text mode. */
 int
 gp_setmode_binary(FILE * pfile, bool binary)
diff --git a/gs/base/gxclfile.c b/gs/base/gxclfile.c
index 2ca35b60d..18ab29d45 100644
--- a/gs/base/gxclfile.c
+++ b/gs/base/gxclfile.c
@@ -15,6 +15,7 @@
 
 
 /* File-based command list implementation */
+#include "assert.h"
 #include "stdio_.h"
 #include "string_.h"
 #include "unistd_.h"
@@ -32,38 +33,149 @@
 
 /* ------ Open/close/unlink ------ */
 
+#define ENC_FILE_STR ("encoded_file_ptr_%p")
+#define ENC_FILE_STRX ("encoded_file_ptr_0x%p")
+
+static void
+file_to_fake_path(clist_file_ptr file, char fname[gp_file_name_sizeof])
+{
+    gs_sprintf(fname, ENC_FILE_STR, file);
+}
+
+static clist_file_ptr
+fake_path_to_file(const char *fname)
+{
+    clist_file_ptr i1, i2;
+
+    int r1 = sscanf(fname, ENC_FILE_STR, &i1);
+    int r2 = sscanf(fname, ENC_FILE_STRX, &i2);
+    return r2 == 1 ? i2 : (r1 == 1 ? i1 : NULL);
+}
+
+/* Use our own FILE structure so that, on some platforms, we write and read
+ * tmp files via a single file descriptor. That allows cleaning of tmp files
+ * to be addressed via DELETE_ON_CLOSE under Windows, and immediate unlink
+ * after opening under Linux. When running in this mode, we keep our own
+ * record of position within the file for the sake of thread safety
+ */
+typedef struct
+{
+    gs_memory_t *mem;
+    FILE *f;
+    int64_t pos;
+} IFILE;
+
+static IFILE *wrap_file(gs_memory_t *mem, FILE *f)
+{
+    IFILE *ifile;
+
+    if (!f) return NULL;
+    ifile = (IFILE *)gs_alloc_bytes(mem->non_gc_memory, sizeof(*ifile), "Allocate wrapped IFILE");
+    if (!ifile)
+    {
+        fclose(f);
+        return NULL;
+    }
+    ifile->mem = mem->non_gc_memory;
+    ifile->f = f;
+    ifile->pos = 0;
+    return ifile;
+}
+
+int close_file(IFILE *ifile)
+{
+    int res = 0;
+    if (ifile)
+    {
+        res = fclose(ifile->f);
+        gs_free_object(ifile->mem, ifile, "Free wrapped IFILE");
+    }
+    return res;
+}
+
 static int
 clist_fopen(char fname[gp_file_name_sizeof], const char *fmode,
             clist_file_ptr * pcf, gs_memory_t * mem, gs_memory_t *data_mem,
             bool ok_to_compress)
 {
-    if (*fname == 0) {
+    if (*fname == 0)
+    {
         if (fmode[0] == 'r')
             return_error(gs_error_invalidfileaccess);
-        *pcf = (clist_file_ptr)gp_open_scratch_file_64(mem,
-                                                   gp_scratch_file_name_prefix,
-                                                   fname, fmode);
-    } else
-        *pcf = gp_fopen(fname, fmode);
-    if (*pcf == NULL) {
+        if (gp_can_share_fdesc())
+        {
+            *pcf = (clist_file_ptr)wrap_file(mem, gp_open_scratch_file_rm(mem,
+                                                       gp_scratch_file_name_prefix,
+                                                       fname, fmode));
+            /* If the platform supports FILE duplication then we overwrite the
+             * file name with an encoded form of the FILE pointer */
+            file_to_fake_path(*pcf, fname);
+        }
+        else
+        {
+            *pcf = (clist_file_ptr)wrap_file(mem, gp_open_scratch_file_64(mem,
+                                                       gp_scratch_file_name_prefix,
+                                                       fname, fmode));
+        }
+    }
+    else
+    {
+        // Check if a special path is passed in. If so, clone the FILE handle
+        clist_file_ptr ocf = fake_path_to_file(fname);
+        if (ocf)
+        {
+            *pcf = wrap_file(mem, gp_fdup(((IFILE *)ocf)->f, fmode));
+        }
+        else
+        {
+            *pcf = wrap_file(mem, gp_fopen(fname, fmode));
+        }
+    }
+
+    if (*pcf == NULL)
+    {
         emprintf1(mem, "Could not open the scratch file %s.\n", fname);
         return_error(gs_error_invalidfileaccess);
     }
+
     return 0;
 }
 
 static int
 clist_unlink(const char *fname)
 {
-    return (unlink(fname) != 0 ? gs_note_error(gs_error_ioerror) : 0);
+    clist_file_ptr ocf = fake_path_to_file(fname);
+    if (ocf)
+    {
+        /* fname is an encoded file pointer. The file will either have been
+         * created with the delete-on-close option, or already have been
+         * unlinked. We need only close the FILE */
+        return close_file((IFILE *)ocf) != 0 ? gs_note_error(gs_error_ioerror) : 0;
+    }
+    else
+    {
+        return (unlink(fname) != 0 ? gs_note_error(gs_error_ioerror) : 0);
+    }
 }
 
 static int
 clist_fclose(clist_file_ptr cf, const char *fname, bool delete)
 {
-    return (fclose((FILE *) cf) != 0 ? gs_note_error(gs_error_ioerror) :
-            delete ? clist_unlink(fname) :
-            0);
+    clist_file_ptr ocf = fake_path_to_file(fname);
+    if (ocf == cf)
+    {
+        /* fname is an encoded file pointer, and cf is the FILE used to create it.
+         * We shouldn't close it unless we have been asked to delete it, in which
+         * case closing it will delete it */
+        if (delete)
+            close_file((IFILE *)ocf);
+    }
+    else
+    {
+        return (close_file((IFILE *) cf) != 0 ? gs_note_error(gs_error_ioerror) :
+                delete ? clist_unlink(fname) :
+                0);
+    }
 }
 
 /* ------ Writing ------ */
@@ -71,7 +183,16 @@ clist_fclose(clist_file_ptr cf, const char *fname, bool delete)
 static int
 clist_fwrite_chars(const void *data, uint len, clist_file_ptr cf)
 {
-    return fwrite(data, 1, len, (FILE *) cf);
+    if (gp_can_share_fdesc())
+    {
+        int res = gp_fpwrite(data, len, ((IFILE *)cf)->pos, ((IFILE *)cf)->f);
+        if (res >= 0)
+            ((IFILE *)cf)->pos += len; return res;
+    }
+    else
+    {
+        return fwrite(data, 1, len, ((IFILE *)cf)->f);
+    }
 }
 
 /* ------ Reading ------ */
@@ -79,33 +200,45 @@ clist_fwrite_chars(const void *data, uint len, clist_file_ptr cf)
 static int
 clist_fread_chars(void *data, uint len, clist_file_ptr cf)
 {
-    FILE *f = (FILE *) cf;
-    byte *str = data;
-
-    /* The typical implementation of fread */
-    /* is extremely inefficient for small counts, */
-    /* so we just use straight-line code instead. */
-    switch (len) {
-        default:
-            return fread(str, 1, len, f);
-        case 8:
-            *str++ = (byte) getc(f);
-        case 7:
-            *str++ = (byte) getc(f);
-        case 6:
-            *str++ = (byte) getc(f);
-        case 5:
-            *str++ = (byte) getc(f);
-        case 4:
-            *str++ = (byte) getc(f);
-        case 3:
-            *str++ = (byte) getc(f);
-        case 2:
-            *str++ = (byte) getc(f);
-        case 1:
-            *str = (byte) getc(f);
-    }
-    return len;
+    if (gp_can_share_fdesc())
+    {
+        int res = gp_fpread(data, len, ((IFILE *)cf)->pos, ((IFILE *)cf)->f);
+        if (res >= 0)
+            ((IFILE *)cf)->pos += res;
+
+        return res;
+    }
+    else
+    {
+        FILE *f = ((IFILE *)cf)->f;
+        byte *str = data;
+
+        /* The typical implementation of fread */
+        /* is extremely inefficient for small counts, */
+        /* so we just use straight-line code instead. */
+        switch (len) {
+            default:
+                return fread(str, 1, len, f);
+            case 8:
+                *str++ = (byte) getc(f);
+            case 7:
+                *str++ = (byte) getc(f);
+            case 6:
+                *str++ = (byte) getc(f);
+            case 5:
+                *str++ = (byte) getc(f);
+            case 4:
+                *str++ = (byte) getc(f);
+            case 3:
+                *str++ = (byte) getc(f);
+            case 2:
+                *str++ = (byte) getc(f);
+            case 1:
+                *str = (byte) getc(f);
+        }
+
+        return len;
+    }
 }
 
 /* ------ Position/status ------ */
@@ -119,43 +252,87 @@ clist_set_memory_warning(clist_file_ptr cf, int bytes_left)
 static int
 clist_ferror_code(clist_file_ptr cf)
 {
-    return (ferror((FILE *) cf) ? gs_error_ioerror : 0);
+    return (ferror(((IFILE *)cf)->f) ? gs_error_ioerror : 0);
 }
 
 static int64_t
 clist_ftell(clist_file_ptr cf)
 {
-    return gp_ftell_64((FILE *) cf);
+    IFILE *ifile = (IFILE *)cf;
+
+    return gp_can_share_fdesc() ? ifile->pos : ftell(ifile->f);
 }
 
 static void
 clist_rewind(clist_file_ptr cf, bool discard_data, const char *fname)
 {
-    FILE *f = (FILE *) cf;
-
-    if (discard_data) {
-        /*
-         * The ANSI C stdio specification provides no operation for
-         * truncating a file at a given position, or even just for
-         * deleting its contents; we have to use a bizarre workaround to
-         * get the same effect.
-         */
-        char fmode[4];
-
-        /* Opening with "w" mode deletes the contents when closing. */
-        (void)freopen(fname, gp_fmode_wb, f);
-        strcpy(fmode, "w+");
-        strcat(fmode, gp_fmode_binary_suffix);
-        (void)freopen(fname, fmode, f);
-    } else {
-        rewind(f);
+    FILE *f = ((IFILE *)cf)->f;
+    IFILE *ocf = fake_path_to_file(fname);
+    char fmode[4];
+
+    strcpy(fmode, "w+");
+    strcat(fmode, gp_fmode_binary_suffix);
+
+    if (ocf)
+    {
+        if (discard_data)
+        {
+            /* fname is an encoded ifile pointer. We can use an entirely
+             * new scratch file. */
+            char tfname[gp_file_name_sizeof];
+            fclose(ocf->f);
+            ocf->f = gp_open_scratch_file_rm(NULL, gp_scratch_file_name_prefix, tfname, fmode);
+        }
+        else
+        {
+            ((IFILE *)cf)->pos = 0;
+        }
+    }
+    else
+    {
+        if (discard_data) {
+            /*
+             * The ANSI C stdio specification provides no operation for
+             * truncating a file at a given position, or even just for
+             * deleting its contents; we have to use a bizarre workaround to
+             * get the same effect.
+             */
+
+            /* Opening with "w" mode deletes the contents when closing. */
+            (void)freopen(fname, gp_fmode_wb, f);
+            (void)freopen(fname, fmode, f);
+        } else {
+            rewind(f);
+        }
     }
 }
 
 static int
 clist_fseek(clist_file_ptr cf, int64_t offset, int mode, const char *ignore_fname)
 {
-    return gp_fseek_64((FILE *) cf, offset, mode);
+    IFILE *ifile = (IFILE *)cf;
+
+    if (gp_can_share_fdesc())
+    {
+        switch (mode)
+        {
+            case SEEK_SET:
+                ifile->pos = offset;
+                break;
+            case SEEK_CUR:
+                ifile->pos += offset;
+                break;
+            case SEEK_END:
+                gp_fseek_64(ifile->f, 0, SEEK_END);
+                ifile->pos = ftell(ifile->f);
+                break;
+        }
+        return 0;
+    }
+    else
+    {
+        return gp_fseek_64(ifile->f, offset, mode);
+    }
 }
 
 static clist_io_procs_t clist_io_procs_file = {