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