%    Copyright (C) 2000 artofcode LLC.  All rights reserved.% % This software is provided AS-IS with no warranty, either express or% implied.% % This software is distributed under license and may not be copied,% modified or distributed except as expressly authorized under the terms% of the license contained in the file LICENSE in this distribution.% % For more information about licensing, please refer to% http://www.ghostscript.com/licensing/. For information on% commercial licensing, go to http://www.artifex.com/licensing/ or% contact Artifex Software, Inc., 101 Lucas Valley Road #110,% San Rafael, CA  94903, U.S.A., +1(415)492-9861. % $Id: gs_resmp.ps,v 1.11 2004/10/25 15:11:37 igor Exp $% A procset to redefine a resource category with a resource map. % Public entries : % Redefine - a procedure for redefining a resource category with a map.%    Methods for interpreting the resource map to be provided by client %    in the argument dictionary.%%    Note that the procedure Redefine is idempotential :%    consequtive calls to it will not replace the category methods,%    but will merge resource maps. If an interleaving redefinition%    needs to cancel the idempotentity, it must remove the entry%    /.IsRedefinedWithMap from the category dictionary. % MakeResourceEnumerator - this procedure is useful for%    redefining any category. It provides a proper order of instances%    and proper stacks during resourceforall. % BindWithCurrentdict - a procedure for generating temporary procedures %    from templates, binding them with a local dictionary. % execstack_lookup - a procedure for communicating through the execution stack.%    It allows for a callee to get an information from an indirect caller. % The procedures are designed for exeution witout putting% the procset instance onto the dictionary stack. languagelevel 2 .setlanguagelevelcurrentglobal true setglobal /MappedCategoryRedefiner 10 dict begin % The procset. currentpacking false setpacking /InstanceEnumeratorPattern   %  - InstanceEnumeratorPattern ...{    % This is a pattern for enumeration procedure to be built dynamically,  % applying BindWithCurrentdict with a temporary dictionary.  % The following names will be replaced with specific objects  % during BindWithCurrentdict :  % en_local_dict - a dictionary for storing the local integer variable 'status'.  % scr - the scratch string argument of resourceforall;  % proc - the procedure argument of resourceforall;  % InstancesStatus - a dictionary that maps resource instance names to their status value;  % Category - the category to be enumerated.   % When this procedure is called from ResourceForAll, the category is the current dictionary.  % We remove it from the dictionary stack before performing the enumeration  % to provide the <proc> to write to the underlying dictionary,  % and put it back after the enumeration is completed.  end  {     0 1 2 {      en_local_dict exch /status exch put      InstancesStatus {                                                    en_local_dict /status get eq {          scr cvs                           % ... (Font)          proc exec                         %        } {          pop        } ifelse                            % ...      } forall    } for                                   % ...  } stopped  Category begin  { stop } if} bind def % An auxiliary proc for BindWithCurrentdict :/.BindAux    % <proc> BindAux <proc>{ 0 exec} bind def setpacking /BindWithCurrentdict     % <proc> BindWithCurrentdict <proc>{    % Make a copy of the given procedure, binding in the values of all names  % defined in currentdict.  % Caution1 : this code cannot handle procedures that were already  %            bound recursively.  % Caution2 : this code don't bind packedarrays. This was done  %            intentionally for a termination of the procedure tree.   dup length array copy  dup length 1 sub -1 0 {                          2 copy get                            % {precopy} i {elem}    dup dup type /arraytype eq exch xcheck and {                                          % {precopy} i {elem}      //.BindAux exec                     % {precopy} i {elem_copy}      2 index 3 1 roll put                % {precopy}    } {      dup dup type /nametype eq exch xcheck and {                                          % {precopy} i {elem}        currentdict exch .knownget {                      2 index 3 1 roll put            % {precopy}        } {                                                      pop        } ifelse      } {        pop pop      } ifelse    } ifelse                              % {precopy}  } for                                   % {copy}  cvx} bind def //.BindAux 0 //BindWithCurrentdict put   % bind the recursive call in 'Bind'. /MakeResourceEnumerator   % <proc> <scr> <InstancesStatus> MakeResourceEnumerator <Enumerator>{  % Build the enumeration procedure :   % Since the resourceforall procedure may leave values on the operand stack,  % we cannot simply store the enumerator's local data on the stack.  % We also cannot use a static dictionary to store local variables,  % because of possible recursion in the resourceforall procedure.  % To work around this, we create a copy of the enumeration procedure and  % bind it dynamically with a temporary dictionary, which contains  % local variables for the currently executing instance of resourceforall.   currentdict                    % Category  6 dict begin % the temporary dictionary    /Category exch def           %    /InstancesStatus exch def    /scr exch def    /proc exch def    /en_local_dict currentdict def    //InstanceEnumeratorPattern //BindWithCurrentdict exec     % Enumerator    /status 0 def % variable for the current status to enumerate - do not bind with it !  end } bind def /execstack_lookup     % <object> execstack_lookup <object1>                      % <object> execstack_lookup null{ % Checks whether execution stack contains a procedure starting with <object>,  % and retrives the 2nd element of the procedure,  % or null if the procedure was not found.  %  % Since 'execstack' actually renders subarrays of procedures,  % the pattern for recognition must be like this :  %  %   { <object> <object1>  %     CallSomething  %   } loop  %  % The solution with 'loop' depends on how GS implements cycles,  % so it must not appear in documents, which are required to be interpreter independent.  % Any other type of cycles are also acceptable.  % If no repitition is really needed, just insert 'exit' into its body.  % If <object> <object1> are not needed for the caller, insert "pop pop" after them.  % If <object1> is really unuseful, the pattern may be simplified :  %  %   { <object> pop  %     CallSomething  %     exit  %   } loop  %  % It will retrieve 'pop' or 'null'.  %  % Note that 2 topmost execstack elements are the execstack_lookup procedure and its caller.  % We don't check them.   currentglobal false setglobal                    % <object> bGlobal  countexecstack array execstack                   % <object> bGlobal [execstack]  dup null exch                                    % <object> bGlobal [execstack] null [execstack]  length 3 sub -1 0 {                              % <object> bGlobal [execstack] null i    2 index exch get                               % <object> bGlobal [execstack] null proc    dup type dup /packedarraytype eq exch /arraytype eq or {      dup length 1 gt {                            % <object> bGlobal [execstack] null proc        dup 0 get                                  % <object> bGlobal [execstack] null proc elem0        5 index eq {                               % <object> bGlobal [execstack] null proc          1 get                                    % <object> bGlobal [execstack] null object1          exch pop exit                            % <object> bGlobal [execstack] object1        } {          pop        } ifelse      } {        pop                                        % <object> bGlobal [execstack] false      } ifelse    } {      pop                                          % <object> bGlobal [execstack] false    } ifelse  } for                                            % <object> bGlobal [execstack] bResult  exch pop exch setglobal exch pop                 % bResult} bind def currentpacking false setpacking/MethodsToRedefine 5 dict begin     % Procedures in this dictionary really are patterns for new category methods.    % The following names will be replaced with specific objects during BindWithCurrentdict :    %   .map - the map dictionary;    %   DefineResource, ResourceStatus, ResourceFileName, FindResource, ResourceForAll     %        - procedures from the original resource category.     /FindResource  % <Name> FindResource <dict>    { RESMPDEBUG { (resmp FindResource beg ) print dup = } if      dup ResourceStatus exec {        pop 2 lt      } {        false      } ifelse                             % bInVirtualMemory      { FindResource exec      } {        dup dup .map exch .knownget {      % /Name /Name <<record>>          dup dup /RecordVirtualMethods get /IsActive get exec {            1 index .getvminstance {       % /Name /Name <<record>> holder              1 get 1 eq            } {              true            } ifelse                       % /Name /Name <<record>> bStatusIs1            4 1 roll                       % bStatusIs1 /Name /Name <<record>>            dup /RecordVirtualMethods get /MakeInstance get exec                                           % bStatusIs1 /Name /Name Instance size            5 1 roll                       % size bStatusIs1 /Name /Name Instance            DefineResource exec            % size bStatusIs1 /Name Instance            % Make ResourceStatus to return correct values for this instance :            % Hack: we replace status values in the instance holder :            exch .getvminstance pop        % size bStatusIs1 Instance holder            dup 5 -1 roll 2 exch put       % bStatusIs1 Instance holder            3 2 roll {                     % Instance holder              1 1 put                      % Instance            } {              pop            } ifelse                       % Instance          } {                              % /Name /Name <<record>>            pop pop FindResource exec                      } ifelse        } {                                % /Name /Name          pop FindResource exec                    } ifelse      } ifelse      RESMPDEBUG { (resmp FindResource end) = } if    } bind def     /ResourceStatus   % <Name> ResourceStatus <status> <size> true                      % <Name> ResourceStatus false    { RESMPDEBUG { (resmp ResourceStatus beg ) print dup == } if      dup ResourceStatus exec {            % /Name status size        1 index 2 lt {          % In VM - return with it.          3 2 roll pop true        } {          % Not in VM.          exch pop exch                    % size /Name          dup .map exch .knownget {        % size /Name <<record>>            dup dup /RecordVirtualMethods get /IsActive get exec {              3 2 roll pop                 % /Name <<record>>              dup /RecordVirtualMethods get /GetSize get exec 2 exch true            } {                            % size /Name <<record>>              pop pop 2 exch true            } ifelse          } {                              % size /Name            pop 2 exch true          } ifelse        } ifelse      } {                                  % /Name        dup .map exch .knownget {          % /Name <<record>>          dup dup /RecordVirtualMethods get /IsActive get exec {            dup /RecordVirtualMethods get /GetSize get exec 2 exch true          } {                              % /Name <<record>>            pop pop false          } ifelse        } {                                % /Name          pop false        } ifelse      } ifelse      RESMPDEBUG { (resmp ResourceStatus end) = } if    } bind def     /ResourceFileName  % <Name> <scratch> ResourceFileName <string>    { RESMPDEBUG { (resmp ResourceFileName beg ) print 1 index = } if      exch                                                    % (scratch) /Name      .map 1 index .knownget {                                % (scratch) /Name <<record>>      	RESMPDEBUG { (resmp ResourceFileName : have a map record.) = } if        dup dup /RecordVirtualMethods get /IsActive get exec {          RESMPDEBUG { (resmp ResourceFileName : record is active.) = } if          dup /RecordVirtualMethods get /GetFilePath get exec % (string)          RESMPDEBUG { (resmp ResourceFileName : retrieving ) print dup = } if        } {                                                   % (scratch) /Name <<record>>          RESMPDEBUG { (resmp ResourceFileName : record is NOT active.) = } if          pop exch ResourceFileName exec          RESMPDEBUG { (resmp ResourceFileName : retrieving ) print dup = } if        } ifelse      } {         RESMPDEBUG { (resmp ResourceFileName : have NO map record.) = } if        exch ResourceFileName exec        RESMPDEBUG { (resmp ResourceFileName : retrieving ) print dup = } if      } ifelse      RESMPDEBUG { (resmp ResourceFileName end) = } if    } bind def     /ResourceForAll  % <template> <proc> <scratch> ResourceForAll -    { RESMPDEBUG { (resmp ResourceForAll beg ) print 2 index = } if      % Create InstancesStatus dictionary :      20 dict % IS - Instances Status      4 1 roll                            % <<IS>> (templ) {proc} (sctarch)                                          % <<IS>> bOrder (templ) {proc} (sctarch)      % Check if we are under another ResourceForAll :      /.DisableResourceOrdering //execstack_lookup exec null eq 4 1 roll       % Put underlying resources to the InstancesStatus dictionary :      currentdict % the category      begin % ResourceForAll removes it locally.      2 index      { cvn                               % <<IS>> bOrder (templ) {proc} (sctarch) /Name        4 index {          dup ResourceStatus exec {pop 6 index 3 1 roll put} {pop} ifelse        } {          5 index exch 2 put % Don't need the ordering, put '2' as a scratch.        } ifelse      }      2 index ResourceForAll exec         % <<IS>> bOrder (templ) {proc} (sctarch)      4 3 roll pop                        % <<IS>> (templ) {proc} (sctarch)      end       % Put .map entries to the InstancesStatus dictionary :      4 -1 roll begin                     % (templ) {proc} (sctarch)      .map {                              % (templ) {proc} (sctarch) /Name record         dup dup /RecordVirtualMethods get /IsActive get exec {           pop                            % (templ) {proc} (sctarch) /Name           dup currentdict exch known {             pop           } {             dup 2 index cvs              % (templ) {proc} (sctarch) /Name (Name)             4 index .stringmatch {       % (templ) {proc} (sctarch) /Name               2 def % It is not in VM.             } {               pop             } ifelse           } ifelse        } {                               % (templ) {proc} (sctarch) /Name record          pop pop        } ifelse      } forall                            % (templ) {proc} (sctarch)       % prepare stacks for the enumeration :      3 2 roll pop                        % {proc} (sctarch)      currentdict end                     % {proc} (scratch) <<IS>>       % Make the enumerator and apply it :      //MakeResourceEnumerator exec exec      RESMPDEBUG { (resmp ResourceForAll end)= } if    } bind def     /GetCIDSystemInfoFromMap   % <Name> GetCIDSystemInfoFromMap <Name>                               % <Name> GetCIDSystemInfoFromMap <dict>    { RESMPDEBUG { (resmp GetCIDSystemInfoFromMap beg ) print dup = } if      % This is a special function for communicating with GetCIDSystemInfo in gs_cidcm.ps .      dup .map exch .knownget {        RESMPDEBUG { (resmp GetCIDSystemInfoFromMap : have a map record.) = } if        dup /RecordVirtualMethods get /GetCSI get exec        dup null ne {          RESMPDEBUG { (resmp GetCIDSystemInfoFromMap : retrieving a dict.) = } if          exch        } if        pop      } if      RESMPDEBUG { (resmp GetCIDSystemInfoFromMap end) = } if    } bind def currentdict end defsetpacking /Redefine     % <OptionsDict> Redefine -{ % Before calling this proc, the OptionsDict must specify options for  % the catregory to be redefined :  % CategoryName - a name of category to redefine;  % MapFileName - a string for the resource map file name;  % VerifyMap - a procedure :  %   <raw_map> VerifyMap -  %   - checks the map for consistency  % PreprocessRecord  - a procedure :  %   <map> <Name> <raw_record> PreprocessRecord <map> <Name> <record> true  %   <map> <Name> <raw_record> PreprocessRecord <map> <Name> <raw_record> false  %   - converts a map record into a dictionary;  %   It must add RecordVirtualMethods dictionary to the record :  %     MakeInstance - a procedure :  %         <Name> <record> MakeInstance <Name> <Instance> <size>  %         - converts the record to resource instance;  %     GetFilePath - a procedure for ResourceFileName :  %         <scratch> <Name> <record> GetFilePath <filepath>  %     GetSize - a procedure for ResourceStatus :  %         <Name> <record> GetSize <size>  %     GetCSI - a procedure for obtaining CIDSystemInfo dictionary from the record :  %         <record> GetCSI <CSI>  %         <record> GetCSI null  %     IsActive - a procedure for skipping records depending on the current device :  %         <record> IsActive <bool>  %     Also it is allowed to contain additional entries for client's needs.  % The OptionsDict is also used for storing some local variables.   % If a category is being redefined several times with this function,  % each redefinition must either use an unique map file,  % or the map file should be scanned by the last redefinition  % (and must be defined in the last one with /MapFileName).  % This happens so because we must accumulate all variants of  % methods before scanning the map. We would like to delay  % the scanning until all redefinitions are done, but it requires  % to implement a queue of "refinish" methods and execute it  % at very end of the prelude.   begin % OptionsDict  CategoryName /Category findresource /OldCategory exch def  OldCategory /.IsRedefinedWithMap known {    % Already redefined with map - don't redefine, but enhance the map.    OldCategory /NewCategory exch def  } {    % Redefine with a new category instance.    OldCategory dup length dict     dup /.PreprocessRecord 4 dict put    copy /NewCategory exch def  } ifelse   % Provide the 'or' logic for PreprocessRecord,  % to allow different record types to be mixed in a single map file.  % We do this with building a dictionary of PreprocessRecord procedures,  % which come from different calls to Redefine :  NewCategory /.PreprocessRecord get dup length % <<pr>> l    currentdict /PreprocessRecord get .growput   currentdict /MapFileName known {    MapFileName .libfile {      1 dict begin      /; {} def      mark exch cvx exec .dicttomark           % <<map>>      end      dup VerifyMap                            % <<map>>    } {      QUIET not {        currentdict /IsMapFileOptional .knownget not { false } if not {          (Warning: the map file ) print dup =string cvs print ( was not found.) =        } if      } if      pop 0 dict                               % <<map>>    } ifelse  } {    currentdict /.map .knownget not {       0 dict                                   % <<map>>    } if  } ifelse   % Preprocess entries :  dup NewCategory /.PreprocessRecord get       % <<map>> <<map>> <<pr>>  3 1 roll {                                   % <<pr>> <<map>> /Name raw_record    false 3 1 roll                             % <<pr>> <<map>> false /Name raw_record     4 index {                                  % <<pr>> <<map>> false /Name raw_record i {pr}      exch pop                                 % <<pr>> <<map>> false /Name raw_record {pr}      exec {                                   % <<pr>> <<map>> false /Name record        3 -1 roll pop true 3 1 roll            % <<pr>> <<map>> true /Name record        exit      } if                                     % <<pr>> <<map>> false /Name raw_record    } forall    3 2 roll {                                 % <<pr>> <<map>> /Name record      2 index 3 1 roll put                     % <<pr>> <<map>>    } {      exch                                     % <<pr>> <<map>> raw_record /Name      (Incorrect record ) print =string cvs print ( of the map file ) print MapFileName =string cvs print (.) =      end % Pops OptionsDict from dstack.      pop pop pop                              %      /Redefine cvx /undefinedresource signalerror    } ifelse  } forall                                     % <<pr>> <<map>>  exch pop                                     % <<map>>    % Add the map :  OldCategory /.IsRedefinedWithMap known {     % <<map>>    % Just add to the old map :    OldCategory /.map get copy pop             %  } {                                          % <<map>>    % Store the map to both the category and OptionsDict :    dup NewCategory exch /.map exch put    /.map exch def                             %  } ifelse  OldCategory /.IsRedefinedWithMap known not {    % Copy old methods to OptionsDict :    [ /DefineResource /ResourceStatus /ResourceFileName       /FindResource /ResourceForAll    ] {      dup OldCategory exch get def    } forall

Lines 1–500 of 522. Load more