/* Copyright (C) 2001-2021 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.,  1305 Grant Avenue - Suite 200, Novato,

   CA 94945, U.S.A., +1(415)492-9861, for further information.

*/

/* Common support for interpreter front ends */

#include "malloc_.h"

#include "memory_.h"

#include "string_.h"

#include "ghost.h"

#include "gp.h"

#include "gscdefs.h"            /* for gs_init_file */

#include "gslib.h"

#include "gsmatrix.h"           /* for gxdevice.h */

#include "gsutil.h"             /* for bytes_compare */

#include "gspaint.h"    /* for gs_erasepage */

#include "gxdevice.h"

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

#include "gxclpage.h"

#include "gdevprn.h"

#include "gxalloc.h"

#include "gxiodev.h"            /* for iodev struct */

#include "gzstate.h"

#include "ierrors.h"

#include "oper.h"

#include "iconf.h"              /* for gs_init_* imports */

#include "idebug.h"

#include "iddict.h"

#include "iname.h"              /* for name_init */

#include "dstack.h"

#include "estack.h"

#include "ostack.h"             /* put here for files.h */

#include "stream.h"             /* for files.h */

#include "files.h"

#include "ialloc.h"

#include "iinit.h"

#include "strimpl.h"            /* for sfilter.h */

#include "sfilter.h"            /* for iscan.h */

#include "iscan.h"

#include "main.h"

#include "store.h"

#include "isave.h"              /* for prototypes */

#include "interp.h"

#include "ivmspace.h"

#include "idisp.h"              /* for setting display device callback */

#include "iplugin.h"

#include "zfile.h"

#include "valgrind.h"

/* ------ Exported data ------ */

/** using backpointers retrieve minst from any memory pointer

 *

 */

gs_main_instance*

get_minst_from_memory(const gs_memory_t *mem)

{

    return (gs_main_instance*)mem->gs_lib_ctx->top_of_system;

}

/** construct main instance caller needs to retain */

gs_main_instance *

gs_main_alloc_instance(gs_memory_t *mem)

{

    gs_main_instance *minst;

    if (mem == NULL)

        return NULL;

    minst = (gs_main_instance *)gs_alloc_bytes_immovable(mem,

                                                         sizeof(gs_main_instance),

                                                         "init_main_instance");

    if (minst == NULL)

        return NULL;

    memset(minst, 0, sizeof(gs_main_instance));

    memcpy(minst, &gs_main_instance_init_values, sizeof(gs_main_instance_init_values));

    minst->heap = mem;

    mem->gs_lib_ctx->top_of_system = minst;

    return minst;

}

op_array_table *

get_op_array(const gs_memory_t *mem, int size)

{

    gs_main_instance *minst = get_minst_from_memory(mem);

    return op_index_op_array_table(minst->i_ctx_p,size);

}

op_array_table *

get_global_op_array(const gs_memory_t *mem)

{

    gs_main_instance *minst = get_minst_from_memory(mem);

    return &minst->i_ctx_p->op_array_table_global;

}

op_array_table *

get_local_op_array(const gs_memory_t *mem)

{

    gs_main_instance *minst = get_minst_from_memory(mem);

    return &minst->i_ctx_p->op_array_table_local;

}

/* ------ Forward references ------ */

static int gs_run_init_file(gs_main_instance *, int *, ref *);

void print_resource_usage(const gs_main_instance *,

                                  gs_dual_memory_t *, const char *);

/* ------ Initialization ------ */

/* Initialization to be done before anything else. */

int

gs_main_init0(gs_main_instance * minst, gp_file * in, gp_file * out, gp_file * err,

              int max_lib_paths)

