%    Copyright (C) 1989, 1990, 1991 Aladdin Enterprises.  All rights reserved.
%    Distributed by Free Software Foundation, Inc.
%
% This file is part of Ghostscript.
%
% Ghostscript is distributed in the hope that it will be useful, but
% WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
% to anyone for the consequences of using it or for whether it serves any
% particular purpose or works at all, unless he says so in writing.  Refer
% to the Ghostscript General Public License for full details.
%
% Everyone is granted permission to copy, modify and redistribute
% Ghostscript, but only under the conditions described in the Ghostscript
% General Public License.  A copy of this license is supposed to have been
% given to you along with Ghostscript so you can know your rights and
% responsibilities.  It should be in a file named COPYING.  Among other
% things, the copyright notice and this notice must be preserved on all
% copies.

%
%  ***********************************************************************
%  *                                                                     *
%  *    M   M    OOO    DDDD     III    FFFFF    III    EEEEE   DDDD     *
%  *    MM MM   O   O   D   D     I     F         I     E       D   D    *
%  *    M M M   O   O   D   D     I     F         I     E       D   D    *
%  *    M   M   O   O   D   D     I     FFF       I     EEE     D   D    *
%  *    M   M   O   O   D   D     I     F         I     E       D   D    *
%  *    M   M   O   O   D   D     I     F         I     E       D   D    *
%  *    M   M    OOO    DDDD     III    F        III    EEEEE   DDDD     *
%  *                                                                     *
%  *                                                                     *
%  *                   FFFFF    III    L       EEEEE                     *
%  *                   F         I     L       E                         *
%  *                   F         I     L       E                         *
%  *                   FFF       I     L       EEE                       *
%  *                   F         I     L       E                         *
%  *                   F         I     L       E                         *
%  *                   F        III    LLLLL   EEEEE                     *
%  *                                                                     *
%  ***********************************************************************
%
%                              .-------------.
%                              |      /\     |
%                              |     /  \    |
%                              |    / /\ \   |
%                              |   / /  \ \  |
%                              |  / / /\ \ \ |
%                              | / / /  \ \ \|
%                              `-------------'  (R)
%                               Autodesk, Inc.
%                   Tools For the Golden Age of Engineering
%
%   In  keeping with subparagraph 2a of the Gnu General Public License
%   (Version 1, February 1989):
%
%   2.  You may modify your copy or  copies  of  the  Program  or  any
%   portion  of  it,  and copy and distribute such modifications under
%   the terms of Paragraph 1 above, provided  that  you  also  do  the
%   following:
%
%      a)  cause the modified files to carry prominent notices stating
%          that you changed the files and the date of any change; and...
%
%   the  following  is  a  summary of the changes to this file made by
%   Autodesk, Inc. in August 1991 in order to adapt Ghostscript to run
%   as  an  ADS  application  and  thereby  to  perform  rendering  of
%   PostScript files within AutoCAD.
%
%
%   ACADPSI.PS      I implemented a new procedure, "arun", which  is  used
%                   by  the  (PSGEN)  function  to run PostScript programs
%                   included  with the PSIN command.  "Arun" is a somewhat
%                   more intelligent version of "run"  which  accommodates
%                   variants  of  PostScript one encounters, especially on
%                   MS-DOS machines.   If  the  binary  "EPSF"  header  is
%                   present,  used  by  desktop  publishing programs which
%                   append a bitmap of the PostScript image to  the  file,
%                   arun  recognises the sentinel, extracts the pointer to
%                   the  bitmap  from  the  header,  and  uses   the   new
%                   setsubfilelimit  operator  to  logically  truncate the
%                   file at that point.  A setfileposition is then done to
%                   skip the header.  To allow processing files with a few
%                   bytes of garbage before the "%!" sentinel, arun  reads
%                   through the file searching for "%!", ignoring anything
%                   it finds before the sentinel.
%
%                   Ghostscript   master   initialisation   file.   Called
%                   GS_INIT.PS in standard Ghostscript.   I  added  a  new
%                   "acadpsversion"  operator  to return the local version
%                   of ACADPS ("2.2-ACADPS:Q001-JW1" in this release).   I
%                   extended error handling to call "flagerrorhappened" so
%                   that the error code can be returned to the  caller  of
%                   (PSGEN).   I  changed  the file name references to the
%                   ACADPSx.PS conventions and integrated the  local  code
%                   for  ARUN, etc., from the version based on Ghostscript
%                   2.1.1.  I used the new NOPAUSE  variable  to  suppress
%                   the  pause  in  "copypage"  and "showpage" rather than
%                   commenting out the user prompt as before.  (New file.)
%
%
% ************************************************************************

% Initialization file for Ghostscript.
% When this is run, systemdict is still writable.

% Acquire the debugging flags.
currentdict /DEBUG known   /DEBUG exch def
  /VMDEBUG
    DEBUG {{vmstatus pop (      ) cvs print pop ( ) print
            systemdict length (      ) cvs print (\n) print flush}}
          {{}} ifelse
  def
currentdict /NODISPLAY known   not /DISPLAYING exch def
currentdict /NOBIND known { /.bind /bind load def   /bind { } def } if
currentdict /NOCACHE known   /NOCACHE exch def
currentdict /NOPAUSE known   /NOPAUSE exch def
currentdict /QUIET known   /QUIET exch def

QUIET not { (Initializing... ) print flush } if

% Acquire systemdict and userdict.
% Note that the dictionary stack only has 1 element at this point!
/systemdict currentdict def
/userdict 200 dict def
userdict begin          % 2 elements now
systemdict begin

VMDEBUG

% Define true and false.
/true 0 0 eq def
/false 0 1 eq def

% Turn on array packing for the rest of initialization.
true setpacking

% Acquire the standard files.
/.stdin (%stdin) (r) file def
/.stdout (%stdout) (w) file def
/.stderr (%stderr) (w) file def

% Define a special version of def for making operator procedures.
/odef
        {1 index exch makeoperator def} bind def

% Define predefined procedures substituting for operators,
% in alphabetical order.
/[      /mark load def
/]      {counttomark array astore exch pop} odef
/abs    {dup 0 lt {neg} if} odef
/cleardictstack
        {countdictstack 2 sub {end} repeat} odef
/.copypage /copypage load def
/copypage
        {.copypage
         (>>copypage, press <return> to continue<<\n) .confirm} odef
/defaultmatrix
        {currentdevice exch deviceparams pop pop
         counttomark 1 add 1 roll cleartomark} odef
/.echo /echo load def
userdict /.echo.mode true put
/echo   {dup /.echo.mode exch store .echo} odef
/eexec  {55665 exch type1decryptfile
         cvx systemdict begin stopped end
         $error /newerror get and {handleerror} if} odef
/executive
        { { prompt (%statementedit) (r) file
            dup bytesavailable 0 lt
             { .stdin bytesavailable 0 lt {closefile exit} if }
            if cvx execute
          } loop
        } odef
/framedevice
        {.stderr (Warning: framedevice is an obsolete operator.\n) writestring
         .stderr flushfile
         pop pop pop setmatrix initclip} odef
/handleerror
        {errordict /handleerror get exec} bind def
/identmatrix
        {{1.0 0.0 0.0 1.0 0.0 0.0} cvlit exch copy} odef
/initgraphics
        {initmatrix newpath initclip 1 setlinewidth 0 setlinecap 0 setlinejoin
         [] 0 setdash 0 setgray 10 setmiterlimit} odef
/initmatrix
        {.tempmatrix defaultmatrix setmatrix} odef
/matrix {6 array identmatrix} odef
/prompt {flush flushpage
         (GS) print count 0 ne
          {(<) print count =only}
         if (>) print flush} bind def
/pstack {0 1 count 3 sub {index ==} for} odef
/run    {dup type /filetype eq { true } { findlibfile } ifelse
          {cvx execute}
          {(r) file}            % let the error happen
         ifelse} odef
/selectfont
        { exch findfont exch
          dup type /arraytype eq { makefont } { scalefont } ifelse
          setfont
        } odef
/showpage
        {.copypage (>>showpage, press <return> to continue<<\n) .confirm
         erasepage initgraphics} odef
/stack  {0 1 count 3 sub {index =} for} odef
/start  { QUIET not
          {(Ghostscript ) print .version print
           (  Copyright (C) 1990, 1991 Aladdin Enterprises,\n) print
           (   Menlo Park, CA.  All rights reserved.\n) print
           (Distributed by Free Software Foundation, Inc.\n) print
           (Ghostscript comes with NO WARRANTY: see the file COPYING for details.\n) print
           flush
          } if
          executive
        } def
% Define version so it prints a warning once, for programs that think that
% they are going to get an Adobe interpreter version.
/version
        { <00>          % Flag to make sure we only do this once
          dup 0 get 0 eq
           { .stderr (Warning -- Ghostscript version #s are not the same as Adobe version #s.\n) writestring
             .stderr flushfile
             0 1 put
           }
           { pop }
          ifelse .version
        } odef
/.version
        (2.2) def

%   ACADPS version string, including base Ghostscript version
/acadpsversion
        (2.2-ACADPS:Q001-JW1) def

% Provide semi-fake but usable definitions for
% the color PostScript extensions (except for colorimage,
% which is actually implemented as an operator).
/setcmykcolor {
        1 exch sub dup dup              % C, M, Y, S, S, S
        6 -1 roll 1 exch sub mul        % M, Y, S, S, red
        exch 5 -1 roll 1 exch sub mul   % Y, S, red, green
        4 -2 roll exch 1 exch sub mul   % red, green, blue
        setrgbcolor
} odef
/currentcmykcolor {
        currentrgbcolor
        3 { 1 exch sub 3 1 roll } repeat
        0
} odef
/setblackgeneration {
        pop
} odef
/currentblackgeneration {
        {}
} odef
/setundercolorremoval {
        pop
} odef
/currentundercolorremoval {
        {}
} odef
/setcolorscreen {
        setscreen 9 {pop} repeat
} odef
/currentcolorscreen {
        currentscreen 3 copy 6 copy
} odef

% Define some additional built-in procedures (beyond the ones defined by
% the PostScript Language Reference Manual).
/concatprocs
        { exch cvlit exch cvlit         % proc1 proc2
          dup length 2 index length add array   % proc1 proc2 newproc
          dup 0 4 index putinterval
          dup 3 index length 3 index putinterval
          exch pop exch pop cvx
        } bind def
/concatstrings
        { 1 index length 1 index length add string
          2 index 1 index copy pop
          dup 3 index length 3 index length getinterval
          2 index exch copy pop
          exch pop exch pop
        } bind def
/copyarray
        { dup length array copy } bind def
/copystring
        { dup length string copy } bind def
/defaultdevice
        { systemdict /DEVICE known
           { systemdict /DEVICE get finddevice }
           { 0 getdevice }
          ifelse
        } bind def
/finddevice
        { systemdict /devicedict get exch get } bind def
/rgbcolor
        { gsave setrgbcolor currentgscolor grestore } bind def
/selectdevice
        { finddevice setdevice } bind def
/signalerror            % object errorname
        { errordict exch get exec } bind def

% Define auxiliary procedures needed for the above.
/shellarguments         % -> shell_arguments true (or) false
        { /ARGUMENTS where
           { /ARGUMENTS get dup type /arraytype eq
              { aload pop /ARGUMENTS null store true }
              { pop false }
             ifelse }
           { false } ifelse
        } bind def
/.confirm
        {DISPLAYING NOPAUSE not and
          {% Print a message and wait for the user to type something.
           % If the user just types a newline, flush it.
           print flush
           .echo.mode false echo
             .stdin dup read
             {dup (\n) 0 get eq {pop pop} {unread} ifelse} {pop} ifelse
           echo}
          {pop} ifelse} bind def
/.identmatrix           % a read-only identity matrix
        matrix readonly def
/.tempmatrix            % a temporary matrix
        matrix def

% Define the procedure used by the C executive for executing user input,
% and also by the run operator.
% This is called with a procedure or file on the operand stack.
/execute
        {stopped $error /newerror get and {handleerror} if} odef

% Create the error handling machinery.
% The interpreter has created the ErrorNames array.
% Define $error.
/$error 11 dict def             % newerror, errorname, command, errorinfo,
                                % ostack, estack, dstack, recordstacks,
                                % binary, .inerror, position
$error begin
  /newerror false def
  /recordstacks true def
  /binary false def
  /.inerror false def
end
% Define errordict.  It has one entry per error name, plus handleerror.
/errordict ErrorNames length 1 add dict def
% Define the standard error handlers.  When they are invoked,
% the top element of the o-stack is the error name;
% the next element is the offending command.
errordict begin
  { //$error /.inerror get .instopped not or
     { (Unrecoverable error: ) print =only flush
       ( in ) print = flush
       count 0 gt
        { (Operand stack:\n  ) print
          0 1 count 3 sub { (  ) print index =only flush } for
          (\n) print flush
        } if
       quit
     } if       % detect error recursion
    $error /.inerror true put
    $error /newerror true put
    $error exch /errorname exch put
    $error exch /command exch put
    $error /dstack undef
    $error /estack undef
    $error /ostack undef
    $error /recordstacks get $error /errorname get /VMerror ne and
     { $error /dstack countdictstack array dictstack put
       $error /estack countexecstack array execstack put
       count array astore dup $error exch /ostack exch put
         aload pop
     } if
    $error /.inerror false put
    stop
  } bind
  ErrorNames
   { [ 1 index 3 index /exec load ] cvx def
   } forall
  pop
end
% Define the standard handleerror.
errordict 
begin
    /handleerror
    { 
	$error 
	begin
	    errorname (interrupt) eq
	    { 
		% Do not print out error messages and stack traces
		% for interrupts; PSIN, if anyone, has that job.
	    }
	    {
		(Error: ) print
		errorname ==only flush
		( in ) print
		/command load ==only flush
		currentdict /ostack known
		{ 
		    (\nOperand stack:\n  ) print ostack { 
			(  ) print ==only 
		    } forall
		} if
		currentdict /estack known
		{ 
		    (\nExecution stack:\n  ) print estack { 
			(  ) print =only 
		    } forall
		} if
		currentdict /dstack known
		{ 
		    (\nDictionary stack:\n  ) print dstack
		    { 
			dup (  ) print length =only (/) print maxlength =only 
		    } forall
		} if
		(\n) print
	    } ifelse
	    flagerrorhappened
	    /newerror false def
	end
	currentdict /position known
	{ 
	    (Current file position is ) print position = 
	}
	if
	flush
	.instopped {
	    stop
	} if
    } bind def
end

% Define the =[only] procedures.  Also define =print and =string,
% which are used by some P*stScr*pt programs even though
% they aren't documented anywhere.
/=print {=only} def
/=string 128 string def
/=      {=only (\n) print} bind def
4 dict begin
  /.buf =string def
  /.print
        {dup type currentdict exch known
         {dup type exec} {.buf cvs print} ifelse
        } bind def
  /stringtype
        {dup rcheck not {pop (--nostringval--)} if print} bind def
  /nametype
        {dup length .buf length gt
         {dup length string}
         {.buf}
        ifelse cvs print} bind def
{0 begin .print end} copyarray dup 0 currentdict put
  cvx bind
end
/=only exch def

% Define the [write]==[only] procedures.
/==     {==only (\n) print} bind def
/==only {.stdout exch write==only} bind def
/write==
        {2 copy write==only pop (\n) writestring} bind def
/.dict 17 dict dup
begin def
  /.buf 128 string def
  /.cvp {.buf cvs .p} bind def
% /.f {the_output_file} def
  /.nop {(-) .p type .cvp (-) .p} bind def
  /.p {.f exch writestring} bind def
  /.p1 {.f exch write} bind def
  /.print
        {dup type .dict exch known
         {dup type exec} {.nop} ifelse
        } bind def
  /integertype /.cvp load def
  /realtype /.cvp load def
  /booleantype /.cvp load def
  /nametype
        {dup xcheck not {(/) .p} if
         dup length .buf length gt
          {dup length string}
          {.buf}
         ifelse cvs .p} bind def
  /arraytype
        {dup rcheck
          {dup xcheck {(})({)} {(])([)} ifelse .p
           exch () exch
           {exch .p .print ( )} forall pop .p}
          {.nop}
         ifelse} bind def
  /operatortype
        {(--) .p .cvp (--) .p} bind def
  /packedarraytype /arraytype load def
  /stringtype
        {dup rcheck
          {(\() .p
           {/.ch exch def
            .ch 32 lt .ch 127 ge or
            {(\\) .p .ch 8#1000 add 8 .buf cvrs 1 3 getinterval .p}
            {.ch 40 eq .ch 41 eq or .ch 92 eq or
             {(\\) .p} if
             .ch .p1}
            ifelse}
           forall (\)) .p}
          {.nop}
         ifelse} bind def
{0 begin exch cvlit /.f exch def .print end} copyarray dup 0 .dict put
  bind cvx
end
/write==only exch def

VMDEBUG

% Define the font directory.
% Make it big to leave room for transformed fonts.
/FontDirectory 100 dict def

% Define the standard encoding vector.
/StandardEncoding
% \00x
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
% \04x
    /space /exclam /quotedbl /numbersign
        /dollar /percent /ampersand /quoteright
    /parenleft /parenright /asterisk /plus
        /comma /hyphen /period /slash
    /zero /one /two /three
        /four /five /six /seven
    /eight /nine /colon /semicolon
        /less /equal /greater /question
% \10x
    /at /A /B /C /D /E /F /G
    /H /I /J /K /L /M /N /O
    /P /Q /R /S /T /U /V /W
    /X /Y /Z /bracketleft /backslash /bracketright /asciicircum /underscore
% \14x
    /quoteleft /a /b /c /d /e /f /g
    /h /i /j /k /l /m /n /o
    /p /q /r /s /t /u /v /w
    /x /y /z /braceleft /bar /braceright /asciitilde /.notdef
% \20x
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
% \24x
    /.notdef /exclamdown /cent /sterling
        /fraction /yen /florin /section
    /currency /quotesingle /quotedblleft /guillemotleft
        /guilsinglleft /guilsinglright /fi /fl
    /.notdef /endash /dagger /daggerdbl
        /periodcentered /.notdef /paragraph /bullet
    /quotesinglbase /quotedblbase /quotedblright /guillemotright
        /ellipsis /perthousand /.notdef /questiondown
% \30x
    /.notdef /grave /acute /circumflex /tilde /macron /breve /dotaccent
    /dieresis /.notdef /ring /cedilla /.notdef /hungarumlaut /ogonek /caron
    /emdash /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
% \34x
    /.notdef /AE /.notdef /ordfeminine /.notdef /.notdef /.notdef /.notdef
    /Lslash /Oslash /OE /ordmasculine /.notdef /.notdef /.notdef /.notdef
    /.notdef /ae /.notdef /.notdef /.notdef /dotlessi /.notdef /.notdef
    /lslash /oslash /oe /germandbls /.notdef /.notdef /.notdef /.notdef
256 packedarray def

% Define the ISO Latin-1 encoding vector.
% The first half is the same as the standard encoding.
/ISOLatin1Encoding
StandardEncoding 0 128 getinterval aload pop
%****** NOTE: the following are missing in the Adobe documentation,
%****** but appear in the displayed table:
%****** macron at 225, dieresis at 230, cedilla at 233, space at 240.
% \20x
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /dotlessi /grave /acute /circumflex /tilde /macron /breve /dotaccent
    /dieresis /.notdef /ring /cedilla /.notdef /hungarumlaut /ogonek /caron
% \24x
    /space /exclamdown /cent /sterling
        /currency /yen /brokenbar /section
    /dieresis /copyright /ordfeminine /guillemotleft
        /logicalnot /hyphen /registered /macron
    /degree /plusminus /twosuperior /threesuperior
        /acute /mu /paragraph /periodcentered
    /cedilla /onesuperior /ordmasculine /guillemotright
        /onequarter /onehalf /threequarters /questiondown
% \30x
    /Agrave /Aacute /Acircumflex /Atilde
        /Adieresis /Aring /AE /Ccedilla
    /Egrave /Eacute /Ecircumflex /Edieresis
        /Igrave /Iacute /Icircumflex /Idieresis
    /Eth /Ntilde /Ograve /Oacute
        /Ocircumflex /Otilde /Odieresis /multiply
    /Oslash /Ugrave /Uacute /Ucircumflex
        /Udieresis /Yacute /Thorn /germandbls
% \34x
    /agrave /aacute /acircumflex /atilde
        /adieresis /aring /ae /ccedilla
    /egrave /eacute /ecircumflex /edieresis
        /igrave /iacute /icircumflex /idieresis
    /eth /ntilde /ograve /oacute
        /ocircumflex /otilde /odieresis /divide
    /oslash /ugrave /uacute /ucircumflex
        /udieresis /yacute /thorn /ydieresis
256 packedarray def

% Define a stub for the Symbol encoding.
userdict begin
  /SymbolEncoding
   { userdict begin (acadpss.ps) run /SymbolEncoding load end
   } bind def
end

% Construct a dictionary of all available devices.
mark
        % Loop until the getdevice gets a rangecheck.
  0 { {dup getdevice exch 1 add} loop} stopped pop
  dict /devicedict exch def
  devicedict begin              % 2nd copy of count is on stack
   { dup devicename cvn dup 3 -1 roll def
     counttomark 1 roll
   } repeat
  end
] /devicenames exch def
$error /newerror false put              % remove error indication

% Define a special version of `run' that aborts on errors.
/run0
        { dup /.currentfilename exch def
           { findlibfile not { stop } if } stopped
           { pop (Can't find initialization file ) print = flush quit } if
          cvx stopped
           { (While reading ) print .currentfilename print (:\n) print flush
             handleerror quit
           } if
        } bind def

%   Internal  procedure  used  by  ARUN to read a 32 bit word in Intel
%   byte order.  Not fast, but squeaky-clean PostScript wise.   Leaves
%   the file positioned after the value read.

/.arunRlong {                         % fileid -- integer
    dup read pop
    1 index read pop 8 bitshift or
    1 index read pop 16 bitshift or
    1 index read pop 24 bitshift or
    exch pop
} bind def

%   Pseudo-intelligent  version  of RUN.  This version accepts all the
%   odd crypto-PostScript files one sees in the real world.  It  knows
%   about  positioning  over  the  binary  EPSF  header  tacked on for
%   PostScript annotated with bitmap images, and if all else fails  it
%   will scan over garbage in a file until it finds the file sentinel.

/arun   {dup type /filetype eq { true } { findlibfile } ifelse

            % Test for the EPSF binary sentinel

            { dup .arunRlong 16#C6D3D0C5 eq
                {
                    % Matched binary sentinel.  Position past it
% (Position past binary EPSF header\n) print flush
                    dup .arunRlong      % PostScript code start address
                    1 index .arunRlong  % PostScript code length
                    1 index add         % Calculate end of PostScript text
                    2 index exch setsubfilelimit % Set logical EOF at text end
                    1 index exch setfileposition % Seek to start of PostScript
                    true
                }
                {
                    % This is not actually a binary EPSF sentinel.  Seek
                    % back to the start of the file.
% (No EPSF Header\n) print flush
                      dup 0 setfileposition
                      false
                }
                ifelse
            not
            {
% (Searching for %!\n) print flush
                    {   dup read
                        { 37 eq { dup read { 33 eq
                            { dup dup fileposition 2 sub setfileposition exit }
                            { unread } } { exit} ifelse
                            ifelse } if }
                        { exit } ifelse
                    } loop

            } if
            cvx execute
            }
            {(r) file}            % let the error happen
           ifelse
} bind def

% Define statusdict, for the benefit of programs
% that think they are running on a LaserWriter or similar printer.
(acadpsd.ps) run0

% Load the initialization files for optional features.
[ (acadpsc.ps) run0 ]                   % a list of file names
 { run0 } forall

% Establish a default upper limit in the character cache,
% namely, 10 times the average expected character size.
mark
 cachestatus 5 index 10 mul 2 index 1 max idiv          % bmax, cmax
  mark exch dup 10 idiv exch setcacheparams
cleartomark
% Conditionally disable the character cache.
NOCACHE { 1 setcachelimit } if
        
VMDEBUG

% Load the standard font environment.
(acadpsf.ps) run0

% Create a null font.  This is the initial font.
7 dict dup begin
  /FontMatrix [ 1 0 0 1 0 0 ] def
  /FontType 3 def
  /FontName () def
  /Encoding StandardEncoding def
  /FontBBox [ 0 0 0 0 ] cvx def         % cvx is bogus, but customary ...
  /BuildChar { pop pop 0 0 setcharwidth } bind def
end
/NullFont exch definefont setfont
% Define NullFont as the font, but remove it from FontDirectory.
/NullFont currentfont def
FontDirectory /NullFont undef

% Bind all the operators defined as procedures.
systemdict
 { dup type /operatortype eq
    { % This might be a real operator, so bind might cause a typecheck.
      { bind } stopped pop
      $error /newerror false put                % remove error indication
    }
   if pop pop
 } forall

% Close up systemdict.
end
systemdict readonly pop

% Establish a default environment.
DISPLAYING
 { defaultdevice
   systemdict /DEVICEWIDTH known systemdict /DEVICEHEIGHT known or
    { matrix deviceparams
      exch /DEVICEWIDTH where
       { pop pop DEVICEWIDTH }
      if
      exch /DEVICEHEIGHT where
       { pop pop DEVICEHEIGHT
         % Replace the Y translation if the Y axis is inverted
         2 index 5 get 0 gt
          { 2 index 5 2 index put
          }
         if
       }
      if
      defaultdevice 4 1 roll makedevice
      counttomark 1 add 1 roll cleartomark
    }
   if setdevice         % does an erasepage
 }
 { nulldevice
 }
ifelse
1 setflat               % initgraphics doesn't set this
{ } settransfer         % ditto
% The following 'ordered dither' spot function was contributed by
% Gregg Townsend.  Thanks, Gregg!
  72 72 dtransform abs exch abs min     % min(|dpi x|,|dpi y|)
  16.001 div 0                  % not 16: avoids rounding problems
   { 1 add 7.9999 mul cvi exch 1 add 7.9999 mul cvi 16 mul add <
        0E 8E 2E AE 06 86 26 A6 0C 8C 2C AC 04 84 24 A4
        CE 4E EE 6E C6 46 E6 66 CC 4C EC 6C C4 44 E4 64
        3E BE 1E 9E 36 B6 16 96 3C BC 1C 9C 34 B4 14 94
        FE 7E DE 5E F6 76 D6 56 FC 7C DC 5C F4 74 D4 54
        01 81 21 A1 09 89 29 A9 03 83 23 A3 0B 8B 2B AB
        C1 41 E1 61 C9 49 E9 69 C3 43 E3 63 CB 4B EB 6B
        31 B1 11 91 39 B9 19 99 33 B3 13 93 3B BB 1B 9B
        F1 71 D1 51 F9 79 D9 59 F3 73 D3 53 FB 7B DB 5B
        0D 8D 2D AD 05 85 25 A5 0F 8F 2F AF 07 87 27 A7
        CD 4D ED 6D C5 45 E5 65 CF 4F EF 6F C7 47 E7 67
        3D BD 1D 9D 35 B5 15 95 3F BF 1F 9F 37 B7 17 97
        FD 7D DD 5D F5 75 D5 55 FF 7F DF 5F F7 77 D7 57
        02 82 22 A2 0A 8A 2A AA 00 80 20 A0 08 88 28 A8
        C2 42 E2 62 CA 4A EA 6A C0 40 E0 60 C8 48 E8 68
        32 B2 12 92 3A BA 1A 9A 30 B0 10 90 38 B8 18 98
        F2 72 D2 52 FA 7A DA 5A F0 70 D0 50 F8 78 D8 58
   > exch get 256 div } bind setscreen
initgraphics
% The interpreter relies on there being at least 2 entries
% on the graphics stack.  Establish the second one now.
gsave

VMDEBUG

% Define control-D as a no-op.  This is a hack to get around problems
% in some common P*stScr*pt-generating applications.
(\004) cvn { } def

% Turn off array packing for interactive use.
false setpacking

QUIET not { (done.\n) print flush } if

%   Set no pause on copypage and showpage
/NOPAUSE true def

% The interpreter will run the initial procedure (start).