home *** CD-ROM | disk | FTP | other *** search
/ jppd.dyndns.org / jppd.dyndns.org.tar / jppd.dyndns.org / QUERYPRO / Impressora_PDF / converter.exe / GPLGS / gs_init.ps < prev    next >
Text File  |  2004-09-07  |  73KB  |  2,202 lines
  1. % Copyright (C) 1989-2004 artofcode LLC. All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_init.ps,v 1.87.2.9 2004/09/06 15:40:52 ray Exp $
  17. % Initialization file for the interpreter.
  18. % When this is run, systemdict is still writable.
  19.  
  20. % Comment lines of the form
  21. %    %% Replace <n> <file(s)>
  22. % indicate places where the next <n> lines should be replaced by
  23. % the contents of <file(s)>, when creating a single merged init file.
  24.  
  25. % The interpreter can call out to PostScript code.  All procedures
  26. % called in this way, and no other procedures defined in these
  27. % initialization files, have names that begin with %, e.g.,
  28. % (%Type1BuildChar) cvn.
  29.  
  30. % Check the interpreter revision.  NOTE: the interpreter code requires
  31. % that the first non-comment token in this file be an integer.
  32. 815
  33. dup revision ne
  34.  { (gs: Interpreter revision \() print revision 10 string cvs print
  35.    (\) does not match gs_init.ps revision \() print 10 string cvs print
  36.    (\).\n) print flush //null 1 .quit
  37.  }
  38. if pop
  39.  
  40. % Acquire userdict, and set its length if necessary.
  41. /userdict where
  42.  { pop userdict maxlength 0 eq }
  43.  { true }
  44. ifelse
  45. systemdict exch
  46.  {        % userdict wasn't already set up by iinit.c.
  47.    dup /userdict
  48.    currentdict dup 200 .setmaxlength        % userdict
  49.    .forceput            % userdict is local, systemdict is global
  50.  }
  51. if begin
  52.  
  53. % Define dummy local/global operators if needed.
  54. systemdict /.setglobal known
  55.  { true .setglobal
  56.  }
  57.  { /.setglobal { pop } bind def
  58.    /.currentglobal { false } bind def
  59.    /.gcheck { pop false } bind def
  60.  }
  61. ifelse
  62.  
  63. % Define .languagelevel if needed.
  64. systemdict /.languagelevel known not { /.languagelevel 1 def } if
  65.  
  66. % Optionally choose a default paper size other than U.S. letter.
  67. % (a4) /PAPERSIZE where { pop pop } { /PAPERSIZE exch def } ifelse
  68.  
  69. % Turn on array packing for the rest of initialization.
  70. true setpacking
  71.  
  72. % Define the old MS-DOS EOF character as a no-op.
  73. % This is a hack to get around the absurd habit of MS-DOS editors
  74. % of adding an EOF character at the end of the file.
  75. <1a> cvn { } def
  76.  
  77. % Acquire the debugging flags.
  78. currentdict /DEBUG known   /DEBUG exch def
  79.  
  80. % if DEBUG is set, set ALL of the subset debugging flags
  81. mark    % '[' isn't defined yet
  82.   /CCFONTDEBUG        % Compiled Fonts
  83.   /CFFDEBUG        % CFF Fonts
  84.   /CMAPDEBUG        % CMAP 
  85.   /DOCIEDEBUG        % CIE color
  86.   /EPSDEBUG        % EPS handling
  87.   /FAPIDEBUG        % Font API
  88.   /INITDEBUG        % Initialization
  89.   /PDFDEBUG        % PDF Interpreter
  90.   /PDFOPTDEBUG        % PDF Optimizer (Linearizer)
  91.   /PDFWRDEBUG        % PDF Writer
  92.   /SETPDDEBUG        % setpagedevice
  93.   /STRESDEBUG        % Static Resources
  94.   /TTFDEBUG        % TTF Fonts
  95.   /VGIFDEBUG        % ViewGIF
  96.   /VJPGDEBUG        % ViewJPEG
  97. counttomark array astore exch pop % ']' isn't defined yet
  98. { dup currentdict exch known DEBUG or def } forall
  99.  
  100.   /VMDEBUG
  101.     INITDEBUG {{print mark
  102.             systemdict /level2dict known
  103.          { .currentglobal dup false .setglobal vmstatus
  104.            true .setglobal vmstatus 3 -1 roll pop
  105.            6 -2 roll pop .setglobal
  106.          }
  107.          { vmstatus 3 -1 roll pop
  108.          }
  109.         ifelse usertime 16#fffff and counttomark
  110.           { ( ) print (           ) cvs print }
  111.         repeat pop
  112.         ( ) print systemdict length (    ) cvs print
  113.         ( ) print countdictstack (  ) cvs print
  114.         ( <) print count (    ) cvs print (>\n) print flush
  115.       }}
  116.       {{pop
  117.       }}
  118.      ifelse
  119.   def
  120.  
  121. currentdict /BATCH known   /BATCH exch def
  122. currentdict /DELAYBIND known   /DELAYBIND exch def
  123. currentdict /DISKFONTS known   /DISKFONTS exch def
  124. currentdict /DOINTERPOLATE .knownget { /INTERPOLATE exch def } if
  125. currentdict /ESTACKPRINT known   /ESTACKPRINT exch def
  126. currentdict /FAKEFONTS known   /FAKEFONTS exch def
  127. currentdict /FIXEDMEDIA known   /FIXEDMEDIA exch def
  128. currentdict /FIXEDRESOLUTION known   /FIXEDRESOLUTION exch def
  129. currentdict /LOCALFONTS known   /LOCALFONTS exch def
  130. currentdict /JOBSERVER known   /JOBSERVER exch def
  131. currentdict /NOBIND known   /NOBIND exch def
  132. /.bind /bind load def
  133. NOBIND { /bind { } def } if
  134. currentdict /NOCACHE known   /NOCACHE exch def
  135. currentdict /NOCCFONTS known   /NOCCFONTS exch def
  136. currentdict /NOCIE known   /NOCIE exch def
  137. currentdict /NOPSICC known   /NOPSICC exch def
  138. currentdict /NODISPLAY known   not /DISPLAYING exch def
  139. currentdict /NOFONTMAP known   /NOFONTMAP exch def
  140. currentdict /NOFONTPATH known   /NOFONTPATH exch def
  141. currentdict /NOGC known   /NOGC exch def
  142. currentdict /NOINTERPOLATE .knownget { /INTERPOLATE exch not def } if
  143. currentdict /NOOUTERSAVE known   /NOOUTERSAVE exch def
  144. currentdict /NOPAGEPROMPT known   /NOPAGEPROMPT exch def
  145. currentdict /NOPAUSE known   /NOPAUSE exch def
  146. currentdict /NOPLATFONTS known   /NOPLATFONTS exch def
  147. currentdict /NOPROMPT known   /NOPROMPT exch def
  148. currentdict /NOTRANSPARENCY known   /NOTRANSPARENCY exch def
  149. currentdict /DOPS known   /DOPS exch def
  150. currentdict /NOSUBSTDEVICECOLORS known   /NOSUBSTDEVICECOLORS exch def
  151. % The default value of ORIENT1 is true, not false.
  152. currentdict /ORIENT1 known not { /ORIENT1 true def } if
  153. currentdict /OSTACKPRINT known   /OSTACKPRINT exch def
  154. currentdict /OUTPUTFILE known    % obsolete
  155.  { /OutputFile /OUTPUTFILE load def
  156.    currentdict /OUTPUTFILE .undef
  157.  } if
  158. currentdict /QUIET known   /QUIET exch def
  159. % DELAYSAFER is effectively the same as newer NOSAFER
  160. currentdict /DELAYSAFER known { /DELAYSAFER true def /NOSAFER true def } if
  161. /SAFER currentdict /NOSAFER known {
  162.   false
  163. } {
  164.   currentdict /SAFER known
  165.   currentdict /PARANOIDSAFER known or    % PARANOIDSAFER is equivalent
  166. }
  167. ifelse def
  168. currentdict /SHORTERRORS known   /SHORTERRORS exch def
  169. currentdict /STRICT known   /STRICT exch def
  170. currentdict /TTYPAUSE known   /TTYPAUSE exch def
  171. currentdict /WRITESYSTEMDICT known   /WRITESYSTEMDICT exch def
  172.  
  173. % Acquire environment variables.
  174. currentdict /DEVICE known not
  175.  { (GS_DEVICE) getenv { /DEVICE exch def } if } if
  176.  
  177. (START) VMDEBUG
  178.  
  179. % Open the standard files, so they will be open at the outermost save level.
  180. (%stdin) (r) file pop
  181. (%stdout) (w) file pop
  182. (%stderr) (w) file pop
  183.  
  184. /.currentuserparams where {
  185.   pop mark
  186.     % The Adobe implementations appear to have very large maximum
  187.     % stack sizes.  This turns out to actually make a difference,
  188.     % since some badly-behaved files include extremely long procedures,
  189.     % or construct huge arrays on the operand stack.
  190.     % We reset the stack sizes now so that we don't have to worry
  191.     % about overflowing the (rather small) built-in stack sizes
  192.     % during initialization.
  193.   /MaxDictStack 500
  194.   /MaxExecStack 5000
  195.   /MaxOpStack 50000
  196.   .dicttomark .setuserparams
  197. } if
  198.  
  199. % Define a procedure for skipping over an unneeded section of code.
  200. % This avoids allocating space for the skipped procedures.
  201. % We can't use readline, because that imposes a line length limit.
  202. /.skipeof    % <string> .skipeof -
  203.  { currentfile exch 1 exch .subfiledecode flushfile
  204.  } .bind def
  205.  
  206. % Define procedures to assist users who don't read the documentation.
  207. userdict begin
  208. /help
  209.  { (Enter PostScript commands.  '(filename) run' runs a file, 'quit' exits.\n)
  210.    print flush
  211.  } .bind def
  212. end
  213.  
  214. % Define =string, which is used by some PostScript programs even though
  215. % it isn't documented anywhere.
  216. % Put it in userdict so that each context can have its own copy.
  217. userdict /=string 256 string put
  218.  
  219. % Print the greeting.
  220.  
  221. /printgreeting
  222.  { mark
  223.    product (Ghostscript) search
  224.     { pop pop pop
  225.       (This software comes with NO WARRANTY: see the file PUBLIC for details.\n)
  226.     }
  227.     { pop
  228.     }
  229.    ifelse
  230.    (\n) copyright
  231.    (\)\n) revisiondate 10 mod revisiondate 10 idiv 10 mod (-)
  232.    revisiondate 100 idiv 10 mod revisiondate 1000 idiv 10 mod (-)
  233.    revisiondate 10000 idiv ( \()
  234.    revision 10 mod
  235.    revision 100 mod 10 idiv (.)
  236.    revision 100 idiv ( )
  237.    product
  238.    counttomark
  239.     { (%stdout) (w) file exch 0 .writecvp
  240.     } repeat pop
  241.  } .bind def
  242.  
  243. QUIET not { printgreeting flush } if
  244.  
  245. % Define a special version of def for making operator procedures.
  246. /obind {    % <name> <proc> obind <name> <oper>
  247.   1 index exch .makeoperator
  248. } .bind def
  249. /odef {        % <name> <proc> odef -
  250.   1 index exch .makeoperator def
  251. } .bind def
  252.  
  253. % Define a special version of def for storing local objects into global
  254. % dictionaries.  Like .forceput, this exists only during initialization.
  255. /.forcedef {        % <key> <value> .forcedef -
  256.   currentdict 3 1 roll .forceput
  257. } .bind odef
  258.  
  259. % Define procedures for accessing variables in systemdict and userdict
  260. % regardless of the contents of the dictionary stack.
  261. /.systemvar {        % <name> .systemvar <value>
  262.   //systemdict exch get
  263. } .bind odef
  264. /.userdict {        % - .userdict <dict>
  265.   /userdict .systemvar
  266. } .bind odef
  267. /.uservar {        % <name> .uservar <value>
  268.   .userdict exch get
  269. } .bind odef
  270.  
  271. % If we're delaying binding, remember everything that needs to be bound later.
  272. DELAYBIND NOBIND not and
  273.  { .currentglobal false .setglobal
  274.    systemdict /.delaybind 1500 array .forceput
  275.    .setglobal
  276.    userdict /.delaycount 0 put
  277.     % When we've done the delayed bind, we want to stop saving.
  278.     % Detect this by the disappearance of .delaybind.
  279.    /bind
  280.     { /.delaybind .systemvar dup length 0 ne
  281.        { .delaycount 2 index put
  282.          .userdict /.delaycount .delaycount 1 add put
  283.        }
  284.        { pop /.bind cvx exec
  285.        }
  286.       ifelse
  287.     } .bind def
  288.  } if
  289.  
  290. %**************** BACKWARD COMPATIBILITY ****************
  291. /hwsizedict mark /HWSize //null .dicttomark readonly def
  292. /copyscanlines {        % <device> <y> <string> copyscanlines <substr>
  293.   0 3 1 roll 3 index //hwsizedict .getdeviceparams
  294.   exch pop exch pop aload pop 3 2 roll
  295.   0 exch //null exch .getbitsrect exch pop
  296. } bind odef
  297. currentdict /hwsizedict .undef
  298. /getdeviceprops
  299.  { //null .getdeviceparams
  300.  } bind odef
  301. /.putdeviceprops
  302.  { //null true counttomark 1 add 3 roll .putdeviceparams
  303.    dup type /booleantype ne
  304.     { dup mark eq { /unknown /rangecheck } if
  305.       counttomark 4 add 1 roll cleartomark pop pop pop
  306.       /.putdeviceprops load exch signalerror
  307.     }
  308.    if
  309.  } bind odef
  310. /.currentfilladjust { .currentfilladjust2 pop } bind odef
  311. /.setfilladjust { dup .setfilladjust2 } bind odef
  312. /.writecvs { 0 .writecvp } bind odef
  313. %**************** DEPRECATED PROCEDURES ****************
  314. %**************** DO NOT USE THESE IN NEW CODE ****************
  315. /max { .max } bind def        % use .max instead
  316. /min { .min } bind def        % use .min instead
  317. /unread /.unread load def    % use .peekstring instead
  318. %**************** END OF BACKWARD COMPATIBILITY SECTION ****************
  319.  
  320. % Utility procedure to sort an array
  321. % <array> <lt-proc> .sort <array>
  322. /.sort {
  323.   1 index length 1 sub -1 1 {
  324.     2 index exch 2 copy get 3 copy    % arr proc arr i arr[i] arr i arr[i]
  325.     0 1 3 index 1 sub {
  326.       3 index 1 index get    % arr proc arr i arr[i] arr imax amax j arr[j]
  327.       2 index 1 index 10 index exec {    % ... amax < arr[j]
  328.     4 2 roll
  329.       } if pop pop
  330.     } for            % arr proc arr i arr[i] arr imax amax
  331.     4 -1 roll exch 4 1 roll put put
  332.   } for pop
  333. } bind def
  334.  
  335. % Utility for removing all entries from a dictionary
  336. /.PurgeDict   % <dict> .PurgeDict -
  337. { { true
  338.     1 index { pop exch pop false exit
  339.     } forall
  340.     { exit
  341.     } if
  342.     1 index exch undef
  343.   } loop
  344.   pop
  345. } bind def
  346.  
  347. % Define predefined procedures substituting for operators,
  348. % in alphabetical order.
  349.  
  350. userdict /#copies 1 put
  351. % Adobe implementations don't accept /[ or /], so we don't either.
  352. ([) cvn
  353.     /mark load def
  354. (]) cvn
  355.     {counttomark array astore exch pop} odef
  356. % .beginpage is redefined if setpagedevice is present.
  357. /.beginpage { } odef
  358. % In LanguageLevel 3, copypage erases the page.
  359. /copypage {
  360.     .languagelevel 3 ge
  361.     dup { 0 } { 1 } ifelse .endpage {
  362.       .currentnumcopies 1 index .outputpage
  363.       (>>copypage, press <return> to continue<<\n) .confirm
  364.       dup { erasepage } if
  365.     } if pop
  366.     systemdict /..page_default_spaces .knownget { //.PurgeDict exec } if
  367.     .beginpage
  368. } odef
  369. /currentmatrix {
  370.     .currentmatrix 6 index astore pop
  371. } odef
  372. % .currentnumcopies is redefined in Level 2.
  373. /.currentnumcopies { #copies } odef
  374. /setcolorscreen where { pop        % not in all Level 1 configurations
  375.    /currentcolorscreen
  376.     { .currenthalftone
  377.        { { 60 exch 0 exch 3 copy 6 copy }    % halftone - not possible
  378.          { 3 copy 6 copy }            % screen
  379.          { }                % colorscreen
  380.        }
  381.       exch get exec
  382.     } odef
  383. } if
  384. /currentscreen
  385.     { .currenthalftone
  386.        { { 60 exch 0 exch }            % halftone - not possible
  387.          { }                % screen
  388.          { 12 3 roll 9 { pop } repeat }    % colorscreen
  389.        }
  390.       exch get exec
  391.     } odef
  392. /.echo /echo load def
  393. userdict /.echo.mode true put
  394. /echo    {dup /.echo.mode exch store .echo} odef
  395. /.eexec_param_dict mark
  396.   /eexec true
  397.   /seed 55665
  398. .dicttomark readonly def
  399. /eexec {
  400.     % Rebind .currentresourcefile if it is the source for the eexec.
  401.   dup //.eexec_param_dict //filterdict /eexecDecode get exec
  402.   cvx exch .currentresourcefile eq
  403.   //systemdict begin { {exec} .execasresource } { exec } ifelse
  404.     % Only pop systemdict if it is still the top element,
  405.     % because this is apparently what Adobe interpreters do.
  406.   currentdict //systemdict eq { end } if
  407. } odef
  408. % .endpage is redefined if setpagedevice is present.
  409. /.endpage { 2 ne } odef
  410. % erasepage mustn't use gsave/grestore, because we call it before
  411. % the graphics state stack has been fully initialized.
  412. /erasepage
  413.     { /currentcolor where
  414.        { pop currentcolor currentcolorspace { setcolorspace setcolor } }
  415.        { /currentcmykcolor where
  416.           { pop currentcmykcolor { setcmykcolor } }
  417.           { currentrgbcolor { setrgbcolor } }
  418.          ifelse
  419.        }
  420.       ifelse
  421.           currentoverprint false setoverprint 1 setgray .fillpage setoverprint
  422.           exec
  423.     } odef
  424. % To satisfy the Genoa FTS, executive must be a procedure, not an operator.
  425. /executive
  426.     { { prompt
  427.          { (%statementedit) (r) file } stopped
  428.          { pop pop $error /errorname get /undefinedfilename eq
  429.         { .clearerror exit } if        % EOF
  430.            handleerror //null        % ioerror??
  431.          }
  432.         if
  433.         cvx { .runexec } execute
  434.       } loop
  435.     } bind def
  436. /filter
  437.     { //filterdict 1 index .knownget
  438.        { exch pop exec }
  439.        { /filter load /undefined signalerror }
  440.       ifelse
  441.     } odef
  442. /handleerror
  443.     JOBSERVER {
  444.       { /errordict .systemvar /.GShandleerror get exec } bind %%% MODIFIED to always use .GShandleerror.
  445.     } {
  446.       { /errordict .systemvar /handleerror get exec } bind %%% original errorhandling
  447.     } ifelse def
  448. /identmatrix [1.0 0.0 0.0 1.0 0.0 0.0] readonly def
  449. /identmatrix
  450.     { dup 0 //identmatrix putinterval } odef
  451. /languagelevel 1 def        % gs_lev2.ps may change this
  452. /makeimagedevice { false makewordimagedevice } odef
  453. /matrix    { 6 array identmatrix } odef
  454. /pathbbox
  455.     { false .pathbbox
  456.     } odef
  457. % .promptmsg is redefined if the interpreter includes readline support.
  458. /.promptmsg {
  459.     (GS) print
  460.     count 0 ne { (<) print count =only } if
  461.     (>) print flush
  462. } bind def
  463. /prompt    { flush flushpage NOPROMPT not { .promptmsg } if } bind def
  464. /pstack    { 0 1 count 3 sub { index == } for } bind def
  465. /putdeviceprops
  466.     { .putdeviceprops { erasepage } if } odef
  467. /quit    { /quit load 0 .quit } odef
  468. /run    { dup type /filetype ne { (r) file } if
  469.         % We must close the file when execution terminates,
  470.         % regardless of the state of the stack,
  471.         % and then propagate an error, if any.
  472.       cvx .runexec
  473.     } odef
  474. % Execute a file.
  475. % Level 2 uses 2 .stop to clear the e-stack for a successful startjob:
  476. % we detect that here, since we need to handle this even if we start out
  477. % without job control in effect.
  478. %
  479. % What we push on the e-stack is the following to be executed in this order:
  480. %    <lit-file|fileproc> .runexec1 <lit-file|fileproc> .runexec2
  481. /.runexec1 {        % <file|fileproc> .runexec1 -
  482.   dup type /filetype ne { cvx exec } if
  483.   cvx //null 2 .stopped
  484.     % If we got back here from a startjob, just keep going.
  485.     % startjob replaces the null on the o-stack with a procedure
  486.     % to be executed when we get back here.
  487.   dup //null ne { exec true } { pop false } ifelse
  488. } bind def
  489. /.runexec2 {        % <continue> <file|fileproc> .runexec2 -
  490.   exch {
  491.     .runexec
  492.   } {
  493.     dup type /filetype ne { cvx exec } if
  494.     closefile
  495.   } ifelse
  496. } bind def
  497. /.runexec {        % <file|fileproc> .runexec -
  498.   cvlit /.runexec1 cvx 1 index /.runexec2 cvx 4 .execn
  499. } bind def
  500. % The following is only for compatibility with Adobe interpreters.
  501. /setdash {
  502.     1 index length 11 gt { /setdash load /limitcheck signalerror } if
  503.     //setdash
  504. } odef
  505. /setdevice
  506.   {
  507.     .setdevice
  508.       {
  509.         mark
  510.           {         % Reset the halftone since the device may differ
  511.             currenthalftone
  512.             dup type /dicttype eq
  513.               { sethalftone }
  514.               { pop }
  515.             ifelse
  516.           }
  517.         stopped
  518.         cleartomark
  519.         erasepage
  520.       }
  521.     if
  522.   }
  523. odef
  524. /setlinecap {
  525.     dup 2 gt { /setlinecap load /rangecheck signalerror } if
  526.     .setlinecap
  527. } odef
  528. /setlinejoin {
  529.     dup 2 gt { /setlinejoin load /rangecheck signalerror } if
  530.     .setlinejoin
  531. } odef
  532. /setmatrix {
  533.     dup aload pop .setmatrix pop
  534. } odef
  535. /showpage {
  536.     0 .endpage .doneshowpage {
  537.       .currentnumcopies true .outputpage
  538.       (>>showpage, press <return> to continue<<\n) .confirm
  539.       initgraphics
  540.           currentoverprint false setoverprint 1 setcolor
  541.           .fillpage
  542.           setoverprint 0 setcolor
  543.     }
  544.     { initgraphics } ifelse
  545.     systemdict /..page_default_spaces .knownget { //.PurgeDict exec } if
  546.     .beginpage
  547. } odef
  548. % Code output by Adobe Illustrator relies on the fact that
  549. % `stack' is a procedure, not an operator!!!
  550. /stack    { 0 1 count 3 sub { index = } for } bind def
  551. /start    { BATCH { //null 0 .quit } { executive } ifelse } def
  552. % Internal uses of stopped that aren't going to do a stop if an error occurs
  553. % should use .internalstopped to avoid setting newerror et al.
  554. /.internalstopped { //null 1 .stopped //null ne } bind def
  555. /store {    % Don't alter operands before completing.
  556.     1 index where { 2 index 2 index put pop pop } { def } ifelse
  557. } odef
  558. /.typenames mark .typenames counttomark packedarray exch pop def
  559. /type {
  560.     //.typenames .type
  561. } odef
  562. currentdict /.typenames .undef
  563. % When running in Level 1 mode, this interpreter is supposed to be
  564. % compatible with PostScript "version" 54.0 (I think).
  565. /version (54.0) readonly def
  566. /.wheredict 10 dict def
  567. /.where /where load def
  568. /where {
  569.     //.wheredict 1 index .knownget { exec } { .where } ifelse
  570. } odef
  571.  
  572. % internaldict is defined in systemdict, but the dictionary is allocated
  573. % in local VM.  However, the procedure must be global, since it is an
  574. % "operator" and must be bind-able into global procedures.
  575. % We make a procedure for creating it, since we must create a new one
  576. % for each context with private local VM.
  577. /.makeinternaldict {
  578.   .currentglobal true .setglobal
  579.     [ /dup .systemvar 1183615869 /eq .systemvar
  580.     [ /pop .systemvar //null ] cvx
  581.     false .setglobal
  582.     dup 1 10 dict .forceput    % proc is global, dict is local
  583.     true .setglobal
  584.     [ /internaldict /cvx .systemvar /invalidaccess /signalerror cvx ] cvx
  585.       /ifelse .systemvar
  586.     ] cvx executeonly
  587.   exch .setglobal
  588. } odef
  589. systemdict /internaldict dup .makeinternaldict .makeoperator
  590. .forceput        % proc is local, systemdict is global
  591. % Move superexec to internaldict if superexec is defined.
  592. currentdict /superexec .knownget {
  593.   1183615869 internaldict /superexec 3 -1 roll put
  594.   currentdict /superexec .undef
  595. } if
  596.  
  597. % Define some additional built-in procedures (beyond the ones defined by
  598. % the PostScript Language Reference Manual).
  599. % Warning: these are not guaranteed to stay the same from one release
  600. % to the next!
  601. /concatstrings    %    (str1) (str2) concatstrings (str1str2)
  602.     { exch dup length 2 index length add string    % str2 str1 new
  603.       dup dup 4 2 roll copy        % str2 new new new1
  604.       length 4 -1 roll putinterval
  605.     } bind def
  606. /copyarray
  607.     { dup length array copy } bind def
  608. % Copy a dictionary per the Level 2 spec even in Level 1.
  609. /.copydict        % <fromdict> <todict> .copydict <todict>
  610.     { dup 3 -1 roll { put dup } forall pop } bind def
  611. /copystring
  612.     { dup length string copy } bind def
  613. /findlibfile {
  614.     .libfile { dup .filename pop exch true } { false } ifelse
  615. } odef
  616. /.growdictlength    % get size for growing a dictionary
  617.     { length 3 mul 2 idiv 1 add
  618.     } bind def
  619. /.growdict        % grow a dictionary
  620.     { dup .growdictlength .setmaxlength
  621.     } bind def
  622. /.growput        % put, grow the dictionary if needed
  623.     { 2 index length 3 index maxlength eq
  624.        { 3 copy pop known not { 2 index .growdict } if
  625.        } if
  626.       put
  627.     } bind def
  628. % .localvmarray may be an operator: see zsysvm.c.
  629. /.localvmarray where {
  630.   pop
  631. } {
  632.   /.localvmarray {
  633.     .currentglobal false .setglobal
  634.     exch array exch .setglobal
  635.   } bind def
  636. } ifelse
  637. /.localvmdict where {
  638.   pop
  639. } {
  640.   /.localvmdict {
  641.     .currentglobal false .setglobal
  642.     exch dict exch .setglobal
  643.   } bind def
  644. } ifelse
  645. /.packtomark
  646.     { counttomark packedarray exch pop } bind def
  647. /ppstack
  648.     { 0 1 count 3 sub { index === } for } bind def
  649. /runlibfile
  650.     {        % We don't want to bind 'run' into this procedure,
  651.             % since run may get redefined.
  652.       findlibfile
  653.        { exch pop /run .systemvar exec }
  654.        { /undefinedfilename signalerror }
  655.       ifelse
  656.     } bind def
  657. /selectdevice
  658.     { finddevice setdevice .setdefaultscreen } bind def
  659. /signalerror        % <object> <errorname> signalerror -
  660.     { /errordict .systemvar exch get exec } bind def
  661.  
  662. % Define the =[only] procedures.  Also define =print,
  663. % which is used by some PostScript programs even though
  664. % it isn't documented anywhere.
  665. /write=only {
  666.     .writecvs
  667. } bind def
  668. /write= {
  669.     1 index exch write=only (\n) writestring
  670. } bind def
  671. /=only    { (%stdout) (w) file exch write=only } bind def
  672. /=    { =only (\n) print } bind def
  673. /=print    /=only load def
  674. % Temporarily define == as = for the sake of runlibfile0.
  675. /== /= load def
  676.  
  677. % The following procedures are documented.
  678. /copydevice {        % <device> copydevice <newdevice>
  679.   false .copydevice2
  680. } odef
  681. /finddevice {        % <devicename> finddevice <device>
  682.   /devicedict .systemvar exch get
  683.   dup 1 get //null eq {
  684.         % This is the first request for this type of device.
  685.         % Create a default instance now.
  686.         % Stack: [proto null]
  687.     .currentglobal true .setglobal exch
  688.     dup dup 0 get copydevice 1 exch put
  689.     exch .setglobal
  690.   } if 1 get
  691. } bind def
  692. /findprotodevice {    % <devicename> findprotodevice <protodevice>
  693.   /devicedict .systemvar exch get 0 get
  694. } bind def
  695.  
  696. % Run a resource file.  This allows us to distinguish resource objects
  697. % from objects coming from input files.
  698. userdict /.currentresourcefile //null put
  699. /.execasresource {    % <file> <proc|runfile> .execasresource -
  700.   /stopped .systemvar
  701.   /.currentresourcefile .uservar
  702.         % Stack: file proc -stopped- currfile
  703.   .userdict /.currentresourcefile 5 index cvlit put
  704.   2 .execn        % stopped <file>
  705.   .userdict /.currentresourcefile 3 -1 roll put
  706.   { stop } if
  707. } bind def
  708. /.runresource {        % <file> .runresource -
  709.   { /run .systemvar exec } .execasresource
  710. } bind def
  711.  
  712. % Define procedures for getting and setting the current device resolution.
  713.  
  714. /gsgetdeviceprop    % <device> <propname> gsgetdeviceprop <value>
  715.  { 2 copy mark exch //null .dicttomark .getdeviceparams
  716.    dup mark eq        % if true, not found
  717.     { pop dup /undefined signalerror }
  718.     { 5 1 roll pop pop pop pop }
  719.    ifelse
  720.  } bind def
  721. /gscurrentresolution    % - gscurrentresolution <[xres yres]>
  722.  { currentdevice /HWResolution gsgetdeviceprop
  723.  } bind def
  724. /gssetresolution    % <[xres yres]> gssetresolution -
  725.  { 2 array astore mark exch /HWResolution exch
  726.    currentdevice copydevice putdeviceprops setdevice
  727.  } bind def
  728.  
  729. % Define auxiliary procedures needed for the above.
  730. /shellarguments        % -> shell_arguments true (or) false
  731.     { /ARGUMENTS where
  732.        { /ARGUMENTS get dup type /arraytype eq
  733.           { aload pop /ARGUMENTS //null store true }
  734.           { pop false }
  735.          ifelse }
  736.        { false } ifelse
  737.     } bind def
  738. /.confirm {
  739.   DISPLAYING NOPAUSE not TTYPAUSE or and {
  740.     % Print a message (unless NOPAGEPROMPT or NOPROMPT is true)
  741.     % and wait for the user to type something.
  742.     % If the user just types a newline, flush it.
  743.     NOPAGEPROMPT NOPROMPT or { pop } { print flush } ifelse
  744.     .confirmread
  745.   } {
  746.     pop
  747.   } ifelse
  748. } bind def
  749. /.confirmread {
  750.   TTYPAUSE {
  751.     (/dev/tty) (r) file dup read pop pop closefile
  752.   } {
  753.     .echo.mode false echo
  754.     (%stdin) (r) file dup read {
  755.       dup (\n) 0 get eq { pop pop } { unread } ifelse
  756.     } {
  757.       pop
  758.     } ifelse echo
  759.   } ifelse
  760. } bind def
  761.  
  762. % Define the procedure used by .runfile, .runstdin and .runstring
  763. % for executing user input.
  764. % This is called with a procedure or executable file on the operand stack.
  765. /.execute {        % <obj> .execute <stopped>
  766.   stopped $error /newerror get and
  767.    { handleerror flush true } { false } ifelse
  768. } bind def
  769. /execute {        % <obj> execute -
  770.   .execute pop
  771. } odef
  772. % Define an execute analogue of runlibfile0.
  773. /execute0 {        % <obj> execute0 -
  774.   .execute { /execute0 cvx 1 .quit } if
  775. } bind def
  776. % Define the procedure that the C code uses for running files
  777. % named on the command line.
  778. /.runfile {
  779.   { runlibfile } execute0
  780. } def
  781. % Define the procedure that the C code uses for running piped input.
  782. % We don't use the obvious { (%stdin) run }, because we want the file to be
  783. % reopened if a startjob does a restore.
  784. /.runstdin {
  785.   { { (%stdin) (r) file cvx } .runexec } execute0
  786. } bind def
  787. % Define the procedure that the C code uses for running commands
  788. % given on the command line with -c.  We turn the string into a file so that
  789. % .runexec can do the right thing with a startjob.
  790. /.runstring {
  791.   .currentglobal exch true .setglobal
  792.   0 () .subfiledecode
  793.   exch .setglobal cvx { .runexec } execute0
  794. } bind def
  795. % Define the procedure that the C code uses to set up for executing
  796. % a string that may be received in pieces.
  797. /.runstringbegin {
  798.   .currentglobal true .setglobal
  799.   { .needinput } bind 0 () .subfiledecode
  800.   exch .setglobal cvx .runexec
  801. } bind def
  802.  
  803. % Define a special version of runlibfile that aborts on errors.
  804. /runlibfile0
  805.     { cvlit dup /.currentfilename exch def
  806.        { findlibfile not { stop } if }
  807.       stopped
  808.        { (Can't find \(or open\) initialization file ) print
  809.          .currentfilename == flush /runlibfile0 cvx 1 .quit
  810.        } if
  811.       exch pop cvx stopped
  812.        { (While reading ) print .currentfilename print (:\n) print flush
  813.          handleerror /runlibfile0 1 .quit
  814.        } if
  815.     } bind def
  816. % Temporarily substitute it for the real runlibfile.
  817. /.runlibfile /runlibfile load def
  818. /runlibfile /runlibfile0 load def
  819.  
  820. % Create the error handling machinery.
  821. % Define the standard error handlers.
  822. % The interpreter has created the ErrorNames array.
  823. /.unstoppederrorhandler    % <command> <errorname> .unstoppederrorhandler -
  824.  {    % This is the handler that gets used for recursive errors,
  825.     % or errors outside the scope of a 'stopped'.
  826.    2 copy SHORTERRORS
  827.     { (%%[ Error: ) print =only flush
  828.       (; OffendingCommand: ) print =only ( ]%%) =
  829.     }
  830.     { (Unrecoverable error: ) print =only flush
  831.       ( in ) print = flush
  832.       count 2 gt
  833.        { (Operand stack:\n  ) print
  834.          count 1 sub -1 2 { (  ) print index =only flush } for
  835.      () = flush
  836.        } if
  837.     }
  838.    ifelse
  839.    -1 0 1 //ErrorNames length 1 sub
  840.     { dup //ErrorNames exch get 3 index eq
  841.        { not exch pop exit } { pop } ifelse
  842.     }
  843.    for exch pop .quit
  844.  } bind def
  845. /.errorhandler        % <command> <errorname> .errorhandler -
  846.   {        % Detect an internal 'stopped'.
  847.     1 .instopped { //null eq { pop pop stop } if } if
  848.     (I) false .setdebug
  849.     $error /.inerror get 1 .instopped { pop } { pop true } ifelse
  850.      { .unstoppederrorhandler
  851.      } if    % detect error recursion
  852.     $error /globalmode .currentglobal false .setglobal put
  853.     $error /.inerror true put
  854.     $error /newerror true put
  855.     $error exch /errorname exch put
  856.     $error exch /command exch put
  857.     $error /recordstacks get $error /errorname get /VMerror ne and
  858.      {        % Attempt to store the stack contents atomically.
  859.        count array astore dup $error /ostack 4 -1 roll
  860.        % Grab the execstack, then remove to two elements that are from
  861.        % this error handler (not interesting).
  862.        countexecstack array execstack dup length 2 sub 0 exch getinterval
  863.        $error /estack 3 -1 roll
  864.        countdictstack array dictstack $error /dstack 3 -1 roll
  865.        put put put aload pop
  866.      }
  867.      { $error /dstack .undef
  868.        $error /estack .undef
  869.        $error /ostack .undef
  870.      }
  871.     ifelse
  872.     $error /position currentfile status
  873.      { currentfile { fileposition } .internalstopped { pop //null } if
  874.      }
  875.      {        % If this was a scanner error, the file is no longer current,
  876.         % but the command holds the file, which may still be open.
  877.        $error /command get dup type /filetype eq
  878.         { { fileposition } .internalstopped { pop //null } if }
  879.         { pop //null }
  880.        ifelse
  881.      }
  882.     ifelse put
  883.         % During initialization, we don't reset the allocation
  884.         % mode on errors.
  885.     $error /globalmode get $error /.nosetlocal get and .setglobal
  886.     $error /.inerror false put
  887.     stop
  888.   } bind def
  889. % Define the standard handleerror.  We break out the printing procedure
  890. % (.printerror) so that it can be extended for binary output
  891. % if the Level 2 facilities are present.
  892.   /.printerror
  893.    { $error begin newerror
  894.      {
  895.        /command load errorname SHORTERRORS
  896.     { (%%[ Error: ) print =only flush
  897.       (; OffendingCommand: ) print =only
  898.       errorinfo dup //null eq {
  899.         pop
  900.       } {
  901.         (;\nErrorInfo:) print
  902.         dup type /arraytype eq
  903.           { { ( ) print =only } forall }
  904.           { ( ) print =only }
  905.         ifelse
  906.       } ifelse
  907.           ( ]%%) = flush
  908.     }
  909.     { (Error: ) print ==only flush
  910.       ( in ) print ==only flush
  911.       errorinfo dup //null eq {
  912.         pop
  913.       } {
  914.         (\nAdditional information: ) print ==only flush
  915.       } ifelse
  916.       .printerror_long
  917.     }
  918.        ifelse
  919.        .clearerror flush
  920.      }
  921.      { % newerror is false, test to see if user has set handleerror to a different
  922.        % routine, if so execute it, otherwise, just return.  This code deals with the
  923.        % Genoa issue of setting /handleerror, and then calling it, without an error
  924.        % being set.  We were erroring in this case, due to /command load failing.
  925.  
  926.        errordict dup /handleerror get  exch
  927.          //JOBSERVER { /.GShandleerror } { /handleerror } ifelse
  928.          get ne
  929.          { errordict begin handleerror end
  930.          }
  931.          if
  932.      }
  933.      ifelse    % newerror 
  934.      end
  935.      flush
  936.     } bind def     
  937.   /.printerror_long            % long error printout,
  938.                     % $error is on the dict stack
  939.    {    % Push the (anonymous) stack printing procedure.
  940.     %  <heading> <==flag> <override-name> <stackname> proc
  941.        {
  942.      currentdict exch .knownget    % stackname defined in $error?
  943.      {
  944.        4 1 roll            % stack: <stack> <head> <==flag> <over>
  945.        errordict exch .knownget    % overridename defined?
  946.        { 
  947.          exch pop exch pop exec    % call override with <stack>
  948.        }
  949.        { 
  950.          exch print exch        % print heading. stack <==flag> <stack>
  951.          1 index not { () = } if
  952.          { 1 index { (\n    ) } { (   ) } ifelse print
  953.            dup type /dicttype eq
  954.            {
  955.          (--dict:) print
  956.          dup rcheck {
  957.            dup length =only (/) print dup maxlength =only
  958.            dup wcheck not { ((ro)) print } if
  959.          } if
  960.          /gcheck where {
  961.            pop gcheck { ((G)) } { ((L)) } ifelse print
  962.          } {
  963.            pop
  964.          } ifelse (--) print
  965.            }
  966.            {
  967.          dup type /stringtype eq 2 index or
  968.          { ==only } { =only } ifelse
  969.            } ifelse
  970.          } forall
  971.          pop
  972.        }
  973.        ifelse            % overridden
  974.      }
  975.      { pop pop pop
  976.      }
  977.      ifelse                % stack known
  978.        }
  979.  
  980.        (\nOperand stack:) OSTACKPRINT /.printostack /ostack 4 index exec
  981.        (\nExecution stack:) ESTACKPRINT /.printestack /estack 4 index exec
  982.        (\nBacktrace:) true /.printbacktrace /backtrace 4 index exec
  983.        (\nDictionary stack:) false /.printdstack /dstack 4 index exec
  984.        () =
  985.        pop    % printing procedure
  986.  
  987.        errorname /VMerror eq
  988.     { (VM status:) print mark vmstatus
  989.       counttomark { ( ) print counttomark -1 roll dup =only } repeat
  990.       cleartomark () =
  991.     } if
  992.  
  993.        .languagelevel 2 ge
  994.     { (Current allocation mode is ) print
  995.       globalmode { (global\n) } { (local\n) } ifelse print
  996.     } if
  997.  
  998.        .oserrno dup 0 ne
  999.     { (Last OS error: ) print
  1000.       errorname /VMerror ne
  1001.        { dup .oserrorstring { = pop } { = } ifelse }
  1002.        { = }
  1003.       ifelse
  1004.     }
  1005.     { pop
  1006.     }
  1007.        ifelse
  1008.  
  1009.        position //null ne
  1010.     { (Current file position is ) print position = }
  1011.        if
  1012.  
  1013.    } bind def
  1014. % Define a procedure for clearing the error indication.
  1015. /.clearerror
  1016.  { $error /newerror false put
  1017.    $error /errorname //null put
  1018.    $error /errorinfo //null put
  1019.    0 .setoserrno
  1020.  } bind def
  1021.  
  1022. % Define $error.  This must be in local VM.
  1023. .currentglobal false .setglobal
  1024. /$error 40 dict .forcedef    % $error is local, systemdict is global
  1025.         % newerror, errorname, command, errorinfo,
  1026.         % ostack, estack, dstack, recordstacks,
  1027.         % binary, globalmode,
  1028.         % .inerror, .nosetlocal, position,
  1029.         % plus extra space for badly designed error handers.
  1030. $error begin
  1031.   /newerror false def
  1032.   /recordstacks true def
  1033.   /binary false def
  1034.   /globalmode .currentglobal def
  1035.   /.inerror false def
  1036.   /.nosetlocal true def
  1037.   /position //null def
  1038. end
  1039. % Define errordict similarly.  It has one entry per error name,
  1040. %   plus handleerror.  However, some astonishingly badly written PostScript
  1041. %   files require it to have at least one empty slot.
  1042. /errordict ErrorNames length 3 add dict
  1043. .forcedef        % errordict is local, systemdict is global
  1044. .setglobal        % contents of errordict are global
  1045. errordict begin
  1046.   ErrorNames
  1047.    { mark 1 index systemdict /.errorhandler get /exec load .packtomark cvx def
  1048.    } forall
  1049. % The handlers for interrupt and timeout are special; there is no
  1050. % 'current object', so they push their own name.
  1051.    { /interrupt /timeout }
  1052.    { mark 1 index dup systemdict /.errorhandler get /exec load .packtomark cvx def
  1053.    } forall
  1054. /handleerror    % this key is 'well known' and some PS may redefine it
  1055.  { /.printerror .systemvar exec
  1056.  } bind def
  1057.     % a private entry that we will always use under JOBSERVER mode
  1058. /.GShandleerror
  1059.  { /.printerror .systemvar exec
  1060.  } bind def
  1061.  
  1062. end
  1063.  
  1064. % Define the [write]==[only] procedures.
  1065. /.dict 8 dict dup
  1066. begin def
  1067.   /.cvp {1 index exch 1 .writecvp} bind def
  1068.   /.p {1 index exch writestring} bind def
  1069.   /.p1 {2 index exch writestring} bind def
  1070.   /.p2 {3 index exch writestring} bind def
  1071.   /.print
  1072.     { dup type .dict exch .knownget { exec } { .cvp } ifelse
  1073.     } bind def
  1074.   /arraytype
  1075.     {dup rcheck
  1076.       {() exch dup xcheck
  1077.         {({) .p2
  1078.          {exch .p1
  1079.           1 index exch .print pop ( )} forall
  1080.          (})}
  1081.         {([) .p2
  1082.          {exch .p1
  1083.           1 index exch .print pop ( )} forall
  1084.          (])}
  1085.        ifelse exch pop .p}
  1086.       {.cvp}
  1087.      ifelse} bind def
  1088.   /packedarraytype /arraytype load def
  1089. {//.dict begin .print pop end}
  1090.   bind
  1091. end
  1092.  
  1093. /write==only exch def
  1094. /write== {1 index exch write==only (\n) writestring} bind def
  1095. /==only { (%stdout) (w) file exch write==only } bind def
  1096. /== {==only (\n) print} bind def
  1097.  
  1098. % Define [write]===[only], an extension that prints dictionaries
  1099. % in readable form and doesn't truncate strings.
  1100. /.dict /write==only load 0 get dup length 2 add dict .copydict dup
  1101. begin def
  1102.   /dicttype
  1103.     { dup rcheck
  1104.        { (<< ) .p1
  1105.           { 2 index 3 -1 roll .print pop ( ) .p1
  1106.         1 index exch .print pop ( ) .p
  1107.           }
  1108.          forall (>>) .p
  1109.        }
  1110.        { .cvp
  1111.        }
  1112.       ifelse
  1113.     } bind def
  1114.   /stringtype
  1115.     { 1 index exch 2 .writecvp
  1116.     } bind def
  1117.  
  1118. {//.dict begin .print pop end}
  1119.   bind
  1120. end
  1121.  
  1122. /write===only exch def
  1123. /write=== {1 index exch write===only (\n) writestring} bind def
  1124. /===only { (%stdout) (w) file exch write===only } bind def
  1125. /=== { ===only (\n) print } bind def
  1126.  
  1127. % Create the initialization queue.
  1128.  
  1129. /.delayed_init_queue 10 dict def
  1130.  
  1131. /.schedule_init   %   <priority> <proc> .schedule_init -
  1132. {
  1133.   //.delayed_init_queue 2 index known {
  1134.     (.delayed_init_queue priority conflict with ) print 1 index =
  1135.     /.schedule_init cvx /configurationerror signalerror
  1136.   } if
  1137.   //.delayed_init_queue 3 1 roll .growput
  1138. } bind def
  1139.  
  1140. /.execute_schedulled_inits %   - .execute_schedulled_inits -
  1141. {
  1142.   { 0 //null //.delayed_init_queue {     % maxp {} p {}
  1143.       3 index 2 index lt {
  1144.         4 2 roll
  1145.       } if
  1146.       pop pop
  1147.     } forall
  1148.     exch //.delayed_init_queue exch undef
  1149.     dup //null eq {
  1150.       pop exit
  1151.     } if
  1152.     exec
  1153.   } loop
  1154. } bind def
  1155.  
  1156. (END PROCS) VMDEBUG
  1157.  
  1158. % Define the font directory.
  1159. /FontDirectory false .setglobal 100 dict true .setglobal
  1160. .forcedef        % FontDirectory is local, systemdict is global
  1161.  
  1162. % Define the encoding dictionary.
  1163. /EncodingDirectory 16 dict def    % enough for Level 2 + PDF standard encodings
  1164.  
  1165. % Define .findencoding.  (This is redefined in Level 2.)
  1166. /.findencoding
  1167.  { //EncodingDirectory exch get exec
  1168.  } bind def
  1169. /.defineencoding
  1170.  { //EncodingDirectory 3 1 roll put
  1171.  } bind def
  1172. % If we've got the composite font extensions, define findencoding.
  1173. % To satisfy the Genoa FTS, findencoding must be a procedure, not an operator.
  1174. /rootfont where { pop /findencoding { .findencoding } def } if
  1175.  
  1176. % Define .registerencoding.
  1177. % NOTE: This procedure no longer does anything, but it must continue to
  1178. % exist for the sake of toolbin/encs2c.ps.
  1179. /.registerencoding {    % <index> <array> .registerencoding -
  1180.   pop pop
  1181. } bind odef
  1182.  
  1183. % Load StandardEncoding.
  1184. %% Replace 1 (gs_std_e.ps)
  1185. (gs_std_e.ps) dup runlibfile VMDEBUG
  1186.  
  1187. % Load ISOLatin1Encoding.
  1188. %% Replace 1 (gs_il1_e.ps)
  1189. (gs_il1_e.ps) dup runlibfile VMDEBUG
  1190.  
  1191. % Define stubs for the Symbol and Dingbats encodings.
  1192. % Note that the first element of the procedure must be the file name,
  1193. % since gs_lev2.ps extracts it to set up the Encoding resource category.
  1194.  
  1195.   /SymbolEncoding { /SymbolEncoding .findencoding } bind def
  1196. %% Replace 3 (gs_sym_e.ps)
  1197.   EncodingDirectory /SymbolEncoding
  1198.    { (gs_sym_e.ps) //systemdict begin runlibfile SymbolEncoding end }
  1199.   bind put
  1200.  
  1201.   /DingbatsEncoding { /DingbatsEncoding .findencoding } bind def
  1202. %% Replace 3 (gs_dbt_e.ps)
  1203.   EncodingDirectory /DingbatsEncoding
  1204.    { (gs_dbt_e.ps) //systemdict begin runlibfile DingbatsEncoding end }
  1205.   bind put
  1206.  
  1207. (END FONTDIR/ENCS) VMDEBUG
  1208.  
  1209. % Construct a dictionary of all available devices.
  1210. % These are (read-only) device prototypes that can't be
  1211. % installed or have their parameters changed.  For this reason,
  1212. % the value in the dictionary is actually a 2-element writable array,
  1213. % to allow us to create a default instance of the prototype on demand.
  1214.  
  1215.     % Loop until the .getdevice gets a rangecheck.
  1216. errordict /rangecheck 2 copy get
  1217. errordict /rangecheck { pop stop } put    % pop the command
  1218.   0 { {dup .getdevice exch 1 add} loop} .internalstopped pop
  1219.   1 add dict  /devicedict 1 index def
  1220.   begin            % 2nd copy of count is on stack
  1221.    { dup .devicename exch
  1222.      dup wcheck { dup } { //null } ifelse 2 array astore def
  1223.    } repeat
  1224.   end
  1225. put        % errordict /rangecheck
  1226. .clearerror
  1227. /devicenames devicedict { pop } forall devicedict length packedarray def
  1228.  
  1229. % Determine the default device.
  1230. /defaultdevice DISPLAYING
  1231.  { systemdict /DEVICE .knownget
  1232.     { devicedict 1 index known not
  1233.        { (Unknown device: ) print =
  1234.      flush /defaultdevice cvx 1 .quit
  1235.        }
  1236.       if
  1237.     }
  1238.     { 0 .getdevice .devicename
  1239.     }
  1240.    ifelse
  1241.  }
  1242.  { /nullpage
  1243.  }
  1244. ifelse
  1245. /.defaultdevicename 1 index def
  1246. finddevice    % make a copy
  1247. def
  1248. devicedict /Default devicedict .defaultdevicename get put
  1249.  
  1250. (END DEVS) VMDEBUG
  1251.  
  1252. % Define statusdict, for the benefit of programs
  1253. % that think they are running on a LaserWriter or similar printer.
  1254. %% Replace 1 (gs_statd.ps)
  1255. (gs_statd.ps) runlibfile
  1256.  
  1257. (END STATD) VMDEBUG
  1258.  
  1259. % Load the standard font environment.
  1260. %% Replace 1 (gs_fonts.ps)
  1261. (gs_fonts.ps) runlibfile
  1262.  
  1263. (END GS_FONTS) VMDEBUG
  1264.  
  1265. % Define the default halftone screen and BG/UCR functions now, so that
  1266. % it will bind in the original definitions of set[color]screen.
  1267. % We make this a procedure so we can call it again when switching devices.
  1268.  
  1269. % Use an ordered dither for low-resolution devices.
  1270. /.setloreshalftone {    % <dpi> .setloreshalftone -
  1271.     % The following 'ordered dither' spot function was contributed by
  1272.     % Gregg Townsend.  Thanks, Gregg!
  1273.    16.001 div 0            % not 16: avoids rounding problems
  1274.     { 1 add 7.9999 mul cvi exch 1 add 7.9999 mul cvi 16 mul add <
  1275.     0E 8E 2E AE 06 86 26 A6 0C 8C 2C AC 04 84 24 A4
  1276.     CE 4E EE 6E C6 46 E6 66 CC 4C EC 6C C4 44 E4 64
  1277.     3E BE 1E 9E 36 B6 16 96 3C BC 1C 9C 34 B4 14 94
  1278.     FE 7E DE 5E F6 76 D6 56 FC 7C DC 5C F4 74 D4 54
  1279.     01 81 21 A1 09 89 29 A9 03 83 23 A3 0B 8B 2B AB
  1280.     C1 41 E1 61 C9 49 E9 69 C3 43 E3 63 CB 4B EB 6B
  1281.     31 B1 11 91 39 B9 19 99 33 B3 13 93 3B BB 1B 9B
  1282.     F1 71 D1 51 F9 79 D9 59 F3 73 D3 53 FB 7B DB 5B
  1283.     0D 8D 2D AD 05 85 25 A5 0F 8F 2F AF 07 87 27 A7
  1284.     CD 4D ED 6D C5 45 E5 65 CF 4F EF 6F C7 47 E7 67
  1285.     3D BD 1D 9D 35 B5 15 95 3F BF 1F 9F 37 B7 17 97
  1286.     FD 7D DD 5D F5 75 D5 55 FF 7F DF 5F F7 77 D7 57
  1287.     02 82 22 A2 0A 8A 2A AA 00 80 20 A0 08 88 28 A8
  1288.     C2 42 E2 62 CA 4A EA 6A C0 40 E0 60 C8 48 E8 68
  1289.     32 B2 12 92 3A BA 1A 9A 30 B0 10 90 38 B8 18 98
  1290.     F2 72 D2 52 FA 7A DA 5A F0 70 D0 50 F8 78 D8 58
  1291.      > exch get 256 div
  1292.     }
  1293.    bind
  1294.         % Use correct, per-plane screens for CMYK devices only.
  1295.    //systemdict /setcolorscreen known processcolors 4 eq and
  1296.     { 3 copy 6 copy //setcolorscreen }
  1297.     { //setscreen }
  1298.    ifelse
  1299. } bind def
  1300. /.setloresscreen {    % <dpi> .setloresscreen -
  1301.   .setloreshalftone
  1302.   0 array cvx settransfer    % Genoa CET won't accept a packed array!
  1303.   /setstrokeadjust where { pop true setstrokeadjust } if
  1304. } bind def
  1305. % Use a 45-degree spot screen for high-resolution devices.
  1306. /.sethireshalftone {    % <dpi> .sethireshalftone <doscreen>
  1307.     % According to information published by Hewlett-Packard,
  1308.     % they use a 60 line screen on 300 DPI printers and
  1309.     % an 85 line screen on 600 DPI printers.
  1310.     % However, we use a 106 line screen, which produces smoother-
  1311.     % looking shades but fewer of them (32 vs. 50).
  1312.     % 46 was suggested as a good frequency value for printers
  1313.     % between 200 and 400 DPI, so we use it for lower resolutions.
  1314.     % Imagesetters need even higher frequency screens.
  1315.    //systemdict /DITHERPPI known
  1316.     { DITHERPPI
  1317.     }
  1318.     { dup cvi 100 idiv 15 .min
  1319.        {//null 46 46 60 60 60 106 106 106 106 133 133 133 133 133 150}
  1320.       exch get
  1321.      }
  1322.    ifelse
  1323.    1 index 4.01 div .min    % at least a 4x4 cell
  1324.    45
  1325.     % The following screen algorithm is used by permission of the author.
  1326.     { 1 add 180 mul cos 1 0.08 add mul exch 2 add 180 mul cos 
  1327.       1 0.08 sub mul add 2 div % (C) 1989 Berthold K.P. Horn
  1328.     }
  1329.    bind
  1330.     % Determine whether we have lots of process colors.
  1331.     % If so, don't bother with color screening or gamma correction.
  1332.     % Also don't do gamma correction on very high-resolution devices.
  1333.     % (This should depend on dot gain, not resolution, but we don't
  1334.     % currently have a way to determine this.) Ignore missing components
  1335.         % (*Values = 1).
  1336.    currentdevice mark
  1337.      /RedValues 0 /GreenValues 0 /BlueValues 0 /GrayValues 0
  1338.    .dicttomark .getdeviceparams
  1339.    counttomark 2 idiv 1 sub
  1340.     { exch pop dup 1 le
  1341.        { pop }
  1342.        { exch dup 1 le
  1343.           { pop }
  1344.           { .min }
  1345.         ifelse
  1346.        }
  1347.       ifelse
  1348.     }
  1349.    repeat
  1350.    exch pop exch pop 32 lt 4 index 800 lt and 5 1 roll
  1351.     % Stack: doscreen dpi freq angle proc
  1352.     % Ghostscript currently doesn't use correct, per-plane halftones
  1353.     % unless setcolorscreen has been executed.  Since these are
  1354.     % computationally much more expensive than binary halftones,
  1355.     % we check to make sure they are really warranted, i.e., we have
  1356.     % a high-resolution CMYK device (i.e., not a display) with
  1357.     % fewer than 5 bits per plane (i.e., not a true-color device).
  1358.    4 -1 roll 150 ge
  1359.     { /setcolorscreen where
  1360.        { pop //systemdict /COLORSCREEN known
  1361.       { COLORSCREEN }
  1362.       { 3 index }
  1363.      ifelse
  1364.      dup false ne
  1365.       { 4 1 roll 3 copy 6 copy 13 -1 roll
  1366.     % For really high-quality screening on printers, we need to
  1367.     % give each plane its own screen angle.  Unfortunately,
  1368.     % this currently has very large space and time costs.
  1369.         true eq        % true => different angles,
  1370.                 % 0 => same angles
  1371.          { { 45 90 15 75 } { 3 1 roll exch pop 12 3 roll } forall
  1372.          }
  1373.         if //setcolorscreen
  1374.       }
  1375.       { pop //setscreen    % false => single binary screen
  1376.       }
  1377.      ifelse
  1378.        }
  1379.        { //setscreen        % setcolorscreen not known
  1380.        }
  1381.       ifelse
  1382.     }
  1383.     { //setscreen            % not high resolution
  1384.     }
  1385.    ifelse
  1386. } bind def
  1387. /.sethiresscreen {    % <dpi> .sethiresscreen 
  1388.   .sethireshalftone     % pushes true if a screen halftone used
  1389.             % Stack: doscree
  1390.   {
  1391.     % Set the transfer function to lighten up the grays.
  1392.     % Parameter values closer to 1 are better for devices with
  1393.     % less dot spreading; lower values are better with more spreading.
  1394.     % The value 0.8 is a compromise that will probably please no one!
  1395.     %
  1396.     % Because of a bug in FrameMaker, we have to accept operands
  1397.     % outside the valid range of [0..1].
  1398.     {
  1399.       dup dup 0.0 gt exch 1.0 lt and
  1400.       {
  1401.         0.8 exp
  1402.       }
  1403.       if
  1404.     }
  1405.   }
  1406.   {
  1407.      % Set the transfer function to the identity.
  1408.      0 array cvx     % Genoa CET won't accept a packed array!
  1409.   }
  1410.   ifelse
  1411.   settransfer
  1412.   /setstrokeadjust where
  1413.   { pop false setstrokeadjust }
  1414.   if
  1415.  
  1416.   % Increase fill adjustment so that we effectively use Adobe's
  1417.   % any-part-of-pixel rule.
  1418.   0.5 .setfilladjust
  1419. } bind def
  1420. % Set the default screen and BG/UCR.
  1421. /.setdefaultbgucr {
  1422.   systemdict /setblackgeneration known {
  1423.     { pop 0 } dup setblackgeneration setundercolorremoval
  1424.   } if
  1425. } bind def
  1426. /.useloresscreen {    % - .useloresscreen <bool>
  1427.     % Compute min(|dpi x|,|dpi y|) as the definition of the resolution.
  1428.   72 72 matrix defaultmatrix dtransform abs exch abs .min
  1429.   dup 150 lt //systemdict /DITHERPPI known not and
  1430. } bind def
  1431.  
  1432. % The following implementation uses LL2 extensions, but only in stopped
  1433. % contexts so that with LL1, the .set??reshalftone will be used.
  1434. %
  1435. %    - .getdefaulthalftone <halftonedict> true    if default found
  1436. %                  false            
  1437. /.getdefaulthalftone {
  1438.   % try the device to see if it has a default halftone
  1439.   { currentdevice /HalftoneDefault gsgetdeviceprop } .internalstopped
  1440.   { pop pop false }        % no device property
  1441.   { dup type /dicttype eq { true } { pop false } ifelse }
  1442.   ifelse
  1443.   % stack: <halftonedict> true    if default found
  1444.   %         false          not found
  1445.   dup not
  1446.   { % device did not provide a default, try Resource
  1447.     pop { /Default /Halftone /findresource .systemvar exec } .internalstopped 
  1448.     { pop pop false } { true } ifelse
  1449.   }
  1450.   if
  1451. } bind def
  1452.  
  1453. /.setdefaulthalftone {
  1454.   .getdefaulthalftone 
  1455.   { sethalftone }
  1456.   { % default not found
  1457.     .useloresscreen { .setloreshalftone } { .sethireshalftone pop } ifelse
  1458.   }
  1459.   ifelse
  1460. } bind def
  1461.  
  1462. /.setdefaultscreen {
  1463.   .useloresscreen { .setloresscreen } { .sethiresscreen } ifelse
  1464.   .setdefaultbgucr
  1465. } bind def
  1466.  
  1467. % Load basic color support
  1468. %% Replace 1 (gs_cspace.ps)
  1469. (gs_cspace.ps) runlibfile
  1470.  
  1471. (END BASIC COLOR) VMDEBUG
  1472.  
  1473. %% Replace 1 (gs_devcs.ps)
  1474. (gs_devcs.ps) runlibfile
  1475.  
  1476. (END LEVEL 1 COLOR) VMDEBUG
  1477.  
  1478. % Load image support
  1479. %% Replace 1 (gs_img.ps)
  1480. (gs_img.ps) runlibfile
  1481.  
  1482. (END IMAGE) VMDEBUG
  1483.  
  1484. % Auxiliary procedures for generating file name templates.
  1485.  
  1486. % Convert a path name into a string suitable for filenameforall
  1487. % For example: (a\\b*?c) to (a\\\\b\\*\\?c)
  1488. /.makepathtemplate {    % str1 -- str2
  1489.    dup length dup add string 0    % result string up to twice the size
  1490.    0 1 4 index length 1 sub {
  1491.      3 index exch get
  1492.      dup 92 eq {        % \ -> \\
  1493.         2 index 2 index 92
  1494.         put
  1495.         exch 1 add exch
  1496.      } 
  1497.      if
  1498.      dup 42 eq {        % * -> \*
  1499.         2 index 2 index 92
  1500.         put
  1501.         exch 1 add exch
  1502.      } 
  1503.      if
  1504.      dup 63 eq {        % ? -> \?
  1505.         2 index 2 index 92
  1506.         put
  1507.         exch 1 add exch
  1508.      } 
  1509.      if
  1510.      2 index 2 index 3 -1 roll put 1 add
  1511.    } for
  1512.    0 exch getinterval exch pop
  1513. } bind def
  1514.  
  1515. %   <dir_list> <template> .generate_dir_list_templates <t1> ... <tN>
  1516. %
  1517. % Generates various valid templates combining a directory list with a given template.
  1518. %
  1519. % Example1 (DOS, Windows) :
  1520. %       [(/gs/lib) (/gs/Resource/) (\gs8.00\Resource)] (*/*) -->
  1521. %       (/gs/lib/*/*) (/gs/Resource/*/*) (\\gs8.00\\Resource/*/*)
  1522. %
  1523. % Example2 (OpenVMS) :
  1524. %       [(gs:[lib]) (gs:[Resource]) (gs800:[Resource)] (*]*) -->
  1525. %       ((gs:[lib.*]*) [gs:[Resource.*]*) ([gs800:[Resource.*]*)
  1526. %
  1527. /.generate_dir_list_templates
  1528. {                                                  % [dl] (templ)
  1529.   % We need to convert paths into templates,
  1530.   % because it can include '\' on DOS.
  1531.   % In same time, the <template> must not convert,
  1532.   % because it is already a template.
  1533.   % Besides that, we cannot combine template using .file_name_combine,
  1534.   % because template syntax breaks the platform path syntax.
  1535.   % To resolve this, we first convert the <template> into 
  1536.   % a fake filename, and combine it with path,
  1537.   % obtaining a correct separator. Then we replace
  1538.   % the fake file name with the given template.
  1539.   %
  1540.  
  1541.   % Create the fake file name :
  1542.   dup dup length string copy                       % [dl] (templ) (ffn)
  1543.   (*) 0 get (?) 0 get (\\) 0 get (x) 0 get 0 0     % [dl] (templ) (ffn) * ? \ x i j
  1544.   { 1 index 7 index length ge { exit } if
  1545.     6 index 2 index get                            % [dl] (templ) (ffn) * ? \ x i j c
  1546.     dup 7 index eq                                 % [dl] (templ) (ffn) * ? \ x i j c bool
  1547.     1 index 7 index eq or { % *?
  1548.       pop 2 index
  1549.     } if                                           % [dl] (templ) (ffn) * ? \ x i j C
  1550.     dup 5 index eq {        % \
  1551.       3 2 roll 1 add 3 1 roll                      % [dl] (templ) (ffn) * ? \ x i' j C
  1552.       2 index 8 index length ge { pop exit } if
  1553.       pop 6 index 2 index get                      % [dl] (templ) (ffn) * ? \ x i' j C'
  1554.     } if
  1555.     7 index 2 index 3 2 roll put                   % [dl] (templ) (ffn) * ? \ x i' j
  1556.     1 add exch 1 add exch                          % [dl] (templ) (ffn) * ? \ x i'' j'
  1557.   } loop                                           % [dl] (templ) (ffn) * ? \ x i j
  1558.   6 1 roll pop                                     % [dl] (templ) (ffn) j * ? \ x
  1559.   exch pop exch pop exch pop exch                  % [dl] (templ) (ffn) x j
  1560.   { dup 3 index length ge { exit } if
  1561.     3 copy exch put
  1562.     1 add
  1563.   } loop
  1564.   pop pop                                          % [dl] (templ) (ffn)
  1565.  
  1566.   % An internal procedure : 
  1567.   {                                 % {} [dl] (templ) (ffn) (dffn)
  1568.     .makepathtemplate               % {} [dl] (templ) (ffn) (Dffn)
  1569.     dup                             % {} [dl] (templ) (ffn) (Dffn) (Dffn)
  1570.     3 index length dup              % {} [dl] (templ) (ffn) (Dffn) (Dffn) templL templL
  1571.     2 index length                  % {} [dl] (templ) (ffn) (Dffn) (Dffn) templL templL DffnL
  1572.     exch sub                        % {} [dl] (templ) (ffn) (Dffn) (Dffn) templL i
  1573.     exch getinterval                % {} [dl] (templ) (ffn) (Dffn) (suffix)
  1574.     3 index exch copy pop           % {} [dl] (templ) (ffn) (dt)
  1575.     5 1 roll                        % (dt) {} [dl] (templ) (ffn)
  1576.   }
  1577.   4 1 roll                                         % {} [dl] (templ) (ffn)
  1578.  
  1579.   % Generate templates :
  1580.   dup .file_name_is_absolute {
  1581.     dup                                            % {} [dl] (templ) (ffn) (ffn)
  1582.     4 index exec                                   % (t1) {} [dl] (templ) (ffn)
  1583.   } {
  1584.     2 index {                                      % {} [dl] (templ) (ffn) (d)
  1585.       1 index                                      % {} [dl] (templ) (ffn) (d) (ffn)
  1586.       false .file_name_combine {                   % {} [dl] (templ) (ffn) (dffn)
  1587.         4 index exec                               % (t1) {} [dl] (templ) (ffn)
  1588.       } {                                          % {} [dl] (templ) (ffn) (d) (ffn)
  1589.         pop pop                                    % {} [dl] (templ) (ffn)
  1590.       } ifelse
  1591.     } forall
  1592.   } ifelse                                         % (t1) (t2) ... (tN) {} [dl] (templ) (ffn)
  1593.   pop pop pop pop                                  % (t1) (t2) ... (tN)
  1594. } bind def
  1595.  
  1596. % Load the initialization files for optional features.
  1597. %% Replace 4 INITFILES
  1598. systemdict /INITFILES known
  1599.  { INITFILES { dup runlibfile VMDEBUG } forall
  1600.  }
  1601. if
  1602.  
  1603. % If Level 2 (or higher) functionality is implemented, enable it now.
  1604. /.setlanguagelevel where {
  1605.   pop 2 .setlanguagelevel
  1606.     % If the resource machinery is loaded, fix up some things now.
  1607.   /.fixresources where { pop .fixresources } if
  1608. } if
  1609. /ll3dict where {
  1610.   pop 3 .setlanguagelevel
  1611. } if
  1612.  
  1613. (END INITFILES) VMDEBUG
  1614.  
  1615. %% Replace 1 (gs_stres.ps)
  1616. (gs_stres.ps) dup runlibfile VMDEBUG
  1617. (END STATIC RESOURCES) VMDEBUG
  1618.  
  1619. % Create a null font.  This is the initial font.
  1620. 8 dict dup begin
  1621.   /FontMatrix [ 1 0 0 1 0 0 ] readonly def
  1622.   /FontType 3 def
  1623.   /FontName () def
  1624.   /Encoding StandardEncoding def
  1625.   /FontBBox { 0 0 0 0 } readonly def % executable is bogus, but customary ...
  1626.   /BuildChar { pop pop 0 0 setcharwidth } bind def
  1627.   /PaintType 0 def        % shouldn't be needed!
  1628. end
  1629. /NullFont exch definefont setfont
  1630.  
  1631. % Define NullFont as the font.
  1632. /NullFont currentfont def
  1633.  
  1634. % Load initial fonts from FONTPATH directories, Fontmap file,
  1635. % and/or .getccfont as appropriate.
  1636. .loadinitialfonts
  1637.  
  1638. % Remove NullFont from FontDirectory, so it can't be accessed by mistake.
  1639. /undefinefont where {
  1640.   pop /NullFont undefinefont
  1641. } {
  1642.   FontDirectory /NullFont .undef
  1643. } ifelse
  1644.  
  1645. (END FONTS) VMDEBUG
  1646.  
  1647. % Restore the real definition of runlibfile.
  1648. /runlibfile /.runlibfile load def
  1649. currentdict /.runlibfile .undef
  1650.  
  1651. % Bind all the operators defined as procedures.
  1652. /.bindoperators        % binds operators in currentdict
  1653.  { % Temporarily disable the typecheck error.
  1654.    errordict /typecheck 2 copy get
  1655.    errordict /typecheck { pop } put    % pop the command
  1656.    currentdict
  1657.     { dup type /operatortype eq
  1658.        { % This might be a real operator, so bind might cause a typecheck,
  1659.      % but we've made the error a no-op temporarily.
  1660.      .bind        % do a real bind even if NOBIND is set
  1661.        }
  1662.       if pop pop
  1663.     } forall
  1664.    put
  1665.  } def
  1666. NOBIND DELAYBIND or not { .bindoperators } if
  1667.  
  1668. % Establish a default environment.
  1669.  
  1670. defaultdevice
  1671. % The following line used to skip setting of page size and resolution if
  1672. % NODISPLAY was selected.  We think this was only to save time and memory,
  1673. % and it is a bad idea because it prevents setting the resolution in this
  1674. % situation, which pstoedit (among other programs) relies on.
  1675. %DISPLAYING not { setdevice (%END DISPLAYING) .skipeof } if
  1676. systemdict /DEVICEWIDTH known
  1677. systemdict /DEVICEHEIGHT known or
  1678. systemdict /DEVICEWIDTHPOINTS known or
  1679. systemdict /DEVICEHEIGHTPOINTS known or
  1680. systemdict /DEVICEXRESOLUTION known or
  1681. systemdict /DEVICEYRESOLUTION known or
  1682. systemdict /PAPERSIZE known or
  1683. not { (%END DEVICE) .skipeof } if
  1684. % Let DEVICE{WIDTH,HEIGHT}[POINTS] override PAPERSIZE.
  1685. systemdict /PAPERSIZE known
  1686. systemdict /DEVICEWIDTH known not and
  1687. systemdict /DEVICEHEIGHT known not and
  1688. systemdict /DEVICEWIDTHPOINTS known not and
  1689. systemdict /DEVICEHEIGHTPOINTS known not and
  1690.  {    % Convert the paper size to device dimensions.
  1691.    true statusdict /.pagetypenames get
  1692.     { PAPERSIZE eq
  1693.        { PAPERSIZE load
  1694.          dup 0 get /DEVICEWIDTHPOINTS exch def
  1695.          1 get /DEVICEHEIGHTPOINTS exch def
  1696.          pop false exit
  1697.        }
  1698.       if
  1699.     }
  1700.    forall
  1701.     { (Unknown paper size: ) print PAPERSIZE ==only (.) =
  1702.     }
  1703.    if
  1704.  }
  1705. if
  1706. % Adjust the device parameters per the command line.
  1707. % It is possible to specify resolution, pixel size, and page size;
  1708. % since any two of these determine the third, conflicts are possible.
  1709. % We simply pass them to .setdeviceparams and let it sort things out.
  1710.    mark /HWResolution //null /HWSize //null /PageSize //null .dicttomark
  1711.    .getdeviceparams .dicttomark begin
  1712.    mark
  1713.     % Check for resolution.
  1714.    /DEVICEXRESOLUTION where dup
  1715.     { exch pop HWResolution 0 DEVICEXRESOLUTION put }
  1716.    if
  1717.    /DEVICEYRESOLUTION where dup
  1718.     { exch pop HWResolution 1 DEVICEYRESOLUTION put }
  1719.    if
  1720.    or { /HWResolution HWResolution } if
  1721.     % Check for device sizes specified in pixels.
  1722.    /DEVICEWIDTH where dup
  1723.     { exch pop HWSize 0 DEVICEWIDTH put }
  1724.    if
  1725.    /DEVICEHEIGHT where dup
  1726.     { exch pop HWSize 1 DEVICEHEIGHT put }
  1727.    if
  1728.    or { /HWSize HWSize } if
  1729.     % Check for device sizes specified in points.
  1730.    /DEVICEWIDTHPOINTS where dup
  1731.     { exch pop PageSize 0 DEVICEWIDTHPOINTS put }
  1732.    if
  1733.    /DEVICEHEIGHTPOINTS where dup
  1734.     { exch pop PageSize 1 DEVICEHEIGHTPOINTS put }
  1735.    if
  1736.    or { /PageSize PageSize } if
  1737.     % Check whether any parameters were set.
  1738.    dup mark eq { pop } { defaultdevice putdeviceprops } ifelse
  1739.    end
  1740. %END DEVICE
  1741. % Set any device properties defined on the command line.
  1742. % If BufferSpace is defined but not MaxBitmap, set MaxBitmap to BufferSpace.
  1743. systemdict /BufferSpace known
  1744. systemdict /MaxBitmap known not and
  1745.  { systemdict /MaxBitmap BufferSpace put
  1746.  } if
  1747. dup getdeviceprops
  1748. counttomark 2 idiv
  1749.  { systemdict 2 index known
  1750.     { pop dup load counttomark 2 roll }
  1751.     { pop pop }
  1752.    ifelse
  1753.  } repeat
  1754. counttomark dup 0 ne
  1755.  { 2 add -1 roll putdeviceprops }
  1756.  { pop pop }
  1757. ifelse
  1758. % If the initial device parameters are invalid, the setdevice may fail.
  1759. % Trap this and produce a reasonable error message.
  1760. { setdevice }        % does an erasepage
  1761. INITDEBUG { exec false } { .internalstopped } ifelse {
  1762.   (**** Unable to open the initial device, quitting.) = flush 1 .quit
  1763. } if
  1764.  
  1765. % If the media size is fixed, update the current page device dictionary.
  1766. FIXEDMEDIA
  1767. dup { pop systemdict /.currentpagedevice known } if
  1768. dup { pop .currentpagedevice exch pop } if
  1769. not { (%END MEDIA) .skipeof } if
  1770. currentpagedevice dup length dict .copydict
  1771. dup /Policies
  1772.     % Stack: <pagedevice> <pagedevice> /Policies
  1773. 1 index /InputAttributes
  1774. 2 copy get dup length dict .copydict
  1775.     % Stack: <pagedevice> <pagedevice> /Policies <pagedevice>
  1776.     %   /InputAttributes <inputattrs'>
  1777. dup 0 2 copy get dup length dict .copydict
  1778.     % Stack: <pagedevice> <pagedevice> /Policies <pagedevice>
  1779.     %   /InputAttributes <inputattrs'> <inputattrs'> 0 <attrs0'>
  1780. dup /PageSize 7 index /PageSize get
  1781. put                % PageSize in 0
  1782. put                % 0 in InputAttributes
  1783. put                % InputAttributes in pagedevice
  1784. % Also change the page size policy so we don't get an error.
  1785.     % Stack: <pagedevice> <pagedevice> /Policies
  1786. 2 copy get dup length dict .copydict
  1787.     % Stack: <pagedevice> <pagedevice> /Policies <policies'>
  1788. dup /PageSize 7 put        % PageSize in Policies
  1789. put                % Policies in pagedevice
  1790. .setpagedevice
  1791. %END MEDIA
  1792.  
  1793. % Set up the interpreter context version of -dUSeCIEColor option
  1794. % so that .getuseciecolor has the correct value (see gs_setpd.ps)
  1795. /setpagedevice where {
  1796.   pop systemdict /UseCIEColor known {
  1797.     mark /UseCIEColor UseCIEColor .dicttomark setpagedevice
  1798.   } if
  1799. } if
  1800.  
  1801. %END DISPLAYING
  1802.  
  1803. (END DEVICE) VMDEBUG
  1804.  
  1805. % Establish a default upper limit in the character cache,
  1806. % namely, enough room for a 18-point character at the resolution
  1807. % of the default device, or for a character consuming 1% of the
  1808. % maximum cache size, whichever is larger.
  1809. mark
  1810.     % Compute limit based on character size.
  1811.   18 dup dtransform
  1812.   exch abs cvi 31 add 32 idiv 4 mul    % X raster
  1813.   exch abs cvi mul        % Y
  1814.     % Compute limit based on allocated space.
  1815.   cachestatus pop pop pop pop pop exch pop 0.01 mul cvi
  1816.   .max dup 10 idiv exch
  1817. setcacheparams
  1818. % Conditionally disable the character cache.
  1819. NOCACHE { 0 setcachelimit } if
  1820.  
  1821. (END CONFIG) VMDEBUG
  1822.  
  1823. % Initialize graphics.
  1824.  
  1825. .setdefaultscreen
  1826. initgraphics
  1827.  
  1828. % The interpreter relies on there being at least 2 entries
  1829. % on the graphics stack.  Establish the second one now.
  1830. gsave
  1831.  
  1832. % Define some control sequences as no-ops.
  1833. % This is a hack to get around problems
  1834. % in some common PostScript-generating applications.
  1835. <04> cvn JOBSERVER {
  1836.     { { clear cleardictstack //false 0 .startnewjob } 2 .stop } bind
  1837.   } {
  1838.     { }
  1839.   } ifelse def
  1840. <1b> cvn {             % UEL is <esc>%-12345X and acts the same as ^D
  1841.   currentfile (%-12345X) .peekstring pop (%-12345X) eq <04> cvn load if
  1842. } bind def
  1843. <1b45> cvn { } def        % PJL reset prologue (ESC E)
  1844. <1b451b> cvn <1b> cvn load def    % PJL reset epilogue (ESC E + UEL)
  1845. (\001M) cvn            % TBCP initiator
  1846.  { currentfile /TBCPDecode filter cvx exec
  1847.  } bind def
  1848. /@PJL                % H-P job control
  1849.  {
  1850.    % Windows 2000 driver includes PJL into %%BeginFeature block.
  1851.    % Identify this from the pattern on the stack: countdictstack lucas mark
  1852.    % and fail the feature request.
  1853.  
  1854.    count 3 ge {
  1855.      dup mark eq {
  1856.        2 index countdictstack eq {
  1857.           1 index /lucas where { /lucas get eq } { pop false } ifelse {
  1858.             stop
  1859.          } if
  1860.        } if
  1861.      } if
  1862.    } if
  1863.    currentfile //=string readline pop pop
  1864.  } bind def
  1865.  
  1866. % Install the EPS handler if needed
  1867. systemdict /EPSBoundingBoxInit known { EPSBoundingBoxInit } if
  1868.  
  1869. % If we want a "safer" system, disable some obvious ways to cause havoc.
  1870. .currentglobal true .setglobal
  1871. /SAFETY 2 dict
  1872.   dup /safe false put
  1873.   dup /tempfiles 10 dict readonly put
  1874. readonly def
  1875. .setglobal
  1876.  
  1877. /.locksafe {
  1878.   SAFETY /safe get not {
  1879.     <<
  1880.       /PermitFileReading [
  1881.         currentuserparams /PermitFileReading get aload pop
  1882.         /FONTPATH .systemvar (*) .generate_dir_list_templates
  1883.           % Library files : 
  1884.         /LIBPATH  .systemvar (*) .generate_dir_list_templates       
  1885.           % Resource files on OpenVMS requires a separate template (gs:[dir.*]*)
  1886.           % because the (gs:[dir]*) doesn't cover them.
  1887.         /LIBPATH  .systemvar (*) .file_name_separator (*)
  1888.           concatstrings concatstrings .generate_dir_list_templates
  1889.         .languagelevel 2 ge {
  1890.             % Default resources :
  1891.           [ currentsystemparams /GenericResourceDir get] (*) .generate_dir_list_templates
  1892.             % Default resources (OpenVMS, see comment above.) :
  1893.           [ currentsystemparams /GenericResourceDir get] (*) .file_name_separator (*)
  1894.             concatstrings concatstrings .generate_dir_list_templates
  1895.         } if
  1896.       ]
  1897.       /LockFilePermissions true
  1898.     >> setuserparams
  1899.   }
  1900.   if
  1901.   % setpagedevice has the side effect of clearing the page, but
  1902.   % we will just document that. Using setpagedevice keeps the device
  1903.   % properties and pagedevice .LockSafetyParams in agreement even
  1904.   % after a restore that changes the value to false.
  1905.   currentglobal currentpagedevice gcheck setglobal % use correct VM space
  1906.   << /.LockSafetyParams true >> setpagedevice
  1907.   setglobal
  1908.   //SAFETY /safe //true .forceput % overrides readonly
  1909. } .bind executeonly odef
  1910.  
  1911. /.setsafe
  1912. {
  1913.   SAFETY /safe get not {
  1914.     <<
  1915.       /PermitFileReading [ ]
  1916.       /PermitFileWriting [ ]
  1917.       /PermitFileControl [ ]
  1918.     >> setuserparams
  1919.   }
  1920.   if
  1921.   .locksafe
  1922. } .bind executeonly odef
  1923.  
  1924. /deletefile {
  1925.   count 1 lt {
  1926.     //deletefile /stackunderflow signalerror
  1927.   }
  1928.   if
  1929.   dup { deletefile } stopped {
  1930.     pop //deletefile $error /errorname get signalerror
  1931.   } {
  1932.     % deletefile succeeded. Remove from tempfile list if present
  1933.     //SAFETY /tempfiles get exch cvn 2 copy known {
  1934.       .forceundef
  1935.     } {
  1936.       pop pop
  1937.     }
  1938.     ifelse
  1939.   }
  1940.   ifelse
  1941. } .bind executeonly odef
  1942.  
  1943. % If a file is opened with .tempfile with SAFER not (yet) set,
  1944. % the file can be deleted later, even if SAFER is set.
  1945. /.tempfile {
  1946.   .tempfile    % filename file
  1947.   //SAFETY /tempfiles get 2 index true .forceput
  1948. } .bind executeonly odef
  1949.  
  1950. % If we are running in SAFER mode, lock things down
  1951. SAFER { .setsafe } if
  1952.  
  1953. % If we delayed binding, make it possible to do it later.
  1954. /.bindnow {
  1955.   currentuserparams /IdiomRecognition .knownget {
  1956.     1 dict dup /IdiomRecognition //false put setuserparams
  1957.   } if
  1958.   //systemdict begin .bindoperators end
  1959.   % Temporarily disable the typecheck error.
  1960.   errordict /typecheck 2 copy get
  1961.   errordict /typecheck { pop } put    % pop the command
  1962.   0 1 .delaycount 1 sub { .delaybind exch get .bind pop } for
  1963.   //systemdict /.delaybind {} .forceput    % reclaim the space
  1964.   //systemdict /.bindnow .forceundef    % ditto
  1965.   put
  1966.   //systemdict /.forcedef .forceundef        % remove temptation
  1967.   //systemdict /.forceput .forceundef        % ditto
  1968.   //systemdict /.forceundef .forceundef        % ditto
  1969.   currentuserparams /IdiomRecognition known {
  1970.     1 dict dup /IdiomRecognition 4 -1 roll put setuserparams
  1971.   } if
  1972. } .bind odef
  1973.  
  1974. % Turn off array packing, since some PostScript code assumes that
  1975. % procedures are writable.
  1976. false setpacking
  1977.  
  1978. (END INIT) VMDEBUG
  1979.  
  1980. /.currentuserparams where {
  1981.   pop
  1982.     % Remove real user params from psuserparams.
  1983.   mark .currentuserparams counttomark 2 idiv {
  1984.     pop psuserparams exch undef
  1985.   } repeat pop
  1986.     % Update the copy of the user parameters.
  1987.   mark .currentuserparams counttomark 2 idiv {
  1988.     userparams 3 1 roll .forceput    % userparams is read-only
  1989.   } repeat pop
  1990.     % Turn on idiom recognition, if available.
  1991.   currentuserparams /IdiomRecognition known {
  1992.     /IdiomRecognition true .definepsuserparam
  1993.   } if
  1994.   psuserparams readonly pop
  1995.   systemdict /.definepsuserparam undef
  1996.     % Save a copy of userparams for use with save/restore
  1997.     % (and, if implemented, context switching).
  1998.   .currentglobal false .setglobal
  1999.      mark userparams { } forall .dicttomark readonly
  2000.      /userparams exch .forcedef        % systemdict is read-only
  2001.   .setglobal
  2002. } if
  2003. /.currentsystemparams where {
  2004.   pop
  2005.     % Remove real system params from pssystemparams.
  2006.   mark .currentsystemparams counttomark 2 idiv {
  2007.     pop pssystemparams exch .forceundef
  2008.   } repeat pop
  2009. } if
  2010.  
  2011. % Set up AlignToPixels :
  2012.  
  2013. /AlignToPixels where {
  2014.   mark /AlignToPixels 2 index /AlignToPixels get .dicttomark setuserparams
  2015.   /AlignToPixels undef
  2016. } if
  2017.  
  2018. % Set up GridFitTT :
  2019.  
  2020. /GridFitTT where {
  2021.   mark /GridFitTT 2 index /GridFitTT get .dicttomark setuserparams
  2022.   /GridFitTT undef
  2023. } if
  2024.  
  2025. % Conditionally turn image interpolation on or off.
  2026. currentdict /INTERPOLATE known not { (%END INTERPOLATE) .skipeof } if
  2027.  
  2028. /.interpolate {
  2029.   dup /Interpolate .knownget not { //false } if
  2030.   /INTERPOLATE .systemvar ne {
  2031.     dup gcheck .currentglobal exch .setglobal
  2032.     exch dup length dict copy
  2033.     dup /Interpolate /INTERPOLATE .systemvar put
  2034.     exch .setglobal
  2035.   } if
  2036. } bind odef
  2037.  
  2038. /colorimage
  2039.   { /INTERPOLATE .systemvar
  2040.       { .currentglobal                    % w h bit [] {}...{} multi ncomp glob
  2041.         //false .setglobal
  2042.         9 dict begin                      % w h bit [] {}...{} multi ncomp glob
  2043.         2 index { 1 index 7 add } { 8 } ifelse
  2044.         copy gsave pop                    % preserve the arguments
  2045.         { 0 /DeviceGray 0 /DeviceRGB /DeviceCMYK }
  2046.         1 index get setcolorspace         % ... glob w h bit [] {}...{} multi ncomp
  2047.         {0 1 0 1 0 1 0 1}
  2048.         1 index 2 mul 0 exch              % ... glob w h bit [] {}...{} multi ncomp {0 1 ...} 0 2*ncomp
  2049.         getinterval /Decode exch def      % ... glob w h bit [] {}...{} multi ncomp
  2050.         exch dup                          % ... glob w h bit [] {}...{} ncomp multi multi
  2051.         /MultipleDataSources exch def     % ... glob w h bit [] {}...{} ncomp multi
  2052.         { array astore} { pop } ifelse    % ... glob w h bit [] [{}...{}]
  2053.         /DataSource exch def              % ... glob w h bit []
  2054.         /ImageMatrix exch def             % ... glob w h bit
  2055.         /BitsPerComponent exch def        % ... glob w h
  2056.         /Height exch def                  % ... glob w
  2057.         /Width exch def                   % ... glob 
  2058.         /ImageType 1 def
  2059.         /Interpolate //true def
  2060.         .setglobal currentdict end        % ... <<>>
  2061.         image grestore
  2062.         exch { 4 add } { 6 } ifelse
  2063.         { pop } repeat                    % -
  2064.       }
  2065.       { colorimage
  2066.       }
  2067.     ifelse
  2068.   } bind odef
  2069.  
  2070. /image
  2071.   { dup type /dicttype eq
  2072.       { dup /ImageType get 3 eq
  2073.           { .currentglobal //false .setglobal exch
  2074.             dup length dict copy begin .setglobal 
  2075.             /DataDict DataDict .interpolate def
  2076.             /MaskDict MaskDict .interpolate def
  2077.             currentdict end
  2078.           }
  2079.           { .interpolate 
  2080.           }
  2081.         ifelse
  2082.         image
  2083.       }
  2084.       { /INTERPOLATE .systemvar
  2085.           { .currentglobal //false .setglobal
  2086.             8 dict begin .setglobal
  2087.             /ImageType 1 def
  2088.             /DataSource 1 index def
  2089.             /ImageMatrix 2 index def
  2090.             /BitsPerComponent 3 index def
  2091.             /Decode {0 1} def
  2092.             /Height 4 index def
  2093.             /Width 5 index def
  2094.             /Interpolate //true def
  2095.             currentdict end
  2096.             gsave /DeviceGray setcolorspace image grestore
  2097.             5 { pop } repeat
  2098.           }
  2099.           { image
  2100.           }
  2101.         ifelse
  2102.       }
  2103.     ifelse
  2104.   } bind odef
  2105.  
  2106. /imagemask {
  2107.   dup type /dicttype eq {
  2108.     .interpolate imagemask
  2109.   } {
  2110.     /INTERPOLATE .systemvar {
  2111.       .currentglobal //false .setglobal
  2112.       8 dict begin .setglobal
  2113.       /ImageType 1 def
  2114.       /DataSource 1 index def
  2115.       /ImageMatrix 2 index def
  2116.       /BitsPerComponent 1 def
  2117.       2 index { {1 0} } { {0 1} } ifelse /Decode exch def
  2118.       /Height 4 index def
  2119.       /Width 5 index def
  2120.       /Interpolate //true def
  2121.       currentdict end imagemask 5 { pop } repeat
  2122.     } {
  2123.       imagemask
  2124.     } ifelse
  2125.   } ifelse
  2126. } bind odef
  2127.  
  2128. currentdict /.interpolate undef
  2129.  
  2130. %END INTERPOLATE
  2131.  
  2132. % Establish local VM as the default.
  2133. false /setglobal where { pop setglobal } { .setglobal } ifelse
  2134. $error /.nosetlocal false put
  2135.  
  2136. (END GLOBAL) VMDEBUG
  2137.  
  2138. /.savelocalstate where {
  2139.     % If we might create new contexts, save away copies of all dictionaries
  2140.     % referenced from systemdict that are stored in local VM,
  2141.     % and also save a copy of the initial gstate.
  2142.   pop .savelocalstate
  2143. } {
  2144.     % If we're *not* running in a multi-context system and FAKEFONTS is
  2145.     % defined, add the fake fonts to LocalFontDirectory.
  2146.   .definefakefonts    % current VM is local
  2147. } ifelse
  2148.  
  2149. % Execude schedilled inits :
  2150. //.execute_schedulled_inits exec
  2151. currentdict /.execute_schedulled_inits undef
  2152. currentdict /.delayed_init_queue undef
  2153. currentdict /.delayed_init_queue undef
  2154.  
  2155. % Remove systemdict entries for things that have been bound in where used
  2156. % and that shouldn't be accessible by name, and close up systemdict.
  2157. currentdict /filterdict .undef
  2158. currentdict /.cidfonttypes .undef
  2159. currentdict /.colorrenderingtypes .undef
  2160. currentdict /.formtypes .undef
  2161. currentdict /.halftonetypes .undef
  2162. currentdict /.imagetypes .undef
  2163. currentdict /.imagemasktypes .undef
  2164. currentdict /.patterntypes .undef
  2165. currentdict /.shadingtypes .undef
  2166. currentdict /.wheredict .undef
  2167. end
  2168.  
  2169. % Clean up VM, and enable GC.
  2170. /vmreclaim where
  2171.  { pop NOGC not { 2 vmreclaim 0 vmreclaim } if
  2172.  } if
  2173. DELAYBIND not {
  2174.   systemdict /.forcedef .undef        % remove temptation
  2175.   systemdict /.forceput .undef        % ditto
  2176.   systemdict /.forceundef .undef    % ditto
  2177. } if
  2178. WRITESYSTEMDICT not { systemdict readonly pop } if
  2179. (END GC) VMDEBUG
  2180.  
  2181. % The Adobe AGM_Core used by Illustrator 9 has some code that breaks
  2182. % if the 'product' is not (Adobe PostScript Parser). A bug has been
  2183. % submitted to Adobe since this also fails with Acrobat Distiller.
  2184. % As a temporary work around, the following HACK will work for
  2185. % devices without spot color support. Once Ghostscript can
  2186. % support DeviceN and spot color separations this will need to
  2187. % be 'true' in some cases.
  2188. userdict /AGM_preserve_spots false put
  2189.  
  2190. % Start the job as encapsulated if requested, if not, perform an
  2191. % outer save so that jobs which depend on global VM not being
  2192. % restored will operate correctly.
  2193. % 
  2194. % Note that .setsafe is already in effect if in SAFER mode.
  2195. % so an exitserver will restore with SAFER mode still in effect.
  2196. JOBSERVER
  2197.   { false 0 .startnewjob }
  2198.   { NOOUTERSAVE not { save pop } if }    % do the outermost save unless disabled
  2199. ifelse
  2200.  
  2201. % The interpreter will run the initial procedure (start).
  2202.