{

    ref *array;

    int code = 0;

    if (gs_debug_c(gs_debug_flag_init_details))

        dmprintf1(minst->heap, "%% Init phase 0 started, instance "PRI_INTPTR"\n",

                  (intptr_t)minst);

    /* Do platform-dependent initialization. */

    /* We have to do this as the very first thing, */

    /* because it detects attempts to run 80N86 executables (N>0) */

    /* on incompatible processors. */

    gp_init();

    /* Initialize the imager. */

    /* Reset debugging flags */

#ifdef PACIFY_VALGRIND

    VALGRIND_HG_DISABLE_CHECKING(gs_debug, 128);

#endif

    memset(gs_debug, 0, 128);

    gs_log_errors = 0;  /* gs_debug['#'] = 0 */

    gp_get_realtime(minst->base_time);

    /* Initialize the file search paths. */

    array = (ref *) gs_alloc_byte_array(minst->heap, max_lib_paths, sizeof(ref),

                                        "lib_path array");

    if (array == 0) {

        gs_lib_finit(1, gs_error_VMerror, minst->heap);

        code = gs_note_error(gs_error_VMerror);

        goto fail;

    }

    make_array(&minst->lib_path.container, avm_foreign, max_lib_paths,

               array);

    make_array(&minst->lib_path.list, avm_foreign | a_readonly, 0,

               minst->lib_path.container.value.refs);

    minst->lib_path.env = NULL;

    minst->lib_path.final = NULL;

    minst->lib_path.count = 0;

    minst->lib_path.first_is_current = 0;

    minst->user_errors = 1;

    minst->init_done = 0;

fail:

    if (gs_debug_c(gs_debug_flag_init_details))

        dmprintf2(minst->heap, "%% Init phase 0 %s, instance "PRI_INTPTR"\n",

                  code < 0 ? "failed" : "done", (intptr_t)minst);

    return code;

}

/* Initialization to be done before constructing any objects. */

int

gs_main_init1(gs_main_instance * minst)

{

    gs_dual_memory_t idmem;

    name_table *nt = NULL;

    int code;

    if (minst->init_done >= 1)

        return 0;

    if (gs_debug_c(gs_debug_flag_init_details))

        dmprintf1(minst->heap, "%% Init phase 1 started, instance "PRI_INTPTR"\n",

                  (intptr_t)minst);

    code = ialloc_init(&idmem, minst->heap,

                       minst->memory_clump_size, gs_have_level2());

    if (code < 0)

        goto fail_early;

    code = gs_lib_init1((gs_memory_t *)idmem.space_system);

    if (code < 0)

        goto fail;

    alloc_save_init(&idmem);

    {

        gs_memory_t *mem = (gs_memory_t *)idmem.space_system;

        nt = names_init(minst->name_table_size, idmem.space_system);

        if (nt == 0) {

            code = gs_note_error(gs_error_VMerror);

            goto fail;

        }

        mem->gs_lib_ctx->gs_name_table = nt;

        code = gs_register_struct_root(mem, &mem->gs_lib_ctx->name_table_root,

                                       (void **)&mem->gs_lib_ctx->gs_name_table,

                                       "the_gs_name_table");

        if (code < 0)

            goto fail;

        mem->gs_lib_ctx->client_check_file_permission = z_check_file_permissions;

    }

    code = obj_init(&minst->i_ctx_p, &idmem);  /* requires name_init */

    if (code < 0)

        goto fail;

    minst->init_done = 1;

    code = i_plugin_init(minst->i_ctx_p);

    if (code < 0)

        goto fail;

    code = i_iodev_init(&idmem);

    if (code < 0) {

fail:

        names_free(nt);

        if (minst->i_ctx_p == NULL)

            ialloc_finit(&idmem);

    }

fail_early:

    if (gs_debug_c(gs_debug_flag_init_details))

        dmprintf2(minst->heap, "%% Init phase 1 %s, instance "PRI_INTPTR"\n",

                  code < 0 ? "failed" : "done", (intptr_t)minst);

    return code;

}

/*

 * Invoke the interpreter. This layer doesn't do much (previously stdio

 * callouts were handled here instead of in the stream processing.

 */

static int

gs_main_interpret(gs_main_instance *minst, ref * pref, int user_errors,

                  int *pexit_code, ref * perror_object)

{

    int code;

    /* set interpreter pointer to lib_path */

    minst->i_ctx_p->lib_path = &minst->lib_path;

    code = gs_interpret(&minst->i_ctx_p, pref,

                        user_errors, pexit_code, perror_object);

    return code;

}

