home *** CD-ROM | disk | FTP | other *** search
/ jppd.dyndns.org / jppd.dyndns.org.tar / jppd.dyndns.org / QUERYPRO / Impressora_PDF / converter.exe / GPLGS / gs_lev2.ps < prev    next >
Text File  |  2004-09-10  |  32KB  |  908 lines
  1. %    Copyright (C) 1990, 2000 Aladdin Enterprises.  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_lev2.ps,v 1.29.2.5 2004/09/09 20:56:59 ray Exp $
  17. % Initialization file for Level 2 functions.
  18. % When this is run, systemdict is still writable,
  19. % but (almost) everything defined here goes into level2dict.
  20.  
  21. level2dict begin
  22.  
  23. % ------ System and user parameters ------ %
  24.  
  25. % User parameters must obey save/restore, and must also be maintained
  26. % per-context.  We implement the former, and some of the latter, here
  27. % with PostScript code.  NOTE: our implementation assumes that user
  28. % parameters change only as a result of setuserparams -- that there are
  29. % no user parameters that are ever changed dynamically by the interpreter
  30. % (although the interpreter may adjust the value presented to setuserparams)
  31. %
  32. % There are two types of user parameters: those which are actually
  33. % maintained in the interpreter, and those which exist only at the
  34. % PostScript level.  We maintain the current state of both types in
  35. % a read-only local dictionary named userparams, defined in systemdict.
  36. % In a multi-context system, each context has its own copy of this
  37. % dictionary.  In addition, there is a constant dictionary named
  38. % psuserparams where each key is the name of a user parameter that exists
  39. % only in PostScript and the value is a procedure to check that the value
  40. % is legal: setuserparams uses this for checking the values.
  41. % setuserparams updates userparams explicitly, in addition to setting
  42. % any user parameters in the interpreter; thus we can use userparams
  43. % to reset those parameters after a restore or a context switch.
  44. % NOTE: the name userparams is known to the interpreter, and in fact
  45. % the interpreter creates the userparams dictionary.
  46.  
  47. % Check parameters that are managed at the PostScript level.
  48. /.checkparamtype {        % <newvalue> <type> .checkparamtype <bool>
  49.   exch type eq
  50. } .bind def
  51. /.checksetparams {        % <newdict> <opname> <checkdict>
  52.                 %   .checksetparams <newdict>
  53.   2 index {
  54.         % Stack: newdict opname checkdict key newvalue
  55.     3 copy 3 1 roll .knownget {
  56.       exec not {
  57.     pop pop pop load /typecheck signalerror
  58.       } if
  59.       dup type /stringtype eq {
  60.     dup rcheck not {
  61.       pop pop pop load /invalidaccess signalerror
  62.     } if
  63.       } if
  64.     } {
  65.       pop
  66.     } ifelse pop pop
  67.   } forall pop pop
  68. } .bind def    % not odef, shouldn't reset stacks
  69.  
  70. % currentuser/systemparams creates and returns a dictionary in the
  71. % current VM.  The easiest way to make this work is to copy any composite
  72. % PostScript-level parameters to global VM.  Currently we have strings
  73. % as well as arrays. For arrays, we also need to copy any contents that
  74. % are in VM. Also copying string parameters insures the contents won't
  75. % be changed. Also be careful to preserve 'executable' state.
  76. /.copyparam {            % <value> .copyparam <value'>
  77.   dup type /arraytype eq {
  78.     .currentglobal true .setglobal exch 
  79.     dup wcheck exch dup xcheck exch        % original attributes
  80.     dup length array exch dup {    % stack: destination_array original_array original_array
  81.       dup type /arraytype eq {
  82.     dup 2 index ne {    % avoid recursion
  83.         .copyparam    % recurse to handle composite array elements
  84.         } {
  85.       % this array self referenced, do it again (yuk!)
  86.       pop 1 index        % get copy of destination array
  87.     } ifelse
  88.       } {
  89.         dup type /stringtype eq {
  90.       .copyparam
  91.         } if 
  92.       }
  93.       ifelse 3 1 roll        % keep arrays on top
  94.     } forall pop astore
  95.     exch { cvx } if        % set executable state
  96.     exch not { readonly } if    % set readonly attribute as original
  97.     exch .setglobal
  98.   } if
  99.   dup type /stringtype eq {
  100.     dup wcheck exch    % save attr for setting readonly
  101.     .currentglobal true .setglobal
  102.     1 index length string exch .setglobal
  103.     copy exch not { readonly } if
  104.   } if
  105. } .bind def
  106.  
  107. % Some user parameters are managed entirely at the PostScript level.
  108. % We take care of that here.
  109. systemdict begin
  110. /psuserparams 48 dict def
  111. /getuserparam {            % <name> getuserparam <value>
  112.   /userparams .systemvar 1 index get exch pop
  113. } odef
  114. % Fill in userparams (created by the interpreter) with current values.
  115. mark .currentuserparams
  116. counttomark 2 idiv {
  117.   userparams 3 1 roll put
  118. } repeat pop
  119. /.definepsuserparam {        % <name> <value> .definepsuserparam -
  120.   psuserparams 3 copy pop
  121.   type cvlit /.checkparamtype cvx 2 packedarray cvx put
  122.   userparams 3 1 roll put
  123. } .bind def
  124. end
  125. /currentuserparams {        % - currentuserparams <dict>
  126.   /userparams .systemvar dup length dict .copydict
  127. } odef
  128. /setuserparams {        % <dict> setuserparams -
  129.     % Check that we will be able to set the PostScript-level
  130.     % user parameters.
  131.   /setuserparams /psuserparams .systemvar .checksetparams
  132.     % Set the C-level user params.  If this succeeds, we know that
  133.     % the password check succeeded.
  134.   dup .setuserparams
  135.     % Now set the PostScript-level params.
  136.     % The interpreter may have adjusted the values of some of the
  137.     % parameters, so we have to read them back.
  138.   dup {
  139.     /userparams .systemvar 2 index known {
  140.       psuserparams 2 index known not {
  141.     pop dup .getuserparam
  142.       } if
  143.       .copyparam
  144.       % special protection for the security related parameters
  145.       [ /PermitFileReading /PermitFileWriting /PermitFileControl ]
  146.       { 2 index eq { % force all strings to readonly
  147.       dup length array exch { readonly exch } forall astore
  148.         } if
  149.       } forall
  150.       % protect top level of parameters that we copied
  151.       dup type dup /arraytype eq exch /stringtype eq or { readonly } if
  152.       /userparams .systemvar 3 1 roll .forceput  % userparams is read-only
  153.     } {
  154.       pop pop
  155.     } ifelse
  156.   } forall
  157.     % A context switch might have occurred during the above loop,
  158.     % causing the interpreter-level parameters to be reset.
  159.     % Set them again to the new values.  From here on, we are safe,
  160.     % since a context switch will consult userparams.
  161.   .setuserparams
  162. } .bind odef
  163. % Initialize user parameters managed here.
  164. /JobName () .definepsuserparam
  165.  
  166. % Restore must restore the user parameters.
  167. % (Since userparams is in local VM, save takes care of saving them.)
  168. /restore {        % <save> restore -
  169.   //restore /userparams .systemvar .setuserparams
  170. } .bind odef
  171.  
  172. % The pssystemparams dictionary holds some system parameters that
  173. % are managed entirely at the PostScript level.
  174. systemdict begin
  175. currentdict /pssystemparams known not {
  176.   /pssystemparams 40 dict readonly def
  177. } if
  178. /getsystemparam {        % <name> getsystemparam <value>
  179.   //pssystemparams 1 index .knownget { exch pop } { .getsystemparam } ifelse
  180. } odef
  181. end
  182. /currentsystemparams {        % - currentsystemparams <dict>
  183.   mark .currentsystemparams //pssystemparams { } forall .dicttomark
  184. } odef
  185. /setsystemparams {        % <dict> setsystemparams -
  186.     % Check that we will be able to set the PostScript-level
  187.     % system parameters.
  188.    /SAFETY .systemvar /safe get {
  189.      % SAFER mode disallows some changes
  190.      [ /GenericResourceDir /FontResourceDir /GenericResourcePathSep ] {
  191.        2 copy .knownget {
  192.      exch //pssystemparams exch .knownget {
  193.            ne { /setsystemparams /invalidaccess signalerror } if
  194.          } {
  195.            pop
  196.          } ifelse
  197.        } {
  198.          pop
  199.        } ifelse
  200.      } forall
  201.    } if
  202.    /setsystemparams //pssystemparams mark exch {
  203.      type cvlit /.checkparamtype cvx 2 packedarray cvx
  204.    } forall .dicttomark .checksetparams
  205.     % Set the C-level system params.  If this succeeds, we know that
  206.     % the password check succeeded.
  207.    dup .setsystemparams
  208.     % Now set the PostScript-level params.  We must copy local strings
  209.     % into global VM.
  210.    dup
  211.     { //pssystemparams 2 index known
  212.        {        % Stack: key newvalue
  213.      .copyparam
  214.      % protect top level parameters that we copied
  215.          dup type dup /arraytype eq exch /stringtype eq or { readonly } if
  216.      //pssystemparams 3 1 roll .forceput    % pssystemparams is read-only
  217.        }
  218.        { pop pop
  219.        }
  220.       ifelse
  221.     }
  222.    forall pop
  223. } .bind odef
  224.  
  225. % Initialize the passwords.
  226. % NOTE: the names StartJobPassword and SystemParamsPassword are known to
  227. % the interpreter, and must be bound to noaccess strings.
  228. % The length of these strings must be max_password (iutil2.h) + 1.
  229. /StartJobPassword 65 string noaccess def
  230. /SystemParamsPassword 65 string noaccess def
  231.  
  232. % Redefine cache parameter setting to interact properly with userparams.
  233. /setcachelimit {
  234.   mark /MaxFontItem 2 index .dicttomark setuserparams pop
  235. } .bind odef
  236. /setcacheparams {
  237.     % The MaxFontCache parameter is a system parameter, which we might
  238.     % not be able to set.  Fortunately, this doesn't matter, because
  239.     % system parameters don't have to be synchronized between this code
  240.     % and the VM.
  241.   counttomark 1 add copy setcacheparams
  242.   currentcacheparams    % mark size lower upper
  243.     3 -1 roll pop
  244.     /MinFontCompress 3 1 roll
  245.     /MaxFontItem exch
  246.   .dicttomark setuserparams
  247.   cleartomark
  248. } .bind odef
  249.  
  250. % Add bogus user and system parameters to satisfy badly written PostScript
  251. % programs that incorrectly assume the existence of all the parameters
  252. % listed in Appendix C of the Red Book.  Note that some of these may become
  253. % real parameters later: code near the end of gs_init.ps takes care of
  254. % removing any such parameters from ps{user,system}params.
  255.  
  256. % psuserparams
  257.   /MaxFormItem 100000 .definepsuserparam
  258.   /MaxPatternItem 20000 .definepsuserparam
  259.   /MaxScreenItem 48000 .definepsuserparam
  260.   /MaxUPathItem 5000 .definepsuserparam
  261.  
  262. % File Access Permission parameters
  263.   .currentglobal true .setglobal
  264.   /.checkFilePermitparams {
  265.     type /arraytype eq {
  266.       currentuserparams /LockFilePermissions get {
  267.         5 { pop } repeat /setuserparams /invalidaccess signalerror
  268.       }{
  269.         % in addition to validating the value, ensure the value is read/only
  270.         dup { readonly exch } forall
  271.         .currentglobal exch dup gcheck .setglobal length array exch .setglobal
  272.     astore readonly
  273.       }
  274.       ifelse
  275.     } {
  276.       5 { pop } repeat /setuserparams /typecheck signalerror
  277.     }
  278.     ifelse
  279.     true
  280.   } .bind def
  281. % Initialize the File Permission access control to wide open
  282. % These will only be accessed via current/set userparams.
  283. % Values are a string containing multiple nul terminated path strings
  284.   /PermitFileReading dup [ (*) ] .definepsuserparam
  285.     psuserparams exch /.checkFilePermitparams load put
  286.   /PermitFileWriting dup [ (*) ] .definepsuserparam
  287.     psuserparams exch /.checkFilePermitparams load put
  288.   /PermitFileControl dup [ (*) ] .definepsuserparam
  289.     psuserparams exch /.checkFilePermitparams load put
  290.   .setglobal
  291.  
  292. pssystemparams begin
  293.   /CurDisplayList 0 .forcedef
  294.   /CurFormCache 0 .forcedef
  295.   /CurOutlineCache 0 .forcedef
  296.   /CurPatternCache 0 .forcedef
  297.   /CurUPathCache 0 .forcedef
  298.   /CurScreenStorage 0 .forcedef
  299.   /CurSourceList 0 .forcedef
  300.   /DoPrintErrors false .forcedef
  301.   /MaxDisplayList 140000 .forcedef
  302.   /MaxFormCache 100000 .forcedef
  303.   /MaxOutlineCache 65000 .forcedef
  304.   /MaxPatternCache 100000 .forcedef
  305.   /MaxUPathCache 300000 .forcedef
  306.   /MaxScreenStorage 84000 .forcedef
  307.   /MaxSourceList 25000 .forcedef
  308.   /RamSize 4194304 .forcedef
  309. end
  310.  
  311. % Define the procedures for handling comment scanning.  The names
  312. % %ProcessComment and %ProcessDSCComment are known to the interpreter.
  313. % These procedures take the file and comment string and file as operands.
  314. /.checkprocesscomment {
  315.   dup null eq {
  316.     pop true
  317.   } {
  318.     dup xcheck {
  319.       type dup /arraytype eq exch /packedarraytype eq or
  320.     } {
  321.       pop false
  322.     } ifelse
  323.   } ifelse
  324. } .bind def
  325. /ProcessComment null .definepsuserparam
  326. psuserparams /ProcessComment {.checkprocesscomment} put
  327. (%ProcessComment) cvn {
  328.   /ProcessComment getuserparam
  329.   dup null eq { pop pop pop } { exec } ifelse
  330. } bind def
  331. /ProcessDSCComment null .definepsuserparam
  332. psuserparams /ProcessDSCComment {.checkprocesscomment} put
  333. /.loadingfont false def
  334. (%ProcessDSCComment) cvn {
  335.   /ProcessDSCComment getuserparam
  336.   dup null eq .loadingfont or { pop pop pop } { exec } ifelse
  337. } bind def
  338.  
  339. % ------ Miscellaneous ------ %
  340.  
  341. (<<) cvn            % - << -mark-
  342.   /mark load def
  343. (>>) cvn            % -mark- <key1> <value1> ... >> <dict>
  344.   /.dicttomark load def
  345. /languagelevel 2 def
  346. % When running in Level 2 mode, this interpreter is supposed to be
  347. % compatible with Adobe version 2017.
  348. /version (2017) readonly def
  349.  
  350. % If binary tokens are supported by this interpreter,
  351. % set an appropriate default binary object format.
  352. /setobjectformat where
  353.  { pop
  354.    /RealFormat getsystemparam (IEEE) eq { 1 } { 3 } ifelse
  355.    /ByteOrder getsystemparam { 1 add } if
  356.    setobjectformat
  357.  } if
  358.  
  359. % Aldus Freehand versions 2.x check for the presence of the
  360. % setcolor operator, and if it is missing, substitute a procedure.
  361. % Unfortunately, the procedure takes different parameters from
  362. % the operator.  As a result, files produced by this application
  363. % cause an error if the setcolor operator is actually defined
  364. % and 'bind' is ever used.  Aldus fixed this bug in Freehand 3.0,
  365. % but there are a lot of files created by the older versions
  366. % still floating around.  Therefore, at Adobe's suggestion,
  367. % we implement the following dreadful hack in the 'where' operator:
  368. %      If the key is /setcolor, and
  369. %        there is a dictionary named FreeHandDict, and
  370. %        currentdict is that dictionary,
  371. %      then "where" consults only that dictionary and not any other
  372. %        dictionaries on the dictionary stack.
  373. .wheredict /setcolor {
  374.   /FreeHandDict .where {
  375.     /FreeHandDict get currentdict eq {
  376.       pop currentdict /setcolor known { currentdict true } { false } ifelse
  377.     } {
  378.       .where
  379.     } ifelse
  380.   } {
  381.     .where
  382.   } ifelse
  383. } bind put
  384.  
  385. % ------ Virtual memory ------ %
  386.  
  387. /currentglobal            % - currentglobal <bool>
  388.   /currentshared load def
  389. /gcheck                % <obj> gcheck <bool>
  390.   /scheck load def
  391. /setglobal            % <bool> setglobal -
  392.   /setshared load def
  393. % We can make the global dictionaries very small, because they auto-expand.
  394. /globaldict currentdict /shareddict .knownget not { 4 dict } if def
  395. /GlobalFontDirectory SharedFontDirectory def
  396.  
  397. % VMReclaim and VMThreshold are user parameters.
  398. /setvmthreshold {        % <int> setvmthreshold -
  399.   mark /VMThreshold 2 index .dicttomark setuserparams pop
  400. } odef
  401. /vmreclaim {            % <int> vmreclaim -
  402.   dup 0 gt {
  403.     .vmreclaim
  404.   } {
  405.     mark /VMReclaim 2 index .dicttomark setuserparams pop
  406.   } ifelse
  407. } odef
  408. -1 setvmthreshold
  409.  
  410. % ------ IODevices ------ %
  411.  
  412. /.getdevparams where {
  413.   pop /currentdevparams {    % <iodevice> currentdevparams <dict>
  414.     .getdevparams .dicttomark
  415.   } odef
  416. } if
  417. /.putdevparams where {
  418.   pop /setdevparams {        % <iodevice> <dict> setdevparams -
  419.     mark 1 index { } forall counttomark 2 add index
  420.     .putdevparams pop pop
  421.   } odef
  422. } if
  423.  
  424. % ------ Job control ------ %
  425.  
  426. serverdict begin
  427.  
  428. % We could protect the job information better, but we aren't attempting
  429. % (currently) to protect ourselves against maliciousness.
  430.  
  431. /.jobsave null def        % top-level save object
  432. /.jobsavelevel 0 def        % save depth of job (0 if .jobsave is null,
  433.                 % 1 otherwise)
  434. /.adminjob true def        % status of current unencapsulated job
  435.  
  436. end        % serverdict
  437.  
  438. % Because there may be objects on the e-stack created since the job save,
  439. % we have to clear the e-stack before doing the end-of-job restore.
  440. % We do this by executing a 2 .stop, which is caught by the 2 .stopped
  441. % in .runexec; we leave on the o-stack a procedure to execute aftewards.
  442. %
  443. %**************** The definition of startjob is not complete yet, since
  444. % it doesn't reset stdin/stdout.
  445. /.startnewjob {            % <exit_bool> <password_level>
  446.                 %   .startnewjob -
  447.     serverdict /.jobsave get dup null eq { pop } { restore } ifelse
  448.     exch {
  449.             % Unencapsulated job
  450.       serverdict /.jobsave null put
  451.       serverdict /.jobsavelevel 0 put
  452.       serverdict /.adminjob 3 -1 roll 1 gt put
  453.         % The Adobe documentation doesn't say what happens to the
  454.         % graphics state stack in this case, but an experiment
  455.         % produced results suggesting that a grestoreall occurs.
  456.       grestoreall
  457.     } {
  458.             % Encapsulated job
  459.       pop
  460.       serverdict /.jobsave save put
  461.       serverdict /.jobsavelevel 1 put
  462.       .userdict /quit /stop load put
  463.     } ifelse
  464.         % Reset the interpreter state.
  465.   clear cleardictstack
  466.   initgraphics
  467.   false setglobal
  468.   2 vmreclaim    % Make sure GC'ed memory is reclaimed and freed.
  469. } bind def
  470. /.startjob {            % <exit_bool> <password> <finish_proc>
  471.                 %   .startjob <ok_bool>
  472.   vmstatus pop pop serverdict /.jobsavelevel get eq
  473.   2 index .checkpassword 0 gt and {
  474.     exch .checkpassword exch count 3 roll count 3 sub { pop } repeat
  475.     cleardictstack
  476.         % Reset the e-stack back to the 2 .stopped in .runexec,
  477.         % passing the finish_proc to be executed afterwards.
  478.     2 .stop
  479.   } {        % Password check failed
  480.     pop pop pop false
  481.   } ifelse
  482. } odef
  483. /startjob {            % <exit_bool> <password> startjob <ok_bool>
  484.     % This is a hack.  We really need some way to indicate explicitly
  485.     % to the interpreter that we are under control of a job server.
  486.   { .startnewjob true } .startjob
  487. } odef
  488.  
  489. % The procedure to undo the job encapsulation 
  490. /.endjob {
  491.   clear cleardictstack
  492.   serverdict /.jobsave get dup null eq { pop } { restore } ifelse
  493.   serverdict /.jobsave null put
  494.   2 vmreclaim   % recover local and global VM
  495. } odef
  496.  
  497. systemdict begin
  498. /quit {                % - quit -
  499.   //systemdict begin serverdict /.jobsave get null eq
  500.    { end //quit }
  501.    { /quit load /invalidaccess /signalerror load end exec }
  502.   ifelse
  503. } bind odef
  504. end
  505.  
  506. % We would like to define exitserver as a procedure, using the code
  507. % that the Red Book says is equivalent to it.  However, since startjob
  508. % resets the exec stack, we can't do this, because control would never
  509. % proceed past the call on startjob if the exitserver is successful.
  510. % Instead, we need to construct exitserver out of pieces of startjob.
  511.  
  512. serverdict begin
  513.  
  514. /exitserver {            % <password> exitserver -
  515.   true exch { .startnewjob } .startjob not {
  516.     /exitserver /invalidaccess signalerror
  517.   } if
  518. } bind def
  519.  
  520. end        % serverdict
  521.  
  522. % ------ Compatibility ------ %
  523.  
  524. % In Level 2 mode, the following replace the definitions that gs_statd.ps
  525. % installs in statusdict and serverdict.
  526. % Note that statusdict must be allocated in local VM.
  527. % We don't bother with many of these yet.
  528.  
  529. /.dict1 { exch mark 3 1 roll .dicttomark } bind def
  530.  
  531. currentglobal false setglobal 25 dict exch setglobal begin
  532. currentsystemparams
  533.  
  534. % The following do not depend on the presence of setpagedevice.
  535. /buildtime 1 index /BuildTime get def
  536. % Also define /buildtime in systemdict because Adobe does so and some fonts use it as ID
  537. systemdict /buildtime dup load put
  538. /byteorder 1 index /ByteOrder get def
  539. /checkpassword { .checkpassword 0 gt } bind def
  540. dup /DoStartPage known
  541.  { /dostartpage { /DoStartPage getsystemparam } bind def
  542.    /setdostartpage { /DoStartPage .dict1 setsystemparams } bind def
  543.  } if
  544. dup /StartupMode known
  545.  { /dosysstart { /StartupMode getsystemparam 0 ne } bind def
  546.    /setdosysstart { { 1 } { 0 } ifelse /StartupMode .dict1 setsystemparams } bind def
  547.  } if
  548. %****** Setting jobname is supposed to set userparams.JobName, too.
  549. /jobname { /JobName getuserparam } bind def
  550. /jobtimeout { /JobTimeout getuserparam } bind def
  551. /ramsize { /RamSize getsystemparam } bind def
  552. /realformat 1 index /RealFormat get def
  553. dup /PrinterName known
  554.  { /setprintername { /PrinterName .dict1 setsystemparams } bind def
  555.  } if
  556. /printername
  557.  { currentsystemparams /PrinterName .knownget not { () } if exch copy
  558.  } bind def
  559. currentuserparams /WaitTimeout known
  560.  { /waittimeout { /WaitTimeout getuserparam } bind def
  561.  } if
  562.  
  563. % The following do require setpagedevice.
  564. /.setpagedevice where { pop } { (%END PAGEDEVICE) .skipeof } ifelse
  565. /defaulttimeouts
  566.  { currentsystemparams dup
  567.    /JobTimeout .knownget not { 0 } if
  568.    exch /WaitTimeout .knownget not { 0 } if
  569.    currentpagedevice /ManualFeedTimeout .knownget not { 0 } if
  570.  } bind def
  571. /margins
  572.  { currentpagedevice /Margins .knownget { exch } { [0 0] } ifelse
  573.  } bind def
  574. /pagemargin
  575.  { currentpagedevice /PageOffset .knownget { 0 get } { 0 } ifelse
  576.  } bind def
  577. /pageparams
  578.  { currentpagedevice
  579.    dup /Orientation .knownget { 1 and ORIENT1 { 1 xor } if } { 0 } ifelse exch
  580.    dup /PageSize get aload pop 3 index 0 ne { exch } if 3 2 roll
  581.    /PageOffset .knownget { 0 get } { 0 } ifelse 4 -1 roll
  582.  } bind def
  583. /setdefaulttimeouts
  584.  { exch mark /ManualFeedTimeout 3 -1 roll
  585.    /Policies mark /ManualFeedTimeout 1 .dicttomark
  586.    .dicttomark setpagedevice
  587.    /WaitTimeout exch mark /JobTimeout 5 2 roll .dicttomark setsystemparams
  588.  } bind def
  589. /.setpagesize { 2 array astore /PageSize .dict1 setpagedevice } bind def
  590. /setduplexmode { /Duplex .dict1 setpagedevice } bind def
  591. /setmargins
  592.  { exch 2 array astore /Margins .dict1 setpagedevice
  593.  } bind def
  594. /setpagemargin { 0 2 array astore /PageOffset .dict1 setpagedevice } bind def
  595. /setpageparams
  596.  { mark /PageSize 6 -2 roll
  597.    4 index 1 and ORIENT1 { 1 } { 0 } ifelse ne { exch } if 2 array astore
  598.    /Orientation 5 -1 roll ORIENT1 { 1 xor } if
  599.    /PageOffset counttomark 2 add -1 roll 0 2 array astore
  600.    .dicttomark setpagedevice
  601.  } bind def
  602. /setresolution
  603.  { dup 2 array astore /HWResolution .dict1 setpagedevice
  604.  } bind def
  605. %END PAGEDEVICE
  606.  
  607. % The following are not implemented yet.
  608. %manualfeed
  609. %manualfeedtimeout
  610. %pagecount
  611. %pagestackorder
  612. %setpagestackorder
  613.  
  614. pop        % currentsystemparams
  615.  
  616. % Flag the current dictionary so it will be swapped when we
  617. % change language levels.  (See zmisc2.c for more information.)
  618. /statusdict currentdict def
  619.  
  620. currentdict end
  621. /statusdict exch .forcedef    % statusdict is local, systemdict is global
  622.  
  623. % The following compatibility operators are in systemdict.  They are
  624. % defined here, rather than in gs_init.ps, because they require the
  625. % resource machinery.
  626.  
  627. /devforall {        % <proc> <scratch> devforall -
  628.   exch {
  629.     1 index currentdevparams
  630.     /Type .knownget { /FileSystem eq } { false } ifelse
  631.     { exec } { pop pop } ifelse
  632.   } /exec load 3 packedarray cvx exch
  633.   (*) 3 1 roll /IODevice resourceforall
  634. } odef
  635. /devstatus {        % <(%disk*%)> devstatus <searchable> <writable>
  636.             %   <hasNames> <mounted> <removable> <searchOrder>
  637.             %   <freePages> <size> true
  638.             % <string> devstatus false
  639.   dup length 5 ge {
  640.     dup 0 5 getinterval (%disk) eq {
  641.       dup /IODevice resourcestatus {
  642.     pop pop dup currentdevparams
  643.     dup /Searchable get
  644.     exch dup /Writeable get
  645.     exch dup /HasNames get
  646.     exch dup /Mounted get
  647.     exch dup /Removable get
  648.     exch dup /SearchOrder get
  649.     exch dup /Free get
  650.     exch /LogicalSize get
  651.     9 -1 roll pop true
  652.       } {
  653.     pop false
  654.       } ifelse
  655.     } {
  656.       pop false
  657.     } ifelse
  658.   } {
  659.     pop false
  660.   } ifelse
  661. } odef
  662.  
  663. % ------ Color spaces ------ %
  664.  
  665. % Move setcolorsapce, setcolor, and colorspacedict to level2dict
  666. level2dict /setcolorspace .cspace_util 1 index get put
  667. level2dict /setcolor .cspace_util 1 index get put
  668. level2dict /colorspacedict .cspace_util 1 index get put
  669.  
  670. % Add the level 2 color spaces
  671. % DevicePixel is actually a LanguageLevel 3 feature; it is here for
  672. % historical reasons.
  673. %% Replace 1 (gs_devpxl.ps) 
  674. (gs_devpxl.ps) runlibfile
  675.  
  676. %% Replace 1 (gs_ciecs2.ps)
  677. (gs_ciecs2.ps) runlibfile
  678.  
  679. %% Replace 1 (gs_indxd.ps)
  680. (gs_indxd.ps) runlibfile
  681.  
  682. %% Replace 1 (gs_sepr.ps)
  683. (gs_sepr.ps) runlibfile
  684.  
  685. %% Replace 1 (gs_patrn.ps)
  686. (gs_patrn.ps) runlibfile
  687.  
  688.  
  689.  
  690. % ------ CIE color rendering ------ %
  691.  
  692. % Define findcolorrendering and a default ColorRendering ProcSet.
  693.  
  694. /findcolorrendering {        % <intentname> findcolorrendering
  695.                 %   <crdname> <found>
  696.   /ColorRendering /ProcSet findresource
  697.   1 index .namestring (.) concatstrings
  698.   1 index /GetPageDeviceName get exec .namestring (.) concatstrings
  699.   2 index /GetHalftoneName get exec .namestring
  700.   concatstrings concatstrings
  701.   dup /ColorRendering resourcestatus {
  702.     pop pop exch pop exch pop true
  703.   } {
  704.     pop /GetSubstituteCRD get exec false
  705.   } ifelse
  706. } odef
  707.  
  708. 5 dict dup begin
  709.  
  710. /GetPageDeviceName {        % - GetPageDeviceName <name>
  711.   currentpagedevice dup /PageDeviceName .knownget {
  712.     exch pop dup null eq { pop /none } if
  713.   } {
  714.     pop /none
  715.   } ifelse
  716. } bind def
  717.  
  718. /GetHalftoneName {        % - GetHalftoneName <name>
  719.   currenthalftone /HalftoneName .knownget not { /none } if
  720. } bind def
  721.  
  722. /GetSubstituteCRD {        % <intentname> GetSubstituteCRD <crdname>
  723.   pop /DefaultColorRendering
  724. } bind def
  725.  
  726. end
  727. % The resource machinery hasn't been activated, so just save the ProcSet
  728. % and let .fixresources finish the installation process.
  729. /ColorRendering exch def
  730.  
  731. % Define setcolorrendering.
  732.  
  733. /.colorrenderingtypes 5 dict def
  734.  
  735. /setcolorrendering {        % <crd> setcolorrendering -
  736.   dup /ColorRenderingType get //.colorrenderingtypes exch get exec
  737. } odef
  738.  
  739. /.setcolorrendering1 where { pop } { (%END CRD) .skipeof } ifelse
  740.  
  741. .colorrenderingtypes 1 {
  742.   dup .buildcolorrendering1 .setcolorrendering1
  743. } .bind put
  744.  
  745. % Note: the value 101 in the next line must be the same as the value of
  746. % GX_DEVICE_CRD1_TYPE in gscrdp.h.
  747. .colorrenderingtypes 101 {
  748.   dup .builddevicecolorrendering1 .setdevicecolorrendering1
  749. } .bind put
  750.  
  751. % sRGB output CRD, D65 white point
  752. mark
  753. /ColorRenderingType 1
  754. /RangePQR [ -0.5 2 -0.5 2 -0.5 2 ] readonly
  755.  
  756. % Bradford Cone Space
  757. /MatrixPQR [ 0.8951 -0.7502  0.0389
  758.          0.2664  1.7135 -0.0685
  759.         -0.1614  0.0367  1.0296] readonly
  760.  
  761. /MatrixLMN [ 3.240449 -0.969265  0.055643
  762.         -1.537136  1.876011 -0.204026
  763.         -0.498531  0.041556  1.057229 ] readonly
  764.  
  765. % Inverse sRGB gamma transform
  766. /EncodeABC [ { dup 0.00304 le
  767.                 { 12.92321 mul }
  768.                 { 1 2.4 div exp 1.055 mul 0.055 sub }
  769.                ifelse
  770.              } bind dup dup
  771.            ] readonly
  772.  
  773. /WhitePoint [ 0.9505 1 1.0890 ] readonly % D65
  774. /BlackPoint [ 0 0 0 ] readonly
  775.  
  776. % VonKries-like transform in Bradford Cone Space
  777.    /TransformPQR
  778.      % The implementations have been moved to C for performance.
  779.      [ { .TransformPQR_scale_WB0 } bind
  780.        { .TransformPQR_scale_WB1 } bind 
  781.        { .TransformPQR_scale_WB2 } bind
  782.      ] readonly
  783. .dicttomark setcolorrendering
  784.  
  785. %END CRD
  786.  
  787. % Initialize a CIEBased color space for sRGB.
  788. /CIEsRGB [ /CIEBasedABC
  789.   mark
  790.     /DecodeLMN [ {
  791.       dup 0.03928 le { 12.92321 div } { 0.055 add 1.055 div 2.4 exp } ifelse
  792.     } bind dup dup ] readonly
  793.     /MatrixLMN [
  794.       0.412457 0.212673 0.019334
  795.       0.357576 0.715152 0.119192
  796.       0.180437 0.072175 0.950301
  797.     ] readonly
  798.     /WhitePoint [0.9505 1.0 1.0890] readonly
  799.   .dicttomark readonly
  800. ] readonly def
  801.  
  802. % ------ Painting ------ %
  803.  
  804. % A straightforward definition of execform that doesn't actually
  805. % do any caching.
  806. /.execform1 {
  807.     % This is a separate operator so that the stacks will be restored
  808.     % properly if an error occurs.
  809.   dup /Matrix get concat
  810.   dup /BBox get aload pop
  811.   exch 3 index sub exch 2 index sub rectclip
  812.   dup /PaintProc get
  813.   1 index /Implementation known not {
  814.     1 index dup /Implementation null .forceput readonly pop
  815.   } if
  816.   exec
  817. } .bind odef    % must bind .forceput
  818.  
  819. /.formtypes 5 dict
  820.   dup 1 /.execform1 load put
  821. def
  822.  
  823. /execform {            % <form> execform -
  824.   gsave {
  825.     dup /FormType get //.formtypes exch get exec
  826.   } stopped grestore { stop } if
  827. } odef
  828.  
  829. /.patterntypes 5 dict
  830.   dup 1 /.buildpattern1 load put
  831. def
  832.  
  833. /makepattern {            % <proto_dict> <matrix> makepattern <pattern>
  834.   //.patterntypes 2 index /PatternType get get
  835.   .currentglobal false .setglobal exch
  836.         % Stack: proto matrix global buildproc
  837.   3 index dup length 1 add dict .copydict
  838.   3 index 3 -1 roll exec 3 -1 roll .setglobal
  839.   1 index /Implementation 3 -1 roll put
  840.   readonly exch pop exch pop
  841. } odef
  842.  
  843. /setpattern {            % [<comp1> ...] <pattern> setpattern -
  844.   currentcolorspace 0 get /Pattern ne {
  845.     [ /Pattern currentcolorspace ] setcolorspace
  846.   } if setcolor
  847. } odef
  848.  
  849. % The following functions emulate the actions of findcmykcustomcolor and
  850. % setcustomcolor.  These functions are described in Adobe's TN 5044.  That
  851. % same document also says "The following ôoperatorsö are not defined in the
  852. % PostScript Language Reference Manual, but should be used as pseudo-operators
  853. % in your PostScript language output. Separation applications from Adobe
  854. % Systems and other vendors will redefine these convention operators to
  855. % separate your documents.  Your application should conditionally define
  856. % procedures with these special names, as shown later in this document."
  857. %
  858. % We are providing these functions because we have found files created by
  859. % "QuarkXPress: pictwpstops filter 1.0" which produce bad shading dictionaries
  860. % if these operators are not defined. 
  861.  
  862. % TN 5044 does not define the contents of the array.  We are simply putting
  863. % the values given into an array.  This is consistent with what we see when
  864. % testing with Adobe Distiller 6.0.
  865. %   <cyan> <magenta> <yellow> <black> <key> findcmykcustomcolor <array>
  866. /findcmykcustomcolor { 5 array astore } bind def
  867.  
  868. % Build a tint transform function for use by setcustomcolor.  This function
  869. % is for a Separation color space which has a DeviceCMYK base color space
  870. % (i.e. 1 input and 4 outputs).  The input to buildcustomtinttransform is the
  871. % array created by findcmykcustomcolor.  The resulting function is:
  872. %   { dup cyan mul exch dup magenta mul exch dup yellow mul exch black mul }
  873. %   Where cyan, magenta, yellow, and black are values from the array.
  874. /buildcustomtinttransform    % <array> buildcustomtinttransform <function>
  875. { [ /dup load 2 index 0 get /mul load
  876.   /exch load /dup load 6 index 1 get /mul load
  877.   /exch load /dup load 10 index 2 get /mul load
  878.   /exch load 13 index 3 get /mul load
  879.   ] cvx bind
  880.   exch pop            % Remove the input array
  881. } bind def
  882.  
  883. % Set a custom color based upon a tint and array which describes the custom
  884. % color.  See findcmykcustomcolor.  First we create and then set a Separation
  885. % colorspace.  Then we set the specified color.
  886. /setcustomcolor            % <array> <tint> setcustomcolor -
  887. { % Start building Separation colorspace
  888.   [ /Separation 3 index 4 get    % Get separation name from array's key
  889.   /DeviceCMYK
  890.   5 index buildcustomtinttransform ]    % build the tint transform function
  891.   setcolorspace            % Set the Separation color space as current
  892.   setcolor            % Set the tint as the current color
  893.   pop                % Remove the input array
  894. } bind def
  895.  
  896. % This proc is supposed to implement a version of overprinting. TN 5044 says
  897. % that this proc is not used by any shipping host-based application. We have
  898. % only found it being used in a proc set in files by Canvas from Deneba Systems.
  899. % Even their proc set does not actually do any overprinting.  However their
  900. % files crash if this is not defined.  Thus we have a copy of this proc but
  901. % we are simply checking for inputs being -1 and if so then we set the value
  902. % to 0.
  903. /setcmykoverprint {
  904.   4 { dup -1 eq { pop 0 } if 4 1 roll } repeat setcmykcolor
  905. } bind def
  906.  
  907. end                % level2dict
  908.