Subversion Repositories planix.SVN

%    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 .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 <proc> to write to the underlying dictionary,

  % and put it back after the enumeration is completed.

  end

  { 

      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 def

setpacking

/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 { 

    } 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

    % 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