home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / apps / dtp / ghost / gs301src / atari / gsmain.c < prev    next >
C/C++ Source or Header  |  1994-09-17  |  11KB  |  377 lines
  1. /* Copyright (C) 1989, 1992, 1993, 1994 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsmain.c */
  20. /* Common support for Ghostscript front ends */
  21. #include "memory_.h"
  22. #include "string_.h"
  23. #include "ghost.h"
  24. #include "gp.h"
  25. #include "gsmatrix.h"            /* for gxdevice.h */
  26. #include "gxdevice.h"
  27. #include "errors.h"
  28. #include "oper.h"
  29. #include "idict.h"
  30. #include "iname.h"            /* for name_init */
  31. #include "dstack.h"
  32. #include "estack.h"
  33. #include "ostack.h"            /* put here for files.h */
  34. #include "stream.h"            /* for files.h */
  35. #include "files.h"
  36. #include "ialloc.h"
  37. #include "strimpl.h"        /* for sfilter.h */
  38. #include "sfilter.h"        /* for iscan.h */
  39. #include "iscan.h"
  40. #include "main.h"
  41. #include "store.h"
  42. #include "isave.h"        /* for prototypes */
  43. #include "interp.h"
  44.  
  45. /* ------ Exported data ------ */
  46.  
  47. /* The only reason we export gs_exit_status is so that window systems */
  48. /* with alert boxes can know whether to pause before exiting if */
  49. /* Ghostscript terminates with an error.  There must be a better way .... */
  50. uint gs_memory_chunk_size = 20000;
  51. int gs_exit_status;
  52. int gs_user_errors;
  53.  
  54. /* File name search paths */
  55. const char **gs_lib_paths;
  56. private int gs_lib_count;
  57. char *gs_lib_env_path;
  58.  
  59. /* Define whether or not to look in the current directory first. */
  60. /* This is wrong by any reasonable criterion, but users insist on it. */
  61. #ifndef SEARCH_HERE_FIRST
  62. #  define SEARCH_HERE_FIRST 1
  63. #endif
  64.  
  65. /* ------ Imported data ------ */
  66.  
  67. /* Configuration information imported from gconfig.c. */
  68. extern gx_device *gx_device_list[];
  69. extern const char *gs_lib_default_path;
  70. extern const char *gs_init_file;
  71. extern ref gs_init_file_array[];
  72.  
  73. /* Imported from gsmisc.c */
  74. extern FILE *gs_debug_out;
  75.  
  76. /* Imported from gsmemory.c */
  77. void gs_malloc_init(P0());
  78. void gs_malloc_release(P0());
  79.  
  80. /* Imported operator procedures */
  81. int zflush(P1(os_ptr));
  82.  
  83. /* ------ Forward references ------ */
  84.  
  85. private int gs_run_init_file(P2(int *, ref *));
  86. private int gs_run_file_open(P2(const char *, ref *));
  87.  
  88. /* ------ Initialization ------ */
  89.  
  90. /* Remember how much initialization has been done. */
  91. private int init1_done, init2_done;
  92.  
  93. /* A handy way to declare and execute an initialization procedure: */
  94. #define call_init(proc)\
  95. { extern void proc(P0()); proc(); }
  96.  
  97. /* Initialization to be done before anything else. */
  98. void
  99. gs_init0(FILE *in, FILE *out, FILE *err, int max_lib_paths)
  100. {    /* Set the Ghostscript versions of stdin/out/err. */
  101.     gs_stdin = in;
  102.     gs_stdout = out;
  103.     gs_stderr = err;
  104.     gs_debug_out = gs_stdout;
  105.  
  106.  
  107.     /* Do platform-dependent initialization. */
  108.     /* We have to do this as the very first thing, */
  109.     /* because it detects attempts to run 80N86 executables (N>0) */
  110.     /* on incompatible processors. */
  111.  
  112. #ifdef atarist
  113.     /* On the ST, memory initialization must preceed gp_init */
  114.     gs_malloc_init();
  115.     gp_init();
  116. #else
  117.     gp_init();
  118.     gs_malloc_init();
  119. #endif
  120.     /* Initialize the file search paths */
  121.     gs_lib_env_path = 0;
  122.     gs_lib_paths =
  123.         (const char **)gs_malloc(max_lib_paths + 4, sizeof(char *),
  124.                      "gs_lib_paths array");
  125.     gs_lib_count = 0;
  126. #if SEARCH_HERE_FIRST
  127.     gs_add_lib_path(gp_current_directory_name);
  128. #endif
  129.     gs_user_errors = 1;
  130.     gs_log_errors = 0;
  131.     /* Reset debugging flags */
  132.     memset(gs_debug, 0, 128);
  133.     init1_done = init2_done = 0;
  134. }
  135.  
  136. /* Initialization to be done before constructing any objects. */
  137. void
  138. gs_init1(void)
  139. {    if ( !init1_done )
  140.     {    {    extern bool gs_have_level2(P0());
  141.             ialloc_init(&gs_memory_default, gs_memory_chunk_size,
  142.                     gs_have_level2());
  143.             alloc_save_init(idmemory);
  144.         }
  145.         name_init(imemory_global);
  146.         call_init(obj_init)        /* requires name_init */
  147.         call_init(scan_init)        /* ditto */
  148.         init1_done = 1;
  149.     }
  150. }
  151.  
  152. /* Initialization to be done before running any files. */
  153. void
  154. gs_init2(void)
  155. {    gs_init1();
  156.     if ( !init2_done )
  157.        {    int code, exit_code;
  158.         ref error_object;
  159.         call_init(igs_init)
  160.         call_init(zop_init)
  161.         {    extern void gs_iodev_init(P1(gs_memory_t *));
  162.             gs_iodev_init(imemory);
  163.         }
  164.         call_init(op_init)    /* requires obj_init, scan_init */
  165.         /* Set up the array of additional initialization files. */
  166.         {    ref *ifp = gs_init_file_array;
  167.             ref ifa;
  168.             for ( ; ifp->value.bytes != 0; ifp++ )
  169.               r_set_size(ifp, strlen((const char *)ifp->value.bytes));
  170.             make_tasv(&ifa, t_array, a_readonly + a_foreign,
  171.                   ifp - gs_init_file_array, refs,
  172.                   gs_init_file_array);
  173.             initial_enter_name("INITFILES", &ifa);
  174.         }
  175.         /* Execute the standard initialization file. */
  176.         code = gs_run_init_file(&exit_code, &error_object);
  177.         if ( code < 0 )
  178.         {    if ( code != e_Fatal )
  179.                 gs_debug_dump_stack(code, &error_object);
  180.             gs_exit_with_code((exit_code ? exit_code : 2), code);
  181.         }
  182.         init2_done = 1;
  183.        }
  184.    }
  185.  
  186. /* Add a library search path to the list. */
  187. void
  188. gs_add_lib_path(const char *lpath)
  189. {    gs_lib_paths[gs_lib_count] = lpath;
  190.     gs_lib_count++;
  191.     gs_set_lib_paths();
  192. }
  193.  
  194. /* ------ Execution ------ */
  195.  
  196. /* Complete the list of library search paths. */
  197. void
  198. gs_set_lib_paths(void)
  199. {    const char **ppath = &gs_lib_paths[gs_lib_count];
  200.     if ( gs_lib_env_path != 0 ) *ppath++ = gs_lib_env_path;
  201.     if ( gs_lib_default_path != 0 ) *ppath++ = gs_lib_default_path;
  202.     *ppath = 0;
  203. }
  204.  
  205. /* Open a file, using the search paths. */
  206. int
  207. gs_lib_open(const char *file_name, ref *pfile)
  208. {    /* This is a separate procedure only to avoid tying up */
  209.     /* extra stack space while running the file. */
  210. #define maxfn 200
  211.     byte fn[maxfn];
  212.     uint len;
  213.     return lib_file_open(file_name, strlen(file_name), fn, maxfn,
  214.                  &len, pfile);
  215. }
  216.  
  217. /* Open and execute a file. */
  218. int
  219. gs_run_file(const char *file_name, int user_errors, int *pexit_code, ref *perror_object)
  220. {    ref initial_file;
  221.     int code = gs_run_file_open(file_name, &initial_file);
  222.     if ( code < 0 ) return code;
  223.     return gs_interpret(&initial_file, user_errors, pexit_code, perror_object);
  224. }
  225. private int
  226. gs_run_file_open(const char *file_name, ref *pfref)
  227. {    gs_set_lib_paths();
  228.     if ( gs_lib_open(file_name, pfref) < 0 )
  229.     {    eprintf1("Can't find initialization file %s.\n", file_name);
  230.         return_error(e_Fatal);
  231.     }
  232.     r_set_attrs(pfref, a_execute + a_executable);
  233.     return 0;
  234. }
  235.  
  236. /* Open and run the very first initialization file. */
  237. private int
  238. gs_run_init_file(int *pexit_code, ref *perror_object)
  239. {    ref *prinit;
  240.     ref ifile;
  241.     ref first_token;
  242.     int code;
  243.     scanner_state state;
  244.     /* We know that .initialfile is defined in systemdict */
  245.     /* as an operator, and that it pushes a file on the o-stack. */
  246.     dict_find_string(systemdict, ".initialfile", &prinit);
  247.     gs_set_lib_paths();
  248.     code = (*real_opproc(prinit))(osp);
  249.     if ( code < 0 )
  250.       {    *pexit_code = 255;
  251.         return code;
  252.       }
  253.     ifile = *osp--;
  254.     /* Check to make sure the first token is an integer */
  255.     /* (for the version number check.) */
  256.     scanner_state_init(&state, false);
  257.     code = scan_token(ifile.value.pfile, &first_token, &state);
  258.     if ( code != 0 || !r_has_type(&first_token, t_integer) )
  259.     {    eprintf1("Initialization file %s does not begin with an integer.\n", gs_init_file);
  260.         *pexit_code = 255;
  261.         return_error(e_Fatal);
  262.     }
  263.     *++osp = first_token;
  264.     r_set_attrs(&ifile, a_executable);
  265.     return gs_interpret(&ifile, gs_user_errors, pexit_code, perror_object);
  266. }
  267. /* Operator to open and return the initial file. */
  268. /* Precompiled initialization can redefine this. */
  269. private int
  270. zinitialfile(os_ptr op)
  271. {    int code = gs_run_file_open(gs_init_file, (ref *)(op + 1));
  272.     if ( code < 0 )
  273.         return code;
  274.     push(1);
  275.     return 0;
  276. }
  277.  
  278. /* Run a string. */
  279. int
  280. gs_run_string(const char *str, int user_errors,
  281.   int *pexit_code, ref *perror_object)
  282. {    return gs_run_string_with_length(str, (uint)strlen(str), user_errors,
  283.                      pexit_code, perror_object);
  284. }
  285. int
  286. gs_run_string_with_length(const char *str, uint length, int user_errors,
  287.   int *pexit_code, ref *perror_object)
  288. {    ref fref;
  289.     int code;
  290.     gs_set_lib_paths();
  291.     code = file_read_string((const byte *)str, length, &fref);
  292.     if ( code < 0 ) return code;
  293.     r_set_attrs(&fref, a_executable);
  294.     {    /* Register fref as a root, so we can know it will still */
  295.         /* be valid after the interpreter returns. */
  296.         ref *pfref = &fref;
  297.         gs_gc_root_t froot;
  298.         gs_memory_t *mem = imemory;    /* in case local mode changes */
  299.         gs_register_ref_root(mem, &froot, (void **)&pfref, "gs_run_string");
  300.         code = gs_interpret(&fref, user_errors, pexit_code, perror_object);
  301.         file_close(&fref);
  302.         gs_unregister_root(mem, &froot, "gs_run_string");
  303.     }
  304.     return code;
  305. }
  306.  
  307. /* ------ Termination ------ */
  308.  
  309. /* Free all resources and exit. */
  310. void
  311. gs_finit(int exit_status, int code)
  312. {    gx_device **pdev = gx_device_list;
  313.     gs_exit_status = exit_status;    /* see above */
  314.     fflush(stderr);            /* in case of error exit */
  315.     for ( ; *pdev != 0; pdev++ )
  316.     {    if ( (*pdev)->is_open )
  317.             gs_closedevice(*pdev);
  318.     }
  319.     /* Do the equivalent of a restore "past the bottom". */
  320.     /* This will release all memory, close all open files, etc. */
  321.     if ( init1_done )
  322.         alloc_restore_all(idmemory);
  323.     /* Do platform-specific cleanup. */
  324.     gp_exit(exit_status, code);
  325. }
  326. void
  327. gs_exit_with_code(int exit_status, int code)
  328. {    gs_finit(exit_status, code);
  329.     exit(exit_status);
  330. }
  331. void
  332. gs_exit(int exit_status)
  333. {    gs_exit_with_code(exit_status, 0);
  334. }
  335.  
  336. /* ------ Debugging ------ */
  337.  
  338. /* Debugging code */
  339. extern void debug_print_ref(P1(const ref *));
  340. extern void debug_dump_stack(P2(const ref_stack *, const char *));
  341.  
  342. /* Dump the stacks after interpretation */
  343. void
  344. gs_debug_dump_stack(int code, ref *perror_object)
  345. {    zflush(osp);    /* force out buffered output */
  346.     dprintf1("\nUnexpected interpreter error %d.\n", code);
  347.     if ( perror_object != 0 )
  348.     {    dputs("Error object: ");
  349.         debug_print_ref(perror_object);
  350.         dputc('\n');
  351.     }
  352.     debug_dump_stack(&o_stack, "Operand stack");
  353.     debug_dump_stack(&e_stack, "Execution stack");
  354. }
  355.  
  356. /* Log an error return.  We always include this, in case other */
  357. /* modules were compiled with DEBUG set. */
  358. #undef gs_log_error        /* in case DEBUG isn't set */
  359. int
  360. gs_log_error(int err, const char _ds *file, int line)
  361. {    if ( gs_log_errors )
  362.       { if ( file == NULL )
  363.           dprintf1("Returning error %d.\n", err);
  364.         else
  365.           dprintf3("%s(%d): Returning error %d.\n",
  366.                (char *)file, line, err);
  367.       }
  368.     return err;
  369. }
  370.  
  371. /* ------ "Operator" definition ------ */
  372.  
  373. op_def gsmain_op_defs[] = {
  374.     {"0.initialfile", zinitialfile},
  375.     op_def_end(0)
  376. };
  377.