home *** CD-ROM | disk | FTP | other *** search
/ Freelog Special Freeware 31 / FreelogHS31.iso / PDF / Ghostscript / gs860w32.exe / gs8.60 / lib / gs_resmp.ps < prev    next >
Text File  |  2007-06-13  |  23KB  |  532 lines
  1. %    Copyright (C) 2000 Artifex Software, Inc.  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_resmp.ps 8046 2007-06-12 20:55:18Z alexcher $
  17. % A procset to redefine a resource category with a resource map.
  18.  
  19. % Public entries :
  20.  
  21. % Redefine - a procedure for redefining a resource category with a map.
  22. %    Methods for interpreting the resource map to be provided by client 
  23. %    in the argument dictionary.
  24. %
  25. %    Note that the procedure Redefine is idempotential :
  26. %    consequtive calls to it will not replace the category methods,
  27. %    but will merge resource maps. If an interleaving redefinition
  28. %    needs to cancel the idempotentity, it must remove the entry
  29. %    /.IsRedefinedWithMap from the category dictionary.
  30.  
  31. % MakeResourceEnumerator - this procedure is useful for
  32. %    redefining any category. It provides a proper order of instances
  33. %    and proper stacks during resourceforall.
  34.  
  35. % BindWithCurrentdict - a procedure for generating temporary procedures 
  36. %    from templates, binding them with a local dictionary.
  37.  
  38. % execstack_lookup - a procedure for communicating through the execution stack.
  39. %    It allows for a callee to get an information from an indirect caller.
  40.  
  41. % The procedures are designed for exeution witout putting
  42. % the procset instance onto the dictionary stack.
  43.  
  44. languagelevel 2 .setlanguagelevel
  45. currentglobal true setglobal
  46.  
  47. /MappedCategoryRedefiner 10 dict begin % The procset.
  48.  
  49. currentpacking false setpacking
  50.  
  51. /InstanceEnumeratorPattern   %  - InstanceEnumeratorPattern ...
  52. {  
  53.   % This is a pattern for enumeration procedure to be built dynamically,
  54.   % applying BindWithCurrentdict with a temporary dictionary.
  55.   % The following names will be replaced with specific objects
  56.   % during BindWithCurrentdict :
  57.   % en_local_dict - a dictionary for storing the local integer variable 'status'.
  58.   % scr - the scratch string argument of resourceforall;
  59.   % proc - the procedure argument of resourceforall;
  60.   % InstancesStatus - a dictionary that maps resource instance names to their status value;
  61.   % Category - the category to be enumerated.
  62.  
  63.   % When this procedure is called from ResourceForAll, the category is the current dictionary.
  64.   % We remove it from the dictionary stack before performing the enumeration
  65.   % to provide the <proc> to write to the underlying dictionary,
  66.   % and put it back after the enumeration is completed.
  67.   end
  68.   { 
  69.     0 1 2 {
  70.       en_local_dict exch /status exch put
  71.       InstancesStatus {                                            
  72.         en_local_dict /status get eq {
  73.           scr cvs                           % ... (Font)
  74.           proc exec                         %
  75.         } {
  76.           pop
  77.         } ifelse                            % ...
  78.       } forall
  79.     } for                                   % ...
  80.   } stopped
  81.   Category begin
  82.   { stop } if
  83. } bind def
  84.  
  85. % An auxiliary proc for BindWithCurrentdict :
  86. /.BindAux    % <proc> BindAux <proc>
  87. { 0 exec
  88. } bind def
  89.  
  90. setpacking
  91.  
  92. /BindWithCurrentdict     % <proc> BindWithCurrentdict <proc>
  93. {  
  94.   % Make a copy of the given procedure, binding in the values of all names
  95.   % defined in currentdict.
  96.   % Caution1 : this code cannot handle procedures that were already
  97.   %            bound recursively.
  98.   % Caution2 : this code don't bind packedarrays. This was done
  99.   %            intentionally for a termination of the procedure tree.
  100.  
  101.   dup length array copy
  102.   dup length 1 sub -1 0 {                      
  103.     2 copy get                            % {precopy} i {elem}
  104.     dup dup type /arraytype eq exch xcheck and {
  105.                                           % {precopy} i {elem}
  106.       //.BindAux exec                     % {precopy} i {elem_copy}
  107.       2 index 3 1 roll put                % {precopy}
  108.     } {
  109.       dup dup type /nametype eq exch xcheck and {
  110.                                           % {precopy} i {elem}
  111.         currentdict exch .knownget {            
  112.           2 index 3 1 roll put            % {precopy}
  113.         } {                                            
  114.           pop
  115.         } ifelse
  116.       } {
  117.         pop pop
  118.       } ifelse
  119.     } ifelse                              % {precopy}
  120.   } for                                   % {copy}
  121.   cvx
  122. } bind def
  123.  
  124. //.BindAux 0 //BindWithCurrentdict put   % bind the recursive call in 'Bind'.
  125.  
  126. /MakeResourceEnumerator   % <proc> <scr> <InstancesStatus> MakeResourceEnumerator <Enumerator>
  127. {
  128.   % Build the enumeration procedure :
  129.  
  130.   % Since the resourceforall procedure may leave values on the operand stack,
  131.   % we cannot simply store the enumerator's local data on the stack.
  132.   % We also cannot use a static dictionary to store local variables,
  133.   % because of possible recursion in the resourceforall procedure.
  134.   % To work around this, we create a copy of the enumeration procedure and
  135.   % bind it dynamically with a temporary dictionary, which contains
  136.   % local variables for the currently executing instance of resourceforall.
  137.  
  138.   % Always place the enumerator in local VM,
  139.   % because its elements may be in local VM.
  140.  
  141.   currentglobal 4 1 roll
  142.   false setglobal
  143.   currentdict                    % Category
  144.   6 dict begin % the temporary dictionary
  145.     /Category exch def
  146.     /InstancesStatus exch def
  147.     /scr exch def
  148.     /proc exch def
  149.     /en_local_dict currentdict def
  150.     //InstanceEnumeratorPattern //BindWithCurrentdict exec     % Enumerator
  151.     /status 0 def % variable for the current status to enumerate - do not bind with it !
  152.   end
  153.   exch setglobal
  154. } bind def
  155.  
  156. /execstack_lookup     % <object> execstack_lookup <object1>
  157.                       % <object> execstack_lookup null
  158. { % Checks whether execution stack contains a procedure starting with <object>,
  159.   % and retrives the 2nd element of the procedure,
  160.   % or null if the procedure was not found.
  161.   %
  162.   % Since 'execstack' actually renders subarrays of procedures,
  163.   % the pattern for recognition must be like this :
  164.   %
  165.   %   { <object> <object1>
  166.   %     CallSomething
  167.   %   } loop
  168.   %
  169.   % The solution with 'loop' depends on how GS implements cycles,
  170.   % so it must not appear in documents, which are required to be interpreter independent.
  171.   % Any other type of cycles are also acceptable.
  172.   % If no repitition is really needed, just insert 'exit' into its body.
  173.   % If <object> <object1> are not needed for the caller, insert "pop pop" after them.
  174.   % If <object1> is really unuseful, the pattern may be simplified :
  175.   %
  176.   %   { <object> pop
  177.   %     CallSomething
  178.   %     exit
  179.   %   } loop
  180.   %
  181.   % It will retrieve 'pop' or 'null'.
  182.   %
  183.   % Note that 2 topmost execstack elements are the execstack_lookup procedure and its caller.
  184.   % We don't check them.
  185.  
  186.   currentglobal false setglobal                    % <object> bGlobal
  187.   countexecstack array execstack                   % <object> bGlobal [execstack]
  188.   dup null exch                                    % <object> bGlobal [execstack] null [execstack]
  189.   length 3 sub -1 0 {                              % <object> bGlobal [execstack] null i
  190.     2 index exch get                               % <object> bGlobal [execstack] null proc
  191.     dup type dup /packedarraytype eq exch /arraytype eq or {
  192.       dup rcheck {
  193.         dup length 1 gt {                          % <object> bGlobal [execstack] null proc
  194.           dup 0 get                                % <object> bGlobal [execstack] null proc elem0
  195.           5 index eq {                             % <object> bGlobal [execstack] null proc
  196.             1 get                                  % <object> bGlobal [execstack] null object1
  197.             exch pop exit                          % <object> bGlobal [execstack] object1
  198.           } {
  199.             pop
  200.           } ifelse
  201.         } {
  202.           pop                                      % <object> bGlobal [execstack] false
  203.         } ifelse
  204.       } {
  205.         pop                                        % <object> bGlobal [execstack] false
  206.       } ifelse
  207.     } {
  208.       pop                                          % <object> bGlobal [execstack] false
  209.     } ifelse
  210.   } for                                            % <object> bGlobal [execstack] bResult
  211.   exch pop exch setglobal exch pop                 % bResult
  212. } bind def
  213.  
  214. currentpacking false setpacking
  215. /MethodsToRedefine 5 dict begin
  216.  
  217.     % Procedures in this dictionary really are patterns for new category methods.
  218.     % The following names will be replaced with specific objects during BindWithCurrentdict :
  219.     %   .map - the map dictionary;
  220.     %   DefineResource, ResourceStatus, ResourceFileName, FindResource, ResourceForAll 
  221.     %        - procedures from the original resource category.
  222.  
  223.     /FindResource  % <Name> FindResource <dict>
  224.     { RESMPDEBUG { (resmp FindResource beg ) print dup = } if
  225.       dup ResourceStatus exec {
  226.         pop 2 lt
  227.       } {
  228.         false
  229.       } ifelse                             % bInVirtualMemory
  230.       { FindResource exec
  231.       } {
  232.         dup dup .map exch .knownget {      % /Name /Name <<record>>
  233.           dup dup /RecordVirtualMethods get /IsActive get exec {
  234.             1 index .getvminstance {       % /Name /Name <<record>> holder
  235.               1 get 1 eq
  236.             } {
  237.               true
  238.             } ifelse                       % /Name /Name <<record>> bStatusIs1
  239.             4 1 roll                       % bStatusIs1 /Name /Name <<record>>
  240.             dup /RecordVirtualMethods get /MakeInstance get exec
  241.                                            % bStatusIs1 /Name /Name Instance size
  242.             5 1 roll                       % size bStatusIs1 /Name /Name Instance
  243.             DefineResource exec            % size bStatusIs1 /Name Instance
  244.             % Make ResourceStatus to return correct values for this instance :
  245.             % Hack: we replace status values in the instance holder :
  246.             exch .getvminstance pop        % size bStatusIs1 Instance holder
  247.             dup 5 -1 roll 2 exch put       % bStatusIs1 Instance holder
  248.             3 2 roll {                     % Instance holder
  249.               1 1 put                      % Instance
  250.             } {
  251.               pop
  252.             } ifelse                       % Instance
  253.           } {                              % /Name /Name <<record>>
  254.             pop pop FindResource exec            
  255.           } ifelse
  256.         } {                                % /Name /Name
  257.           pop FindResource exec            
  258.         } ifelse
  259.       } ifelse
  260.       RESMPDEBUG { (resmp FindResource end) = } if
  261.     } bind def
  262.  
  263.     /ResourceStatus   % <Name> ResourceStatus <status> <size> true
  264.                       % <Name> ResourceStatus false
  265.     { RESMPDEBUG { (resmp ResourceStatus beg ) print dup == } if
  266.       dup ResourceStatus exec {            % /Name status size
  267.         1 index 2 lt {
  268.           % In VM - return with it.
  269.           3 2 roll pop true
  270.         } {
  271.           % Not in VM.
  272.           exch pop exch                    % size /Name
  273.           dup .map exch .knownget {        % size /Name <<record>>
  274.             dup dup /RecordVirtualMethods get /IsActive get exec {
  275.               3 2 roll pop                 % /Name <<record>>
  276.               dup /RecordVirtualMethods get /GetSize get exec 2 exch true
  277.             } {                            % size /Name <<record>>
  278.               pop pop 2 exch true
  279.             } ifelse
  280.           } {                              % size /Name
  281.             pop 2 exch true
  282.           } ifelse
  283.         } ifelse
  284.       } {                                  % /Name
  285.         dup .map exch .knownget {          % /Name <<record>>
  286.           dup dup /RecordVirtualMethods get /IsActive get exec {
  287.             dup /RecordVirtualMethods get /GetSize get exec 2 exch true
  288.           } {                              % /Name <<record>>
  289.             pop pop false
  290.           } ifelse
  291.         } {                                % /Name
  292.           pop false
  293.         } ifelse
  294.       } ifelse
  295.       RESMPDEBUG { (resmp ResourceStatus end) = } if
  296.     } bind def
  297.  
  298.     /ResourceFileName  % <Name> <scratch> ResourceFileName <string>
  299.     { RESMPDEBUG { (resmp ResourceFileName beg ) print 1 index = } if
  300.       exch                                                    % (scratch) /Name
  301.       .map 1 index .knownget {                                % (scratch) /Name <<record>>
  302.           RESMPDEBUG { (resmp ResourceFileName : have a map record.) = } if
  303.         dup dup /RecordVirtualMethods get /IsActive get exec {
  304.           RESMPDEBUG { (resmp ResourceFileName : record is active.) = } if
  305.           dup /RecordVirtualMethods get /GetFilePath get exec % (string)
  306.           RESMPDEBUG { (resmp ResourceFileName : retrieving ) print dup = } if
  307.         } {                                                   % (scratch) /Name <<record>>
  308.           RESMPDEBUG { (resmp ResourceFileName : record is NOT active.) = } if
  309.           pop exch ResourceFileName exec
  310.           RESMPDEBUG { (resmp ResourceFileName : retrieving ) print dup = } if
  311.         } ifelse
  312.       } { 
  313.         RESMPDEBUG { (resmp ResourceFileName : have NO map record.) = } if
  314.         exch ResourceFileName exec
  315.         RESMPDEBUG { (resmp ResourceFileName : retrieving ) print dup = } if
  316.       } ifelse
  317.       RESMPDEBUG { (resmp ResourceFileName end) = } if
  318.     } bind def
  319.  
  320.     /ResourceForAll  % <template> <proc> <scratch> ResourceForAll -
  321.     { RESMPDEBUG { (resmp ResourceForAll beg ) print CategoryName =string cvs print ( ) print 2 index = } if
  322.       % Create InstancesStatus dictionary :
  323.       20 dict % IS - Instances Status
  324.       4 1 roll                            % <<IS>> (templ) {proc} (sctarch)
  325.       % Check if we are under another ResourceForAll :
  326.       /.DisableResourceOrdering //execstack_lookup exec null eq 4 1 roll
  327.                                           % <<IS>> bOrder (templ) {proc} (sctarch)
  328.  
  329.       % Put underlying resources to the InstancesStatus dictionary :
  330.       currentdict % the category
  331.       begin % ResourceForAll removes it locally.
  332.       2 index
  333.       { cvn                               % <<IS>> bOrder (templ) {proc} (sctarch) /Name
  334.         4 index {
  335.           dup ResourceStatus exec {pop 6 index 3 1 roll put} {pop} ifelse
  336.         } {
  337.           5 index exch 2 put % Don't need the ordering, put '2' as a scratch.
  338.         } ifelse
  339.       }
  340.       2 index ResourceForAll exec         % <<IS>> bOrder (templ) {proc} (sctarch)
  341.       4 3 roll pop                        % <<IS>> (templ) {proc} (sctarch)
  342.       end
  343.  
  344.       % Put .map entries to the InstancesStatus dictionary :
  345.       4 -1 roll begin                     % (templ) {proc} (sctarch)
  346.       .map {                              % (templ) {proc} (sctarch) /Name record
  347.          dup dup /RecordVirtualMethods get /IsActive get exec {
  348.            pop                            % (templ) {proc} (sctarch) /Name
  349.            dup currentdict exch known {
  350.              pop
  351.            } {
  352.              dup 2 index cvs              % (templ) {proc} (sctarch) /Name (Name)
  353.              4 index .stringmatch {       % (templ) {proc} (sctarch) /Name
  354.                2 def % It is not in VM.
  355.              } {
  356.                pop
  357.              } ifelse
  358.            } ifelse
  359.         } {                               % (templ) {proc} (sctarch) /Name record
  360.           pop pop
  361.         } ifelse
  362.       } forall                            % (templ) {proc} (sctarch)
  363.  
  364.       % prepare stacks for the enumeration :
  365.       3 2 roll pop                        % {proc} (sctarch)
  366.       currentdict end                     % {proc} (scratch) <<IS>>
  367.  
  368.       % Make the enumerator and apply it :
  369.       //MakeResourceEnumerator exec exec
  370.       RESMPDEBUG { (resmp ResourceForAll end)= } if
  371.     } bind def
  372.  
  373.     /GetCIDSystemInfoFromMap   % <Name> GetCIDSystemInfoFromMap <Name>
  374.                                % <Name> GetCIDSystemInfoFromMap <dict>
  375.     { RESMPDEBUG { (resmp GetCIDSystemInfoFromMap beg ) print dup = } if
  376.       % This is a special function for communicating with GetCIDSystemInfo in gs_cidcm.ps .
  377.       dup .map exch .knownget {
  378.         RESMPDEBUG { (resmp GetCIDSystemInfoFromMap : have a map record.) = } if
  379.         dup /RecordVirtualMethods get /GetCSI get exec
  380.         dup null ne {
  381.           RESMPDEBUG { (resmp GetCIDSystemInfoFromMap : retrieving a dict.) = } if
  382.           exch
  383.         } if
  384.         pop
  385.       } if
  386.       RESMPDEBUG { (resmp GetCIDSystemInfoFromMap end) = } if
  387.     } bind def
  388.  
  389. currentdict end def
  390. setpacking
  391.  
  392. /Redefine     % <OptionsDict> Redefine -
  393. { % Before calling this proc, the OptionsDict must specify options for
  394.   % the catregory to be redefined :
  395.   % CategoryName - a name of category to redefine;
  396.   % MapFileName - a string for the resource map file name;
  397.   % VerifyMap - a procedure :
  398.   %   <raw_map> VerifyMap -
  399.   %   - checks the map for consistency
  400.   % PreprocessRecord  - a procedure :
  401.   %   <map> <Name> <raw_record> PreprocessRecord <map> <Name> <record> true
  402.   %   <map> <Name> <raw_record> PreprocessRecord <map> <Name> <raw_record> false
  403.   %   - converts a map record into a dictionary;
  404.   %   It must add RecordVirtualMethods dictionary to the record :
  405.   %     MakeInstance - a procedure :
  406.   %         <Name> <record> MakeInstance <Name> <Instance> <size>
  407.   %         - converts the record to resource instance;
  408.   %     GetFilePath - a procedure for ResourceFileName :
  409.   %         <scratch> <Name> <record> GetFilePath <filepath>
  410.   %     GetSize - a procedure for ResourceStatus :
  411.   %         <Name> <record> GetSize <size>
  412.   %     GetCSI - a procedure for obtaining CIDSystemInfo dictionary from the record :
  413.   %         <record> GetCSI <CSI>
  414.   %         <record> GetCSI null
  415.   %     IsActive - a procedure for skipping records depending on the current device :
  416.   %         <record> IsActive <bool>
  417.   %     Also it is allowed to contain additional entries for client's needs.
  418.   % The OptionsDict is also used for storing some local variables.
  419.  
  420.   % If a category is being redefined several times with this function,
  421.   % each redefinition must either use an unique map file,
  422.   % or the map file should be scanned by the last redefinition
  423.   % (and must be defined in the last one with /MapFileName).
  424.   % This happens so because we must accumulate all variants of
  425.   % methods before scanning the map. We would like to delay
  426.   % the scanning until all redefinitions are done, but it requires
  427.   % to implement a queue of "refinish" methods and execute it
  428.   % at very end of the prelude.
  429.  
  430.   begin % OptionsDict
  431.   CategoryName /Category findresource /OldCategory exch def
  432.   OldCategory /.IsRedefinedWithMap known {
  433.     % Already redefined with map - don't redefine, but enhance the map.
  434.     OldCategory /NewCategory exch def
  435.   } {
  436.     % Redefine with a new category instance.
  437.     OldCategory dup length dict 
  438.     dup /.PreprocessRecord 4 dict put
  439.     copy /NewCategory exch def
  440.   } ifelse
  441.  
  442.   % Provide the 'or' logic for PreprocessRecord,
  443.   % to allow different record types to be mixed in a single map file.
  444.   % We do this with building a dictionary of PreprocessRecord procedures,
  445.   % which come from different calls to Redefine :
  446.   NewCategory /.PreprocessRecord get dup length % <<pr>> l  
  447.   currentdict /PreprocessRecord get .growput
  448.  
  449.   currentdict /MapFileName known {
  450.     MapFileName .libfile {
  451.       1 dict begin
  452.       /; {} def
  453.       mark exch cvx exec .dicttomark           % <<map>>
  454.       end
  455.       dup VerifyMap                            % <<map>>
  456.     } {
  457.       QUIET not {
  458.         currentdict /IsMapFileOptional .knownget not { false } if not {
  459.           (Warning: the map file ) print dup =string cvs print ( was not found.) =
  460.         } if
  461.       } if
  462.       pop 0 dict                               % <<map>>
  463.     } ifelse
  464.   } {
  465.     currentdict /.map .knownget not { 
  466.       0 dict                                   % <<map>>
  467.     } if
  468.   } ifelse
  469.  
  470.   % Preprocess entries :
  471.   dup NewCategory /.PreprocessRecord get       % <<map>> <<map>> <<pr>>
  472.   3 1 roll {                                   % <<pr>> <<map>> /Name raw_record
  473.     false 3 1 roll                             % <<pr>> <<map>> false /Name raw_record 
  474.     4 index {                                  % <<pr>> <<map>> false /Name raw_record i {pr}
  475.       exch pop                                 % <<pr>> <<map>> false /Name raw_record {pr}
  476.       exec {                                   % <<pr>> <<map>> false /Name record
  477.         3 -1 roll pop true 3 1 roll            % <<pr>> <<map>> true /Name record
  478.         exit
  479.       } if                                     % <<pr>> <<map>> false /Name raw_record
  480.     } forall
  481.     3 2 roll {                                 % <<pr>> <<map>> /Name record
  482.       2 index 3 1 roll put                     % <<pr>> <<map>>
  483.     } {
  484.       exch                                     % <<pr>> <<map>> raw_record /Name
  485.       (Incorrect record ) print =string cvs print ( of the map file ) print MapFileName =string cvs print (.) =
  486.       end % Pops OptionsDict from dstack.
  487.       pop pop pop                              %
  488.       /Redefine cvx /undefinedresource signalerror
  489.     } ifelse
  490.   } forall                                     % <<pr>> <<map>>
  491.   exch pop                                     % <<map>>
  492.  
  493.  
  494.   % Add the map :
  495.   OldCategory /.IsRedefinedWithMap known {     % <<map>>
  496.     % Just add to the old map :
  497.     OldCategory /.map get copy pop             %
  498.   } {                                          % <<map>>
  499.     % Store the map to both the category and OptionsDict :
  500.     dup NewCategory exch /.map exch put
  501.     /.map exch def                             %
  502.   } ifelse
  503.   OldCategory /.IsRedefinedWithMap known not {
  504.     % Copy old methods to OptionsDict :
  505.     [ /DefineResource /ResourceStatus /ResourceFileName 
  506.       /FindResource /ResourceForAll
  507.     ] {
  508.       dup OldCategory exch get def
  509.     } forall
  510.     
  511.     % Build new methods :
  512.     //MethodsToRedefine {
  513.       //BindWithCurrentdict exec NewCategory 3 1 roll put  
  514.     } forall
  515.     CategoryName /CIDFont ne {
  516.       NewCategory /GetCIDSystemInfoFromMap undef
  517.       % This is some ugly, sorry.
  518.     } if
  519.     % Redefine the category :
  520.     NewCategory /.IsRedefinedWithMap true put
  521.     CategoryName NewCategory /Category defineresource pop
  522.   } if
  523.   end % OptionsDict
  524. } bind executeonly def
  525.  
  526. currentdict /PutPreprocessRecord .undef
  527.  
  528. currentdict end
  529. /ProcSet defineresource pop
  530.  
  531. setglobal .setlanguagelevel
  532.