home *** CD-ROM | disk | FTP | other *** search
/ jppd.dyndns.org / jppd.dyndns.org.tar / jppd.dyndns.org / QUERYPRO / Impressora_PDF / converter.exe / GPLGS / gs_resmp.ps < prev    next >
Text File  |  2003-02-19  |  22KB  |  505 lines
  1. %    Copyright (C) 2000 artofcode LLC.  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,v 1.10 2003/02/18 19:57:16 igor Exp $
  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.   currentdict                    % Category
  139.   6 dict begin % the temporary dictionary
  140.     /Category exch def           %
  141.     /InstancesStatus exch def
  142.     /scr exch def
  143.     /proc exch def
  144.     /en_local_dict currentdict def
  145.     //InstanceEnumeratorPattern //BindWithCurrentdict exec     % Enumerator
  146.     /status 0 def % variable for the current status to enumerate - do not bind with it !
  147.   end
  148.  
  149. } bind def
  150.  
  151. /execstack_lookup     % <object> execstack_lookup <object1>
  152.                       % <object> execstack_lookup null
  153. { % Checks whether execution stack contains a procedure starting with <object>,
  154.   % and retrives the 2nd element of the procedure,
  155.   % or null if the procedure was not found.
  156.   %
  157.   % Since 'execstack' actually renders subarrays of procedures,
  158.   % the pattern for recognition must be like this :
  159.   %
  160.   %   { <object> <object1>
  161.   %     CallSomething
  162.   %   } loop
  163.   %
  164.   % The solution with 'loop' depends on how GS implements cycles,
  165.   % so it must not appear in documents, which are required to be interpreter independent.
  166.   % Any other type of cycles are also acceptable.
  167.   % If no repitition is really needed, just insert 'exit' into its body.
  168.   % If <object> <object1> are not needed for the caller, insert "pop pop" after them.
  169.   % If <object1> is really unuseful, the pattern may be simplified :
  170.   %
  171.   %   { <object> pop
  172.   %     CallSomething
  173.   %     exit
  174.   %   } loop
  175.   %
  176.   % It will retrieve 'pop' or 'null'.
  177.   %
  178.   % Note that 2 topmost execstack elements are the execstack_lookup procedure and its caller.
  179.   % We don't check them.
  180.  
  181.   currentglobal false setglobal                    % <object> bGlobal
  182.   countexecstack array execstack                   % <object> bGlobal [execstack]
  183.   dup null exch                                    % <object> bGlobal [execstack] null [execstack]
  184.   length 3 sub -1 0 {                              % <object> bGlobal [execstack] null i
  185.     2 index exch get                               % <object> bGlobal [execstack] null proc
  186.     dup type dup /packedarraytype eq exch /arraytype eq or {
  187.       dup length 1 gt {                            % <object> bGlobal [execstack] null proc
  188.         dup 0 get                                  % <object> bGlobal [execstack] null proc elem0
  189.         5 index eq {                               % <object> bGlobal [execstack] null proc
  190.           1 get                                    % <object> bGlobal [execstack] null object1
  191.           exch pop exit                            % <object> bGlobal [execstack] object1
  192.         } {
  193.           pop
  194.         } ifelse
  195.       } {
  196.         pop                                        % <object> bGlobal [execstack] false
  197.       } ifelse
  198.     } {
  199.       pop                                          % <object> bGlobal [execstack] false
  200.     } ifelse
  201.   } for                                            % <object> bGlobal [execstack] bResult
  202.   exch pop exch setglobal exch pop                 % bResult
  203. } bind def
  204.  
  205. currentpacking false setpacking
  206. /MethodsToRedefine 5 dict begin
  207.  
  208.     % Procedures in this dictionary really are patterns for new category methods.
  209.     % The following names will be replaced with specific objects during BindWithCurrentdict :
  210.     %   .map - the map dictionary;
  211.     %   DefineResource, ResourceStatus, ResourceFileName, FindResource, ResourceForAll 
  212.     %        - procedures from the original resource category.
  213.  
  214.     /FindResource  % <Name> FindResource <dict>
  215.     { dup ResourceStatus exec {
  216.         pop 2 lt
  217.       } {
  218.         false
  219.       } ifelse                             % bInVirtualMemory
  220.       { FindResource exec
  221.       } {
  222.         dup dup .map exch .knownget {      % /Name /Name <<record>>
  223.           dup dup /RecordVirtualMethods get /IsActive get exec {
  224.             1 index .getvminstance {       % /Name /Name <<record>> holder
  225.               1 get 1 eq
  226.             } {
  227.               true
  228.             } ifelse                       % /Name /Name <<record>> bStatusIs1
  229.             4 1 roll                       % bStatusIs1 /Name /Name <<record>>
  230.             dup /RecordVirtualMethods get /MakeInstance get exec
  231.                                            % bStatusIs1 /Name /Name Instance size
  232.             5 1 roll                       % size bStatusIs1 /Name /Name Instance
  233.             DefineResource exec            % size bStatusIs1 /Name Instance
  234.             % Make ResourceStatus to return correct values for this instance :
  235.             % Hack: we replace status values in the instance holder :
  236.             exch .getvminstance pop        % size bStatusIs1 Instance holder
  237.             dup 5 -1 roll 2 exch put       % bStatusIs1 Instance holder
  238.             3 2 roll {                     % Instance holder
  239.               1 1 put                      % Instance
  240.             } {
  241.               pop
  242.             } ifelse                       % Instance
  243.           } {                              % /Name /Name <<record>>
  244.             pop pop FindResource exec            
  245.           } ifelse
  246.         } {                                % /Name /Name
  247.           pop FindResource exec            
  248.         } ifelse
  249.       } ifelse
  250.     } bind def
  251.  
  252.     /ResourceStatus   % <Name> ResourceStatus <status> <size> true
  253.                       % <Name> ResourceStatus false
  254.     { dup ResourceStatus exec {            % /Name status size
  255.         1 index 2 lt {
  256.           % In VM - return with it.
  257.           3 2 roll pop true
  258.         } {
  259.           % Not in VM.
  260.           exch pop exch                    % size /Name
  261.           dup .map exch .knownget {        % size /Name <<record>>
  262.             dup dup /RecordVirtualMethods get /IsActive get exec {
  263.               3 2 roll pop                 % /Name <<record>>
  264.               dup /RecordVirtualMethods get /GetSize get exec 2 exch true
  265.             } {                            % size /Name <<record>>
  266.               pop pop 2 exch true
  267.             } ifelse
  268.           } {                              % size /Name
  269.             pop 2 exch true
  270.           } ifelse
  271.         } ifelse
  272.       } {                                  % /Name
  273.         dup .map exch .knownget {          % /Name <<record>>
  274.           dup dup /RecordVirtualMethods get /IsActive get exec {
  275.             dup /RecordVirtualMethods get /GetSize get exec 2 exch true
  276.           } {                              % /Name <<record>>
  277.             pop pop false
  278.           } ifelse
  279.         } {                                % /Name
  280.           pop false
  281.         } ifelse
  282.       } ifelse
  283.     } bind def
  284.  
  285.     /ResourceFileName  % <Name> <scratch> ResourceFileName <string>
  286.     { exch                                                    % (scratch) /Name
  287.       .map 1 index .knownget {                                % (scratch) /Name <<record>>
  288.         dup dup /RecordVirtualMethods get /IsActive get exec {
  289.           dup /RecordVirtualMethods get /GetFilePath get exec % (string)
  290.         } {                                                   % (scratch) /Name <<record>>
  291.           pop exch ResourceFileName exec
  292.         } ifelse
  293.       } { 
  294.         exch ResourceFileName exec
  295.       } ifelse
  296.     } bind def
  297.  
  298.     /ResourceForAll  % <template> <proc> <scratch> ResourceForAll -
  299.     { % Create InstancesStatus dictionary :
  300.       20 dict % IS - Instances Status
  301.       4 1 roll                            % <<IS>> (templ) {proc} (sctarch)
  302.                                           % <<IS>> bOrder (templ) {proc} (sctarch)
  303.       % Check if we are under another ResourceForAll :
  304.       /.DisableResourceOrdering //execstack_lookup exec null eq 4 1 roll
  305.  
  306.       % Put underlying resources to the InstancesStatus dictionary :
  307.       currentdict % the category
  308.       begin % ResourceForAll removes it locally.
  309.       2 index
  310.       { cvn                               % <<IS>> bOrder (templ) {proc} (sctarch) /Name
  311.         4 index {
  312.           dup ResourceStatus exec {pop 6 index 3 1 roll put} {pop} ifelse
  313.         } {
  314.           5 index exch 2 put % Don't need the ordering, put '2' as a scratch.
  315.         } ifelse
  316.       }
  317.       2 index ResourceForAll exec         % <<IS>> bOrder (templ) {proc} (sctarch)
  318.       4 3 roll pop                        % <<IS>> (templ) {proc} (sctarch)
  319.       end
  320.  
  321.       % Put .map entries to the InstancesStatus dictionary :
  322.       4 -1 roll begin                     % (templ) {proc} (sctarch)
  323.       .map {                              % (templ) {proc} (sctarch) /Name record
  324.          dup dup /RecordVirtualMethods get /IsActive get exec {
  325.            pop                            % (templ) {proc} (sctarch) /Name
  326.            dup currentdict exch known {
  327.              pop
  328.            } {
  329.              dup 2 index cvs              % (templ) {proc} (sctarch) /Name (Name)
  330.              4 index .stringmatch {       % (templ) {proc} (sctarch) /Name
  331.                2 def % It is not in VM.
  332.              } {
  333.                pop
  334.              } ifelse
  335.            } ifelse
  336.         } {                               % (templ) {proc} (sctarch) /Name record
  337.           pop pop
  338.         } ifelse
  339.       } forall                            % (templ) {proc} (sctarch)
  340.  
  341.       % prepare stacks for the enumeration :
  342.       3 2 roll pop                        % {proc} (sctarch)
  343.       currentdict end                     % {proc} (scratch) <<IS>>
  344.  
  345.       % Make the enumerator and apply it :
  346.       //MakeResourceEnumerator exec exec
  347.  
  348.     } bind def
  349.  
  350.     /GetCIDSystemInfoFromMap   % <Name> GetCIDSystemInfoFromMap <Name>
  351.                                % <Name> GetCIDSystemInfoFromMap <dict>
  352.     { % This is a special function for communicating with GetCIDSystemInfo in gs_cidcm.ps .
  353.       dup .map exch .knownget {
  354.         dup /RecordVirtualMethods get /GetCSI get exec
  355.         dup null ne {
  356.           exch
  357.         } if
  358.         pop
  359.       } if
  360.     } bind def
  361.  
  362. currentdict end def
  363. setpacking
  364.  
  365. /Redefine     % <OptionsDict> Redefine -
  366. { % Before calling this proc, the OptionsDict must specify options for
  367.   % the catregory to be redefined :
  368.   % CategoryName - a name of category to redefine;
  369.   % MapFileName - a string for the resource map file name;
  370.   % VerifyMap - a procedure :
  371.   %   <raw_map> VerifyMap -
  372.   %   - checks the map for consistency
  373.   % PreprocessRecord  - a procedure :
  374.   %   <map> <Name> <raw_record> PreprocessRecord <map> <Name> <record> true
  375.   %   <map> <Name> <raw_record> PreprocessRecord <map> <Name> <raw_record> false
  376.   %   - converts a map record into a dictionary;
  377.   %   It must add RecordVirtualMethods dictionary to the record :
  378.   %     MakeInstance - a procedure :
  379.   %         <Name> <record> MakeInstance <Name> <Instance> <size>
  380.   %         - converts the record to resource instance;
  381.   %     GetFilePath - a procedure for ResourceFileName :
  382.   %         <scratch> <Name> <record> GetFilePath <filepath>
  383.   %     GetSize - a procedure for ResourceStatus :
  384.   %         <Name> <record> GetSize <size>
  385.   %     GetCSI - a procedure for obtaining CIDSystemInfo dictionary from the record :
  386.   %         <record> GetCSI <CSI>
  387.   %         <record> GetCSI null
  388.   %     IsActive - a procedure for skipping records depending on the current device :
  389.   %         <record> IsActive <bool>
  390.   %     Also it is allowed to contain additional entries for client's needs.
  391.   % The OptionsDict is also used for storing some local variables.
  392.  
  393.   % If a category is being redefined several times with this function,
  394.   % each redefinition must either use an unique map file,
  395.   % or the map file should be scanned by the last redefinition
  396.   % (and must be defined in the last one with /MapFileName).
  397.   % This happens so because we must accumulate all variants of
  398.   % methods before scanning the map. We would like to delay
  399.   % the scanning until all redefinitions are done, but it requires
  400.   % to implement a queue of "refinish" methods and execute it
  401.   % at very end of the prelude.
  402.  
  403.   begin % OptionsDict
  404.   CategoryName /Category findresource /OldCategory exch def
  405.   OldCategory /.IsRedefinedWithMap known {
  406.     % Already redefined with map - don't redefine, but enhance the map.
  407.     OldCategory /NewCategory exch def
  408.   } {
  409.     % Redefine with a new category instance.
  410.     OldCategory dup length dict 
  411.     dup /.PreprocessRecord 4 dict put
  412.     copy /NewCategory exch def
  413.   } ifelse
  414.  
  415.   % Provide the 'or' logic for PreprocessRecord,
  416.   % to allow different record types to be mixed in a single map file.
  417.   % We do this with building a dictionary of PreprocessRecord procedures,
  418.   % which come from different calls to Redefine :
  419.   NewCategory /.PreprocessRecord get dup length % <<pr>> l  
  420.   currentdict /PreprocessRecord get .growput
  421.  
  422.   currentdict /MapFileName known {
  423.     MapFileName .libfile {
  424.       1 dict begin
  425.       /; {} def
  426.       mark exch cvx exec .dicttomark           % <<map>>
  427.       end
  428.       dup VerifyMap                            % <<map>>
  429.     } {
  430.       QUIET not {
  431.         currentdict /IsMapFileOptional .knownget not { false } if not {
  432.           (Warning: the map file ) print dup =string cvs print ( was not found.) =
  433.         } if
  434.       } if
  435.       pop 0 dict                               % <<map>>
  436.     } ifelse
  437.   } {
  438.     currentdict /.map .knownget not { 
  439.       0 dict                                   % <<map>>
  440.     } if
  441.   } ifelse
  442.  
  443.   % Preprocess entries :
  444.   dup NewCategory /.PreprocessRecord get       % <<map>> <<map>> <<pr>>
  445.   3 1 roll {                                   % <<pr>> <<map>> /Name raw_record
  446.     false 3 1 roll                             % <<pr>> <<map>> false /Name raw_record 
  447.     4 index {                                  % <<pr>> <<map>> false /Name raw_record i {pr}
  448.       exch pop                                 % <<pr>> <<map>> false /Name raw_record {pr}
  449.       exec {                                   % <<pr>> <<map>> false /Name record
  450.         3 -1 roll pop true 3 1 roll            % <<pr>> <<map>> true /Name record
  451.         exit
  452.       } if                                     % <<pr>> <<map>> false /Name raw_record
  453.     } forall
  454.     3 2 roll {                                 % <<pr>> <<map>> /Name record
  455.       2 index 3 1 roll put                     % <<pr>> <<map>>
  456.     } {
  457.       exch                                     % <<pr>> <<map>> raw_record /Name
  458.       (Incorrect record ) print =string cvs print ( of the map file ) print MapFileName =string cvs print (.) =
  459.       end % Pops OptionsDict from dstack.
  460.       pop pop pop                              %
  461.       /Redefine cvx /undefinedresource signalerror
  462.     } ifelse
  463.   } forall                                     % <<pr>> <<map>>
  464.   exch pop                                     % <<map>>
  465.  
  466.  
  467.   % Add the map :
  468.   OldCategory /.IsRedefinedWithMap known {     % <<map>>
  469.     % Just add to the old map :
  470.     OldCategory /.map get copy pop             %
  471.   } {                                          % <<map>>
  472.     % Store the map to both the category and OptionsDict :
  473.     dup NewCategory exch /.map exch put
  474.     /.map exch def                             %
  475.   } ifelse
  476.   OldCategory /.IsRedefinedWithMap known not {
  477.     % Copy old methods to OptionsDict :
  478.     [ /DefineResource /ResourceStatus /ResourceFileName 
  479.       /FindResource /ResourceForAll
  480.     ] {
  481.       dup OldCategory exch get def
  482.     } forall
  483.     
  484.     % Build new methods :
  485.     //MethodsToRedefine {
  486.       //BindWithCurrentdict exec NewCategory 3 1 roll put  
  487.     } forall
  488.     CategoryName /CIDFont ne {
  489.       NewCategory /GetCIDSystemInfoFromMap undef
  490.       % This is some ugly, sorry.
  491.     } if
  492.     % Redefine the category :
  493.     NewCategory /.IsRedefinedWithMap true put
  494.     CategoryName NewCategory /Category defineresource pop
  495.   } if
  496.   end % OptionsDict
  497. } bind executeonly def
  498.  
  499. currentdict /PutPreprocessRecord .undef
  500.  
  501. currentdict end
  502. /ProcSet defineresource pop
  503.  
  504. setglobal .setlanguagelevel
  505.