/* gcc wants prototypes for all external functions. */

int gs_main_init2aux(gs_main_instance * minst);

static const op_array_table empty_table = { { { 0 } } };

/* This is an external function to work around      */

/* a bug in gcc 4.5.1 optimizer. See bug 692684.    */

int gs_main_init2aux(gs_main_instance * minst) {

    i_ctx_t * i_ctx_p = minst->i_ctx_p;

    if (minst->init_done < 2) {

        int code, exit_code;

        ref error_object, ifa;

        /* Set up enough so that we can safely be garbage collected */

        i_ctx_p->op_array_table_global = empty_table;

        i_ctx_p->op_array_table_local = empty_table;

        code = zop_init(i_ctx_p);

        if (code < 0)

            return code;

        code = op_init(i_ctx_p);        /* requires obj_init */

        if (code < 0)

            return code;

        /* Set up the array of additional initialization files. */

        make_const_string(&ifa, a_readonly | avm_foreign, gs_init_files_sizeof - 2, gs_init_files);

        code = i_initial_enter_name(i_ctx_p, "INITFILES", &ifa);

        if (code < 0)

            return code;

        /* Set up the array of emulator names. */

        make_const_string(&ifa, a_readonly | avm_foreign, gs_emulators_sizeof - 2, gs_emulators);

        code = i_initial_enter_name(i_ctx_p, "EMULATORS", &ifa);

        if (code < 0)

            return code;

        /* Pass the search path. */

        code = i_initial_enter_name(i_ctx_p, "LIBPATH", &minst->lib_path.list);

        if (code < 0)

            return code;

        /* Execute the standard initialization file. */

        code = gs_run_init_file(minst, &exit_code, &error_object);

        if (code < 0)

            return code;

        minst->init_done = 2;

        /* NB this is to be done with device parameters

         * both minst->display and  display_set_callback() are going away

        */

        if ((code = reopen_device_if_required(minst)) < 0)

            return code;

        if ((code = gs_main_run_string(minst,

                "JOBSERVER "

                " { false 0 .startnewjob } "

                " { NOOUTERSAVE not { save pop } if } "

                "ifelse", 0, &exit_code,

                &error_object)) < 0)

           return code;

    }

    return 0;

}

int

gs_main_set_language_param(gs_main_instance *minst,

                           gs_param_list    *plist)

