%    Copyright (C) 1989, 2000 Aladdin Enterprises.  All rights reserved.% % This file is part of Aladdin Ghostscript.% % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author% or distributor accepts any responsibility for the consequences of using it,% or for whether it serves any particular purpose or works at all, unless he% or she says so in writing.  Refer to the Aladdin Ghostscript Free Public% License (the "License") for full details.% % Every copy of Aladdin Ghostscript must include a copy of the License,% normally in a plain ASCII text file named PUBLIC.  The License grants you% the right to copy, modify and redistribute Aladdin Ghostscript, but only% under certain conditions described in the License.  Among other things, the% License requires that the copyright notice and this notice be preserved on% all copies. % $Id: gs_init.ps,v 1.3 2000/03/10 18:47:31 lpd Exp $% Initialization file for the interpreter.% When this is run, systemdict is still writable. % Comment lines of the form%	%% Replace <n> <file(s)>% indicate places where the next <n> lines should be replaced by% the contents of <file(s)>, when creating a single merged init file. % The interpreter can call out to PostScript code.  All procedures% called in this way, and no other procedures defined in these% initialization files, have names that begin with %, e.g.,% (%Type1BuildChar) cvn. % Check the interpreter revision.  NOTE: the interpreter code requires% that the first non-comment token in this file be an integer.601dup revision ne { (gs: Interpreter revision \() print revision 10 string cvs print   (\) does not match gs_init.ps revision \() print 10 string cvs print   (\).\n) print flush null 1 .quit }if pop % Acquire userdict, and set its length if necessary./userdict where { pop userdict maxlength 0 eq } { true }ifelsesystemdict exch {		% userdict wasn't already set up by iinit.c.   dup /userdict   currentdict dup 200 .setmaxlength		% userdict   .forceput			% userdict is local, systemdict is global }if begin % Define dummy local/global operators if needed.systemdict /.setglobal known { true .setglobal } { /.setglobal { pop } bind def   /.currentglobal { false } bind def   /.gcheck { pop false } bind def }ifelse % Define .languagelevel if needed.systemdict /.languagelevel known not { /.languagelevel 1 def } if % Optionally choose a default paper size other than U.S. letter.% (a4) /PAPERSIZE where { pop pop } { /PAPERSIZE exch def } ifelse % Turn on array packing for the rest of initialization.true setpacking % Define the old MS-DOS EOF character as a no-op.% This is a hack to get around the absurd habit of MS-DOS editors% of adding an EOF character at the end of the file.<1a> cvn { } def % Acquire the debugging flags.currentdict /DEBUG known   /DEBUG exch def  /VMDEBUG    DEBUG {{print mark            systemdict /level2dict known	     { .currentglobal dup false .setglobal vmstatus	       true .setglobal vmstatus 3 -1 roll pop	       6 -2 roll pop .setglobal	     }	     { vmstatus 3 -1 roll pop	     }	    ifelse usertime 16#fffff and counttomark	      { ( ) print (           ) cvs print }	    repeat pop	    ( ) print systemdict length (    ) cvs print	    ( ) print countdictstack (  ) cvs print	    ( <) print count (    ) cvs print (>\n) print flush	  }}	  {{pop	  }}	 ifelse  def currentdict /BATCH known   /BATCH exch defcurrentdict /DELAYBIND known   /DELAYBIND exch defcurrentdict /DISKFONTS known   /DISKFONTS exch defcurrentdict /DOINTERPOLATE .knownget { /INTERPOLATE exch def } ifcurrentdict /ESTACKPRINT known   /ESTACKPRINT exch defcurrentdict /FAKEFONTS known   /FAKEFONTS exch defcurrentdict /FIXEDMEDIA known   /FIXEDMEDIA exch defcurrentdict /FIXEDRESOLUTION known   /FIXEDRESOLUTION exch defcurrentdict /LOCALFONTS known   /LOCALFONTS exch defcurrentdict /NOBIND known   /NOBIND exch def/.bind /bind load defNOBIND { /bind { } def } ifcurrentdict /NOCACHE known   /NOCACHE exch defcurrentdict /NOCIE known   /NOCIE exch defcurrentdict /NODISPLAY known   not /DISPLAYING exch defcurrentdict /NOFONTMAP known   /NOFONTMAP exch defcurrentdict /NOFONTPATH known   /NOFONTPATH exch defcurrentdict /NOGC known   /NOGC exch defcurrentdict /NOINTERPOLATE .knownget { /INTERPOLATE exch not def } ifcurrentdict /NOPAGEPROMPT known   /NOPAGEPROMPT exch defcurrentdict /NOPAUSE known   /NOPAUSE exch defcurrentdict /NOPLATFONTS known   /NOPLATFONTS exch defcurrentdict /NOPROMPT known   /NOPROMPT exch def% The default value of ORIENT1 is true, not false.currentdict /ORIENT1 known not { /ORIENT1 true def } ifcurrentdict /OSTACKPRINT known   /OSTACKPRINT exch defcurrentdict /OUTPUTFILE known	% obsolete { /OutputFile /OUTPUTFILE load def   currentdict /OUTPUTFILE .undef } ifcurrentdict /QUIET known   /QUIET exch defcurrentdict /SAFER known   /SAFER exch defcurrentdict /SHORTERRORS known   /SHORTERRORS exch defcurrentdict /STRICT known   /STRICT exch defcurrentdict /TTYPAUSE known   /TTYPAUSE exch defcurrentdict /WRITESYSTEMDICT known   /WRITESYSTEMDICT exch def % Acquire environment variables.currentdict /DEVICE known not { (GS_DEVICE) getenv { /DEVICE exch def } if } if (START) VMDEBUG % Open the standard files, so they will be open at the outermost save level.(%stdin) (r) file pop(%stdout) (w) file pop(%stderr) (w) file pop /.currentuserparams where {  pop mark	% The Adobe implementations appear to have very large maximum	% stack sizes.  This turns out to actually make a difference,	% since some badly-behaved files include extremely long procedures,	% or construct huge arrays on the operand stack.	% We reset the stack sizes now so that we don't have to worry	% about overflowing the (rather small) built-in stack sizes	% during initialization.  /MaxDictStack 500  /MaxExecStack 5000  /MaxOpStack 50000  .dicttomark .setuserparams} if % Define a procedure for skipping over an unneeded section of code.% This avoids allocating space for the skipped procedures.% We can't use readline, because that imposes a line length limit./.skipeof	% <string> .skipeof - { currentfile exch 1 exch .subfiledecode flushfile } .bind def % Define procedures to assist users who don't read the documentation.userdict begin/help { (Enter PostScript commands.  '(filename) run' runs a file, 'quit' exits.\n)   print flush } .bind def/? /help load defend % Define =string, which is used by some PostScript programs even though% it isn't documented anywhere.% Put it in userdict so that each context can have its own copy.userdict /=string 256 string put % Print the greeting. /printgreeting { mark   product (Ghostscript) search    { pop pop pop      (This software comes with NO WARRANTY: see the file PUBLIC for details.\n)    }    { pop    }   ifelse   (\n) copyright   (\)\n) revisiondate 10 mod revisiondate 10 idiv 10 mod (-)   revisiondate 100 idiv 10 mod revisiondate 1000 idiv 10 mod (-)   revisiondate 10000 idiv ( \()   revision 10 mod   revision 100 mod dup 0 ne { 10 idiv } { pop } ifelse (.)   revision 100 idiv ( )   product   counttomark    { (%stdout) (w) file exch 0 .writecvp    } repeat pop } .bind def QUIET not { printgreeting flush } if % Define a special version of def for making operator procedures./obind {	% <name> <proc> obind <name> <oper>  1 index exch .makeoperator} .bind def/odef {		% <name> <proc> odef -  1 index exch .makeoperator def} .bind def % Define a special version of def for storing local objects into global% dictionaries.  Like .forceput, this exists only during initialization./.forcedef {		% <key> <value> .forcedef -  currentdict 3 1 roll .forceput} .bind odef % Define procedures for accessing variables in systemdict and userdict% regardless of the contents of the dictionary stack./.systemvar {		% <name> .systemvar <value>  //systemdict exch get} .bind odef/.userdict {		% - .userdict <dict>  /userdict .systemvar} .bind odef/.uservar {		% <name> .uservar <value>  .userdict exch get} .bind odef % If we're delaying binding, remember everything that needs to be bound later.DELAYBIND NOBIND not and { .currentglobal false .setglobal   systemdict /.delaybind 1500 array .forceput   .setglobal   userdict /.delaycount 0 put	% When we've done the delayed bind, we want to stop saving.	% Detect this by the disappearance of .delaybind.   /bind    { /.delaybind .systemvar dup length 0 ne       { .delaycount 2 index put         .userdict /.delaycount .delaycount 1 add put       }       { pop .bind       }      ifelse    } .bind def } if %**************** BACKWARD COMPATIBILITY/hwsizedict mark /HWSize null .dicttomark readonly def/copyscanlines {		% <device> <y> <string> copyscanlines <substr>  0 3 1 roll 3 index //hwsizedict .getdeviceparams  exch pop exch pop aload pop 3 2 roll  0 exch null exch .getbitsrect exch pop} bind odefcurrentdict /hwsizedict .undef/getdeviceprops { null .getdeviceparams } bind odef/.putdeviceprops { null true counttomark 1 add 3 roll .putdeviceparams   dup type /booleantype ne    { dup mark eq { /unknown /rangecheck } if      counttomark 4 add 1 roll cleartomark pop pop pop      /.putdeviceprops load exch signalerror    }   if } bind odef/max { .max } bind def/min { .min } bind def/.currentfilladjust { .currentfilladjust2 pop } bind odef/.setfilladjust { dup .setfilladjust2 } bind odef/.writecvs { 0 .writecvp } bind odef % Define predefined procedures substituting for operators,% in alphabetical order. userdict /#copies 1 put% Adobe implementations don't accept /[ or /], so we don't either.([) cvn	/mark load def(]) cvn	{counttomark array astore exch pop} odef% .beginpage is redefined if setpagedevice is present./.beginpage { } odef% In LanguageLevel 3, copypage erases the page./copypage {	.languagelevel 3 ge	dup { 0 } { 1 } ifelse .endpage {	  .currentnumcopies 1 index .outputpage	  (>>copypage, press <return> to continue<<\n) .confirm	  dup { erasepage } if	} if pop .beginpage} odef/currentmatrix {	.currentmatrix 6 index astore pop} odef% .currentnumcopies is redefined in Level 2./.currentnumcopies { #copies } odef/setcolorscreen where { pop		% not in all Level 1 configurations   /currentcolorscreen	{ .currenthalftone	   { { 60 exch 0 exch 3 copy 6 copy }	% halftone - not possible	     { 3 copy 6 copy }			% screen	     { }				% colorscreen	   }	  exch get exec	} odef} if/currentscreen	{ .currenthalftone	   { { 60 exch 0 exch }			% halftone - not possible	     { }				% screen	     { 12 3 roll 9 { pop } repeat }	% colorscreen	   }	  exch get exec	} odef/.echo /echo load defuserdict /.echo.mode true put/echo	{dup /.echo.mode exch store .echo} odef/eexec {	% Rebind .currentresourcefile if it is the source for the eexec.  dup 55665 //filterdict /eexecDecode get exec  cvx exch .currentresourcefile eq  //systemdict begin { {exec} .execasresource } { exec } ifelse	% Only pop systemdict if it is still the top element,	% because this is apparently what Adobe interpreters do.  currentdict //systemdict eq { end } if} odef% .endpage is redefined if setpagedevice is present./.endpage { 2 ne } odef% erasepage mustn't use gsave/grestore, because we call it before% the graphics state stack has been fully initialized./erasepage	{ /currentcolor where	   { pop currentcolor currentcolorspace { setcolorspace setcolor } }	   { /currentcmykcolor where	      { pop currentcmykcolor { setcmykcolor } }	      { currentrgbcolor { setrgbcolor } }	     ifelse	   }	  ifelse 1 setgray .fillpage exec	} odef% To satisfy the Genoa FTS, executive must be a procedure, not an operator./executive	{ { NOPROMPT not { prompt } if	     { (%statementedit) (r) file } stopped	     { pop pop $error /errorname get /undefinedfilename eq		{ .clearerror exit } if		% EOF	       handleerror null		% ioerror??	     }	    if	    cvx { .runexec } execute	  } loop	} bind def/filter	{ //filterdict 1 index .knownget	   { exch pop exec }	   { /filter load /undefined signalerror }	  ifelse	} odef/handleerror	{ /errordict .systemvar /handleerror get exec } bind def/identmatrix [1.0 0.0 0.0 1.0 0.0 0.0] readonly def/identmatrix	{ dup 0 //identmatrix putinterval } odef/languagelevel 1 def		% gs_lev2.ps may change this/makeimagedevice { false makewordimagedevice } odef/matrix	{ 6 array identmatrix } odef/pathbbox	{ false .pathbbox	} odef% .promptmsg is redefined if the interpreter includes readline support./.promptmsg {	(GS) print	count 0 ne { (<) print count =only } if	(>) print flush} bind def/prompt	{ flush flushpage .promptmsg } bind def/pstack	{ 0 1 count 3 sub { index == } for } bind def/putdeviceprops	{ .putdeviceprops { erasepage } if } odef/quit	{ /quit load 0 .quit } odef/run	{ dup type /filetype ne { (r) file } if		% We must close the file when execution terminates,		% regardless of the state of the stack,		% and then propagate an error, if any.	  cvx .runexec	} odef% Execute a file.% Level 2 uses 2 .stop to clear the e-stack for a successful startjob:% we detect that here, since we need to handle this even if we start out% without job control in effect.%% What we push on the e-stack is the following to be executed in this order:%	<lit-file|fileproc> .runexec1 <lit-file|fileproc> .runexec2/.runexec1 {		% <file|fileproc> .runexec1 -  dup type /filetype ne { cvx exec } if  cvx null 2 .stopped	% If we got back here from a startjob, just keep going.	% startjob replaces the null on the o-stack with a procedure	% to be executed when we get back here.  dup null ne { exec true } { pop false } ifelse} bind def/.runexec2 {		% <continue> <file|fileproc> .runexec2 -  exch {    .runexec  } {    dup type /filetype ne { cvx exec } if    closefile  } ifelse} bind def/.runexec {		% <file|fileproc> .runexec -  cvlit /.runexec1 cvx 1 index /.runexec2 cvx 4 .execn} bind def% The following is only for compatibility with Adobe interpreters./setdash {	1 index length 11 gt { /setdash load /limitcheck signalerror } if	//setdash} odef/setdevice	{ .setdevice { erasepage } if } odef/setlinecap {	dup 2 gt { /setlinecap load /rangecheck signalerror } if	.setlinecap} odef/setlinejoin {	dup 2 gt { /setlinejoin load /rangecheck signalerror } if	.setlinejoin} odef/setmatrix {	dup aload pop .setmatrix pop} odef/showpage {	0 .endpage .doneshowpage {	  .currentnumcopies true .outputpage	  (>>showpage, press <return> to continue<<\n) .confirm	  erasepage	} if initgraphics .beginpage} odef% Code output by Adobe Illustrator relies on the fact that% `stack' is a procedure, not an operator!!!/stack	{ 0 1 count 3 sub { index = } for } bind def/start	{ BATCH { null 0 .quit } { executive } ifelse } def% Internal uses of stopped that aren't going to do a stop if an error occurs% should use .internalstopped to avoid setting newerror et al./.internalstopped { null 1 .stopped null ne } bind def/store {	% Don't alter operands before completing.	1 index where { 2 index 2 index put pop pop } { def } ifelse} odef/.typenames mark .typenames counttomark packedarray exch pop def/type {	//.typenames .type} odefcurrentdict /.typenames .undef% When running in Level 1 mode, this interpreter is supposed to be% compatible with PostScript "version" 54.0 (I think)./version (54.0) readonly def/.wheredict 10 dict def/.where /where load def/where {	//.wheredict 1 index .knownget { exec } { .where } ifelse} odef % internaldict is defined in systemdict, but is allocated in local VM.% We make a procedure for creating it, since we must create a new one% for each context with private local VM./.makeinternaldict {  .currentglobal false .setglobal    [ /dup .systemvar 1183615869 /eq .systemvar	[ /pop .systemvar 10 dict ] cvx	[ /internaldict /cvx .systemvar /invalidaccess /signalerror cvx ] cvx      /ifelse .systemvar    ] cvx executeonly  exch .setglobal} odefsystemdict /internaldict dup .makeinternaldict .makeoperator.forceput		% proc is local, systemdict is global% Move superexec to internaldict if superexec is defined.currentdict /superexec .knownget {  1183615869 internaldict /superexec 3 -1 roll put  currentdict /superexec .undef} if % Define some additional built-in procedures (beyond the ones defined by% the PostScript Language Reference Manual).% Warning: these are not guaranteed to stay the same from one release% to the next!/concatstrings	{ exch dup length 2 index length add string	% str2 str1 new	  dup dup 4 2 roll copy		% str2 new new new1	  length 4 -1 roll putinterval

Lines 1–500 of 1697. Load more