/* Copyright (C) 2001-2026 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.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* plmain.c */

/* Main program command-line interpreter for PCL interpreters */

#include "std.h"

#include "gserrors.h"

#include "ctype_.h"

#include "string_.h"

#include <stdlib.h> /* atof */

#include "assert_.h"

#include "gdebug.h"

#include "gscdefs.h"

#include "gsio.h"

#include "gstypes.h"

#include "gserrors.h"

#include "gsmemory.h"

#include "gsmalloc.h"

#include "gsmchunk.h"

#include "gsstruct.h"

#include "gxalloc.h"

#include "gsalloc.h"

#include "gsargs.h"

#include "gp.h"

#include "gsdevice.h"

#include "gxdevice.h"

#include "gxdevsop.h"       /* for gxdso_* */

#include "gxclpage.h"

#include "gdevprn.h"

#include "gsparam.h"

#include "gslib.h"

#include "pjtop.h"

#include "plparse.h"

#include "plmain.h"

#include "pltop.h"

#include "plapi.h"

#include "gslibctx.h"

#include "gsicc_manage.h"

#include "gxiodev.h"

#include "stream.h"

#include "strmio.h"

#include "gp.h"

/* includes for the display device */

#include "gdevdevn.h"

#include "gsequivc.h"

#include "gdevdsp.h"

#include "gdevdsp2.h"

#define OMIT_SAVED_PAGES

#define OMIT_SAVED_PAGES_TEST

/* if we are not doing saved_pages, omit saved-pages-test mode as well */

#ifdef OMIT_SAVED_PAGES

#   ifndef OMIT_SAVED_PAGES_TEST

#       define OMIT_SAVED_PAGES_TEST

#   endif

#endif

/* Include the extern for the device list. */

extern_gs_lib_device_list();

/* Extern for PDL(s): currently in one of: plimpl.c (XL & PCL), */

/* pcimpl.c (PCL only), or pximpl (XL only) depending on make configuration.*/

extern pl_interp_implementation_t *pdl_implementations[];    /* zero-terminated list */

#define PJL_VERSION_STRING GS_STRINGIZE(PJLVERSION)

/* Define the usage message. */

static const char *pl_usage = "\

Usage: %s [option* file]+...\n\