{

    ref value;

    int code = 0;

    i_ctx_t *i_ctx_p = minst->i_ctx_p;

    uint space = icurrent_space;

    gs_param_enumerator_t enumerator;

    gs_param_key_t key;

    gs_lib_ctx_t *ctx = minst->heap->gs_lib_ctx;

    ref error_object;

    /* If we're up and running as a jobserver, exit encapsulation. */

    if (minst->init_done > 1) {

        code = gs_main_run_string(minst,

                                  "JOBSERVER {true 0 startjob pop} if",

                                  0, &code, &error_object);

        if (code < 0) return code;

    }

    ialloc_set_space(idmemory, avm_system);

    param_init_enumerator(&enumerator);

    while ((code = param_get_next_key(plist, &enumerator, &key)) == 0) {

        char string_key[256]; /* big enough for any reasonable key */

        gs_param_typed_value pvalue;

        if (key.size > sizeof(string_key) - 1) {

            code = gs_note_error(gs_error_rangecheck);

            break;

        }

        memcpy(string_key, key.data, key.size);

        string_key[key.size] = 0;

        if ((code = param_read_typed(plist, string_key, &pvalue)) != 0) {

            code = (code > 0 ? gs_note_error(gs_error_unknownerror) : code);

            break;

        }

        switch (pvalue.type) {

        case gs_param_type_null:

            make_null(&value);

            break;

        case gs_param_type_bool:

            if (pvalue.value.b)

                make_true(&value);

            else

                make_false(&value);

            break;

        case gs_param_type_int:

            make_int(&value, (ps_int)pvalue.value.i);

            break;

        case gs_param_type_i64:

            make_int(&value, (ps_int)pvalue.value.i64);

            break;

        case gs_param_type_long:

            make_int(&value, (ps_int)pvalue.value.l);

            break;

        case gs_param_type_size_t:

            make_int(&value, (ps_int)pvalue.value.z);

            break;

        case gs_param_type_float:

            make_real(&value, pvalue.value.f);

            break;

        case gs_param_type_dict:

            /* We don't support dicts for now */

            continue;

        case gs_param_type_dict_int_keys:

            /* We don't support dicts with int keys for now */

            continue;

        case gs_param_type_array:

            /* We don't support arrays for now */

            continue;

        case gs_param_type_string:

            if (pvalue.value.s.data == NULL || pvalue.value.s.size == 0)

                make_empty_string(&value, a_readonly);

            else {

                size_t len = pvalue.value.s.size;

                byte *body = ialloc_string(len, "-s");

                if (body == NULL)

                    return gs_error_Fatal;

                memcpy(body, pvalue.value.s.data, len);

                make_const_string(&value, a_readonly | avm_system, len, body);

            }

            break;

        case gs_param_type_name:

            code = name_ref(ctx->memory, pvalue.value.n.data, pvalue.value.n.size, &value, 1);

            break;

        case gs_param_type_int_array:

            /* We don't support arrays for now */

            continue;

        case gs_param_type_float_array:

            /* We don't support arrays for now */

            continue;

        case gs_param_type_string_array:

            /* We don't support arrays for now */

            continue;

        default:

            continue;

        }

        if (code < 0)

            break;

        ialloc_set_space(idmemory, space);

        /* Enter the name in systemdict. */

        i_initial_enter_name_copy(minst->i_ctx_p, string_key, &value);

    }

    if (minst->init_done > 1) {

        int code2 = 0;

        code2 = gs_main_run_string(minst,

                                   "JOBSERVER {false 0 startjob pop} if",

                                   0, &code2, &error_object);

        if (code >= 0)

            code = code2;

    }

    return code;

}

static int

gs_main_push_params(gs_main_instance *minst)

{

    int code;

    gs_c_param_list *plist;

    plist = minst->param_list;

    if (!plist)

        return 0;

    code = gs_putdeviceparams(minst->i_ctx_p->pgs->device,

                              (gs_param_list *)plist);

    if (code < 0)

        return code;

    code = gs_main_set_language_param(minst, (gs_param_list *)plist);

    if (code < 0)

        return code;

    gs_c_param_list_release(plist);

    return code;

}

int

gs_main_init2(gs_main_instance * minst)

{

    i_ctx_t *i_ctx_p;

    int code = gs_main_init1(minst);

    if (code < 0)

        return code;

    code = gs_main_push_params(minst);

    if (code < 0)

        return code;

    if (minst->init_done >= 2)

        return 0;

    if (gs_debug_c(gs_debug_flag_init_details))

        dmprintf1(minst->heap, "%% Init phase 2 started, instance "PRI_INTPTR"\n",

                  (intptr_t)minst);

    code = gs_main_init2aux(minst);

    if (code < 0)

       goto fail;

    i_ctx_p = minst->i_ctx_p; /* reopen_device_if_display or run_string may change it */

    /* Now process the initial saved-pages=... argument, if any as well as saved-pages-test */

    {

       gx_device *pdev = gs_currentdevice(minst->i_ctx_p->pgs); /* get the current device */

       gx_device_printer *ppdev = (gx_device_printer *)pdev;

        if (minst->saved_pages_test_mode) {

            if ((dev_proc(pdev, dev_spec_op)(pdev, gxdso_supports_saved_pages, NULL, 0) <= 0)) {

                /* no warning or error if saved-pages-test mode is used, just disable it */

                minst->saved_pages_test_mode = false;  /* device doesn't support it */

            } else {

                if ((code = gx_saved_pages_param_process(ppdev, (byte *)"begin", 5)) < 0)

                    goto fail;

                if (code > 0)

                    if ((code = gs_erasepage(minst->i_ctx_p->pgs)) < 0)

                        goto fail;

            }

        } else if (minst->saved_pages_initial_arg != NULL) {

            if (dev_proc(pdev, dev_spec_op)(pdev, gxdso_supports_saved_pages, NULL, 0) <= 0) {

                while (pdev->child)

                    pdev = pdev->child;   /* so we get the real device name */

                outprintf(minst->heap,

                          "   --saved-pages not supported by the '%s' device.\n",

                          pdev->dname);

                code = gs_error_Fatal;

                goto fail;

            }

            code = gx_saved_pages_param_process(ppdev, (byte *)minst->saved_pages_initial_arg,

                                                strlen(minst->saved_pages_initial_arg));

            if (code > 0)

                if ((code = gs_erasepage(minst->i_ctx_p->pgs)) < 0)

                    goto fail;

        }

    }

    if (code >= 0) {

        if (gs_debug_c(':'))

            print_resource_usage(minst, &gs_imemory, "Start");

        gp_readline_init(&minst->readline_data, minst->heap); /* lgtm [cpp/useless-expression] */

    }

fail:

    if (gs_debug_c(gs_debug_flag_init_details))

        dmprintf2(minst->heap, "%% Init phase 2 %s, instance "PRI_INTPTR"\n",

                  code < 0 ? "failed" : "done", (intptr_t)minst);

    return code;

}

