home *** CD-ROM | disk | FTP | other *** search
/ swCHIP 1991 January / swCHIP_95-1.bin / utility / gs333ini / gs3.33 / gs_res.ps < prev    next >
Text File  |  1995-12-09  |  14KB  |  526 lines
  1. %    Copyright (C) 1994 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. % Initialization file for Level 2 resource machinery.
  19. % When this is run, systemdict is still writable,
  20. % but everything defined here goes into level2dict.
  21.  
  22. level2dict begin
  23.  
  24. (BEGIN RESOURCES) VMDEBUG
  25.  
  26. % We keep track of (global) instances with another entry in the resource
  27. % dictionary, an Instances dictionary.  For categories with implicit
  28. % instances, the values in Instances are the same as the keys;
  29. % for other categories, the values are [instance status size].
  30.  
  31. % Note that the dictionary that defines a resource category is stored
  32. % in global memory.  The PostScript manual says that each category must
  33. % manage global and local instances separately.  However, objects in
  34. % global memory other than systemdict can't reference objects in local memory.
  35. % This means that the resource category dictionary, which would otherwise be
  36. % the obvious place to keep track of the instances, can't be used to keep
  37. % track of local instances.  Instead, we define a dictionary in local VM
  38. % called localinstancedict, in which the key is the category name and
  39. % the value is the analogue of Instances for local instances.
  40.  
  41. % We don't currently implement automatic resource unloading.
  42. % When we do, it should be hooked to the garbage collector.
  43.  
  44. currentglobal false setglobal systemdict begin
  45.   /localinstancedict 5 dict def
  46. end true setglobal
  47. /.emptydict 0 dict readonly def
  48. setglobal
  49.  
  50. % Resource category dictionaries have the following keys (those marked with
  51. % * are optional):
  52. %    Standard, defined in the Red Book:
  53. %        Category (name)
  54. %        *InstanceType (name)
  55. %        DefineResource
  56. %        UndefineResource
  57. %        FindResource
  58. %        ResourceStatus
  59. %        ResourceForAll
  60. %        *ResourceFileName
  61. %    Additional, specific to our implementation:
  62. %        Instances (dictionary)
  63. %        .LocalInstances
  64. %            - .LocalInstances <dict>
  65. %        .GetInstance
  66. %            <key> .GetInstance <instance> -true-
  67. %            <key> .GetInstance -false-
  68. %        .CheckResource
  69. %            <value> .CheckResource <ok>
  70. %        .DoLoadResource
  71. %            <key> .DoLoadResource - (may give an error)
  72. %        .LoadResource
  73. %            <key> .LoadResource - (may give an error)
  74. %        .ResourceFile
  75. %            <key> .ResourceFile <file> -true-
  76. %            <key> .ResourceFile <key> -false-
  77. % All the above procedures expect that the top dictionary on the d-stack
  78. % is the resource dictionary.
  79.  
  80. % Define enough of the Category category so we can define other categories.
  81. % The dictionary we're about to create will become the Category
  82. % category definition dictionary.
  83.  
  84. 12 dict begin
  85.  
  86.         % Standard entries
  87.  
  88. /Category /Category def
  89. /InstanceType /dicttype def
  90.  
  91. /DefineResource
  92.     { dup .CheckResource
  93.        { dup /Category 3 index cvlit .growput readonly
  94.          dup [ exch 0 -1 ] exch
  95.          Instances 4 2 roll put
  96.        }
  97.        { /typecheck signalerror
  98.        }
  99.       ifelse
  100.     } bind def
  101. /FindResource        % (redefined below)
  102.     { Instances exch get 0 get
  103.     } bind def
  104.  
  105.         % Additional entries
  106.  
  107. /Instances 25 dict def
  108. Instances /Category [currentdict 0 -1] put
  109.  
  110. /.LocalInstances 0 dict def
  111. /.GetInstance
  112.     { Instances exch .knownget
  113.     } bind def
  114. /.CheckResource
  115.     { dup gcheck currentglobal and
  116.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  117.          /UndefineResource }
  118.        { 2 index exch known and }
  119.       forall exch pop
  120.     } bind def
  121.  
  122. Instances end begin    % for the base case of findresource
  123.  
  124. (END CATEGORY) VMDEBUG
  125.  
  126. % Define the resource operators.  I don't see how we can possibly restore
  127. % the stacks after an error, since the procedure may have popped and
  128. % pushed elements arbitrarily....
  129.  
  130. mark
  131. /defineresource
  132.     { /Category findresource dup begin
  133.       /InstanceType known
  134.        { dup type InstanceType ne
  135.           { dup type /packedarraytype eq InstanceType /arraytype eq and
  136.         not { /typecheck signalerror } if
  137.           } if
  138.        } if
  139.       /DefineResource load stopped end { stop } if
  140.     }
  141. /findresource
  142.     { dup /Category eq
  143.        { pop //Category 0 get } { /Category findresource } ifelse
  144.       begin
  145.       /FindResource load stopped end { stop } if
  146.     }
  147. /resourceforall
  148.     { /Category findresource begin
  149.       /ResourceForAll load stopped end { stop } if
  150.     }
  151. /resourcestatus
  152.     { /Category findresource begin
  153.       /ResourceStatus load stopped end { stop } if
  154.     }
  155. /undefineresource
  156.     { /Category findresource begin
  157.       /UndefineResource load stopped end { stop } if
  158.     }
  159. end        % Instances of Category
  160. counttomark 2 idiv { bind odef } repeat pop
  161.  
  162. % Define the Generic category.
  163.  
  164. /Generic mark
  165.  
  166.         % Standard entries
  167.  
  168. % We're still running in Level 1 mode, so dictionaries won't expand.
  169. % Leave room for the /Category entry.
  170. /Category null
  171.  
  172. /DefineResource
  173.     { dup .CheckResource
  174.        { dup [ exch 0 -1 ] exch
  175.          currentglobal
  176.           { false setglobal 2 index UndefineResource    % remove local def if any
  177.         true setglobal
  178.         Instances dup //.emptydict eq
  179.          { pop 3 dict /Instances 1 index def
  180.          }
  181.         if
  182.           }
  183.           { .LocalInstances dup //.emptydict eq
  184.              { pop 3 dict localinstancedict Category 2 index put
  185.          }
  186.         if
  187.           }
  188.          ifelse
  189.          4 2 roll .growput
  190.        }
  191.        { /typecheck signalerror
  192.        }
  193.       ifelse
  194.     } bind
  195. /UndefineResource
  196.     {  { dup 2 index .knownget
  197.           { dup 1 get 1 ge
  198.          { dup 0 null put 1 2 put pop pop }
  199.          { pop exch undef }
  200.         ifelse
  201.           }
  202.           { pop pop
  203.           }
  204.          ifelse
  205.        }
  206.       currentglobal
  207.        { 2 copy Instances exch exec
  208.        }
  209.       if .LocalInstances exch exec
  210.     } bind
  211. /FindResource
  212.     { dup ResourceStatus
  213.        { pop 1 gt            % not in VM
  214.           { .DoLoadResource
  215.           }
  216.          if
  217.          .GetInstance pop        % can't fail
  218.          0 get
  219.        }
  220.        { /undefinedresource signalerror
  221.        }
  222.       ifelse
  223.     } bind
  224. /ResourceStatus
  225.     { dup .GetInstance
  226.        { exch pop dup 1 get exch 2 get true }
  227.        { .ResourceFile
  228.           { closefile 2 -1 true }
  229.           { pop false }
  230.          ifelse
  231.        }
  232.       ifelse
  233.     } bind
  234. /ResourceForAll
  235.     { % **************** Doesn't present instance groups in
  236.       % **************** the correct order yet.
  237.       % We construct a new procedure so we don't have to use
  238.       % static resources to hold the iteration state.
  239.       3 packedarray        % template, proc, scratch
  240.       { exch pop    % stack contains: key, {template, proc, scratch}
  241.         2 copy 0 get .stringmatch
  242.          { 1 index type dup /stringtype eq exch /nametype eq or
  243.         { 2 copy 2 get cvs
  244.           exch 1 get 3 -1 roll pop
  245.         }
  246.         { 1 get
  247.         }
  248.            ifelse exec
  249.          }
  250.          { pop pop
  251.          }
  252.         ifelse
  253.       } /exec cvx 3 packedarray cvx
  254.       % We must pop the resource dictionary off the dict stack
  255.       % when doing the actual iteration, and restore it afterwards.
  256.       currentglobal .LocalInstances length 0 eq or not
  257.        {        % We must do local instances, and do them first.
  258.          /forall cvx 1 index currentdict 3 packedarray cvx
  259.          .LocalInstances 3 1 roll end exec begin
  260.        }
  261.       if
  262.       Instances exch
  263.       /forall cvx currentdict 2 packedarray cvx
  264.       end exec begin
  265.     } bind
  266.  
  267.         % Additional entries
  268.  
  269. % Unfortunately, we can't create the real Instances dictionary now,
  270. % because if someone copies the Generic category (which pp. 95-96 of the
  271. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  272. % the Instances.  Instead, we have to create Instances on demand,
  273. % just like the entry in localinstancedict.
  274. % We also have to prevent anyone from creating instances of Generic itself.
  275. /Instances //.emptydict
  276.  
  277. /.LocalInstances
  278.     { localinstancedict Category .knownget not { //.emptydict } if
  279.     } bind
  280. /.GetInstance
  281.     { currentglobal
  282.        { Instances exch .knownget }
  283.        { .LocalInstances 1 index .knownget
  284.           { exch pop true }
  285.           { Instances exch .knownget }
  286.          ifelse
  287.        }
  288.       ifelse
  289.     } bind
  290. /.CheckResource
  291.     { pop true
  292.     } bind
  293. /.DoLoadResource
  294.     { dup vmstatus pop exch pop exch
  295.       .LoadResource
  296.       vmstatus pop exch pop exch sub
  297.       1 index .GetInstance not
  298.        { pop /undefinedresource signalerror }    % didn't load
  299.       if
  300.       dup 1 1 put
  301.       2 3 -1 roll put
  302.     } bind
  303. /.LoadResource
  304.     { dup .ResourceFile
  305.        { exch pop currentglobal
  306.           { run }
  307.           { true setglobal { run } stopped false setglobal { stop } if }
  308.          ifelse
  309.        }
  310.        { /undefinedresource signalerror
  311.        }
  312.      ifelse
  313.     } bind
  314. /.ResourceFile
  315.     { currentdict /ResourceFileName known
  316.        { mark 1 index 100 string { ResourceFileName }
  317.          stopped
  318.           { cleartomark false }
  319.           { exch pop findlibfile
  320.          { exch pop exch pop true }
  321.          { false }
  322.         ifelse
  323.           }
  324.          ifelse
  325.        }
  326.        { false }
  327.       ifelse
  328.     } bind
  329.  
  330. .dicttomark
  331. /Category defineresource pop
  332.  
  333. % Fill in the rest of the Category category.
  334. /Category /Category findresource dup
  335. /Generic /Category findresource begin
  336.  { /FindResource /ResourceForAll /ResourceStatus /UndefineResource /.ResourceFile }
  337.  { dup load put dup } forall
  338. pop readonly pop end
  339.  
  340. (END GENERIC) VMDEBUG
  341.  
  342. % Define the fixed categories.
  343.  
  344. mark
  345.     % Things other than types
  346.  /ColorSpaceFamily
  347.    mark colorspacedict { pop } forall .packtomark
  348.  /Emulator
  349.    mark EMULATORS { cvn } forall .packtomark
  350.  /Filter
  351.    mark filterdict { pop } forall .packtomark
  352.  /IODevice
  353.     % Loop until the .getiodevice gets a rangecheck.
  354.    errordict /rangecheck 2 copy get
  355.    errordict /rangecheck { pop stop } put    % pop the command
  356.    mark 0 { {dup .getiodevice exch 1 add} loop} stopped pop pop pop .packtomark
  357.    4 1 roll put
  358.    .clearerror
  359.     % Types
  360.  /setcolorrendering where
  361.   { pop /ColorRenderingType
  362.      {1}
  363.   } if
  364.  /.buildfont0 where
  365.   { pop /FMapType
  366.      {2 3 4 5 6 7 8}
  367.   } if
  368.  /FontType
  369.    [/.buildfont0 where {pop 0} if
  370.     /.buildfont1 where {pop 1} if
  371.     3]
  372.  /FormType
  373.    {1}
  374.  /HalftoneType
  375.    {1 2 3 4 5}
  376.  /ImageType
  377.    {1}
  378.  /PatternType
  379.    {1}            % should check for Pattern color space
  380. counttomark 2 idiv
  381.  { mark
  382.  
  383.         % Standard entries
  384.  
  385.    /DefineResource
  386.     { /invalidaccess signalerror } bind
  387.    /UndefineResource
  388.     { /invalidaccess signalerror } bind
  389.    /FindResource
  390.     { Instances exch get } bind
  391.    /ResourceStatus
  392.     { Instances exch known { 0 0 true } { false } ifelse } bind
  393.    /ResourceForAll
  394.     /Generic /Category findresource /ResourceForAll get
  395.  
  396.         % Additional entries
  397.  
  398.    counttomark 2 add -1 roll
  399.    dup length dict dup begin exch { dup def } forall end readonly
  400.    /Instances exch
  401.    /.LocalInstances    % used by ResourceForAll
  402.     0 dict def
  403.  
  404.    .dicttomark /Category defineresource pop
  405.  } repeat pop
  406.  
  407. (END FIXED) VMDEBUG
  408.  
  409. % Define the other built-in categories.
  410.  
  411. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  412.  { counttomark 2 idiv 2 add        % Instances, Category
  413.    /Generic /Category findresource dup maxlength 3 -1 roll add dict copy begin
  414.    counttomark 2 idiv { def } repeat pop    % pop the mark
  415.    currentdict end /Category defineresource pop
  416.  } bind def
  417.  
  418. /ColorRendering mark /InstanceType /dicttype .definecategory
  419. /ColorSpace mark /InstanceType /arraytype .definecategory
  420. /Form mark /InstanceType /dicttype .definecategory
  421. /Halftone mark /InstanceType /dicttype .definecategory
  422. /Pattern mark /InstanceType /dicttype .definecategory
  423. /ProcSet mark /InstanceType /dicttype .definecategory
  424.  
  425. (END MISC) VMDEBUG
  426.  
  427. % Define the Encoding category.
  428.  
  429. /Encoding mark
  430.  
  431. /InstanceType /arraytype
  432.  
  433. % Handle lazily loaded encodings that aren't loaded yet.
  434.  
  435. /Instances mark
  436.   .encodingdict
  437.    { length 256 eq { pop } { [null 2 -1] } ifelse
  438.    } forall
  439. .dicttomark
  440.  
  441. /.ResourceFileDict mark
  442.   .encodingdict
  443.    { dup length 256 eq { pop pop } { 0 get } ifelse
  444.    } forall
  445. .dicttomark
  446.  
  447. /ResourceFileName
  448.  { exch dup .ResourceFileDict exch .knownget
  449.     { exch pop exch copy }
  450.     { exch pop /undefinedresource signalerror }
  451.    ifelse
  452.  } bind
  453.  
  454. .definecategory            % Encoding
  455.  
  456. /.findencoding { /Encoding findresource } bind def
  457. /findencoding /.findencoding load odef
  458. /.defineencoding
  459.  { 2 copy /Encoding defineresource pop
  460.    //.encodingdict 3 1 roll put
  461.  } bind def
  462.  
  463. (END ENCODING) VMDEBUG
  464.  
  465. % Define the Font category.
  466.  
  467. /Font mark
  468.  
  469. /InstanceType /dicttype
  470.  
  471. /DefineResource
  472.     { 2 copy //definefont exch pop
  473.       /Generic /Category findresource /DefineResource get exec
  474.     } bind
  475. /UndefineResource
  476.     { dup //undefinefont
  477.       /Generic /Category findresource /UndefineResource get exec
  478.     } bind
  479. /FindResource
  480.     { dup ResourceStatus
  481.        { pop 1 gt { .DoLoadResource } if }
  482.        { .DoLoadResource }
  483.       ifelse
  484.       .GetInstance pop 0 get
  485.     } bind
  486.  
  487. /.LoadResource
  488.     { //findfont exec pop
  489.     } bind
  490.  
  491. /Instances FontDirectory length 2 mul dict
  492.  
  493. .definecategory            % Font
  494.  
  495. % Make entries for fonts already loaded.
  496. /Font /Category findresource begin
  497. FontDirectory
  498.  { dup .gcheck { Instances } { .LocalInstances } ifelse
  499.    3 1 roll [exch 0 -1] .growput
  500.  }
  501. forall end
  502.  
  503. % Redefine font "operators".
  504. /.definefontmap
  505.  { /Font /Category findresource /Instances get
  506.    dup 3 index known
  507.     { pop }
  508.     { 2 index [null 2 -1] .growput }
  509.    ifelse
  510.    //.definefontmap exec
  511.  } bind def
  512. Fontmap { .definefontmap } forall
  513.  
  514. /definefont
  515.     { /Font defineresource } bind odef
  516. /undefinefont
  517.     { /Font undefineresource } bind odef
  518. /findfont
  519.     { /Font findresource } bind def    % Must be a procedure, not an operator
  520.  
  521. % Remove initialization utilities.
  522. currentdict /.definecategory undef
  523. currentdict /.emptydict undef
  524.  
  525. end                % level2dict
  526.