522 lines
22 KiB
PostScript
522 lines
22 KiB
PostScript
% 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
|
|
{
|
|
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 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
|