home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 August / PCWorld_2000-08_cd.bin / Software / TemaCD / ghostscr / gs601w32.exe / gs6.01 / lib / gs_res.ps < prev    next >
Text File  |  2000-03-09  |  26KB  |  833 lines
  1. %    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % $Id: gs_res.ps,v 1.2 2000/03/10 04:54:15 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 - (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. % All the above procedures expect that the top dictionary on the d-stack
  90. % is the resource dictionary.
  91.  
  92. % Define enough of the Category category so we can define other categories.
  93. % The dictionary we're about to create will become the Category
  94. % category definition dictionary.
  95.  
  96. % .findcategory and .resourceexec are only called from within the
  97. % implementation of the resource 'operators', so they doesn't have to worry
  98. % about cleaning up the stack if they fail (the interpreter's stack
  99. % protection machinery for pseudo-operators takes care of this).
  100. /.findcategory {    % <name> .findcategory -
  101.             %   (pushes the category on the dstack)
  102.   /Category findresource begin
  103. } bind def
  104.  
  105. /.resourceexec {    % <key> /xxxResource .resourceexec -
  106.             %   (also pops the category from the dstack)
  107.   load exec end
  108. } bind def
  109.  
  110. 15 dict begin
  111.  
  112.         % Standard entries
  113.  
  114. /Category /Category def
  115. /InstanceType /dicttype def
  116.  
  117. /DefineResource
  118.     { .CheckResource
  119.        { dup /Category 3 index cvlit .growput
  120.         % We would like to make Category dictionaries read-only,
  121.         % and we used to do that here, but we can't do it,
  122.         % because we have to be able to replace the dummy, empty
  123.         % Instances dictionary with the real one later.
  124.          dup [ exch 0 -1 ] exch
  125.          Instances 4 2 roll put
  126.        }
  127.        { /defineresource load /typecheck signalerror
  128.        }
  129.       ifelse
  130.     } bind def
  131. /FindResource        % (redefined below)
  132.     { Instances exch get 0 get
  133.     } bind def
  134.  
  135.         % Additional entries
  136.  
  137. /Instances 30 dict def
  138. Instances /Category [currentdict 0 -1] put
  139.  
  140. /.LocalInstances 0 dict def
  141. /.GetInstance
  142.     { Instances exch .knownget
  143.     } bind def
  144. /.CheckResource
  145.     { dup gcheck currentglobal and
  146.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  147.          /UndefineResource }
  148.        { 2 index exch known and }
  149.       forall
  150.       not { /defineresource load /invalidaccess signalerror } if
  151.       true
  152.     } bind def
  153.  
  154. Instances end begin    % for the base case of findresource
  155.  
  156. (END CATEGORY) VMDEBUG
  157.  
  158. % Define the resource operators.  We use the "stack protection" feature of
  159. % odef to make sure the stacks are restored properly on an error.
  160. % This requires that the operators not pop anything from the stack until
  161. % they have executed their logic successfully.  We can't make this
  162. % work for resourceforall, because the procedure it executes mustn't see
  163. % the operands of resourceforall on the stack, but we can make it work for
  164. % the others.
  165.  
  166. mark
  167. /defineresource {    % <key> <instance> <category> defineresource <instance>
  168.     3 copy .findcategory
  169.     currentdict /InstanceType known {
  170.       dup type InstanceType ne {
  171.         dup type /packedarraytype eq InstanceType /arraytype eq and
  172.         not { /defineresource load /typecheck signalerror } if
  173.       } if
  174.     } if
  175.     /DefineResource .resourceexec
  176.     4 1 roll pop pop pop
  177. }
  178. /findresource {        % <key> <category> findresource <instance>
  179.     2 copy dup /Category eq
  180.       { pop //Category 0 get begin } { .findcategory } ifelse
  181.     /FindResource .resourceexec exch pop exch pop
  182. }
  183. /resourceforall {    % <template> <proc> <scratch> <category> resourceforall -
  184.     dup /Category findresource begin
  185.     /ResourceForAll load
  186.         % Make sure we can recover the original operands.
  187.         % Stack: ...operands... proc
  188.     5 copy pop 4 packedarray count
  189.         % Stack: ...operands... proc saved count
  190.     4 -1 roll pop        % pop the category
  191.     /stopped load 3 1 roll
  192.     3 .execn
  193.         % Stack: ... stopped saved count
  194.     3 -1 roll {
  195.         % The count is the original stack depth + 2.
  196.       count exch 4 sub sub { exch pop } repeat
  197.       aload pop stop
  198.     } {
  199.       pop pop
  200.     } ifelse end
  201. }
  202. /resourcestatus {    % <key> <category> resourcestatus <status> <size> true
  203.             % <key> <category> resourcestatus false
  204.     2 copy .findcategory /ResourceStatus .resourceexec
  205.      { 4 2 roll pop pop true } { pop pop false } ifelse
  206. }
  207. /undefineresource {    % <key> <category> undefineresource -
  208.     2 copy .findcategory /UndefineResource .resourceexec pop pop
  209. }
  210. end        % Instances of Category
  211. counttomark 2 idiv { bind odef } repeat pop
  212.  
  213. % Define the system parameters used for the Generic implementation of
  214. % ResourceFileName.
  215. systemdict begin
  216. currentdict /pssystemparams known not {
  217.   /pssystemparams 10 dict readonly def
  218. } if
  219. pssystemparams begin
  220.   /FontResourceDir (/Resource/Font/) readonly .forcedef    % pssys'params is r-o
  221.   /GenericResourceDir (/Resource/) readonly .forcedef    % pssys'params is r-o
  222.   /GenericResourcePathSep (/) readonly .forcedef    % pssys'params is r-o
  223. end
  224. end
  225.  
  226. % Define the generic algorithm for computing resource file names.
  227. /.rfnstring 100 string def
  228. /.genericrfn        % <key> <scratch> <prefix> .genericrfn <filename>
  229.  { 3 -1 roll //.rfnstring cvs concatstrings exch copy
  230.  } bind def
  231.  
  232. % Define the Generic category.
  233.  
  234. /Generic mark
  235.  
  236.         % Standard entries
  237.  
  238. % We're still running in Level 1 mode, so dictionaries won't expand.
  239. % Leave room for the /Category entry.
  240. /Category null
  241.  
  242. /DefineResource
  243.     { .CheckResource
  244.        { dup [ exch 0 -1 ]
  245.             % Stack: key value instance
  246.          currentglobal
  247.           { false setglobal 2 index UndefineResource    % remove local def if any
  248.         true setglobal
  249.         Instances dup //.emptydict eq
  250.          { pop 3 dict /Instances 1 index def
  251.          }
  252.         if
  253.           }
  254.           { .LocalInstances dup //.emptydict eq
  255.              { pop 3 dict localinstancedict Category 2 index put
  256.          }
  257.         if
  258.           }
  259.          ifelse
  260.             % Stack: key value instance instancedict
  261.          3 index 2 index .growput
  262.             % Now make the resource value read-only.
  263.          0 2 copy get { readonly } .internalstopped pop
  264.          dup 4 1 roll put exch pop exch pop
  265.        }
  266.        { /defineresource load /typecheck signalerror
  267.        }
  268.       ifelse
  269.     } bind
  270. /UndefineResource
  271.     {  { dup 2 index .knownget
  272.           { dup 1 get 1 ge
  273.          { dup 0 null put 1 2 put pop pop }
  274.          { pop exch .undef }
  275.         ifelse
  276.           }
  277.           { pop pop
  278.           }
  279.          ifelse
  280.        }
  281.       currentglobal
  282.        { 2 copy Instances exch exec
  283.        }
  284.       if .LocalInstances exch exec
  285.     } bind
  286. /FindResource
  287.     { dup ResourceStatus
  288.        { pop 1 gt            % not in VM
  289.           { .DoLoadResource
  290.           }
  291.          if
  292.          .GetInstance pop        % can't fail
  293.          0 get
  294.        }
  295.        { /findresource load /undefinedresource signalerror
  296.        }
  297.       ifelse
  298.     } bind
  299. /ResourceStatus
  300.     { dup .GetInstance
  301.        { exch pop dup 1 get exch 2 get true }
  302.        { .ResourceFile
  303.           { closefile 2 -1 true }
  304.           { pop false }
  305.          ifelse
  306.        }
  307.       ifelse
  308.     } bind
  309. /ResourceForAll
  310.     {    % **************** Doesn't present instance groups in
  311.         % **************** the correct order yet.
  312.         % Construct a new procedure to hold the arguments.
  313.         % It must be in local VM to avoid a possible invalidaccess.
  314.       .currentglobal 4 1 roll false .setglobal
  315.       3 packedarray        % template, proc, scratch
  316.       { exch pop    % stack contains: key, {template, proc, scratch}
  317.         2 copy 0 get .stringmatch
  318.          { 1 index type dup /stringtype eq exch /nametype eq or
  319.         { 2 copy 2 get cvs
  320.           exch 1 get 3 -1 roll pop
  321.         }
  322.         { 1 get
  323.         }
  324.            ifelse exec
  325.          }
  326.          { pop pop
  327.          }
  328.         ifelse
  329.       } /exec cvx 3 packedarray
  330.         % Stack: global? iterproc
  331.         % We must pop the resource dictionary off the dict stack
  332.         % when doing the actual iteration, and restore it afterwards.
  333.       exch {
  334.         true .setglobal
  335.       } {
  336.         .LocalInstances length 0 ne {
  337.         % We must do local instances, and do them first.
  338.           .LocalInstances exch cvx /forall cvx 1 index cvlit
  339.           currentdict end 3 .execn begin
  340.         } if
  341.       } ifelse
  342.       Instances exch cvx
  343.       /forall cvx currentdict end 2 .execn begin
  344.     } bind
  345. /ResourceFileName
  346.     { /GenericResourceDir getsystemparam 
  347.       Category .namestring concatstrings
  348.       /GenericResourcePathSep getsystemparam concatstrings
  349.       .genericrfn
  350.     } bind
  351.  
  352.         % Additional entries
  353.  
  354. % Unfortunately, we can't create the real Instances dictionary now,
  355. % because if someone copies the Generic category (which pp. 95-96 of the
  356. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  357. % the Instances.  Instead, we have to create Instances on demand,
  358. % just like the entry in localinstancedict.
  359. % We also have to prevent anyone from creating instances of Generic itself.
  360. /Instances //.emptydict
  361.  
  362. /.LocalInstances
  363.     { localinstancedict Category .knownget not { //.emptydict } if
  364.     } bind
  365. /.GetInstance
  366.     { currentglobal
  367.        { Instances exch .knownget }
  368.        { .LocalInstances 1 index .knownget
  369.           { exch pop true }
  370.           { Instances exch .knownget }
  371.          ifelse
  372.        }
  373.       ifelse
  374.     } bind
  375. /.CheckResource
  376.     { true
  377.     } bind
  378. /.DoLoadResource
  379.     { dup vmstatus pop exch pop exch
  380.       .LoadResource
  381.       vmstatus pop exch pop exch sub
  382.       1 index .GetInstance not
  383.        { pop dup /undefinedresource signalerror }    % didn't load
  384.       if
  385.       dup 1 1 put
  386.       2 3 -1 roll put
  387.     } bind
  388. /.LoadResource
  389.     { dup .ResourceFile
  390.        { exch pop currentglobal
  391.           { .runresource }
  392.           { true setglobal { .runresource } stopped false setglobal { stop } if }
  393.          ifelse
  394.        }
  395.        { dup /undefinedresource signalerror
  396.        }
  397.      ifelse
  398.     } bind
  399. /.ResourceFile
  400.     { currentdict /ResourceFileName known
  401.        { mark 1 index 100 string { ResourceFileName }
  402.          .internalstopped
  403.           { cleartomark false }
  404.           { exch pop findlibfile
  405.          { exch pop exch pop true }
  406.          { pop false }
  407.         ifelse
  408.           }
  409.          ifelse
  410.        }
  411.        { false }
  412.       ifelse
  413.     } bind
  414.  
  415. .dicttomark
  416. /Category defineresource pop
  417.  
  418. % Fill in the rest of the Category category.
  419. /Category /Category findresource dup
  420. /Generic /Category findresource begin
  421.  { /FindResource /ResourceForAll /ResourceStatus /UndefineResource
  422.    /ResourceFileName /.ResourceFile /.LoadResource /.DoLoadResource
  423.  }
  424.  { dup load put dup } forall
  425. pop readonly pop end
  426.  
  427. (END GENERIC) VMDEBUG
  428.  
  429. % Define the fixed categories.
  430.  
  431. mark
  432.     % Non-Type categories with existing entries.
  433.  /ColorSpaceFamily
  434.    { }    % These must be deferred, because optional features may add some.
  435.  /Emulator
  436.    mark EMULATORS { cvn } forall .packtomark
  437.  /Filter
  438.    { }    % These must be deferred, because optional features may add some.
  439.  /IODevice
  440.     % Loop until the .getiodevice gets a rangecheck.
  441.    errordict /rangecheck 2 copy get
  442.    errordict /rangecheck { pop stop } put    % pop the command
  443.    mark 0 { {
  444.     dup .getiodevice dup null eq { pop } { exch } ifelse 1 add
  445.    } loop} .internalstopped
  446.    pop pop pop .packtomark
  447.    4 1 roll put
  448.    .clearerror
  449.     % Type categories listed in the Red Book.
  450.  /ColorRenderingType
  451.    { }    % These must be deferred, because optional features may add some.
  452.  /FMapType
  453.    { }    % These must be deferred, because optional features may add some.
  454.  /FontType
  455.    { }    % These must be deferred, because optional features may add some.
  456.  /FormType
  457.    { }    % These must be deferred, because optional features may add some.
  458.  /HalftoneType
  459.    { }    % These must be deferred, because optional features may add some.
  460.  /ImageType
  461.    { }    % Deferred, optional features may add some.
  462.  /PatternType
  463.    { }  % Deferred, optional features may add some.
  464.     % Type categories added since the Red Book.
  465.  /setsmoothness where {
  466.    pop /ShadingType { }    % Deferred, optional features may add some.
  467.  } if
  468. counttomark 2 idiv
  469.  { mark
  470.  
  471.         % Standard entries
  472.  
  473.         % We'd like to prohibit defineresource,
  474.         % but because optional features may add entries, we can't.
  475.         % We can at least require that the key and value match.
  476.    /DefineResource
  477.     { currentglobal not
  478.        { /defineresource load /invalidaccess signalerror }
  479.        { 2 copy ne
  480.           { /defineresource load /rangecheck signalerror }
  481.           { dup Instances 4 -2 roll .growput }
  482.          ifelse
  483.        }
  484.       ifelse
  485.     } bind
  486.    /UndefineResource
  487.     { /undefineresource load /invalidaccess signalerror } bind
  488.    /FindResource
  489.     { Instances 1 index .knownget
  490.        { exch pop }
  491.        { /findresource load /undefinedresource signalerror }
  492.       ifelse
  493.     } bind
  494.    /ResourceStatus
  495.     { Instances exch known { 0 0 true } { false } ifelse } bind
  496.    /ResourceForAll
  497.     /Generic /Category findresource /ResourceForAll get
  498.  
  499.         % Additional entries
  500.  
  501.    counttomark 2 add -1 roll
  502.    dup length dict dup begin exch { dup def } forall end
  503.         % We'd like to make the Instances readonly here,
  504.         % but because optional features may add entries, we can't.
  505.    /Instances exch
  506.    /.LocalInstances    % used by ResourceForAll
  507.     0 dict def
  508.  
  509.    .dicttomark /Category defineresource pop
  510.  } repeat pop
  511.  
  512. (END FIXED) VMDEBUG
  513.  
  514. % Define the other built-in categories.
  515.  
  516. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  517.  { counttomark 2 idiv 2 add        % Instances, Category
  518.    /Generic /Category findresource dup maxlength 3 -1 roll add
  519.    dict .copydict begin
  520.    counttomark 2 idiv { def } repeat pop    % pop the mark
  521.    currentdict end /Category defineresource pop
  522.  } bind def
  523.  
  524. /ColorRendering mark /InstanceType /dicttype .definecategory
  525. % ColorSpace is defined below
  526. % Encoding is defined below
  527. % Font is defined below
  528. /Form mark /InstanceType /dicttype .definecategory
  529. /Halftone mark /InstanceType /dicttype .definecategory
  530. /Pattern mark /InstanceType /dicttype .definecategory
  531. /ProcSet mark /InstanceType /dicttype .definecategory
  532. % Added since the Red Book:
  533. /ControlLanguage mark /InstanceType /dicttype .definecategory
  534. /HWOptions mark /InstanceType /dicttype .definecategory
  535. /Localization mark /InstanceType /dicttype .definecategory
  536. /OutputDevice mark /InstanceType /dicttype .definecategory
  537. /PDL mark /InstanceType /dicttype .definecategory
  538. % CIDFont, CIDMap, and CMap are defined in gs_cidfn.ps
  539. % FontSet is defined in gs_cff.ps
  540. % IdiomSet is defined in gs_ll3.ps
  541. % InkParams and TrapParams are defined in gs_trap.ps
  542.  
  543. (END MISC) VMDEBUG
  544.  
  545. % Define the ColorSpace category.
  546.  
  547. /.defaultcsnames mark
  548.   /DefaultGray 0
  549.   /DefaultRGB 1
  550.   /DefaultCMYK 2
  551. .dicttomark readonly def
  552.  
  553. % The "hooks" are no-ops here, redefined in LL3.
  554. /.definedefaultcs {    % <index> <value> .definedefaultcs -
  555.   pop pop
  556. } bind def
  557. /.undefinedefaultcs {    % <index> .undefinedefaultcs -
  558.   pop
  559. } bind def
  560.  
  561. /ColorSpace mark
  562.  
  563. /InstanceType /arraytype
  564.  
  565. % We keep track of whether there are any local definitions for any of
  566. % the Default keys.  This information must get saved and restored in
  567. % parallel with the local instance dictionary, so it must be stored in
  568. % local VM.  Therefore, we use a local array (actually, a procedure)
  569. % to hold the flag.
  570.  
  571. % We'll need to use .forceput to initialize this correctly.
  572. /.LocalDefaults null
  573.  
  574. /DefineResource {
  575.   2 copy /Generic /Category findresource /DefineResource get exec
  576.   exch pop
  577.   exch //.defaultcsnames exch .knownget {
  578.     1 index .definedefaultcs
  579.     currentglobal not { /.LocalDefaults load 0 true put } if
  580.   } if
  581. } bind
  582.  
  583. /UndefineResource {
  584.   dup /Generic /Category findresource /UndefineResource get exec
  585.   //.defaultcsnames exch .knownget {
  586.     .undefinedefaultcs
  587.     currentglobal not {
  588.     % Recompute .LocalDefaults by scanning.  This is rarely needed.
  589.       /.LocalDefaults load 0 false //.defaultcsnames {
  590.     pop .LocalInstances exch known { pop true exit } if
  591.       } forall put
  592.     } if
  593.   } if
  594. } bind
  595.  
  596. .definecategory            % ColorSpace
  597.  
  598. currentglobal false setglobal
  599. /ColorSpace /Category findresource
  600.   /.LocalDefaults [false] cvx .forceput    % category is global, array is local
  601. setglobal
  602.  
  603. % Define the Encoding category.
  604.  
  605. /Encoding mark
  606.  
  607. /InstanceType /arraytype
  608.  
  609. % Handle already-registered encodings, including lazily loaded encodings
  610. % that aren't loaded yet.
  611.  
  612. /Instances mark
  613.   EncodingDirectory
  614.    { dup length 256 eq { [ exch readonly 0 -1 ] } { pop [null 2 -1] } ifelse
  615.    } forall
  616. .dicttomark
  617.  
  618. /.ResourceFileDict mark
  619.   EncodingDirectory
  620.    { dup length 256 eq { pop pop } { 0 get } ifelse
  621.    } forall
  622. .dicttomark
  623.  
  624. /ResourceFileName
  625.  { .ResourceFileDict 2 index .knownget
  626.     { exch copy exch pop }
  627.     { /Generic /Category findresource /ResourceFileName get exec }
  628.    ifelse
  629.  } bind
  630.  
  631. .definecategory            % Encoding
  632.  
  633. % Make placeholders in level2dict for the redefined Encoding operators,
  634. % so that they will be swapped properly when we switch language levels.
  635.  
  636. /.findencoding /.findencoding load def
  637. /findencoding /findencoding load def
  638. /.defineencoding /.defineencoding load def
  639.  
  640. (END ENCODING) VMDEBUG
  641.  
  642. % Define the Font category.
  643.  
  644. /.fontstatus {        % <fontname> .fontstatus <fontname> <found>
  645.   {        % Create a loop context just so we can exit it early.
  646.         % Check Fontmap.
  647.     Fontmap 1 index .knownget {
  648.       {
  649.     dup type /nametype eq {
  650.       .fontstatus { null exit } if
  651.     } {
  652.       dup type /stringtype eq {
  653.         findlibfile { closefile pop null exit } if pop
  654.       } {
  655.         % Procedure, assume success.
  656.         pop null exit
  657.       } ifelse
  658.     } ifelse
  659.       } forall dup null eq { pop true exit } if
  660.     } if
  661.         % Convert names to strings; give up on other types.
  662.     dup type /nametype eq { .namestring } if
  663.     dup type /stringtype ne { false exit } if
  664.         % Check the resource directory.
  665.     dup .fonttempstring /FontResourceDir getsystemparam .genericrfn
  666.     status {
  667.       pop pop pop pop true exit
  668.     } if
  669.         % Check for a file on the search path with the same name
  670.         % as the font.
  671.     findlibfile { closefile true exit } if
  672.         % Scan a FONTPATH directory and try again.
  673.     .scannextfontdir not { false exit } if
  674.   } loop
  675. } bind def
  676.  
  677. /Font mark
  678.  
  679. /InstanceType /dicttype
  680.  
  681. /DefineResource
  682.     { 2 copy //definefont exch pop
  683.       /Generic /Category findresource /DefineResource get exec
  684.     } bind
  685. /UndefineResource
  686.     { dup //undefinefont
  687.       /Generic /Category findresource /UndefineResource get exec
  688.     } bind
  689. /FindResource
  690.     { dup ResourceStatus
  691.        { pop 1 gt { .loadfont } { .GetInstance pop 0 get } ifelse }
  692.        { .loadfont }
  693.       ifelse
  694.     } bind
  695. /ResourceForAll {
  696.     { .scannextfontdir not { exit } if } loop
  697.     /Generic /Category findresource /ResourceForAll get exec
  698. } bind
  699. /ResourceStatus {
  700.     dup .GetInstance {
  701.       exch pop dup 1 get exch 2 get true
  702.     } {
  703.       .fontstatus { pop 2 -1 true } { pop false } ifelse
  704.     } ifelse
  705. } bind
  706.  
  707. /.loadfont
  708.     { dup vmstatus pop exch pop exch
  709.         % Hack: rebind .currentresourcefile so that all calls of
  710.         % definefont will know these are built-in fonts.
  711.       currentfile {pop //findfont exec} .execasresource  % (findfont is a procedure)
  712.       exch vmstatus pop exch pop exch sub
  713.         % stack: name font vmused
  714.         % findfont has the prerogative of not calling definefont
  715.         % in certain obscure cases of font substitution.
  716.       2 index .GetInstance
  717.        { dup 1 1 put
  718.          2 3 -1 roll put
  719.        }
  720.        { pop
  721.        }
  722.       ifelse exch pop
  723.     } bind
  724.  
  725. /Instances FontDirectory length 2 mul dict
  726.  
  727. .definecategory            % Font
  728.  
  729. % Redefine font "operators".
  730. /.definefontmap
  731.  { /Font /Category findresource /Instances get
  732.    dup 3 index known
  733.     { pop
  734.     }
  735.     { 2 index
  736.         % Make sure we create the array in global VM.
  737.       .currentglobal true .setglobal
  738.       [null 2 -1] exch .setglobal
  739.       .growput
  740.     }
  741.    ifelse
  742.    //.definefontmap exec
  743.  } bind def
  744.  
  745. % Make sure the old definitions are still in systemdict so that
  746. % they will get bound properly.
  747. systemdict begin
  748.   /.origdefinefont /definefont load def
  749.   /.origundefinefont /undefinefont load def
  750.   /.origfindfont /findfont load def
  751. end
  752. /definefont {
  753.   /Font defineresource
  754. } bind odef
  755. /undefinefont {
  756.   /Font undefineresource
  757. } bind odef
  758. % The Red Book requires that findfont be a procedure, not an operator,
  759. % but it still needs to restore the stacks reliably if it fails.
  760. /.findfontop {
  761.   /Font findresource
  762. } bind odef
  763. /findfont {
  764.   .findfontop
  765. } bind def    % Must be a procedure, not an operator
  766.  
  767. % Remove initialization utilities.
  768. currentdict /.definecategory .undef
  769. currentdict /.emptydict .undef
  770.  
  771. end                % level2dict
  772.  
  773. % Convert deferred resources after we finally switch to Level 2.
  774.  
  775. /.fixresources {
  776.     % Encoding resources
  777.   EncodingDirectory
  778.    { dup length 256 eq
  779.       { /Encoding defineresource pop }
  780.       { pop pop }
  781.      ifelse
  782.    } forall
  783.   /.findencoding { /Encoding findresource } bind def
  784.   /findencoding /.findencoding load def        % must be a procedure
  785.   /.defineencoding { /Encoding defineresource pop } bind def
  786.     % ColorRendering resources and ProcSet
  787.   systemdict /ColorRendering .knownget {
  788.     /ColorRendering exch /ProcSet defineresource pop
  789.     systemdict /ColorRendering undef
  790.     /Default currentcolorrendering /ColorRendering defineresource pop
  791.   } if
  792.     % ColorSpace resources
  793.   systemdict /CIEsRGB .knownget {
  794.     /sRGB exch /ColorSpace defineresource pop
  795.     systemdict /CIEsRGB undef
  796.   } if
  797.     % ColorSpaceFamily resources
  798.   colorspacedict { pop dup /ColorSpaceFamily defineresource pop } forall
  799.     % Filter resources
  800.   filterdict { pop dup /Filter defineresource pop } forall
  801.     % FontType and FMapType resources
  802.   buildfontdict { pop dup /FontType defineresource pop } forall
  803.   mark
  804.     buildfontdict 0 known { 2 3 4 5 6 7 8 } if
  805.     buildfontdict 9 known { 9 } if
  806.   counttomark { dup /FMapType defineresource pop } repeat pop
  807.     % FormType resources
  808.   .formtypes { pop dup /FormType defineresource pop } forall
  809.     % HalftoneType resources
  810.   .halftonetypes { pop dup /HalftoneType defineresource pop } forall
  811.     % ColorRenderingType resources
  812.   .colorrenderingtypes {pop dup /ColorRenderingType defineresource pop} forall
  813.     % ImageType resources
  814.   .imagetypes { pop dup /ImageType defineresource pop } forall
  815.     % PatternType resources
  816.   .patterntypes { pop dup /PatternType defineresource pop } forall
  817.     % Make the fixed resource categories immutable.
  818.   /.shadingtypes where {
  819.     pop .shadingtypes { pop dup /ShadingType defineresource pop } forall
  820.   } if
  821.   [ /ColorSpaceFamily /Emulator /Filter /IODevice /ColorRenderingType
  822.     /FMapType /FontType /FormType /HalftoneType /ImageType /PatternType
  823.     /.shadingtypes where { pop /ShadingType } if
  824.   ] {
  825.     /Category findresource
  826.     dup /Instances get readonly pop
  827.     .LocalInstances readonly pop
  828.     readonly pop
  829.   } forall
  830.     % clean up
  831.   systemdict /.fixresources undef
  832. } bind def
  833.