home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dtp / ghostscript / 5.10 / gs_res.ps < prev    next >
Encoding:
Text File  |  1997-12-28  |  18.7 KB  |  666 lines
  1. %    Copyright (C) 1994, 1996, 1997 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 (almost) 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 and if we do, it should be hooked to the garbage collector.
  43. % However, Ed Taft of Adobe says their interpreters don't implement this
  44. % either, so we aren't going to worry about it for a while.
  45.  
  46. currentglobal false setglobal systemdict begin
  47.   /localinstancedict 5 dict def
  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 - (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. % All the above procedures expect that the top dictionary on the d-stack
  88. % is the resource dictionary.
  89.  
  90. % Define enough of the Category category so we can define other categories.
  91. % The dictionary we're about to create will become the Category
  92. % category definition dictionary.
  93.  
  94. /.findcategory        % <name> .findcategory <category>
  95.  { { /Category findresource } stopped { pop stop } if
  96.  } bind def
  97.  
  98. /.resourceexec        % <key> /xxxResource .resourceexec -
  99.  {            %   (also pops the category from the dstack)
  100.    load stopped { Category end stop } if end
  101.  } bind def
  102.  
  103. 12 dict begin
  104.  
  105.         % Standard entries
  106.  
  107. /Category /Category def
  108. /InstanceType /dicttype def
  109.  
  110. /DefineResource
  111.     { .CheckResource
  112.        { dup /Category 3 index cvlit .growput
  113.         % We would like to make Category dictionaries read-only,
  114.         % and we used to do that here, but we can't do it,
  115.         % because we have to be able to replace the dummy, empty
  116.         % Instances dictionary with the real one later.
  117.          dup [ exch 0 -1 ] exch
  118.          Instances 4 2 roll put
  119.        }
  120.        { /defineresource load /typecheck signalerror
  121.        }
  122.       ifelse
  123.     } bind def
  124. /FindResource        % (redefined below)
  125.     { Instances exch get 0 get
  126.     } bind def
  127.  
  128.         % Additional entries
  129.  
  130. /Instances 25 dict def
  131. Instances /Category [currentdict 0 -1] put
  132.  
  133. /.LocalInstances 0 dict def
  134. /.GetInstance
  135.     { Instances exch .knownget
  136.     } bind def
  137. /.CheckResource
  138.     { dup gcheck currentglobal and
  139.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  140.          /UndefineResource }
  141.        { 2 index exch known and }
  142.       forall
  143.       not { /defineresource load /invalidaccess signalerror } if
  144.       true
  145.     } bind def
  146.  
  147. Instances end begin    % for the base case of findresource
  148.  
  149. (END CATEGORY) VMDEBUG
  150.  
  151. % Define the resource operators.  We use the "stack protection" feature of
  152. % odef to make sure the stacks are restored properly on an error.
  153. % This requires that the operators not pop anything from the stack until
  154. % they have executed their logic successfully.  We can't make this
  155. % work for resourceforall, but we can make it work for the others.
  156.  
  157. mark
  158. /defineresource {    % <key> <instance> <category> defineresource <instance>
  159.     3 copy .findcategory dup begin
  160.     /InstanceType known {
  161.       dup type InstanceType ne {
  162.         dup type /packedarraytype eq InstanceType /arraytype eq and
  163.         not { /defineresource load /typecheck signalerror } if
  164.       } if
  165.     } if
  166.     /DefineResource .resourceexec
  167.     4 1 roll pop pop pop
  168. }
  169. /findresource {        % <key> <category> findresource <instance>
  170.     2 copy dup /Category eq
  171.       { pop //Category 0 get } { .findcategory } ifelse
  172.     begin
  173.     /FindResource .resourceexec exch pop exch pop
  174. }
  175. /resourceforall {    % <template> <proc> <scratch> <category> resourceforall -
  176.     .findcategory begin /ResourceForAll .resourceexec
  177. }
  178. /resourcestatus {    % <key> <category> resourcestatus <status> <size> true
  179.             % <key> <category> resourcestatus false
  180.     2 copy .findcategory begin /ResourceStatus .resourceexec
  181.      { 4 2 roll pop pop true } { pop pop false } ifelse
  182. }
  183. /undefineresource {    % <key> <category> undefineresource -
  184.     2 copy .findcategory begin /UndefineResource .resourceexec pop pop
  185. }
  186. end        % Instances of Category
  187. counttomark 2 idiv { bind odef } repeat pop
  188.  
  189. % Define the system parameters used for the Generic implementation of
  190. % ResourceFileName.
  191. systemdict begin
  192. currentdict /systemparams known not { /systemparams 10 dict readonly def } if
  193. systemparams
  194.   dup /FontResourceDir (/Resource/Font/) readonly .forceput
  195.   dup /GenericResourceDir (/Resource/) readonly .forceput
  196.   dup /GenericResourcePathSep (/) readonly .forceput
  197. pop
  198. end
  199.  
  200. % Define the generic algorithm for computing resource file names.
  201. /.rfnstring 100 string def
  202. /.genericrfn        % <key> <scratch> <prefix> .genericrfn <filename>
  203.  { 3 -1 roll //.rfnstring cvs concatstrings exch copy
  204.  } bind def
  205.  
  206. % Define the Generic category.
  207.  
  208. /Generic mark
  209.  
  210.         % Standard entries
  211.  
  212. % We're still running in Level 1 mode, so dictionaries won't expand.
  213. % Leave room for the /Category entry.
  214. /Category null
  215.  
  216. /DefineResource
  217.     { .CheckResource
  218.        { dup [ exch 0 -1 ]
  219.             % Stack: key value instance
  220.          currentglobal
  221.           { false setglobal 2 index UndefineResource    % remove local def if any
  222.         true setglobal
  223.         Instances dup //.emptydict eq
  224.          { pop 3 dict /Instances 1 index def
  225.          }
  226.         if
  227.           }
  228.           { .LocalInstances dup //.emptydict eq
  229.              { pop 3 dict localinstancedict Category 2 index put
  230.          }
  231.         if
  232.           }
  233.          ifelse
  234.             % Stack: key value instance instancedict
  235.          3 index 2 index .growput
  236.             % Now make the resource value read-only.
  237.          0 2 copy get { readonly } .internalstopped pop
  238.          dup 4 1 roll put exch pop exch pop
  239.        }
  240.        { /defineresource load /typecheck signalerror
  241.        }
  242.       ifelse
  243.     } bind
  244. /UndefineResource
  245.     {  { dup 2 index .knownget
  246.           { dup 1 get 1 ge
  247.          { dup 0 null put 1 2 put pop pop }
  248.          { pop exch .undef }
  249.         ifelse
  250.           }
  251.           { pop pop
  252.           }
  253.          ifelse
  254.        }
  255.       currentglobal
  256.        { 2 copy Instances exch exec
  257.        }
  258.       if .LocalInstances exch exec
  259.     } bind
  260. /FindResource
  261.     { dup ResourceStatus
  262.        { pop 1 gt            % not in VM
  263.           { .DoLoadResource
  264.           }
  265.          if
  266.          .GetInstance pop        % can't fail
  267.          0 get
  268.        }
  269.        { /findresource load /undefinedresource signalerror
  270.        }
  271.       ifelse
  272.     } bind
  273. /ResourceStatus
  274.     { dup .GetInstance
  275.        { exch pop dup 1 get exch 2 get true }
  276.        { .ResourceFile
  277.           { closefile 2 -1 true }
  278.           { pop false }
  279.          ifelse
  280.        }
  281.       ifelse
  282.     } bind
  283. /ResourceForAll
  284.     { % **************** Doesn't present instance groups in
  285.       % **************** the correct order yet.
  286.       % We construct a new procedure so we don't have to use
  287.       % static resources to hold the iteration state.
  288.       % Make sure it is in local VM, to avoid an invalidaccess.
  289.       3 copy .currentglobal 4 1 roll false .setglobal
  290.       3 packedarray        % template, proc, scratch
  291.       { exch pop    % stack contains: key, {template, proc, scratch}
  292.         2 copy 0 get .stringmatch
  293.          { 1 index type dup /stringtype eq exch /nametype eq or
  294.         { 2 copy 2 get cvs
  295.           exch 1 get 3 -1 roll pop
  296.         }
  297.         { 1 get
  298.         }
  299.            ifelse exec
  300.          }
  301.          { pop pop
  302.          }
  303.         ifelse
  304.       } /exec cvx 3 packedarray cvx
  305.       % Stack: template proc scratch global? iterproc
  306.       % We must pop the resource dictionary off the dict stack
  307.       % when doing the actual iteration, and restore it afterwards.
  308.       currentglobal .LocalInstances length 0 eq or not
  309.        {        % We must do local instances, and do them first.
  310.          /forall cvx 1 index currentdict 3 packedarray cvx
  311.          .LocalInstances 3 1 roll end exec begin
  312.        }
  313.       if
  314.       exch .setglobal
  315.       Instances exch
  316.       /forall cvx currentdict
  317.       end 2 .execn begin pop pop pop
  318.     } bind
  319. /ResourceFileName
  320.     { /GenericResourceDir getsystemparam 
  321.       Category .namestring concatstrings
  322.       /GenericResourcePathSep getsystemparam concatstrings
  323.       .genericrfn
  324.     } bind
  325.  
  326.         % Additional entries
  327.  
  328. % Unfortunately, we can't create the real Instances dictionary now,
  329. % because if someone copies the Generic category (which pp. 95-96 of the
  330. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  331. % the Instances.  Instead, we have to create Instances on demand,
  332. % just like the entry in localinstancedict.
  333. % We also have to prevent anyone from creating instances of Generic itself.
  334. /Instances //.emptydict
  335.  
  336. /.LocalInstances
  337.     { localinstancedict Category .knownget not { //.emptydict } if
  338.     } bind
  339. /.GetInstance
  340.     { currentglobal
  341.        { Instances exch .knownget }
  342.        { .LocalInstances 1 index .knownget
  343.           { exch pop true }
  344.           { Instances exch .knownget }
  345.          ifelse
  346.        }
  347.       ifelse
  348.     } bind
  349. /.CheckResource
  350.     { true
  351.     } bind
  352. /.DoLoadResource
  353.     { dup vmstatus pop exch pop exch
  354.       .LoadResource
  355.       vmstatus pop exch pop exch sub
  356.       1 index .GetInstance not
  357.        { pop dup /undefinedresource signalerror }    % didn't load
  358.       if
  359.       dup 1 1 put
  360.       2 3 -1 roll put
  361.     } bind
  362. /.LoadResource
  363.     { dup .ResourceFile
  364.        { exch pop currentglobal
  365.           { run }
  366.           { true setglobal { run } stopped false setglobal { stop } if }
  367.          ifelse
  368.        }
  369.        { dup /undefinedresource signalerror
  370.        }
  371.      ifelse
  372.     } bind
  373. /.ResourceFile
  374.     { currentdict /ResourceFileName known
  375.        { mark 1 index 100 string { ResourceFileName }
  376.          .internalstopped
  377.           { cleartomark false }
  378.           { exch pop findlibfile
  379.          { exch pop exch pop true }
  380.          { pop false }
  381.         ifelse
  382.           }
  383.          ifelse
  384.        }
  385.        { false }
  386.       ifelse
  387.     } bind
  388.  
  389. .dicttomark
  390. /Category defineresource pop
  391.  
  392. % Fill in the rest of the Category category.
  393. /Category /Category findresource dup
  394. /Generic /Category findresource begin
  395.  { /FindResource /ResourceForAll /ResourceStatus /UndefineResource /.ResourceFile }
  396.  { dup load put dup } forall
  397. pop readonly pop end
  398.  
  399. (END GENERIC) VMDEBUG
  400.  
  401. % Define the fixed categories.
  402.  
  403. mark
  404.     % Things other than types
  405.  /ColorSpaceFamily
  406.    mark colorspacedict { pop } forall .packtomark
  407.  /Emulator
  408.    mark EMULATORS { cvn } forall .packtomark
  409.  /Filter
  410.    mark filterdict { pop } forall .packtomark
  411.  /IODevice
  412.     % Loop until the .getiodevice gets a rangecheck.
  413.    errordict /rangecheck 2 copy get
  414.    errordict /rangecheck { pop stop } put    % pop the command
  415.    mark 0 { {dup .getiodevice exch 1 add} loop} .internalstopped
  416.    pop pop pop .packtomark
  417.    4 1 roll put
  418.    .clearerror
  419.     % Types
  420.  /setcolorrendering where
  421.   { pop /ColorRenderingType
  422.      {1}
  423.   } if
  424.  /FMapType
  425.    { }    % These must be deferred, because optional features may add some.
  426.  /FontType
  427.    { }    % These must be deferred, because optional features may add some.
  428.  /FormType
  429.    {1}
  430.  /HalftoneType
  431.    {1 2 3 4 5}
  432.  /ImageType
  433.    {1}
  434.  /PatternType
  435.    {1}            % should check for Pattern color space
  436. counttomark 2 idiv
  437.  { mark
  438.  
  439.         % Standard entries
  440.  
  441.         % We'd like to prohibit defineresource,
  442.         % but because optional features may add entries, we can't.
  443.         % We can at least require that the key and value match.
  444.    /DefineResource
  445.     { currentglobal not
  446.        { /defineresource load /invalidaccess signalerror }
  447.        { 2 copy ne
  448.           { /defineresource load /rangecheck signalerror }
  449.           { dup Instances 4 -2 roll .growput }
  450.          ifelse
  451.        }
  452.       ifelse
  453.     } bind
  454.    /UndefineResource
  455.     { /undefineresource load /invalidaccess signalerror } bind
  456.    /FindResource
  457.     { Instances 1 index .knownget
  458.        { exch pop }
  459.        { /findresource load /undefinedresource signalerror }
  460.       ifelse
  461.     } bind
  462.    /ResourceStatus
  463.     { Instances exch known { 0 0 true } { false } ifelse } bind
  464.    /ResourceForAll
  465.     /Generic /Category findresource /ResourceForAll get
  466.  
  467.         % Additional entries
  468.  
  469.    counttomark 2 add -1 roll
  470.    dup length dict dup begin exch { dup def } forall end
  471.         % We'd like to make the Instances readonly here,
  472.         % but because optional features may add entries, we can't.
  473.    /Instances exch
  474.    /.LocalInstances    % used by ResourceForAll
  475.     0 dict def
  476.  
  477.    .dicttomark /Category defineresource pop
  478.  } repeat pop
  479.  
  480. (END FIXED) VMDEBUG
  481.  
  482. % Define the other built-in categories.
  483.  
  484. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  485.  { counttomark 2 idiv 2 add        % Instances, Category
  486.    /Generic /Category findresource dup maxlength 3 -1 roll add
  487.    dict .copydict begin
  488.    counttomark 2 idiv { def } repeat pop    % pop the mark
  489.    currentdict end /Category defineresource pop
  490.  } bind def
  491.  
  492. /ColorRendering mark /InstanceType /dicttype .definecategory
  493. /ColorSpace mark /InstanceType /arraytype .definecategory
  494. /Form mark /InstanceType /dicttype .definecategory
  495. /Halftone mark /InstanceType /dicttype .definecategory
  496. /Pattern mark /InstanceType /dicttype .definecategory
  497. /ProcSet mark /InstanceType /dicttype .definecategory
  498.  
  499. (END MISC) VMDEBUG
  500.  
  501. % Define the Encoding category.
  502.  
  503. /Encoding mark
  504.  
  505. /InstanceType /arraytype
  506.  
  507. % Handle already-registered encodings, including lazily loaded encodings
  508. % that aren't loaded yet.
  509.  
  510. /Instances mark
  511.   EncodingDirectory
  512.    { dup length 256 eq { [ exch readonly 0 -1 ] } { pop [null 2 -1] } ifelse
  513.    } forall
  514. .dicttomark
  515.  
  516. /.ResourceFileDict mark
  517.   EncodingDirectory
  518.    { dup length 256 eq { pop pop } { 0 get } ifelse
  519.    } forall
  520. .dicttomark
  521.  
  522. /ResourceFileName
  523.  { .ResourceFileDict 2 index .knownget
  524.     { exch copy exch pop }
  525.     { /Generic /Category findresource /ResourceFileName get exec }
  526.    ifelse
  527.  } bind
  528.  
  529. .definecategory            % Encoding
  530.  
  531. % Make placeholders in level2dict for the redefined Encoding operators,
  532. % so that they will be swapped properly when we switch language levels.
  533.  
  534. /.findencoding /.findencoding load def
  535. /findencoding /findencoding load def
  536. /.defineencoding /.defineencoding load def
  537.  
  538. (END ENCODING) VMDEBUG
  539.  
  540. % Define the Font category.
  541.  
  542. /Font mark
  543.  
  544. /InstanceType /dicttype
  545.  
  546. /DefineResource
  547.     { 2 copy //definefont exch pop
  548.       /Generic /Category findresource /DefineResource get exec
  549.     } bind
  550. /UndefineResource
  551.     { dup //undefinefont
  552.       /Generic /Category findresource /UndefineResource get exec
  553.     } bind
  554. /FindResource
  555.     { dup ResourceStatus
  556.        { pop 1 gt { .loadfont } { .GetInstance pop 0 get } ifelse }
  557.        { .loadfont }
  558.       ifelse
  559.     } bind
  560. /ResourceFileName
  561.     { /FontResourceDir getsystemparam .genericrfn
  562.     } bind
  563.  
  564. /.loadfont
  565.     { dup vmstatus pop exch pop exch
  566.       //findfont exec exch        % findfont is a procedure....
  567.       vmstatus pop exch pop exch sub
  568.         % stack: name font vmused
  569.         % findfont has the prerogative of not calling definefont
  570.         % in certain obscure cases of font substitution.
  571.       2 index .GetInstance
  572.        { dup 1 1 put
  573.          2 3 -1 roll put
  574.        }
  575.        { pop
  576.        }
  577.       ifelse exch pop
  578.     } bind
  579.  
  580. /Instances FontDirectory length 2 mul dict
  581.  
  582. .definecategory            % Font
  583.  
  584. % Redefine font "operators".
  585. /.definefontmap
  586.  { /Font /Category findresource /Instances get
  587.    dup 3 index known
  588.     { pop
  589.     }
  590.     { 2 index
  591.         % Make sure we create the array in global VM.
  592.       .currentglobal true .setglobal
  593.       [null 2 -1] exch .setglobal
  594.       .growput
  595.     }
  596.    ifelse
  597.    //.definefontmap exec
  598.  } bind def
  599.  
  600. % Make sure the old definitions are still in systemdict so that
  601. % they will get bound properly.
  602. systemdict begin
  603.   /.origdefinefont /definefont load def
  604.   /.origundefinefont /undefinefont load def
  605.   /.origfindfont /findfont load def
  606. end
  607. /definefont {
  608.   /Font defineresource
  609. } bind odef
  610. /undefinefont {
  611.   /Font undefineresource
  612. } bind odef
  613. % The Red Book requires that findfont be a procedure, not an operator,
  614. % but it still needs to restore the stacks reliably if it fails.
  615. /.findfontop {
  616.   /Font findresource
  617. } bind odef
  618. /findfont {
  619.   .findfontop
  620. } bind def    % Must be a procedure, not an operator
  621.  
  622. % Remove initialization utilities.
  623. currentdict /.definecategory .undef
  624. currentdict /.emptydict .undef
  625.  
  626. end                % level2dict
  627.  
  628. % Convert deferred resources after we finally switch to Level 2.
  629.  
  630. /.fixresources {
  631.     % Encoding resources
  632.  EncodingDirectory
  633.    { dup length 256 eq
  634.       { /Encoding defineresource pop }
  635.       { pop pop }
  636.      ifelse
  637.    } forall
  638.   /.findencoding { /Encoding findresource } bind def
  639.   /findencoding /.findencoding load odef
  640.   /.defineencoding { /Encoding defineresource pop } bind def
  641.     % ColorRendering resources and ProcSet
  642.   systemdict /ColorRendering .knownget {
  643.     /ColorRendering exch /ProcSet defineresource pop
  644.     systemdict /ColorRendering undef
  645.     /DefaultColorRendering currentcolorrendering /ColorRendering
  646.       defineresource pop
  647.     % FontType and FMapType resources
  648.   buildfontdict { pop dup /FontType defineresource pop } forall
  649.   mark
  650.     buildfontdict 0 known { 2 3 4 5 6 7 8 } if
  651.     buildfontdict 9 known { 9 } if
  652.   counttomark { dup /FMapType defineresource pop } repeat pop
  653.   } if
  654.     % Make the fixed resource categories immutable.
  655.   { /ColorSpaceFamily /Emulator /Filter /IODevice /ColorRenderingType
  656.     /FMapType /FontType /FormType /HalftoneType /ImageType /PatternType
  657.   } {
  658.     /Category findresource
  659.     dup /Instances get readonly pop
  660.     .LocalInstances readonly pop
  661.     readonly pop
  662.   } forall
  663.     % clean up
  664.   systemdict /.fixresources undef
  665. } bind def
  666.