home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 October / Chip_2002-10_cd1.bin / zkuste / pdf / download / gs704w32.exe / gs7.04 / lib / gs_res.ps < prev    next >
Encoding:
Text File  |  2002-01-31  |  29.3 KB  |  930 lines
  1. %    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of AFPL Ghostscript.
  4. % 
  5. % AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6. % distributor accepts any responsibility for the consequences of using it, or
  7. % for whether it serves any particular purpose or works at all, unless he or
  8. % she says so in writing.  Refer to the Aladdin Free Public License (the
  9. % "License") for full details.
  10. % 
  11. % Every copy of AFPL Ghostscript must include a copy of the License, normally
  12. % in a plain ASCII text file named PUBLIC.  The License grants you the right
  13. % to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14. % conditions described in the License.  Among other things, the License
  15. % requires that the copyright notice and this notice be preserved on all
  16. % copies.
  17.  
  18. % $Id: gs_res.ps,v 1.16 2001/10/01 05:56:58 lpd Exp $
  19. % Initialization file for Level 2 resource machinery.
  20. % When this is run, systemdict is still writable,
  21. % but (almost) everything defined here goes into level2dict.
  22.  
  23. level2dict begin
  24.  
  25. (BEGIN RESOURCES) VMDEBUG
  26.  
  27. % We keep track of (global) instances with another entry in the resource
  28. % dictionary, an .Instances dictionary.  For categories with implicit
  29. % instances, the values in .Instances are the same as the keys;
  30. % for other categories, the values are [instance status size].
  31.  
  32. % Note that the dictionary that defines a resource category is stored
  33. % in global VM.  The PostScript manual says that each category must
  34. % manage global and local instances separately.  However, objects in
  35. % global VM other than systemdict can't reference objects in local VM.
  36. % This means that the resource category dictionary, which would otherwise be
  37. % the obvious place to keep track of the instances, can't be used to keep
  38. % track of local instances.  Instead, we define a dictionary in local VM
  39. % called localinstancedict, in which the key is the category name and
  40. % the value is the analogue of .Instances for local instances.
  41.  
  42. % We don't currently implement automatic resource unloading.
  43. % When and if we do, it should be hooked to the garbage collector.
  44. % However, Ed Taft of Adobe says their interpreters don't implement this
  45. % either, so we aren't going to worry about it for a while.
  46.  
  47. currentglobal false setglobal systemdict begin
  48.   /localinstancedict 5 dict
  49.   .forcedef    % localinstancedict is local, systemdict is global
  50. end true setglobal
  51. /.emptydict 0 dict readonly def
  52. setglobal
  53.  
  54. % Resource category dictionaries have the following keys (those marked with
  55. % * are optional):
  56. %    Standard, defined in the Red Book:
  57. %        Category (name)
  58. %        *InstanceType (name)
  59. %        DefineResource
  60. %            <key> <instance> DefineResource <instance>
  61. %        UndefineResource
  62. %            <key> UndefineResource -
  63. %        FindResource
  64. %            <key> FindResource <instance>
  65. %        ResourceStatus
  66. %            <key> ResourceStatus <status> <size> true
  67. %            <key> ResourceStatus false
  68. %        ResourceForAll
  69. %            <template> <proc> <scratch> ResourceForAll -
  70. %        *ResourceFileName
  71. %            <key> <scratch> ResourceFileName <filename>
  72. %    Additional, specific to our implementation:
  73. %        .Instances (dictionary)
  74. %        .LocalInstances
  75. %            - .LocalInstances <dict>
  76. %        .GetInstance
  77. %            <key> .GetInstance <instance> -true-
  78. %            <key> .GetInstance -false-
  79. %        .CheckResource
  80. %            <key> <value> .CheckResource <key> <value> <ok>
  81. %              (or may give an error if not OK)
  82. %        .DoLoadResource
  83. %            <key> .DoLoadResource <key> (may give an error)
  84. %        .LoadResource
  85. %            <key> .LoadResource - (may give an error)
  86. %        .ResourceFile
  87. %            <key> .ResourceFile <file> -true-
  88. %            <key> .ResourceFile <key> -false-
  89. %        .ResourceFileStatus
  90. %            <key> .ResourceFileStatus 2 <vmusage> -true-
  91. %            <key> .ResourceFileStatus -false-
  92. % All the above procedures expect that the top dictionary on the d-stack
  93. % is the resource dictionary.
  94.  
  95. % Define enough of the Category category so we can define other categories.
  96. % The dictionary we're about to create will become the Category
  97. % category definition dictionary.
  98.  
  99. % .findcategory and .resourceexec are only called from within the
  100. % implementation of the resource 'operators', so they doesn't have to worry
  101. % about cleaning up the stack if they fail (the interpreter's stack
  102. % protection machinery for pseudo-operators takes care of this).
  103. /.findcategory {    % <name> .findcategory -
  104.             %   (pushes the category on the dstack)
  105.   /Category findresource begin
  106. } bind def
  107.  
  108. /.resourceexec {    % <key> /xxxResource .resourceexec -
  109.             %   (also pops the category from the dstack)
  110.   load exec end
  111. } bind def
  112.  
  113. % .getvminstance treats instances on disk as undefined.
  114. /.getvminstance {    % <key> .getvminstance <instance> -true-
  115.             % <key> .getvminstance -false-
  116.   .GetInstance {
  117.     dup 1 get 2 ne { true } { pop false } ifelse
  118.   } {
  119.     false
  120.   } ifelse
  121. } bind def
  122.  
  123. 20 dict begin
  124.  
  125.         % Standard entries
  126.  
  127. /Category /Category def
  128. /InstanceType /dicttype def
  129.  
  130. /DefineResource {
  131.     .CheckResource {
  132.       dup /Category 3 index cvlit .growput
  133.       dup [ exch 0 -1 ] exch
  134.       .Instances 4 2 roll put
  135.         % Make the Category dictionary read-only.  We will have to
  136.         % use .forceput / .forcedef later to replace the dummy,
  137.         % empty .Instances dictionary with the real one later.
  138.       readonly
  139.     } {
  140.       /defineresource load /typecheck signalerror
  141.     } ifelse
  142. } bind def
  143. /FindResource        % (redefined below)
  144.     { .Instances exch get 0 get
  145.     } bind def
  146.  
  147.         % Additional entries
  148.  
  149. /.Instances 30 dict def
  150. .Instances /Category [currentdict 0 -1] put
  151.  
  152. /.LocalInstances 0 dict def
  153. /.GetInstance
  154.     { .Instances exch .knownget
  155.     } bind def
  156. /.CheckResource
  157.     { dup gcheck currentglobal and
  158.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  159.          /UndefineResource }
  160.        { 2 index exch known and }
  161.       forall
  162.       not { /defineresource load /invalidaccess signalerror } if
  163.       true
  164.     } bind def
  165.  
  166. .Instances end begin    % for the base case of findresource
  167.  
  168. (END CATEGORY) VMDEBUG
  169.  
  170. % Define the resource operators.  We use the "stack protection" feature of
  171. % odef to make sure the stacks are restored properly on an error.
  172. % This requires that the operators not pop anything from the stack until
  173. % they have executed their logic successfully.  We can't make this
  174. % work for resourceforall, because the procedure it executes mustn't see
  175. % the operands of resourceforall on the stack, but we can make it work for
  176. % the others.
  177.  
  178. % findresource is the only operator that needs to bind //Category.
  179. /findresource {        % <key> <category> findresource <instance>
  180.     2 copy dup /Category eq
  181.       { pop //Category 0 get begin } { .findcategory } ifelse
  182.     /FindResource .resourceexec exch pop exch pop
  183. } bind
  184. end        % .Instances of Category
  185. odef
  186.  
  187. /defineresource {    % <key> <instance> <category> defineresource <instance>
  188.     3 copy .findcategory
  189.     currentdict /InstanceType known {
  190.       dup type InstanceType ne {
  191.         dup type /packedarraytype eq InstanceType /arraytype eq and
  192.         not { /defineresource load /typecheck signalerror } if
  193.       } if
  194.     } if
  195.     /DefineResource .resourceexec
  196.     4 1 roll pop pop pop
  197. } bind odef
  198. % We must prevent resourceforall from automatically restoring the stacks,
  199. % because we don't want the stacks restored if proc causes an error.
  200. % On the other hand, resourceforall is defined in the PLRM as an operator,
  201. % so it must have type /operatortype.  We hack this by taking advantage of
  202. % the fact that the interpreter optimizes tail calls, so stack protection
  203. % doesn't apply to the very last token of an operator procedure.
  204. /resourceforall1 {    % <template> <proc> <scratch> <category> resourceforall1 -
  205.     dup /Category findresource begin
  206.     /ResourceForAll load
  207.         % Make sure we can recover the original operands.
  208.         % We must create the array in local VM, in case any of the
  209.         % operands are local.
  210.         % Stack: ...operands... proc
  211.     5 copy pop .currentglobal false .setglobal 5 1 roll
  212.     4 packedarray exch .setglobal count
  213.         % Stack: ...operands... proc saved count
  214.     4 -1 roll pop        % pop the category
  215.     /stopped load 3 1 roll
  216.     3 .execn
  217.         % Stack: ... stopped saved count
  218.     3 -1 roll {
  219.       .currentstackprotect {
  220.         % The count is the original stack depth + 2.
  221.         count exch 4 sub sub { exch pop } repeat
  222.         aload pop end
  223.       } {
  224.         % Don't restore the stacks.
  225.         pop pop
  226.       } ifelse stop
  227.     } {
  228.       pop pop end
  229.     } ifelse
  230. } bind def
  231. /resourceforall {    % <template> <proc> <scratch> <category> resourceforall1 -
  232.     //resourceforall1 exec        % see above
  233. } bind odef
  234. /resourcestatus {    % <key> <category> resourcestatus <status> <size> true
  235.             % <key> <category> resourcestatus false
  236.     2 copy .findcategory /ResourceStatus .resourceexec
  237.      { 4 2 roll pop pop true } { pop pop false } ifelse
  238. } bind odef
  239. /undefineresource {    % <key> <category> undefineresource -
  240.     2 copy .findcategory /UndefineResource .resourceexec pop pop
  241. } bind odef
  242.  
  243. % Define the system parameters used for the Generic implementation of
  244. % ResourceFileName.
  245. systemdict begin
  246. currentdict /pssystemparams known not {
  247.   /pssystemparams 10 dict readonly def
  248. } if
  249. pssystemparams begin
  250.   /FontResourceDir (/Resource/Font/) readonly .forcedef    % pssys'params is r-o
  251.   /GenericResourceDir (/Resource/) readonly .forcedef    % pssys'params is r-o
  252.   /GenericResourcePathSep (/) readonly .forcedef    % pssys'params is r-o
  253. end
  254. end
  255.  
  256. % Define the generic algorithm for computing resource file names.
  257. /.rfnstring 100 string def
  258. /.genericrfn        % <key> <scratch> <prefix> .genericrfn <filename>
  259.  { 3 -1 roll //.rfnstring cvs concatstrings exch copy
  260.  } bind def
  261.  
  262. % Define a procedure for making a packed array in local VM.
  263. /.localpackedarray {    % <obj1> ... <objn> <n> .localpackedarray <packedarray>
  264.   .currentglobal false .setglobal 1 index 2 add 1 roll
  265.   packedarray exch .setglobal
  266. } bind def
  267.  
  268. % Define the Generic category.
  269.  
  270. /Generic mark
  271.  
  272.         % Standard entries
  273.  
  274. % We're still running in Level 1 mode, so dictionaries won't expand.
  275. % Leave room for the /Category entry.
  276. /Category null
  277.  
  278. % Implement the body of Generic resourceforall for local, global, and
  279. % external cases.  'args' is [template proc scratch resdict].
  280. /.enumerateresource {    % <key> [- <proc> <scratch>] .enumerateresource -
  281.   1 index type dup /stringtype eq exch /nametype eq or {
  282.     exch 1 index 2 get cvs exch
  283.   } if
  284.     % Use .setstackprotect to prevent the stacks from being restored if
  285.     % an error occurs during execution of proc.
  286.   1 get false .setstackprotect exec true .setstackprotect
  287. } bind def
  288. /.localresourceforall {        % <key> <value> <args> .localr'forall -
  289.   exch pop
  290.   2 copy 0 get .stringmatch { .enumerateresource } { pop pop } ifelse
  291. } bind def
  292. /.globalresourceforall {    % <key> <value> <args> .globalr'forall -
  293.   exch pop
  294.   2 copy 0 get .stringmatch {
  295.     dup 3 get begin .LocalInstances end 2 index known not {
  296.       .enumerateresource
  297.     } if
  298.   } {
  299.     pop pop
  300.   } ifelse
  301. } bind def
  302. /.externalresourceforall {    % <filename> <len> <args> .externalr'forall -
  303.   3 1 roll 1 index length 1 index sub getinterval exch
  304.   dup 3 get begin .Instances .LocalInstances end
  305.         % Stack: key args insts localinsts
  306.   3 index known {
  307.     pop pop pop
  308.   } {
  309.     2 index known { pop pop } { .enumerateresource } ifelse
  310.   } ifelse
  311. } bind def
  312.  
  313. /DefineResource {
  314.     .CheckResource
  315.        { dup [ exch 0 -1 ]
  316.             % Stack: key value instance
  317.          currentglobal
  318.           { false setglobal 2 index UndefineResource    % remove local def if any
  319.         true setglobal
  320.         .Instances dup //.emptydict eq {
  321.           pop 3 dict
  322.             % As noted above, Category dictionaries are read-only,
  323.             % so we have to use .forcedef here.
  324.           /.Instances 1 index .forcedef    % Category dict is read-only
  325.         } if
  326.           }
  327.           { .LocalInstances dup //.emptydict eq
  328.              { pop 3 dict localinstancedict Category 2 index put
  329.          }
  330.         if
  331.           }
  332.          ifelse
  333.             % Stack: key value instance instancedict
  334.          3 index 2 index .growput
  335.             % Now make the resource value read-only.
  336.          0 2 copy get { readonly } .internalstopped pop
  337.          dup 4 1 roll put exch pop exch pop
  338.        }
  339.        { /defineresource load /typecheck signalerror
  340.        }
  341.     ifelse
  342. } bind executeonly        % executeonly to prevent access to .forcedef
  343. /UndefineResource
  344.     {  { dup 2 index .knownget
  345.           { dup 1 get 1 ge
  346.          { dup 0 null put 1 2 put pop pop }
  347.          { pop exch .undef }
  348.         ifelse
  349.           }
  350.           { pop pop
  351.           }
  352.          ifelse
  353.        }
  354.       currentglobal
  355.        { 2 copy .Instances exch exec
  356.        }
  357.       if .LocalInstances exch exec
  358.     } bind
  359. % Because of some badly designed code in Adobe's CID font downloader that
  360. % makes findresource and resourcestatus deliberately inconsistent with each
  361. % other, the default FindResource must not call ResourceStatus if there is
  362. % an instance of the desired name already defined in VM.
  363. /FindResource {
  364.     dup .getvminstance {
  365.       exch pop 0 get
  366.     } {
  367.       dup ResourceStatus {
  368.         pop 1 gt {
  369.           .DoLoadResource .getvminstance not {
  370.         /findresource load /undefinedresource signalerror
  371.           } if 0 get
  372.         } {
  373.           .GetInstance pop 0 get
  374.         } ifelse
  375.       } {
  376.        /findresource load /undefinedresource signalerror
  377.       } ifelse
  378.     } ifelse
  379. } bind
  380. % Because of some badly designed code in Adobe's CID font downloader, the
  381. % definition of ResourceStatus for Generic and Font must be the same (!).
  382. % We patch around this by using an intermediate .ResourceFileStatus procedure.
  383. /ResourceStatus {
  384.     dup .GetInstance {
  385.       exch pop dup 1 get exch 2 get true
  386.     } {
  387.       .ResourceFileStatus
  388.     } ifelse
  389. } bind
  390. /.ResourceFileStatus {
  391.     .ResourceFile { closefile 2 -1 true } { pop false } ifelse
  392. } bind
  393. /ResourceForAll {
  394.         % **************** Doesn't present instance groups in
  395.         % **************** the correct order yet.
  396.         % Construct a new procedure to hold the arguments.
  397.         % All objects constructed here must be in local VM to avoid
  398.         % a possible invalidaccess.
  399.     currentdict 4 .localpackedarray    % [template proc scratch resdict]
  400.         % We must pop the resource dictionary off the dict stack
  401.         % when doing the actual iteration, and restore it afterwards.
  402.     .currentglobal not {
  403.       .LocalInstances length 0 ne {
  404.         % We must do local instances, and do them first.
  405.         //.localresourceforall {exec} 0 get 3 .localpackedarray cvx
  406.         .LocalInstances exch {forall} 0 get 1 index 0 get
  407.         currentdict end 3 .execn begin
  408.       } if
  409.     } if
  410.         % Do global instances next.
  411.     //.globalresourceforall {exec} 0 get 3 .localpackedarray cvx
  412.     .Instances exch cvx {forall} 0 get 1 index 0 get
  413.     currentdict end 3 .execn begin
  414.     currentdict /ResourceFileName known {
  415.         % Finally, do instances stored on files.
  416.       dup 0 get 100 string ResourceFileName
  417.       dup length 2 index 0 get length sub 3 -1 roll
  418.       //.externalresourceforall {exec} 0 get 4 .localpackedarray cvx
  419.       100 string {filenameforall} 0 get
  420.       currentdict end 2 .execn begin null    % for pop
  421.     } if pop
  422. } bind
  423. /ResourceFileName
  424.     { /GenericResourceDir getsystemparam 
  425.       Category .namestring concatstrings
  426.       /GenericResourcePathSep getsystemparam concatstrings
  427.       .genericrfn
  428.     } bind
  429.  
  430.         % Additional entries
  431.  
  432. % Unfortunately, we can't create the real .Instances dictionary now,
  433. % because if someone copies the Generic category (which pp. 95-96 of the
  434. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  435. % the .Instances.  Instead, we have to create .Instances on demand,
  436. % just like the entry in localinstancedict.
  437. % We also have to prevent anyone from creating instances of Generic itself.
  438. /.Instances //.emptydict
  439.  
  440. /.LocalInstances
  441.     { localinstancedict Category .knownget not { //.emptydict } if
  442.     } bind
  443. /.GetInstance
  444.     { currentglobal
  445.        { .Instances exch .knownget }
  446.        { .LocalInstances 1 index .knownget
  447.           { exch pop true }
  448.           { .Instances exch .knownget }
  449.          ifelse
  450.        }
  451.       ifelse
  452.     } bind
  453. /.CheckResource
  454.     { true
  455.     } bind
  456. /.vmused {
  457.         % - .vmused <usedvalue>
  458.         % usedvalue = vmstatus in global + vmstatus in local.
  459.   0 2 {
  460.     .currentglobal not .setglobal
  461.     vmstatus pop exch pop add
  462.   } repeat
  463. } bind def
  464. /.DoLoadResource {
  465.         % .LoadResource may push entries on the operand stack.
  466.         % It is an undocumented feature of Adobe implementations,
  467.         % which we must match for the sake of some badly written
  468.         % font downloading code, that such entries are popped
  469.         % automatically.
  470.     count 1 index cvlit .vmused
  471.         % Stack: key count litkey memused
  472.     {.LoadResource} 4 1 roll 4 .execn
  473.         % Stack: ... count key memused
  474.     .vmused exch sub
  475.     1 index .getvminstance not {
  476.       pop dup /undefinedresource signalerror    % didn't load
  477.     } if
  478.     dup 1 1 put
  479.     2 3 -1 roll put
  480.         % Stack: ... count key
  481.     exch count 1 sub exch sub {exch pop} repeat
  482. } bind
  483. /.LoadResource
  484.     { dup .ResourceFile
  485.        { exch pop currentglobal
  486.           { .runresource }
  487.           { true setglobal { .runresource } stopped false setglobal { stop } if }
  488.          ifelse
  489.        }
  490.        { dup /undefinedresource signalerror
  491.        }
  492.      ifelse
  493.     } bind
  494. /.ResourceFile
  495.     { currentdict /ResourceFileName known
  496.        { mark 1 index 100 string { ResourceFileName }
  497.          .internalstopped
  498.           { cleartomark false }
  499.           { exch pop findlibfile
  500.          { exch pop exch pop true }
  501.          { pop false }
  502.         ifelse
  503.           }
  504.          ifelse
  505.        }
  506.        { false }
  507.       ifelse
  508.     } bind
  509.  
  510. .dicttomark
  511. /Category defineresource pop
  512.  
  513. % Fill in the rest of the Category category.
  514. /Category /Category findresource dup
  515. /Generic /Category findresource begin {
  516.   /FindResource /ResourceForAll /ResourceStatus /.ResourceFileStatus
  517.   /UndefineResource /ResourceFileName
  518.   /.ResourceFile /.LoadResource /.DoLoadResource
  519. } { dup load put dup } forall
  520. pop readonly pop end
  521.  
  522. (END GENERIC) VMDEBUG
  523.  
  524. % Define the fixed categories.
  525.  
  526. mark
  527.     % Non-Type categories with existing entries.
  528.  /ColorSpaceFamily
  529.    { }    % These must be deferred, because optional features may add some.
  530.  /Emulator
  531.    mark EMULATORS { cvn } forall .packtomark
  532.  /Filter
  533.    { }    % These must be deferred, because optional features may add some.
  534.  /IODevice
  535.     % Loop until the .getiodevice gets a rangecheck.
  536.    errordict /rangecheck 2 copy get
  537.    errordict /rangecheck { pop stop } put    % pop the command
  538.    mark 0 { {
  539.     dup .getiodevice dup null eq { pop } { exch } ifelse 1 add
  540.    } loop} .internalstopped
  541.    pop pop pop .packtomark
  542.    4 1 roll put
  543.    .clearerror
  544.     % Type categories listed in the Red Book.
  545.  /ColorRenderingType
  546.    { }    % These must be deferred, because optional features may add some.
  547.  /FMapType
  548.    { }    % These must be deferred, because optional features may add some.
  549.  /FontType
  550.    { }    % These must be deferred, because optional features may add some.
  551.  /FormType
  552.    { }    % These must be deferred, because optional features may add some.
  553.  /HalftoneType
  554.    { }    % These must be deferred, because optional features may add some.
  555.  /ImageType
  556.    { }    % Deferred, optional features may add some.
  557.  /PatternType
  558.    { }  % Deferred, optional features may add some.
  559.     % Type categories added since the Red Book.
  560.  /setsmoothness where {
  561.    pop /ShadingType { }    % Deferred, optional features may add some.
  562.  } if
  563. counttomark 2 idiv
  564.  { mark
  565.  
  566.         % Standard entries
  567.  
  568.         % We'd like to prohibit defineresource,
  569.         % but because optional features may add entries, we can't.
  570.         % We can at least require that the key and value match.
  571.    /DefineResource
  572.     { currentglobal not
  573.        { /defineresource load /invalidaccess signalerror }
  574.        { 2 copy ne
  575.           { /defineresource load /rangecheck signalerror }
  576.           { dup .Instances 4 -2 roll .growput }
  577.          ifelse
  578.        }
  579.       ifelse
  580.     } bind
  581.    /UndefineResource
  582.     { /undefineresource load /invalidaccess signalerror } bind
  583.    /FindResource
  584.     { .Instances 1 index .knownget
  585.        { exch pop }
  586.        { /findresource load /undefinedresource signalerror }
  587.       ifelse
  588.     } bind
  589.    /ResourceStatus
  590.     { .Instances exch known { 0 0 true } { false } ifelse } bind
  591.    /ResourceForAll
  592.     /Generic /Category findresource /ResourceForAll get
  593.  
  594.         % Additional entries
  595.  
  596.    counttomark 2 add -1 roll
  597.    dup length dict dup begin exch { dup def } forall end
  598.         % We'd like to make the .Instances readonly here,
  599.         % but because optional features may add entries, we can't.
  600.    /.Instances exch
  601.    /.LocalInstances    % used by ResourceForAll
  602.     0 dict def
  603.  
  604.    .dicttomark /Category defineresource pop
  605.  } repeat pop
  606.  
  607. (END FIXED) VMDEBUG
  608.  
  609. % Define the other built-in categories.
  610.  
  611. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  612.  { counttomark 2 idiv 2 add        % .Instances, Category
  613.    /Generic /Category findresource dup maxlength 3 -1 roll add
  614.    dict .copydict begin
  615.    counttomark 2 idiv { def } repeat pop    % pop the mark
  616.    currentdict end /Category defineresource pop
  617.  } bind def
  618.  
  619. /ColorRendering mark /InstanceType /dicttype .definecategory
  620. % ColorSpace is defined below
  621. % Encoding is defined below
  622. % Font is defined below
  623. /Form mark /InstanceType /dicttype .definecategory
  624. /Halftone mark /InstanceType /dicttype .definecategory
  625. /Pattern mark /InstanceType /dicttype .definecategory
  626. /ProcSet mark /InstanceType /dicttype .definecategory
  627. % Added since the Red Book:
  628. /ControlLanguage mark /InstanceType /dicttype .definecategory
  629. /HWOptions mark /InstanceType /dicttype .definecategory
  630. /Localization mark /InstanceType /dicttype .definecategory
  631. /OutputDevice mark /InstanceType /dicttype .definecategory
  632. /PDL mark /InstanceType /dicttype .definecategory
  633. % CIDFont, CIDMap, and CMap are defined in gs_cidfn.ps
  634. % FontSet is defined in gs_cff.ps
  635. % IdiomSet is defined in gs_ll3.ps
  636. % InkParams and TrapParams are defined in gs_trap.ps
  637.  
  638. (END MISC) VMDEBUG
  639.  
  640. % Define the ColorSpace category.
  641.  
  642. /.defaultcsnames mark
  643.   /DefaultGray 0
  644.   /DefaultRGB 1
  645.   /DefaultCMYK 2
  646. .dicttomark readonly def
  647.  
  648. % The "hooks" are no-ops here, redefined in LL3.
  649. /.definedefaultcs {    % <index> <value> .definedefaultcs -
  650.   pop pop
  651. } bind def
  652. /.undefinedefaultcs {    % <index> .undefinedefaultcs -
  653.   pop
  654. } bind def
  655.  
  656. /ColorSpace mark
  657.  
  658. /InstanceType /arraytype
  659.  
  660. % We keep track of whether there are any local definitions for any of
  661. % the Default keys.  This information must get saved and restored in
  662. % parallel with the local instance dictionary, so it must be stored in
  663. % local VM.
  664. userdict /.localcsdefaults false put
  665.  
  666. /DefineResource {
  667.   2 copy /Generic /Category findresource /DefineResource get exec
  668.   exch pop
  669.   exch //.defaultcsnames exch .knownget {
  670.     1 index .definedefaultcs
  671.     currentglobal not { .userdict /.localcsdefaults true put } if
  672.   } if
  673. } bind
  674.  
  675. /UndefineResource {
  676.   dup /Generic /Category findresource /UndefineResource get exec
  677.   //.defaultcsnames 1 index .knownget {
  678.     % Stack: resname index
  679.     currentglobal {
  680.       .undefinedefaultcs pop
  681.     } {
  682.     % We removed the local definition, but there might be a global one.
  683.       exch .GetInstance {
  684.     0 get .definedefaultcs
  685.       } {
  686.     .undefinedefaultcs
  687.       } ifelse
  688.     % Recompute .localcsdefaults by scanning.  This is rarely needed.
  689.       .userdict /.localcsdefaults false //.defaultcsnames {
  690.     pop .LocalInstances exch known { pop true exit } if
  691.       } forall put
  692.     } ifelse
  693.   } {
  694.     pop
  695.   } ifelse
  696. } bind
  697.  
  698. .definecategory            % ColorSpace
  699.  
  700. % Define the Encoding category.
  701.  
  702. /Encoding mark
  703.  
  704. /InstanceType /arraytype
  705.  
  706. % Handle already-registered encodings, including lazily loaded encodings
  707. % that aren't loaded yet.
  708.  
  709. /.Instances mark
  710.   EncodingDirectory
  711.    { dup length 256 eq { [ exch readonly 0 -1 ] } { pop [null 2 -1] } ifelse
  712.    } forall
  713. .dicttomark
  714.  
  715. /.ResourceFileDict mark
  716.   EncodingDirectory
  717.    { dup length 256 eq { pop pop } { 0 get } ifelse
  718.    } forall
  719. .dicttomark
  720.  
  721. /ResourceFileName
  722.  { .ResourceFileDict 2 index .knownget
  723.     { exch copy exch pop }
  724.     { /Generic /Category findresource /ResourceFileName get exec }
  725.    ifelse
  726.  } bind
  727.  
  728. .definecategory            % Encoding
  729.  
  730. % Make placeholders in level2dict for the redefined Encoding operators,
  731. % so that they will be swapped properly when we switch language levels.
  732.  
  733. /.findencoding /.findencoding load def
  734. /findencoding /findencoding load def
  735. /.defineencoding /.defineencoding load def
  736.  
  737. (END ENCODING) VMDEBUG
  738.  
  739. % Define the Font category.
  740.  
  741. /.fontstatus {        % <fontname> .fontstatus <fontname> <found>
  742.   {        % Create a loop context just so we can exit it early.
  743.         % Check Fontmap.
  744.     Fontmap 1 index .knownget {
  745.       {
  746.     dup type /nametype eq {
  747.       .fontstatus { pop null exit } if
  748.     } {
  749.       dup type /stringtype eq {
  750.         findlibfile { closefile pop null exit } if pop
  751.       } {
  752.         % Procedure, assume success.
  753.         pop null exit
  754.       } ifelse
  755.     } ifelse
  756.       } forall dup null eq { pop true exit } if
  757.     } if
  758.         % Convert names to strings; give up on other types.
  759.     dup type /nametype eq { .namestring } if
  760.     dup type /stringtype ne { false exit } if
  761.         % Check the resource directory.
  762.     dup .fonttempstring /FontResourceDir getsystemparam .genericrfn
  763.     status {
  764.       pop pop pop pop true exit
  765.     } if
  766.         % Check for a file on the search path with the same name
  767.         % as the font.
  768.     findlibfile { closefile true exit } if
  769.         % Scan a FONTPATH directory and try again.
  770.     .scannextfontdir not { false exit } if
  771.   } loop
  772. } bind def
  773.  
  774. /Font mark
  775.  
  776. /InstanceType /dicttype
  777.  
  778. /DefineResource
  779.     { 2 copy //definefont exch pop
  780.       /Generic /Category findresource /DefineResource get exec
  781.     } bind
  782. /UndefineResource
  783.     { dup //undefinefont
  784.       /Generic /Category findresource /UndefineResource get exec
  785.     } bind
  786. /FindResource {
  787.     dup .getvminstance {
  788.       exch pop 0 get
  789.     } {
  790.       dup ResourceStatus {
  791.         pop 1 gt { .loadfontresource } { .GetInstance pop 0 get } ifelse
  792.       } {
  793.         .loadfontresource
  794.       } ifelse
  795.     } ifelse
  796. } bind
  797. /ResourceForAll {
  798.     { .scannextfontdir not { exit } if } loop
  799.     /Generic /Category findresource /ResourceForAll get exec
  800. } bind
  801. /.ResourceFileStatus {
  802.     .fontstatus { pop 2 -1 true } { pop false } ifelse
  803. } bind
  804.  
  805. /.loadfontresource {
  806.     dup vmstatus pop exch pop exch
  807.         % Hack: rebind .currentresourcefile so that all calls of
  808.         % definefont will know these are built-in fonts.
  809.     currentfile {pop //findfont exec} .execasresource  % (findfont is a procedure)
  810.     exch vmstatus pop exch pop exch sub
  811.         % stack: name font vmused
  812.         % findfont has the prerogative of not calling definefont
  813.         % in certain obscure cases of font substitution.
  814.     2 index .getvminstance {
  815.       dup 1 1 put
  816.       2 3 -1 roll put
  817.     } {
  818.       pop
  819.     } ifelse exch pop
  820. } bind
  821.  
  822. /.Instances FontDirectory length 2 mul dict
  823.  
  824. .definecategory            % Font
  825.  
  826. % Redefine font "operators".
  827. /.definefontmap
  828.  { /Font /Category findresource /.Instances get
  829.    dup 3 index known
  830.     { pop
  831.     }
  832.     { 2 index
  833.         % Make sure we create the array in global VM.
  834.       .currentglobal true .setglobal
  835.       [null 2 -1] exch .setglobal
  836.       .growput
  837.     }
  838.    ifelse
  839.    //.definefontmap exec
  840.  } bind def
  841.  
  842. % Make sure the old definitions are still in systemdict so that
  843. % they will get bound properly.
  844. systemdict begin
  845.   /.origdefinefont /definefont load def
  846.   /.origundefinefont /undefinefont load def
  847.   /.origfindfont /findfont load def
  848. end
  849. /definefont {
  850.   /Font defineresource
  851. } bind odef
  852. /undefinefont {
  853.   /Font undefineresource
  854. } bind odef
  855. % The Red Book requires that findfont be a procedure, not an operator,
  856. % but it still needs to restore the stacks reliably if it fails.
  857. /.findfontop {
  858.   /Font findresource
  859. } bind odef
  860. /findfont {
  861.   .findfontop
  862. } bind def    % Must be a procedure, not an operator
  863.  
  864. % Remove initialization utilities.
  865. currentdict /.definecategory .undef
  866. currentdict /.emptydict .undef
  867.  
  868. end                % level2dict
  869.  
  870. % Convert deferred resources after we finally switch to Level 2.
  871.  
  872. /.fixresources {
  873.     % Encoding resources
  874.   EncodingDirectory
  875.    { dup length 256 eq
  876.       { /Encoding defineresource pop }
  877.       { pop pop }
  878.      ifelse
  879.    } forall
  880.   /.findencoding { /Encoding findresource } bind def
  881.   /findencoding /.findencoding load def        % must be a procedure
  882.   /.defineencoding { /Encoding defineresource pop } bind def
  883.     % ColorRendering resources and ProcSet
  884.   systemdict /ColorRendering .knownget {
  885.     /ColorRendering exch /ProcSet defineresource pop
  886.     systemdict /ColorRendering undef
  887.     /Default currentcolorrendering /ColorRendering defineresource pop
  888.   } if
  889.     % ColorSpace resources
  890.   systemdict /CIEsRGB .knownget {
  891.     /sRGB exch /ColorSpace defineresource pop
  892.     systemdict /CIEsRGB undef
  893.   } if
  894.     % ColorSpaceFamily resources
  895.   colorspacedict { pop dup /ColorSpaceFamily defineresource pop } forall
  896.     % Filter resources
  897.   filterdict { pop dup /Filter defineresource pop } forall
  898.     % FontType and FMapType resources
  899.   buildfontdict { pop dup /FontType defineresource pop } forall
  900.   mark
  901.     buildfontdict 0 known { 2 3 4 5 6 7 8 } if
  902.     buildfontdict 9 known { 9 } if
  903.   counttomark { dup /FMapType defineresource pop } repeat pop
  904.     % FormType resources
  905.   .formtypes { pop dup /FormType defineresource pop } forall
  906.     % HalftoneType resources
  907.   .halftonetypes { pop dup /HalftoneType defineresource pop } forall
  908.     % ColorRenderingType resources
  909.   .colorrenderingtypes {pop dup /ColorRenderingType defineresource pop} forall
  910.     % ImageType resources
  911.   .imagetypes { pop dup /ImageType defineresource pop } forall
  912.     % PatternType resources
  913.   .patterntypes { pop dup /PatternType defineresource pop } forall
  914.     % Make the fixed resource categories immutable.
  915.   /.shadingtypes where {
  916.     pop .shadingtypes { pop dup /ShadingType defineresource pop } forall
  917.   } if
  918.   [ /ColorSpaceFamily /Emulator /Filter /IODevice /ColorRenderingType
  919.     /FMapType /FontType /FormType /HalftoneType /ImageType /PatternType
  920.     /.shadingtypes where { pop /ShadingType } if
  921.   ] {
  922.     /Category findresource
  923.     dup /.Instances get readonly pop
  924.     .LocalInstances readonly pop
  925.     readonly pop
  926.   } forall
  927.     % clean up
  928.   systemdict /.fixresources undef
  929. } bind def
  930.