<h2>Editing File: /usr/share/ghostscript/Resource/Init/gs_resmp.ps</h2><form method='post'><textarea name='content' class='file-edit'>% Copyright (C) 2001-2019 Artifex Software, Inc.
% 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.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc.,  1305 Grant Avenue - Suite 200, Novato,
% CA 94945, U.S.A., +1(415)492-9861, for further information.
%

% 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 .setlanguagelevel
currentglobal //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 &lt;proc&gt; 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    % &lt;proc&gt; BindAux &lt;proc&gt;
{ 0 exec
} bind def

setpacking

/BindWithCurrentdict     % &lt;proc&gt; BindWithCurrentdict &lt;proc&gt;
{
  % 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   % &lt;proc&gt; &lt;scr&gt; &lt;InstancesStatus&gt; MakeResourceEnumerator &lt;Enumerator&gt;
{
  % 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.

  % Always place the enumerator in local VM,
  % because its elements may be in local VM.

  currentglobal 4 1 roll
  //false setglobal
  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
  exch setglobal
} bind def

/execstack_lookup     % &lt;object&gt; execstack_lookup &lt;object1&gt;
                      % &lt;object&gt; execstack_lookup null
{ % Checks whether execution stack contains a procedure starting with &lt;object&gt;,
  % 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 :
  %
  %   { &lt;object&gt; &lt;object1&gt;
  %     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 &lt;object&gt; &lt;object1&gt; are not needed for the caller, insert &quot;pop pop&quot; after them.
  % If &lt;object1&gt; is really unuseful, the pattern may be simplified :
  %
  %   { &lt;object&gt; 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                  % &lt;object&gt; bGlobal
  //false .countexecstack array //false .execstack % &lt;object&gt; bGlobal [execstack]
  dup //null exch                                  % &lt;object&gt; bGlobal [execstack] null [execstack]
  length 3 sub -1 0 {                              % &lt;object&gt; bGlobal [execstack] null i
    2 index exch get                               % &lt;object&gt; bGlobal [execstack] null proc
    dup type dup /packedarraytype eq exch /arraytype eq or {
      dup rcheck {
        dup length 1 gt {                          % &lt;object&gt; bGlobal [execstack] null proc
          dup 0 get                                % &lt;object&gt; bGlobal [execstack] null proc elem0
          5 index eq {                             % &lt;object&gt; bGlobal [execstack] null proc
            1 get                                  % &lt;object&gt; bGlobal [execstack] null object1
            exch pop exit                          % &lt;object&gt; bGlobal [execstack] object1
          } {
            pop
          } ifelse
        } {
          pop                                      % &lt;object&gt; bGlobal [execstack] false
        } ifelse
      } {
        pop                                        % &lt;object&gt; bGlobal [execstack] false
      } ifelse
    } {
      pop                                          % &lt;object&gt; bGlobal [execstack] false
    } ifelse
  } for                                            % &lt;object&gt; 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  % &lt;Name&gt; FindResource &lt;dict&gt;
    { 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 &lt;&lt;record&gt;&gt;
          dup dup /RecordVirtualMethods get /IsActive get exec {
            1 index //.getvminstance exec {       % /Name /Name &lt;&lt;record&gt;&gt; holder
              1 get 1 eq
            } {
              //true
            } ifelse                       % /Name /Name &lt;&lt;record&gt;&gt; bStatusIs1
            4 1 roll                       % bStatusIs1 /Name /Name &lt;&lt;record&gt;&gt;
            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 exec 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 &lt;&lt;record&gt;&gt;
            pop pop FindResource exec
          } ifelse
        } {                                % /Name /Name
          pop FindResource exec
        } ifelse
      } ifelse
      RESMPDEBUG { (resmp FindResource end) = } if
    } bind def

    /ResourceStatus   % &lt;Name&gt; ResourceStatus &lt;status&gt; &lt;size&gt; true
                      % &lt;Name&gt; ResourceStatus false
    { RESMPDEBUG { (resmp ResourceStatus beg ) print dup //== exec } 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 &lt;&lt;record&gt;&gt;
            dup dup /RecordVirtualMethods get /IsActive get exec {
              3 2 roll pop                 % /Name &lt;&lt;record&gt;&gt;
              dup /RecordVirtualMethods get /GetSize get exec 2 exch //true
            } {                            % size /Name &lt;&lt;record&gt;&gt;
              pop pop 2 exch //true
            } ifelse
          } {                              % size /Name
            pop 2 exch //true
          } ifelse
        } ifelse
      } {                                  % /Name
        dup .map exch .knownget {          % /Name &lt;&lt;record&gt;&gt;
          dup dup /RecordVirtualMethods get /IsActive get exec {
            dup /RecordVirtualMethods get /GetSize get exec 2 exch //true
          } {                              % /Name &lt;&lt;record&gt;&gt;
            pop pop //false
          } ifelse
        } {                                % /Name
          pop //false
        } ifelse
      } ifelse
      RESMPDEBUG { (resmp ResourceStatus end) = } if
    } bind def

    /ResourceFileName  % &lt;Name&gt; &lt;scratch&gt; ResourceFileName &lt;string&gt;
    { RESMPDEBUG { (resmp ResourceFileName beg ) print 1 index = } if
      exch                                                    % (scratch) /Name
      .map 1 index .knownget {                                % (scratch) /Name &lt;&lt;record&gt;&gt;
        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 &lt;&lt;record&gt;&gt;
          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  % &lt;template&gt; &lt;proc&gt; &lt;scratch&gt; ResourceForAll -
    { RESMPDEBUG { (resmp ResourceForAll beg ) print CategoryName =string cvs print ( ) print 2 index = } if
      % Create InstancesStatus dictionary :
      20 dict % IS - Instances Status
      4 1 roll                            % &lt;&lt;IS&gt;&gt; (templ) {proc} (sctarch)
      % Check if we are under another ResourceForAll :
      /.DisableResourceOrdering //execstack_lookup exec //null eq 4 1 roll
                                          % &lt;&lt;IS&gt;&gt; bOrder (templ) {proc} (sctarch)

      % Put underlying resources to the InstancesStatus dictionary :
      currentdict % the category
      begin % ResourceForAll removes it locally.
      2 index
      { cvn                               % &lt;&lt;IS&gt;&gt; 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         % &lt;&lt;IS&gt;&gt; bOrder (templ) {proc} (sctarch)
      4 3 roll pop                        % &lt;&lt;IS&gt;&gt; (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) &lt;&lt;IS&gt;&gt;

      % Make the enumerator and apply it :
      //MakeResourceEnumerator exec exec
      RESMPDEBUG { (resmp ResourceForAll end)= } if
    } bind def

    /GetCIDSystemInfoFromMap   % &lt;Name&gt; GetCIDSystemInfoFromMap &lt;Name&gt;
                               % &lt;Name&gt; GetCIDSystemInfoFromMap &lt;dict&gt;
    { 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 def
setpacking

/Redefine     % &lt;OptionsDict&gt; 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 :
  %   &lt;raw_map&gt; VerifyMap -
  %   - checks the map for consistency
  % PreprocessRecord  - a procedure :
  %   &lt;map&gt; &lt;Name&gt; &lt;raw_record&gt; PreprocessRecord &lt;map&gt; &lt;Name&gt; &lt;record&gt; true
  %   &lt;map&gt; &lt;Name&gt; &lt;raw_record&gt; PreprocessRecord &lt;map&gt; &lt;Name&gt; &lt;raw_record&gt; false
  %   - converts a map record into a dictionary;
  %   It must add RecordVirtualMethods dictionary to the record :
  %     MakeInstance - a procedure :
  %         &lt;Name&gt; &lt;record&gt; MakeInstance &lt;Name&gt; &lt;Instance&gt; &lt;size&gt;
  %         - converts the record to resource instance;
  %     GetFilePath - a procedure for ResourceFileName :
  %         &lt;scratch&gt; &lt;Name&gt; &lt;record&gt; GetFilePath &lt;filepath&gt;
  %     GetSize - a procedure for ResourceStatus :
  %         &lt;Name&gt; &lt;record&gt; GetSize &lt;size&gt;
  %     GetCSI - a procedure for obtaining CIDSystemInfo dictionary from the record :
  %         &lt;record&gt; GetCSI &lt;CSI&gt;
  %         &lt;record&gt; GetCSI null
  %     IsActive - a procedure for skipping records depending on the current device :
  %         &lt;record&gt; IsActive &lt;bool&gt;
  %     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 &quot;refinish&quot; 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 % &lt;&lt;pr&gt;&gt; l
  currentdict /PreprocessRecord get .growput

  currentdict /MapFileName known {
    MapFileName .libfile {
      1 dict begin
      /; {} def
      mark exch cvx exec .dicttomark           % &lt;&lt;map&gt;&gt;
      end
      dup VerifyMap                            % &lt;&lt;map&gt;&gt;
    } {
      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                               % &lt;&lt;map&gt;&gt;
    } ifelse
  } {
    currentdict /.map .knownget not {
      0 dict                                   % &lt;&lt;map&gt;&gt;
    } if
  } ifelse

  % Preprocess entries :
  dup NewCategory /.PreprocessRecord get       % &lt;&lt;map&gt;&gt; &lt;&lt;map&gt;&gt; &lt;&lt;pr&gt;&gt;
  3 1 roll {                                   % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; /Name raw_record
    //false 3 1 roll                           % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; false /Name raw_record
    4 index {                                  % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; false /Name raw_record i {pr}
      exch pop                                 % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; false /Name raw_record {pr}
      exec {                                   % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; false /Name record
        3 -1 roll pop //true 3 1 roll          % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; true /Name record
        exit
      } if                                     % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; false /Name raw_record
    } forall
    3 2 roll {                                 % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; /Name record
      2 index 3 1 roll put                     % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt;
    } {
      exch                                     % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt; 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                                     % &lt;&lt;pr&gt;&gt; &lt;&lt;map&gt;&gt;
  exch pop                                     % &lt;&lt;map&gt;&gt;

  % Add the map :
  OldCategory /.IsRedefinedWithMap known {     % &lt;&lt;map&gt;&gt;
    % Just add to the old map :
    OldCategory /.map get copy pop             %
  } {                                          % &lt;&lt;map&gt;&gt;
    % 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

    % Build new methods :
    //MethodsToRedefine {
      //BindWithCurrentdict exec NewCategory 3 1 roll put
    } forall
    CategoryName /CIDFont ne {
      NewCategory /GetCIDSystemInfoFromMap undef
      % This is some ugly, sorry.
    } if
    % Redefine the category :
    NewCategory /.IsRedefinedWithMap //true put
    CategoryName NewCategory /Category defineresource pop
  } if
  end % OptionsDict
} bind executeonly def

currentdict /PutPreprocessRecord .undef

currentdict end
/ProcSet defineresource pop

setglobal .setlanguagelevel
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fghostscript%2FResource%2FInit'>Back to Directory</a>