/* ------ Search paths ------ */

#define LIB_PATH_EXTEND 5

/* If the existing array is full, extend it */

static int

extend_path_list_container (gs_main_instance * minst, gs_file_path * pfp)

{

    uint len = r_size(&minst->lib_path.container);

    ref *paths, *opaths = minst->lib_path.container.value.refs;

    /* Add 5 entries at a time to reduce VM thrashing */

    paths = (ref *) gs_alloc_byte_array(minst->heap, len + LIB_PATH_EXTEND, sizeof(ref),

                                        "extend_path_list_container array");

    if (paths == 0) {

        return_error(gs_error_VMerror);

    }

    make_array(&minst->lib_path.container, avm_foreign, len + LIB_PATH_EXTEND, paths);

    make_array(&minst->lib_path.list, avm_foreign | a_readonly, 0,

               minst->lib_path.container.value.refs);

    memcpy(paths, opaths, len * sizeof(ref));

    r_set_size(&minst->lib_path.list, len);

    gs_free_object (minst->heap, opaths, "extend_path_list_container");

    return(0);

}

static int

lib_path_insert_copy_of_string(gs_main_instance *minst, int pos, size_t strlen, const char *str)

{

    ref *paths;

    int listlen = r_size(&minst->lib_path.list); /* The real number of entries currently in the list */

    byte *newstr;

    int code;

    /* Extend the container if required */

    if (listlen == r_size(&minst->lib_path.container)) {

        code = extend_path_list_container(minst, &minst->lib_path);

        if (code < 0) {

            emprintf(minst->heap, "\nAdding path to search paths failed.\n");

            return(code);

        }

    }

    /* Copy the string */

    newstr = gs_alloc_string(minst->heap, strlen, "lib_path_add");

    if (newstr == NULL)

        return gs_error_VMerror;

    memcpy(newstr, str, strlen);

    /* Shuffle up the entries */

    paths = &minst->lib_path.container.value.refs[pos];

    if (pos != listlen)

        memmove(paths + 1, paths, (listlen-pos) * sizeof(*paths));

    /* And insert the new string, converted to a PS thing */

    make_const_string(paths, avm_foreign | a_readonly,

                      strlen,

                      newstr);

    /* Update the list length */

    r_set_size(&minst->lib_path.list, listlen+1);

    return 0;

}

/* Internal routine to add a set of directories to a search list. */

/* Returns 0 or an error code. */

static int

lib_path_add(gs_main_instance * minst, const char *dirs)

