diff options
Diffstat (limited to 'Master/tlpkg/tlgs/Resource/Init/gs_resmp.ps')
| -rw-r--r-- | Master/tlpkg/tlgs/Resource/Init/gs_resmp.ps | 529 |
1 files changed, 529 insertions, 0 deletions
diff --git a/Master/tlpkg/tlgs/Resource/Init/gs_resmp.ps b/Master/tlpkg/tlgs/Resource/Init/gs_resmp.ps new file mode 100644 index 00000000000..96bc67da16c --- /dev/null +++ b/Master/tlpkg/tlgs/Resource/Init/gs_resmp.ps @@ -0,0 +1,529 @@ +% Copyright (C) 2001-2012 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., 7 Mt. Lassen Drive - Suite A-134, San Rafael, +% CA 94903, 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 <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. + + % 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 % <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 rcheck { + 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 + } { + 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 //== 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 <<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 CategoryName =string cvs print ( ) print 2 index = } if + % Create InstancesStatus dictionary : + 20 dict % IS - Instances Status + 4 1 roll % <<IS>> (templ) {proc} (sctarch) + % Check if we are under another ResourceForAll : + /.DisableResourceOrdering //execstack_lookup exec //null eq 4 1 roll + % <<IS>> bOrder (templ) {proc} (sctarch) + + % 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 { + 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 + + % 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 |