Options: -dNOPAUSE -E[#] -h -L<PCL|PCLXL> -K<maxK> -l<PCL5C|PCL5E|RTL> -Z...\n\

         -sDEVICE=<dev> -g<W>x<H> -r<X>[x<Y>] -d{First|Last}Page=<#>\n\

         -H<l>x<b>x<r>x<t> -dNOCACHE\n\

         -sOutputFile=<file> (-s<option>=<string> | -d<option>[=<value>])*\n\

         -J<PJL commands>\n";

/* Simple structure to hold the contents of a buffered file.

 * We have a list of chunks of data held in an index. */

typedef struct

{

    gs_memory_t *memory;

    size_t index_max; /* Size of the index */

    size_t len;

    byte **index;

} buffered_file;

/* Work in 1 meg chunks for now. */

#define BUFFERED_FILE_CHUNK_SHIFT 20

#define BUFFERED_FILE_CHUNK_SIZE (1<<BUFFERED_FILE_CHUNK_SHIFT)

typedef enum {

    /* Default: Never reset resources automatically on job changes. */

    PL_RESET_RESOURCES_NEVER = 0,

    /* Reset resources whenver we drop back to PJL. */

    PL_RESET_RESOURCES_ON_PJL = 1,

    /* Reset resources whenever we change language (other than to drop

     * back to PJL). */

    PL_RESET_RESOURCES_ON_LANGUAGE_CHANGE = 2

} pl_resource_reset;

/*

 * Main instance for all interpreters.

 */

struct pl_main_instance_s

{

    /* The following are set at initialization time. */

    gs_memory_t *memory;

    gs_memory_t *device_memory;

    long base_time[2];          /* starting time */

    int error_report;           /* -E# */

    bool pause;                 /* -dNOPAUSE => false */

    bool safer;                  /* -dNOSAFER => false */

    gx_device *device;

    gs_gc_root_t *device_root;

    int device_index;

    pl_main_get_codepoint_t *get_codepoint;

                                /* Get next 'unicode' codepoint */

    pl_interp_implementation_t *implementation; /*-L<Language>*/

    char pcl_personality[6];    /* a character string to set pcl's

                                   personality - rtl, pcl5c, pcl5e, and

                                   pcl == default.  NB doesn't belong here. */

    bool interpolate;

    bool nocache;

    bool page_set_on_command_line;

    long page_size[2];

    bool res_set_on_command_line;

    float res[2];

    bool high_level_device;

    bool supports_rasterops;

#ifndef OMIT_SAVED_PAGES_TEST

    bool saved_pages_test_mode;

#endif

    bool pjl_from_args; /* pjl was passed on the command line */

    int scanconverter;

    /* we have to store these in the main instance until the languages

       state is sufficiently initialized to set the parameters. */

    char *piccdir;

    char *pdefault_gray_icc;

    char *pdefault_rgb_icc;

    char *pdefault_cmyk_icc;

    gs_c_param_list params;

    arg_list args;

    pl_interp_implementation_t **implementations;

    pl_interp_implementation_t *curr_implementation;

    /* We keep track of the last (non PJL) implementation we used.

     * This is used to conditionally reset soft fonts etc. */

    pl_interp_implementation_t *prev_non_pjl_implementation;

    pl_resource_reset reset_resources;

    /* When processing data via 'run_string', interpreters may not

     * completely consume the data they are passed each time. We use

     * this buffer to carry over data between calls. */

    byte *buf_ptr;

    int buf_fill;

    int buf_max;

    void *display; /* display device pointer - to support legacy API. Will

                    * be removed. */

    bool detect_runstring_language;

    bool revert_to_pjl_after_runstring;

    bool mid_runstring; /* True if we are mid-runstring */

    void *buffering_runstring_as_file;

    /* The state for gsapi param enumeration */

    gs_c_param_list enum_params;

    gs_param_enumerator_t enum_iter;

    char *enum_keybuf;

    int enum_keybuf_max;

};

/* ---------------- Forward decls ------------------ */

static int pl_main_languages_init(gs_memory_t * mem, pl_main_instance_t * inst);

static pl_interp_implementation_t

    *pl_select_implementation(pl_interp_implementation_t * pjl_instance,

                              pl_main_instance_t * pmi,

                              const char *data,

                              int len);

/* Process the options on the command line. */

static stream *pl_main_arg_fopen(const char *fname, void *mem);

/* Process the options on the command line, including making the

   initial device and setting its parameters.  */

static int pl_main_process_options(pl_main_instance_t * pmi, arg_list * pal,

                                   pl_interp_implementation_t * pjl_instance);

static pl_interp_implementation_t *pl_pjl_select(pl_main_instance_t * pmi, pl_interp_implementation_t *pjl_instance);

/* return index in gs device list -1 if not found */

static inline int

get_device_index(const gs_memory_t * mem, const char *value)

{

    const gx_device *const *dev_list;

    int num_devs = gs_lib_device_list(&dev_list, NULL);

    int di;

    for (di = 0; di < num_devs; ++di)

        if (!strcmp(gs_devicename(dev_list[di]), value))

            break;

    if (di == num_devs) {

        errprintf(mem, "Unknown device name %s.\n", value);

        return -1;

    }

    return di;

}

static int

legacy_display_callout(void *instance,

                       void *handle,

                       const char *dev_name,

                       int id,

                       int size,

                       void *data)

{

    pl_main_instance_t *inst = (pl_main_instance_t *)handle;

    if (dev_name == NULL)

        return -1;

    if (strcmp(dev_name, "display") != 0)

        return -1;

    if (id == DISPLAY_CALLOUT_GET_CALLBACK_LEGACY) {

        /* get display callbacks */

        gs_display_get_callback_t *cb = (gs_display_get_callback_t *)data;

        cb->callback = inst->display;

        return 0;

    }

    return -1;

}

int

pl_main_set_display_callback(pl_main_instance_t *inst, void *callback)

{

    int code;

    if (inst->display == NULL && callback != NULL) {

        /* First registration. */

        code = gs_lib_ctx_register_callout(inst->memory,

                                           legacy_display_callout,

                                           inst);

        if (code < 0)

            return code;

    }

    if (inst->display != NULL && callback == NULL) {

        /* Deregistered. */

        gs_lib_ctx_deregister_callout(inst->memory,

                                      legacy_display_callout,

                                      inst);

    }

    inst->display = callback;

    return 0;

}

int

pl_main_init_with_args(pl_main_instance_t *inst, int argc, char *argv[])

{

    gs_memory_t *mem = inst->memory;

    pl_interp_implementation_t *pjli;

    int code;

    gp_init();

    /* debug flags we reset this out of gs_lib_init0 which sets these

       and the allocator we want the debug setting but we do our own

       allocator */

#if defined(PACIFY_VALGRIND) && defined VALGRIND_HG_DISABLE_CHECKING

    VALGRIND_HG_DISABLE_CHECKING(gs_debug, 128);

#endif

    memset(gs_debug, 0, 128);

    gs_log_errors = 0;

    if (gs_lib_init1(mem) < 0)

        return -1;

    {

        /*

         * gs_iodev_init has to be called here (late), rather than

         * with the rest of the library init procedures, because of

         * some hacks specific to MS Windows for patching the

         * stdxxx IODevices.

         */

        if (gs_iodev_init(mem) < 0)

            return gs_error_Fatal;

    }

    gp_get_realtime(inst->base_time);

    if (arg_init(&inst->args, (const char **)argv, argc, pl_main_arg_fopen, mem,

                 inst->get_codepoint, mem) < 0)

        return gs_error_Fatal;

    /* Create PDL instances, etc */

    if (pl_main_languages_init(mem, inst) < 0) {

        return gs_error_Fatal;

    }

    inst->curr_implementation = pjli = inst->implementations[0];

    /* initialize pjl, needed for option processing. */

    if (pl_init_job(pjli, inst->device) < 0) {

        return gs_error_Fatal;

    }

    code = pl_main_process_options(inst,

                                   &inst->args,

                                   pjli);

    if (code == gs_error_invalidexit)

        code = 0; /* This is given by someone running "quit" in PS. */

    else if (argc == 1 || code < 0) {

        /* Print error verbage and return */

        int i;

        const gx_device **dev_list;

        int num_devs =

            gs_lib_device_list((const gx_device * const **)&dev_list,

                               NULL);

        if (code != gs_error_Info)

            errprintf(mem, pl_usage, argv[0]);

        errprintf(mem, "Version: %s\n", PJL_VERSION_STRING);

        errprintf(mem, "Languages:");

        for (i = 0; inst->implementations[i] != NULL; i++) {

            if (((i + 1)) % 9 == 0)

                errprintf(mem, "\n");

            errprintf(mem, " %s", pl_characteristics(inst->implementations[i])->language);

        }

        errprintf(mem, "\nDevices:");

        for (i = 0; i < num_devs; ++i) {

            if (((i + 1)) % 9 == 0)

                errprintf(mem, "\n");

            errprintf(mem, " %s", gs_devicename(dev_list[i]));

        }

        errprintf(mem, "\n");

        return code == gs_error_Info ? 0 : gs_error_Fatal;

    }

    return 0;

}

static int

revert_to_pjli(pl_main_instance_t *minst)

{

    pl_interp_implementation_t *pjli =

        minst->implementations[0];

    int code;

    /* If we're already in PJL, don't clear the state. */

    if (minst->curr_implementation == pjli)

        return 0;

    if (minst->curr_implementation) {

        code = pl_dnit_job(minst->curr_implementation);

        if (code < 0) {

            minst->curr_implementation = NULL;

            return code;

        }

    }

    minst->curr_implementation = NULL;

    /* We may want to reset the fonts. */

    if (minst->prev_non_pjl_implementation &&

        minst->reset_resources == PL_RESET_RESOURCES_ON_PJL) {

        if_debug1m('I', minst->memory, "Resetting resources (%s)\n",

                   pl_characteristics(minst->curr_implementation)->language);

        code = pl_reset(minst->prev_non_pjl_implementation, PL_RESET_RESOURCES);

        if (code < 0)

            return code;

    }

    minst->curr_implementation = pjli;

    code = pl_init_job(minst->curr_implementation, minst->device);

    return code;

}

int

pl_main_run_string_begin(pl_main_instance_t *minst)

{

    int code;

    if (minst->mid_runstring == 1) {

        dmprintf(minst->memory, "Can't begin a run_string during a run_string\n");

        return -1;

    }

    minst->mid_runstring = 1;

    /* If the current implementation is PJL (language 0) then don't

     * actually init here. Instead, just mark us as needing to auto

     * detect the language type when we get some data. */

    minst->detect_runstring_language = (minst->curr_implementation == minst->implementations[0]);

    minst->revert_to_pjl_after_runstring = minst->detect_runstring_language;

    if (minst->detect_runstring_language)

        return 0;

    code = pl_process_begin(minst->curr_implementation);

    if (code < 0)

        minst->mid_runstring = 0;

    return code;

}

static int

ensure_buf_size(pl_main_instance_t *minst, int len)

{

    int max = minst->buf_max;

    if (len < max)

        return 0;

    if (max == 0)

        max = 4096;

    while (max < len) {

        max *= 2;

        if (max < 0)

            return_error(gs_error_VMerror);

    }

    if (minst->buf_max == 0) {

        minst->buf_ptr = gs_alloc_bytes(minst->memory, max, "minst_buffer");

        if (minst->buf_ptr == NULL)

            return_error(gs_error_VMerror);

    } else {

        byte *newbuf = gs_resize_object(minst->memory, minst->buf_ptr, max, "minst_buffer");

        if (newbuf == NULL)

            return_error(gs_error_VMerror);

        minst->buf_ptr = newbuf;

    }

    minst->buf_max = max;

    return 0;

}

static

int buffer_data(pl_main_instance_t *minst, const char *data, unsigned int len)

{

    buffered_file *bf = minst->buffering_runstring_as_file;

    size_t newlen = bf->len + len;

    size_t start = bf->len;

    size_t chunk_max;

    size_t num_chunks = (bf->len + BUFFERED_FILE_CHUNK_SIZE-1)>>BUFFERED_FILE_CHUNK_SHIFT;

    if (len == 0)

         return 0;

    /* Copy anything that fits into the next chunk. */

    if (start < num_chunks<<BUFFERED_FILE_CHUNK_SHIFT) {

        size_t max = (num_chunks<<BUFFERED_FILE_CHUNK_SHIFT) - start;

        if (max > len)

            max = len;

        memcpy(&bf->index[start>>BUFFERED_FILE_CHUNK_SHIFT][start & (BUFFERED_FILE_CHUNK_SIZE-1)],

               data, max);

        bf->len += max;

        data += max;

        start += max;

        len -= (unsigned int)max;

        if (len == 0)

             return 0;

    }

    /* Do we need to extend the chunk index? */

    chunk_max = bf->index_max<<BUFFERED_FILE_CHUNK_SHIFT;

    if (newlen > chunk_max) {

        byte **new_index;

        if (chunk_max < 32*BUFFERED_FILE_CHUNK_SIZE)

            chunk_max = 32*BUFFERED_FILE_CHUNK_SIZE;

        while (newlen > chunk_max)

            chunk_max *= 2;

        chunk_max >>= BUFFERED_FILE_CHUNK_SHIFT;

        if (bf->index == NULL) {

            new_index = (byte **)gs_alloc_bytes(bf->memory,

                                                (size_t)sizeof(byte *) * chunk_max,

                                                "buffered_file_index");

        } else {

            new_index = (byte **)gs_resize_object(bf->memory,

                                                  bf->index,

                                                  (size_t)sizeof(byte *) * chunk_max,

                                                  "buffered_file_index");

        }

        if (new_index == NULL)

            return_error(gs_error_VMerror);

        bf->index = new_index;

        bf->index_max = chunk_max;

    }

    /* Now allocate chunks and copy in the data. */

    do {

        unsigned int max;

        byte *chunk = gs_alloc_bytes(bf->memory,

                                     BUFFERED_FILE_CHUNK_SIZE,

                                     "buffered_file_chunk");

        if (chunk == NULL)

            return_error(gs_error_VMerror);

        bf->index[start>>BUFFERED_FILE_CHUNK_SHIFT] = chunk;

        max = len;

        if (max > BUFFERED_FILE_CHUNK_SIZE)

            max = BUFFERED_FILE_CHUNK_SIZE;

        memcpy(chunk, data, max);

        data += max;

        bf->len = (start += max);

        len -= max;

    } while (len);

    return 0;

}

static int

start_need_file(pl_main_instance_t *minst, const char *data, unsigned int len)

{

    buffered_file *bf = (buffered_file *)gs_alloc_bytes(minst->memory->non_gc_memory,

                                                        sizeof(*bf), "buffered_file");

    if (bf == NULL)

        return_error(gs_error_VMerror);

    memset(bf, 0, sizeof(*bf));

    bf->memory = minst->memory->non_gc_memory;

    minst->buffering_runstring_as_file = bf;

    return buffer_data(minst, data, len);

}

static void

drop_buffered_file(buffered_file *bf)

{

    size_t i;

    if (bf == NULL)

        return;

    for (i = (bf->len+BUFFERED_FILE_CHUNK_SIZE-1)>>BUFFERED_FILE_CHUNK_SHIFT; i > 0; i--)

    {

        gs_free_object(bf->memory, bf->index[i-1], "buffered_file_chunk");

    }

    gs_free_object(bf->memory, bf->index, "buffered_file_index");

    gs_free_object(bf->memory, bf, "buffered_file_index");

}

typedef struct

{

   gp_file base;

   buffered_file *bf;

   gs_offset_t pos;

} gp_file_buffered;

static int

buffered_file_getc(gp_file *gp_)

{

    gp_file_buffered *gp = (gp_file_buffered *)gp_;

    gs_offset_t pos = gp->pos;

    if (pos >= gp->bf->len)

        return -1;

    gp->pos++;

    return (int)gp->bf->index[pos>>BUFFERED_FILE_CHUNK_SHIFT][pos & ((1<<BUFFERED_FILE_CHUNK_SHIFT)-1)];

}

static int

buffered_file_read(gp_file *gp_, size_t size, unsigned int count, void *buf)

{

    gp_file_buffered *gp = (gp_file_buffered *)gp_;

    gs_offset_t pos = gp->pos;

    gs_offset_t end;

    gs_offset_t n = 0;

    size_t bytes;

    bytes = size * count;

    end = pos + bytes;

    if (end > gp->bf->len)

        end = gp->bf->len;

    if (end <= pos)

        return 0;

    if (bytes > end - pos)

        bytes = end - pos;

    while (bytes > 0) {

        gs_offset_t off = pos & (BUFFERED_FILE_CHUNK_SIZE-1);

        gs_offset_t left = BUFFERED_FILE_CHUNK_SIZE - off;

        if (left > bytes)

            left = bytes;

        memcpy(buf, &gp->bf->index[pos>>BUFFERED_FILE_CHUNK_SHIFT][off],

               left);

        bytes -= left;

        n += left;

    }

    gp->pos += n;

    return n/size;

}

static int

buffered_file_seek(gp_file *gp_, gs_offset_t offset, int whence)

{

    gp_file_buffered *gp = (gp_file_buffered *)gp_;

    gs_offset_t pos;

    if (whence == SEEK_END)

        pos = gp->bf->len + offset;

    else if (whence == SEEK_CUR)

        pos = gp->pos + offset;

    else

        pos = offset;

    if (pos < 0)

        pos = 0;

    else if (pos > gp->bf->len)

        pos = gp->bf->len;

    gp->pos = pos;

    return 0;

}

static gs_offset_t

buffered_file_tell(gp_file *gp_)

{

    gp_file_buffered *gp = (gp_file_buffered *)gp_;

    return gp->pos;

}

static int

buffered_file_eof(gp_file *gp_)

{

    gp_file_buffered *gp = (gp_file_buffered *)gp_;

    return gp->pos == gp->bf->len;

}

static int

buffered_file_seekable(gp_file *gp)

{

    return 1;

}

static gp_file_ops_t buffered_file_ops = {

    NULL, /* close */

    buffered_file_getc,

    NULL, /* putc */

    buffered_file_read,

    NULL, /* write */

    buffered_file_seek,

    buffered_file_tell,

    buffered_file_eof,

    NULL, /* dup */

    buffered_file_seekable,

    NULL, /* pread */

    NULL, /* pwrite */

    NULL, /* is_char_buffered */

    NULL, /* fflush */

    NULL, /* ferror */

    NULL, /* get_file */

    NULL, /* clearerr */

    NULL /* reopen */

};

static int

buffered_file_fs_open_file(const gs_memory_t *mem,

                           void *secret,

                     const char *fname,

                     const char *mode,

                           gp_file **file)

{

    gp_file_buffered *gp;

    if (strcmp(fname, "gpdl_buffered_file:"))

        return 0;

    if (mode[0] != 'r')

        return_error(gs_error_invalidaccess);

    gp = (gp_file_buffered *)gp_file_alloc(mem, &buffered_file_ops,

                                           sizeof(*gp), "gp_file_buffered");

    if (gp == NULL)

        return_error(gs_error_VMerror); /* Allocation failed */

    /* Setup the crypt-specific state */

    gp->bf = (buffered_file *)secret;

    /* Return the new instance */

    *file = &gp->base;

    return 0;

}

static gsapi_fs_t buffered_file_fs = {

    buffered_file_fs_open_file,

    NULL,

    NULL,

    NULL,

    NULL

};

static int

do_run_string_continue(pl_main_instance_t *minst, const char *str, unsigned int length)

{

    stream_cursor_read cursor;

    int code;

    pl_interp_implementation_t *pjli = minst->implementations[0];

    const byte *initial_pos;

    int unread;

    if (minst->buffering_runstring_as_file)

        return buffer_data(minst, str, length);

    /* First off, get all our data into a single buffer (both anything

     * buffered from previous calls, and anything we have now). */

    if (minst->buf_fill > 0) {

        /* Ensure we have a buffer large enough. */

        code = ensure_buf_size(minst, length + minst->buf_fill);

        if (code < 0)

            return code;

        memcpy(&minst->buf_ptr[minst->buf_fill], str, length);

        minst->buf_fill += length;

        stream_cursor_read_init(&cursor, (const byte *)minst->buf_ptr, length);

    } else {

        /* Use the callers buffer directly. */

        stream_cursor_read_init(&cursor, (const byte *)str, length);

    }

    /* Now process that buffer. The outside loop here is used as we

     * try different languages. */

    do {

        /* Remember where we started this attempt so we can spot us

         * failing to make progress. */

        initial_pos = cursor.ptr;

        if (minst->detect_runstring_language) {

            pl_interp_implementation_t *desired_implementation;

            minst->detect_runstring_language = 0;

            desired_implementation = pl_select_implementation(pjli,

                                                              minst,

                                                (const char *)cursor.ptr+1,

                                                         (int)length);

            /* Possibly this never happens? But attempt to cope anyway. */

            if (desired_implementation == NULL) {

                code = -1;

                break;

            }

            if (gs_debug_c('I') || gs_debug_c(':'))

                dmlprintf1(minst->memory, "PDL detected as %s\n",

                           pl_characteristics(desired_implementation)->language);

            /* If the language implementation needs changing, change it. */

            if (desired_implementation != pjli) {

                code = pl_init_job(desired_implementation, minst->device);

                minst->curr_implementation = desired_implementation;

                if (code < 0)

                    return code;

            }

            code = pl_process_begin(minst->curr_implementation);

            if (code < 0)

                return code;

        }

        code = pl_process(minst->curr_implementation, &cursor);

        if (code == gs_error_NeedFile) {

            code = start_need_file(minst, (const char *)cursor.ptr + 1, cursor.limit - cursor.ptr);

            cursor.ptr = cursor.limit;

            break;

        }

        if (code == gs_error_NeedInput) {

            code = 0;

            break;

        }

        if (code == 0 && cursor.ptr != cursor.limit) {

            code = gs_error_InterpreterExit;

        }

        if (code == gs_error_InterpreterExit) {

            if (minst->curr_implementation == pjli) {

                /* We might have just hit a ENTER LANGUAGE. */

                /* Ideally, we should look at what language ENTER LANGUAGE

                 * said to use, and then swap to that. That means looking up

                 * a variable in the pjl interpreter, and we don't have the

                 * means to do that at the moment. For now let's assume it

                 * says "auto" and let's process it based on that. */

                minst->detect_runstring_language = 1;

            } else {

                /* The interpreter itself has hit UEL. Automatically guess

                 * what comes next. Probably back to PJL. */

                minst->detect_runstring_language = 1;

                if (minst->revert_to_pjl_after_runstring) {

                    code = revert_to_pjli(minst);

                    if (code < 0)

                        break;

                }

            }

            code = 0;

        }

        /* If we have data left, and we made progress last time,

         * head back to the top to try again with the remaining

         * data in the buffer. */

    } while (code >= 0 && cursor.ptr != initial_pos);

    /* Now, deal with any unread data. */

    unread = (int)(cursor.limit - cursor.ptr);

    if (unread) {

        /* We used count bytes, but still have unread bytes left. */

        if (minst->buf_fill > 0) {

            /* Move the remaining data down our buffer. */

            int count = (int)(cursor.ptr + 1 - minst->buf_ptr);

            memmove(&minst->buf_ptr[0], &minst->buf_ptr[count],

                    unread);

        } else {

            /* Store the remaining data in the buffer. */

            int count = (int)(cursor.ptr + 1 - (const byte *)str);

            int code2 = ensure_buf_size(minst, unread);

            if (code2 < 0)

                return code < 0 ? code : code2;

            memcpy(&minst->buf_ptr[0], str + count, unread);

        }

    }

    minst->buf_fill = (int)unread;

    return code;

}

int

pl_main_run_string_continue(pl_main_instance_t *minst, const char *str, unsigned int length)

{

    int code;

    code = do_run_string_continue(minst, str, length);

    if (code < 0)

        minst->mid_runstring = 0;

    return code;

}

static int

pl_main_run_file_utf8(pl_main_instance_t *minst, const char *prefix_commands, const char *filename)

{

    bool new_job = true;

    pl_interp_implementation_t *pjli =

        minst->implementations[0];

    gs_memory_t *mem = minst->memory;

    stream *s;

    int code = 0;

    bool is_stdin = filename[0] == '-' && filename[1] == 0;

    bool use_process_file = false;

    bool first_job = true;

    pl_interp_implementation_t *desired_implementation = NULL;

    if (is_stdin) {

        code = gs_get_callout_stdin(&s, mem);

        if (code < 0)

            return code;

    } else {

        s = sfopen(filename, "r", mem);

    }

    if (s == NULL)

        return gs_error_undefinedfilename;

    /* This function can run in 2 modes. Either it can run a file directly

     * using the run_file mechanism, or it can feed the data piecemeal

     * using the run_string mechanism. Which one depends on several things:

     *

     * If we're being piped data, then we have to use run_string.

     * If we are entered (as is usually the case) with PJL as the selected

     * interpreter, then we do a quick assessment of the file contents to

     * pick an interpreter. If the first interpreter has a run_file method

     * then we'll use that.

     *

     * This means that files that start with PJL data will always be run

     * using run_string.

     */

    for (;;) {

        if_debug1m('I', mem, "[i][file pos=%ld]\n",

                   sftell(s));

        /* Check for EOF and prepare the next block of data. */

        if (s->cursor.r.ptr == s->cursor.r.limit && sfeof(s)) {

            if_debug0m('I', mem, "End of of data\n");

            if (pl_process_end(minst->curr_implementation) < 0)

                 goto error_fatal;

            pl_process_eof(minst->curr_implementation);

            if (revert_to_pjli(minst) < 0)

                goto error_fatal_reverted;

            break;

        }

        code = s_process_read_buf(s);

        if (code < 0)

            break;

        if (s->end_status == ERRC)

            break;

        if (new_job) {

            /* The only time the current implementation won't be PJL,

             * is if someone has preselected a particular language

             * before calling this function. */

            if (minst->curr_implementation == pjli) {

                /* Autodetect the language based on the content. */

                desired_implementation = pl_select_implementation(

                                                    pjli,

                                                    minst,

                                      (const char *)s->cursor.r.ptr+1,

                                               (int)(s->cursor.r.limit -

                                                     s->cursor.r.ptr));

                /* Possibly this never happens? But attempt to cope anyway. */

                if (desired_implementation == NULL)

                    goto flush_to_end_of_job;

                if (gs_debug_c('I') || gs_debug_c(':'))

                    dmlprintf1(mem, "PDL detected as %s\n",

                               pl_characteristics(desired_implementation)->language);

                /* If the language implementation needs changing, change it. */

                if (desired_implementation != pjli) {

                    /* If we are being asked to swap to a language implementation

                     * that is different to the last (non-PJL) implementation that

                     * we were using, we may want to clear soft-fonts. */

                    if (minst->prev_non_pjl_implementation &&

                        minst->reset_resources == PL_RESET_RESOURCES_ON_LANGUAGE_CHANGE &&

                        desired_implementation != minst->prev_non_pjl_implementation) {

                        if_debug1m('I', mem, "Resetting resources (%s)\n",

                                   pl_characteristics(minst->curr_implementation)->language);

                        code = pl_reset(minst->prev_non_pjl_implementation, PL_RESET_RESOURCES);

                        if (code < 0)

                            goto error_fatal;

                    }

                    code = pl_dnit_job(pjli);

                    minst->curr_implementation = NULL;

                    if (code >= 0)

                        code = pl_init_job(desired_implementation, minst->device);

                    minst->curr_implementation = desired_implementation;

                    minst->prev_non_pjl_implementation = desired_implementation;

                    if (code < 0)

                        goto error_fatal;

                }