{

    gs_file_path * pfp = &minst->lib_path;

    uint len = r_size(&pfp->list);

    const char *dpath = dirs;

    int code;

    if (dirs == 0)

        return 0;

    for (;;) {                  /* Find the end of the next directory name. */

        const char *npath = dpath;

        while (*npath != 0 && *npath != gp_file_name_list_separator)

            npath++;

        if (npath > dpath) {

            code = gs_add_control_path_len(minst->heap, gs_permit_file_reading, dpath, npath - dpath);

            if (code < 0) return code;

            code = lib_path_insert_copy_of_string(minst, len, npath - dpath, dpath);

            if (code < 0)

                return code;

            len++;

            /* Update length/count so we don't lose entries if a later

             * iteration fails. */

            r_set_size(&pfp->list, len);

        }

        if (!*npath)

            break;

        dpath = npath + 1;

    }

    return 0;

}

static void

set_lib_path_length(gs_main_instance * minst, int newsize)

{

    gs_file_path * pfp = &minst->lib_path;

    uint len = r_size(&pfp->list); /* Yes, list, not container */

    uint i;

    /* Free any entries that are discarded by us shortening the list */

    for (i = newsize; i < len; i++)

        gs_free_object(minst->heap, pfp->container.value.refs[i].value.bytes, "lib_path entry");

    r_set_size(&pfp->list, newsize);

}

/* Add a library search path to the list. */

int

gs_main_add_lib_path(gs_main_instance * minst, const char *lpath)

{

    gs_file_path * pfp = &minst->lib_path;

    int code;

    /* Throw away all the elements after the user ones. */

    set_lib_path_length(minst, pfp->count + pfp->first_is_current);

    /* Now add the new one */

    code = lib_path_add(minst, lpath);

    if (code < 0)

        return code;

    /* Update the count of user paths */

    pfp->count = r_size(&pfp->list) - pfp->first_is_current;

    /* Now add back in the others */

    return gs_main_set_lib_paths(minst);

}

/* ------ Execution ------ */

extern_gx_io_device_table();

/* Complete the list of library search paths. */

/* This may involve adding the %rom%Resource/Init and %rom%lib/ paths (for COMPILE_INITS) */

/* and adding or removing the current directory as the first element (for -P and -P-). */

int

gs_main_set_lib_paths(gs_main_instance * minst)

{

    int code = 0;

    int i, have_rom_device = 0;

    /* We are entered with a list potentially full of stuff already.

     * In general the list is of the form:

     *    <optionally, the current directory>

     *    <any -I specified directories, "count" of them>

     *    <any directories from the environment variable>

     *    <if there is a romfs, the romfs paths>

     *    <any directories from the 'final' variable>

     *

     * Unfortunately, the value read from the environment variable may not

     * have actually been read the first time this function is called, so

     * we can see the value change over time. Short of a complete rewrite

     * this requires us to clear the latter part of the list and repopulate

     * it each time we run through.

     */

    /* First step, ensure that we have the current directory as our

     * first entry, iff we need it. */

    if (minst->search_here_first && !minst->lib_path.first_is_current) {

        /* We should have a "gp_current_directory" at the start, and we haven't.

         * So insert one. */

        code = gs_add_control_path_len(minst->heap, gs_permit_file_reading,

                gp_current_directory_name, strlen(gp_current_directory_name));

        if (code < 0) return code;

        code = lib_path_insert_copy_of_string(minst, 0,

                                              strlen(gp_current_directory_name),

                                              gp_current_directory_name);

        if (code < 0)

            return code;

    } else if (!minst->search_here_first && minst->lib_path.first_is_current) {

        /* We have a "gp_current_directory" at the start, and we shouldn't have.

         * Remove it. */

        int listlen = r_size(&minst->lib_path.list); /* The real number of entries currently in the list */

        ref *paths = minst->lib_path.container.value.refs;

        gs_free_object(minst->heap, paths->value.bytes, "lib_path entry");

        --listlen;

        memmove(paths, paths + 1, listlen * sizeof(*paths));

        r_set_size(&minst->lib_path.list, listlen);

        code = gs_remove_control_path_len(minst->heap, gs_permit_file_reading,

                gp_current_directory_name, strlen(gp_current_directory_name));

        if (code < 0) return code;

    }

    minst->lib_path.first_is_current = minst->search_here_first;

    /* Now, the horrid bit. We throw away all the entries after the user entries */

    set_lib_path_length(minst, minst->lib_path.count + minst->lib_path.first_is_current);

    /* Now we (re)populate the end of the list. */

    if (minst->lib_path.env != 0) {

        code = lib_path_add(minst, minst->lib_path.env);

        if (code < 0) return code;

        code = gs_add_control_path(minst->heap, gs_permit_file_reading, minst->lib_path.env);

        if (code < 0) return code;

    }

    /* now put the %rom%lib/ device path before the gs_lib_default_path on the list */

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

        const gx_io_device *iodev = gx_io_device_table[i];

        const char *dname = iodev->dname;

        const char *fcheckname = "Resource/Init/gs_init.ps";

        if (dname && strlen(dname) == 5 && !memcmp("%rom%", dname, 5)) {

            struct stat pstat;

            /* gs_error_unregistered means no usable romfs is available */

            /* gpdl always includes a real romfs, but it may or may have the Postscript

               resources in it, so we explicitly check for a fairly vital file

             */

            int code = iodev->procs.file_status((gx_io_device *)iodev, fcheckname, &pstat);

            if (code != gs_error_unregistered && code != gs_error_undefinedfilename){

                have_rom_device = 1;

            }

            break;

        }

    }

    if (have_rom_device) {

        code = lib_path_add(minst, "%rom%Resource/Init/");

        if (code < 0)

            return code;

        code = lib_path_add(minst, "%rom%lib/");

    }

    else code = 0;

    if (minst->lib_path.final != NULL && code >= 0)

        code = lib_path_add(minst, minst->lib_path.final);

    return code;

}

/* Open a file, using the search paths. */

int

gs_main_lib_open(gs_main_instance * minst, const char *file_name, ref * pfile)

{

    /* This is a separate procedure only to avoid tying up */

    /* extra stack space while running the file. */

    i_ctx_t *i_ctx_p = minst->i_ctx_p;

#define maxfn 2048

    char fn[maxfn];

    uint len;

    return lib_file_open(&minst->lib_path, imemory,

                         NULL, /* Don't check permissions here, because permlist

                                  isn't ready running init files. */

                          file_name, strlen(file_name), fn, maxfn, &len, pfile);

}

/* Open and execute a file. */

int

gs_main_run_file(gs_main_instance * minst, const char *file_name, int user_errors, int *pexit_code, ref * perror_object)

{

    ref initial_file;

    int code = gs_main_run_file_open(minst, file_name, &initial_file);

    if (code < 0)

        return code;

    return gs_main_interpret(minst, &initial_file, user_errors,

                        pexit_code, perror_object);

}

int

gs_main_run_file_open(gs_main_instance * minst, const char *file_name, ref * pfref)

{

    gs_main_set_lib_paths(minst);

    if (gs_main_lib_open(minst, file_name, pfref) < 0) {

        emprintf1(minst->heap,

                  "Can't find initialization file %s.\n",

                  file_name);

        return_error(gs_error_Fatal);

    }

    r_set_attrs(pfref, a_execute + a_executable);

    return 0;

}

/* Open and run the very first initialization file. */

static int

gs_run_init_file(gs_main_instance * minst, int *pexit_code, ref * perror_object)

{

    i_ctx_t *i_ctx_p = minst->i_ctx_p;

    ref ifile;

    ref first_token;

    int code;

    scanner_state state;

    gs_main_set_lib_paths(minst);

    code = gs_main_run_file_open(minst, gs_init_file, &ifile);

    if (code < 0) {

        *pexit_code = 255;

        return code;

    }

    /* Check to make sure the first token is an integer */

    /* (for the version number check.) */

    gs_scanner_init(&state, &ifile);

    code = gs_scan_token(i_ctx_p, &first_token, &state);

    if (code != 0 || !r_has_type(&first_token, t_integer)) {

        emprintf1(minst->heap,

                  "Initialization file %s does not begin with an integer.\n",

                  gs_init_file);

        *pexit_code = 255;

        return_error(gs_error_Fatal);

    }

    *++osp = first_token;

    r_set_attrs(&ifile, a_executable);

    return gs_main_interpret(minst, &ifile, minst->user_errors,

                        pexit_code, perror_object);

}

/* Run a string. */

int

gs_main_run_string(gs_main_instance * minst, const char *str, int user_errors,

                   int *pexit_code, ref * perror_object)

{

    return gs_main_run_string_with_length(minst, str, (uint) strlen(str),

                                          user_errors,

                                          pexit_code, perror_object);

}

int

gs_main_run_string_with_length(gs_main_instance * minst, const char *str,

         uint length, int user_errors, int *pexit_code, ref * perror_object)

{

    int code;

    code = gs_main_run_string_begin(minst, user_errors,

                                    pexit_code, perror_object);

    if (code < 0)

        return code;

    code = gs_main_run_string_continue(minst, str, length, user_errors,

                                       pexit_code, perror_object);

    if (code != gs_error_NeedInput)

        return code;

    code = gs_main_run_string_end(minst, user_errors,

                                  pexit_code, perror_object);

    /* Not okay for user to use .needinput

     * This treats it as a fatal error.

     */

    if (code == gs_error_NeedInput)

        return_error(gs_error_Fatal);

    return code;

}

/* Set up for a suspendable run_string. */

int

gs_main_run_string_begin(gs_main_instance * minst, int user_errors,

                         int *pexit_code, ref * perror_object)

{

    const char *setup = ".runstringbegin";

    ref rstr;

    int code;

    gs_main_set_lib_paths(minst);

    make_const_string(&rstr, avm_foreign | a_readonly | a_executable,

                      strlen(setup), (const byte *)setup);

    code = gs_main_interpret(minst, &rstr, user_errors, pexit_code,

                             perror_object);

    return (code == gs_error_NeedInput ? 0 : code == 0 ? gs_error_Fatal : code);

}

/* Continue running a string with the option of suspending. */

int

gs_main_run_string_continue(gs_main_instance * minst, const char *str,

         uint length, int user_errors, int *pexit_code, ref * perror_object)

{

    ref rstr;

    if (length == 0)

        return 0;               /* empty string signals EOF */

    make_const_string(&rstr, avm_foreign | a_readonly, length,

                      (const byte *)str);

    return gs_main_interpret(minst, &rstr, user_errors, pexit_code,

                             perror_object);

}

uint

gs_main_get_uel_offset(gs_main_instance * minst)

{

    if (minst->i_ctx_p == NULL)

        return 0;

    return (uint)minst->i_ctx_p->uel_position;

}

/* Signal EOF when suspended. */

int

gs_main_run_string_end(gs_main_instance * minst, int user_errors,

                       int *pexit_code, ref * perror_object)

{

    ref rstr;

    make_empty_const_string(&rstr, avm_foreign | a_readonly);

    return gs_main_interpret(minst, &rstr, user_errors, pexit_code,

                             perror_object);

}

gs_memory_t *

gs_main_get_device_memory(gs_main_instance * minst)

{

  gs_memory_t *dev_mem = NULL;

  if (minst && minst->init_done >= 1) {

      i_ctx_t * i_ctx_p = minst->i_ctx_p;

      dev_mem = imemory_global->stable_memory;

  }

  return dev_mem;

}

int

gs_main_set_device(gs_main_instance * minst, gx_device *pdev)

{

    i_ctx_t *i_ctx_p = minst->i_ctx_p;

    ref error_object;

    int code;

    if (pdev == NULL) {

        /* Leave job encapsulation, restore the graphics state gsaved below (so back to the nullpage device)

           and re-enter job encapsulation.

           We rely on the end of job encapsulation restore to the put the gstate stack back how it was when

           we entered job encapsulation below, so the grestore will pickup the correct gstate.

         */

        code = gs_main_run_string(minst,

                                 "true 0 startjob pop grestore false 0 startjob pop",

                                 0, &code, &error_object);