summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlgs/lib/gs_res.ps
diff options
context:
space:
mode:
Diffstat (limited to 'Master/tlpkg/tlgs/lib/gs_res.ps')
-rw-r--r--Master/tlpkg/tlgs/lib/gs_res.ps1119
1 files changed, 1119 insertions, 0 deletions
diff --git a/Master/tlpkg/tlgs/lib/gs_res.ps b/Master/tlpkg/tlgs/lib/gs_res.ps
new file mode 100644
index 00000000000..5ad6e404f09
--- /dev/null
+++ b/Master/tlpkg/tlgs/lib/gs_res.ps
@@ -0,0 +1,1119 @@
+% Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises. 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_res.ps 7724 2007-02-20 23:54:19Z alexcher $
+% Initialization file for Level 2 resource machinery.
+% When this is run, systemdict is still writable,
+% but (almost) everything defined here goes into level2dict.
+
+level2dict begin
+
+(BEGIN RESOURCES) VMDEBUG
+
+% We keep track of (global) instances with another entry in the resource
+% dictionary, an .Instances dictionary. For categories with implicit
+% instances, the values in .Instances are the same as the keys;
+% for other categories, the values are [instance status size].
+
+% Note that the dictionary that defines a resource category is stored
+% in global VM. The PostScript manual says that each category must
+% manage global and local instances separately. However, objects in
+% global VM other than systemdict can't reference objects in local VM.
+% This means that the resource category dictionary, which would otherwise be
+% the obvious place to keep track of the instances, can't be used to keep
+% track of local instances. Instead, we define a dictionary in local VM
+% called localinstancedict, in which the key is the category name and
+% the value is the analogue of .Instances for local instances.
+
+% We don't currently implement automatic resource unloading.
+% When and if we do, it should be hooked to the garbage collector.
+% However, Ed Taft of Adobe says their interpreters don't implement this
+% either, so we aren't going to worry about it for a while.
+
+currentglobal false setglobal systemdict begin
+ /localinstancedict 5 dict
+ .forcedef % localinstancedict is local, systemdict is global
+end true setglobal
+/.emptydict 0 dict readonly def
+setglobal
+
+% Resource category dictionaries have the following keys (those marked with
+% * are optional):
+% Standard, defined in the Red Book:
+% Category (name)
+% *InstanceType (name)
+% DefineResource
+% <key> <instance> DefineResource <instance>
+% UndefineResource
+% <key> UndefineResource -
+% FindResource
+% <key> FindResource <instance>
+% ResourceStatus
+% <key> ResourceStatus <status> <size> true
+% <key> ResourceStatus false
+% ResourceForAll
+% <template> <proc> <scratch> ResourceForAll -
+% *ResourceFileName
+% <key> <scratch> ResourceFileName <filename>
+% Additional, specific to our implementation:
+% .Instances (dictionary)
+% .LocalInstances
+% - .LocalInstances <dict>
+% .GetInstance
+% <key> .GetInstance <instance> -true-
+% <key> .GetInstance -false-
+% .CheckResource
+% <key> <value> .CheckResource <key> <value> <ok>
+% (or may give an error if not OK)
+% .DoLoadResource
+% <key> .DoLoadResource <key> (may give an error)
+% .LoadResource
+% <key> .LoadResource - (may give an error)
+% .ResourceFile
+% <key> .ResourceFile <file> -true-
+% <key> .ResourceFile <key> -false-
+% .ResourceFileStatus
+% <key> .ResourceFileStatus 2 <vmusage> -true-
+% <key> .ResourceFileStatus -false-
+% All the above procedures expect that the top dictionary on the d-stack
+% is the resource dictionary.
+
+% Define enough of the Category category so we can define other categories.
+% The dictionary we're about to create will become the Category
+% category definition dictionary.
+
+% .findcategory and .resourceexec are only called from within the
+% implementation of the resource 'operators', so they don't have to worry
+% about cleaning up the stack if they fail (the interpreter's stack
+% protection machinery for pseudo-operators takes care of this).
+% Note that all places that look up categories must use .findcategory
+% so that the command in case of error will be correct rather than an
+% internal invocation of findresource.
+/.findcategory { % <name> .findcategory -
+ % (pushes the category on the dstack)
+ /Category .findresource begin % note: *not* findresource
+} bind def
+
+% If an error occurs within the logic of a resource operator (after operand
+% acquisition and checking), the Adobe interpreters report the operator name,
+% not the operator object, as the command in $error. For this reason, and
+% this reason only, all resource operators must wrap their logic code in
+% /<opername> cvx { ...logic... } .errorexec
+
+% The Category resource signals /undefined rather than /undefinedresource,
+% both when referenced implicitly (to look up the category for a general
+% resource operation) and when it is accessed directly (/Category /xxx
+% findresource). Because of this, all resource operators must use
+% .undefinedresource rather than signalling undefinedresource directly.
+/.undefinedresource { % <command> .undefinedresource -
+ /Category dup load eq { /undefined } { /undefinedresource } ifelse
+ signaloperror
+} bind def
+
+/.resourceexec { % <key> /xxxResource .resourceexec -
+ % (also pops the category from the dstack)
+ load exec end
+} bind def
+
+% .getvminstance treats instances on disk as undefined.
+/.getvminstance { % <key> .getvminstance <instance> -true-
+ % <key> .getvminstance -false-
+ .GetInstance {
+ dup 1 get 2 ne { true } { pop false } ifelse
+ } {
+ false
+ } ifelse
+} bind def
+
+20 dict begin
+
+ % Standard entries
+
+/Category /Category def
+/InstanceType /dicttype def
+
+/DefineResource {
+ .CheckResource {
+ dup /Category 3 index cvlit .growput
+ dup [ exch 0 -1 ] exch
+ .Instances 4 2 roll put
+ % Make the Category dictionary read-only. We will have to
+ % use .forceput / .forcedef later to replace the dummy,
+ % empty .Instances dictionary with the real one later.
+ readonly
+ } {
+ /defineresource cvx /typecheck signaloperror
+ } ifelse
+} bind def
+/FindResource % (redefined below)
+ { .Instances exch get 0 get
+ } bind def
+
+ % Additional entries
+
+/.Instances 30 dict def
+.Instances /Category [currentdict 0 -1] put
+
+/.LocalInstances 0 dict def
+/.GetInstance
+ { .Instances exch .knownget
+ } bind def
+/.CheckResource
+ { dup gcheck currentglobal and
+ { /DefineResource /FindResource /ResourceForAll /ResourceStatus
+ /UndefineResource }
+ { 2 index exch known and }
+ forall
+ not { /defineresource cvx /invalidaccess signaloperror } if
+ true
+ } bind def
+
+.Instances end begin % for the base case of findresource
+
+(END CATEGORY) VMDEBUG
+
+% Define the resource operators. We use the "stack protection" feature of
+% odef to make sure the stacks are restored properly on an error.
+% This requires that the operators not pop anything from the stack until
+% they have executed their logic successfully. We can't make this
+% work for resourceforall, because the procedure it executes mustn't see
+% the operands of resourceforall on the stack, but we can make it work for
+% the others.
+
+% findresource is the only operator that needs to bind //Category.
+% We define its contents as a separate procedure so that .findcategory
+% can use it without entering another level of pseudo-operator.
+/.findresource { % <key> <category> findresource <instance>
+ 2 copy dup /Category eq
+ { pop //Category 0 get begin } { .findcategory } ifelse
+ /FindResource .resourceexec exch pop exch pop
+} bind
+end % .Instances of Category
+def
+/findresource {
+ % See above re .errorexec.
+ 1 .argindex % also catch stackunderflow
+ dup type /stringtype eq { cvn } if % for CET 23-13-04
+ 3 1 roll exch pop
+ dup type /nametype ne {
+ /findresource .systemvar /typecheck signalerror
+ } if
+ /findresource cvx //.findresource .errorexec
+} odef
+
+/defineresource { % <key> <instance> <category> defineresource <instance>
+ 2 .argindex 2 index 2 index % catch stackunderflow
+ % See above re .errorexec.
+ /defineresource cvx {
+ .findcategory
+ currentdict /InstanceType known {
+ dup type InstanceType ne {
+ dup type /packedarraytype eq InstanceType /arraytype eq and
+ not { /defineresource cvx /typecheck signaloperror } if
+ } if
+ } if
+ /DefineResource .resourceexec
+ 4 1 roll pop pop pop
+ } .errorexec
+} bind odef
+% We must prevent resourceforall from automatically restoring the stacks,
+% because we don't want the stacks restored if proc causes an error or
+% executes a 'stop'. On the other hand, resourceforall is defined in the
+% PLRM as an operator, so it must have type /operatortype. We hack this
+% by taking advantage of the fact that the interpreter optimizes tail
+% calls, so stack protection doesn't apply to the very last token of an
+% operator procedure.
+/resourceforall1 { % <template> <proc> <scratch> <category> resourceforall1 -
+ dup .findcategory
+ /ResourceForAll load
+ % Stack: <template> <proc> <scratch> <category> proc
+ exch pop % pop the category
+ exec end
+} bind def
+/resourceforall { % <template> <proc> <scratch> <category> resourceforall1 -
+ //resourceforall1 exec % see above
+} bind odef
+/resourcestatus { % <key> <category> resourcestatus <status> <size> true
+ % <key> <category> resourcestatus false
+ {
+ 0 .argindex type /nametype ne {
+ % CET 23-26 wants typecheck here, not undefineresource that happens
+ % without the check.
+ /resourcestatus cvx /typecheck signalerror
+ } if
+ 2 copy .findcategory /ResourceStatus .resourceexec
+ { 4 2 roll pop pop true } { pop pop false } ifelse
+ } stopped {
+ % Although resourcestatus is an operator, Adobe uses executable name
+ % for error reporting. CET 23-26
+ /resourcestatus cvx $error /errorname get signalerror
+ } if
+} bind odef
+/undefineresource { % <key> <category> undefineresource -
+ 0 .argindex type /nametype ne {
+ /undefinedresource cvx /typecheck signaloperror
+ } if
+ 1 .argindex 1 index % catch stackunderflow
+
+ { .findcategory /UndefineResource .resourceexec pop pop
+ } stopped {
+ % Although undefineresource is an operator, Adobe uses executable name
+ % here but uses operator for the errors above. CET 23-33
+ /undefineresource cvx $error /errorname get signalerror
+ } if
+} bind odef
+
+% Define the system parameters used for the Generic implementation of
+% ResourceFileName.
+systemdict begin
+
+% - .default_resource_dir <string>
+/.default_resource_dir {
+ .file_name_parent .file_name_directory_separator concatstrings
+ (Resource) concatstrings
+ /LIBPATH .systemvar {
+ dup .file_name_current eq {
+ pop
+ } {
+ 1 index false .file_name_combine {
+ exch pop exit
+ } {
+ pop pop
+ } ifelse
+ } ifelse
+ } forall
+} bind def
+
+% <path> <name> <string> .resource_dir_name <path> <name> <string>
+/.resource_dir_name
+{ systemdict 2 index .knownget {
+ exch pop
+ systemdict 1 index undef
+ } {
+ dup () ne {
+ .file_name_directory_separator concatstrings
+ } if
+ 2 index exch false .file_name_combine not {
+ (Error: .default_resource_dir returned ) print exch print ( that can't combine with ) print =
+ /.default_resource_dir cvx /configurationerror signalerror
+ } if
+ } ifelse
+} bind def
+
+currentdict /pssystemparams known not {
+ /pssystemparams 10 dict readonly def
+} if
+pssystemparams begin
+ .default_resource_dir
+ /FontResourceDir (Font) .resource_dir_name
+ readonly .forcedef % pssys'params is r-o
+ /GenericResourceDir () .resource_dir_name
+ readonly .forcedef % pssys'params is r-o
+ pop % .default_resource_dir
+ /GenericResourcePathSep
+ .file_name_separator readonly .forcedef % pssys'params is r-o
+ (%diskFontResourceDir) cvn (/Resource/Font/) readonly .forcedef % pssys'params is r-o
+ (%diskGenericResourceDir) cvn (/Resource/) readonly .forcedef % pssys'params is r-o
+end
+end
+
+% Check if GenericResourceDir presents in LIBPATH.
+
+% The value of GenericResourceDir must end with directory separator.
+% We use .file_name_combine to check it.
+% Comments use OpenVMS syntax, because it is the most complicated case.
+(x) pssystemparams /GenericResourcePathSep get
+(y) concatstrings concatstrings dup length % (x]y) l1
+pssystemparams /GenericResourceDir get dup length exch % (x]y) l1 l2 (dir)
+3 index true .file_name_combine not {
+ exch
+ (File name ) print print ( cant combine with ) print =
+ /GenericResourceDir cvx /configurationerror signaloperror
+} if
+dup length % (x]y) l1 l2 (dir.x]y) l
+4 2 roll add % (x]y) (dir.x]y) l ll
+ne {
+ (GenericResourceDir value does not end with directory separator.\n) =
+ /GenericResourceDir cvx /configurationerror signaloperror
+} if
+pop pop
+
+% Define the generic algorithm for computing resource file names.
+/.rfnstring 8192 string def
+/.genericrfn % <key> <scratch> <prefix> .genericrfn <filename>
+ { 3 -1 roll //.rfnstring cvs concatstrings exch copy
+ } bind def
+
+% Define the Generic category.
+
+/Generic mark
+
+ % Standard entries
+
+% We're still running in Level 1 mode, so dictionaries won't expand.
+% Leave room for the /Category entry.
+/Category null
+
+% Implement the body of Generic resourceforall for local, global, and
+% external cases. 'args' is [template proc scratch resdict].
+/.enumerateresource { % <key> [- <proc> <scratch>] .enumerateresource -
+ 1 index type dup /stringtype eq exch /nametype eq or {
+ exch 1 index 2 get cvs exch
+ } if
+ % Use .setstackprotect to prevent the stacks from being restored if
+ % an error occurs during execution of proc.
+ 1 get false .setstackprotect exec true .setstackprotect
+} bind def
+/.localresourceforall { % <key> <value> <args> .localr'forall -
+ exch pop
+ 2 copy 0 get .stringmatch { .enumerateresource } { pop pop } ifelse
+} bind def
+/.globalresourceforall { % <key> <value> <args> .globalr'forall -
+ exch pop
+ 2 copy 0 get .stringmatch {
+ dup 3 get begin .LocalInstances end 2 index known not {
+ .enumerateresource
+ } {
+ pop pop
+ } ifelse
+ } {
+ pop pop
+ } ifelse
+} bind def
+/.externalresourceforall { % <filename> <len> <args> .externalr'forall -
+ 3 1 roll 1 index length 1 index sub getinterval exch
+ dup 3 get begin .Instances .LocalInstances end
+ % Stack: key args insts localinsts
+ 3 index known {
+ pop pop pop
+ } {
+ 2 index known { pop pop } { .enumerateresource } ifelse
+ } ifelse
+} bind def
+
+/DefineResource {
+ .CheckResource
+ { dup [ exch 0 -1 ]
+ % Stack: key value instance
+ currentglobal
+ { false setglobal 2 index UndefineResource % remove local def if any
+ true setglobal
+ .Instances dup //.emptydict eq {
+ pop 3 dict
+ % As noted above, Category dictionaries are read-only,
+ % so we have to use .forcedef here.
+ /.Instances 1 index .forcedef % Category dict is read-only
+ } if
+ }
+ { .LocalInstances dup //.emptydict eq
+ { pop 3 dict localinstancedict Category 2 index put
+ }
+ if
+ }
+ ifelse
+ % Stack: key value instance instancedict
+ 3 index 2 index .growput
+ % Now make the resource value read-only.
+ 0 2 copy get { readonly } .internalstopped pop
+ dup 4 1 roll put exch pop exch pop
+ }
+ { /defineresource cvx /typecheck signaloperror
+ }
+ ifelse
+} .bind executeonly % executeonly to prevent access to .forcedef
+/UndefineResource
+ { { dup 2 index .knownget
+ { dup 1 get 1 ge
+ { dup 0 null put 1 2 put pop pop }
+ { pop exch .undef }
+ ifelse
+ }
+ { pop pop
+ }
+ ifelse
+ }
+ currentglobal
+ { 2 copy .Instances exch exec
+ }
+ if .LocalInstances exch exec
+ } bind
+% Because of some badly designed code in Adobe's CID font downloader that
+% makes findresource and resourcestatus deliberately inconsistent with each
+% other, the default FindResource must not call ResourceStatus if there is
+% an instance of the desired name already defined in VM.
+/FindResource {
+ dup //null eq {
+ % CET 13-06 wants /typecheck for "null findencoding" but
+ % .knownget doesn't fail on null
+ /findresource cvx /typecheck signaloperror
+ } if
+ dup .getvminstance {
+ exch pop 0 get
+ } {
+ dup ResourceStatus {
+ pop 1 gt {
+ .DoLoadResource .getvminstance not {
+ /findresource cvx .undefinedresource
+ } if 0 get
+ } {
+ .GetInstance pop 0 get
+ } ifelse
+ } {
+ /findresource cvx .undefinedresource
+ } ifelse
+ } ifelse
+} bind
+% Because of some badly designed code in Adobe's CID font downloader, the
+% definition of ResourceStatus for Generic and Font must be the same (!).
+% We patch around this by using an intermediate .ResourceFileStatus procedure.
+/ResourceStatus {
+ dup .GetInstance {
+ exch pop dup 1 get exch 2 get true
+ } {
+ .ResourceFileStatus
+ } ifelse
+} bind
+/.ResourceFileStatus {
+ .ResourceFile { closefile 2 -1 true } { pop false } ifelse
+} bind
+/ResourceForAll {
+ % Construct a new procedure to hold the arguments.
+ % All objects constructed here must be in local VM to avoid
+ % a possible invalidaccess.
+ currentdict 4 .localvmpackedarray % [template proc scratch resdict]
+ % We must pop the resource dictionary off the dict stack
+ % when doing the actual iteration, and restore it afterwards.
+ .currentglobal not {
+ .LocalInstances length 0 ne {
+ % We must do local instances, and do them first.
+ //.localresourceforall {exec} 0 get 3 .localvmpackedarray cvx
+ .LocalInstances exch {forall} 0 get 1 index 0 get
+ currentdict end 3 .execn begin
+ } if
+ } if
+ % Do global instances next.
+ //.globalresourceforall {exec} 0 get 3 .localvmpackedarray cvx
+ .Instances exch cvx {forall} 0 get 1 index 0 get
+ currentdict end 3 .execn begin
+ mark % args [
+ Category .namestring .file_name_separator concatstrings
+ 2 index 0 get % args [ (c/) (t)
+ dup length 3 1 roll % args [ l (c/) (t)
+ concatstrings % args [ l (c/t)
+ [
+ true /LIBPATH .systemvar 3 index
+ .generate_dir_list_templates_with_length % args (t) [ l [(pt) Lp ...]
+ % also add on the Resources as specified by the GenericResourceDir
+ true [ currentsystemparams /GenericResourceDir get]
+ counttomark 1 add index .generate_dir_list_templates_with_length
+ % Resource files on OpenVMS require a separate template (gs:[dir.*]*)
+ true [ currentsystemparams /GenericResourceDir get]
+ counttomark 1 add index .file_name_separator (*)
+ concatstrings concatstrings .generate_dir_list_templates_with_length
+ ] exch pop
+ dup length 1 sub 0 exch 2 exch { % args [ l [] i
+ 2 copy get % args [ l [] i (pt)
+ exch 2 index exch 1 add get % args [ l [] (pt) Lp
+ exch % args [ l [] Lp (pt)
+
+ { % args [ l [] Lp (pf)
+ dup length % args [ l [] Lp (pf) Lpf
+ 2 index sub % args [ l [] Lp (pf) Lf
+ 2 index exch % args [ l [] Lp (pf) Lp Lf
+ getinterval cvn dup % args [ l [] Lp /n /n
+ 5 2 roll % args [ /n /n l [] Lp
+ } //.rfnstring filenameforall
+ pop % args [ /n1 /n1 ... /nN /nN l []
+ } for % args [ /n1 /n1 ... /nN /nN l []
+ pop pop
+ .dicttomark % An easy way to exclude duplicates. % args <</n/n>>
+ % {
+ { pop } 0 get
+ 2 index 2 get { cvs 0 } aload pop 5 index
+ //.externalresourceforall {exec} 0 get
+ % }
+ 7 .localvmpackedarray cvx
+ 3 2 roll pop % args
+ { forall } 0 get
+ currentdict end 2 .execn begin
+} bind
+/.file_name_is_iodevice_or_absolute
+{ {
+ dup length 0 gt {
+ dup 0 get (%) 0 get eq {
+ pop true exit
+ } if
+ } if
+ .file_name_is_absolute exit
+ } loop
+} bind def
+/ResourceFileName
+ { % /in (scr)
+ exch //.rfnstring cvs % (scr) (n)
+ /GenericResourcePathSep getsystemparam exch % (scr) (/) (n)
+ Category .namestring % (scr) (/) (n) (c)
+ 3 1 roll % (scr) (c) (/) (n)
+ concatstrings concatstrings % (scr) (c/n)
+ /GenericResourceDir getsystemparam //.file_name_is_iodevice_or_absolute exec not {
+ /GenericResourceDir getsystemparam exch concatstrings
+ findlibfile
+ { % (scr) (p/c/n) file
+ pop exch copy true % (p/c/n) true
+ } { % (scr) (c/n)
+ false % (scr) (c/n) false
+ } ifelse
+ } { % (scr) (c/n)
+ false % (scr) (c/n) false
+ } ifelse
+ not { % (scr) (c/n)
+ /GenericResourceDir getsystemparam % (scr) (c/n) (d/)
+ dup length exch % (scr) (c/n) Ld (d/)
+ 3 index copy pop % (scr') (c/n) Ld
+ 1 index length % (scr') (c/n) Ld Lcn
+ 3 index 3 copy pop % (scr') (c/n) Ld Lcn (scr') Ld Lcn
+ getinterval % (scr') (c/n) Ld Lcn (scr[Ld:Lcn])
+ 4 3 roll exch % (scr') Ld Lcn (c/n) (scr[Ld:Lcn])
+ copy pop % (scr'') Ld Lcn
+ add 0 exch getinterval % (scr''[0:Ld+Lcn])
+ } if
+ } bind
+
+ % Additional entries
+
+% Unfortunately, we can't create the real .Instances dictionary now,
+% because if someone copies the Generic category (which pp. 95-96 of the
+% 2nd Edition Red Book says is legitimate), they'll wind up sharing
+% the .Instances. Instead, we have to create .Instances on demand,
+% just like the entry in localinstancedict.
+% We also have to prevent anyone from creating instances of Generic itself.
+/.Instances //.emptydict
+
+/.LocalInstances
+ { localinstancedict Category .knownget not { //.emptydict } if
+ } bind
+/.GetInstance
+ { currentglobal
+ { .Instances exch .knownget }
+ { .LocalInstances 1 index .knownget
+ { exch pop true }
+ { .Instances exch .knownget }
+ ifelse
+ }
+ ifelse
+ } bind
+/.CheckResource
+ { true
+ } bind
+/.vmused {
+ % - .vmused <usedvalue>
+ % usedvalue = vmstatus in global + vmstatus in local.
+ 0 2 {
+ .currentglobal not .setglobal
+ vmstatus pop exch pop add
+ } repeat
+} bind def
+/.DoLoadResource {
+ % .LoadResource may push entries on the operand stack.
+ % It is an undocumented feature of Adobe implementations,
+ % which we must match for the sake of some badly written
+ % font downloading code, that such entries are popped
+ % automatically.
+ count 1 index cvlit .vmused
+ % Stack: key count litkey memused
+ {.LoadResource} 4 1 roll 4 .execn
+ % Stack: ... count key memused
+ .vmused exch sub
+ 1 index .getvminstance not {
+ pop dup .undefinedresource % didn't load
+ } if
+ dup 1 1 put
+ 2 3 -1 roll put
+ % Stack: ... count key
+ exch count 1 sub exch sub {exch pop} repeat
+} bind
+/.LoadResource
+ { dup .ResourceFile
+ { exch pop currentglobal
+ { .runresource }
+ { true setglobal { .runresource } stopped false setglobal { stop } if }
+ ifelse
+ }
+ { dup .undefinedresource
+ }
+ ifelse
+ } bind
+/.ResourceFile
+ {
+ Category //.rfnstring cvs length % key l
+ dup //.rfnstring dup length 2 index sub % key l l (buf) L-l
+ 3 2 roll exch getinterval % key l ()
+ .file_name_directory_separator exch copy length add % key l1
+ dup //.rfnstring dup length 2 index sub % key l1 l1 (buf) L-l
+ 3 2 roll exch getinterval % key l1 ()
+ 2 index exch cvs length add % key l2
+ //.rfnstring exch 0 exch getinterval % key (relative_path)
+ .libfile {
+ exch pop true
+ } {
+ pop
+ currentdict /ResourceFileName known {
+ mark 1 index //.rfnstring { ResourceFileName } .internalstopped {
+ cleartomark false
+ } {
+ (r) { file } .internalstopped {
+ cleartomark false
+ } {
+ exch pop exch pop true
+ } ifelse
+ } ifelse
+ } {
+ pop false
+ } ifelse
+ } ifelse
+ } bind
+
+
+
+.dicttomark
+/Category defineresource pop
+
+% Fill in the rest of the Category category.
+/Category /Category findresource dup
+/Generic /Category findresource begin {
+ /FindResource /ResourceForAll /ResourceStatus /.ResourceFileStatus
+ /UndefineResource /ResourceFileName
+ /.ResourceFile /.LoadResource /.DoLoadResource
+} { dup load put dup } forall
+pop readonly pop end
+
+(END GENERIC) VMDEBUG
+
+% Define the fixed categories.
+
+mark
+ % Non-Type categories with existing entries.
+ /ColorSpaceFamily
+ { } % These must be deferred, because optional features may add some.
+ /Emulator
+ mark EMULATORS { cvn } forall .packtomark
+ /Filter
+ { } % These must be deferred, because optional features may add some.
+ /IODevice
+ % Loop until the .getiodevice gets a rangecheck.
+ errordict /rangecheck 2 copy get
+ errordict /rangecheck { pop stop } put % pop the command
+ mark 0 { {
+ dup .getiodevice dup null eq { pop } { exch } ifelse 1 add
+ } loop} .internalstopped
+ pop pop pop .packtomark
+ 4 1 roll put
+ .clearerror
+ % Type categories listed in the Red Book.
+ /ColorRenderingType
+ { } % These must be deferred, because optional features may add some.
+ /FMapType
+ { } % These must be deferred, because optional features may add some.
+ /FontType
+ { } % These must be deferred, because optional features may add some.
+ /FormType
+ { } % These must be deferred, because optional features may add some.
+ /HalftoneType
+ { } % These must be deferred, because optional features may add some.
+ /ImageType
+ { } % Deferred, optional features may add some.
+ /PatternType
+ { } % Deferred, optional features may add some.
+ % Type categories added since the Red Book.
+ /setsmoothness where {
+ pop /ShadingType { } % Deferred, optional features may add some.
+ } if
+counttomark 2 idiv
+ { mark
+
+ % Standard entries
+
+ % We'd like to prohibit defineresource,
+ % but because optional features may add entries, we can't.
+ % We can at least require that the key and value match.
+ /DefineResource
+ { currentglobal not
+ { /defineresource cvx /invalidaccess signaloperror }
+ { 2 copy ne
+ { /defineresource cvx /rangecheck signaloperror }
+ { dup .Instances 4 -2 roll .growput }
+ ifelse
+ }
+ ifelse
+ } bind
+ /UndefineResource
+ { /undefineresource cvx /invalidaccess signaloperror } bind
+ /FindResource
+ { .Instances 1 index .knownget
+ { exch pop }
+ { /findresource cvx .undefinedresource }
+ ifelse
+ } bind
+ /ResourceStatus
+ { .Instances exch known { 0 0 true } { false } ifelse } bind
+ /ResourceForAll
+ /Generic .findcategory /ResourceForAll load end
+
+ % Additional entries
+
+ counttomark 2 add -1 roll
+ dup length dict dup begin exch { dup def } forall end
+ % We'd like to make the .Instances readonly here,
+ % but because optional features may add entries, we can't.
+ /.Instances exch
+ /.LocalInstances % used by ResourceForAll
+ 0 dict def
+
+ .dicttomark /Category defineresource pop
+ } repeat pop
+
+(END FIXED) VMDEBUG
+
+% Define the other built-in categories.
+
+/.definecategory % <name> -mark- <key1> ... <valuen> .definecategory -
+ { counttomark 2 idiv 2 add % .Instances, Category
+ /Generic /Category findresource dup maxlength 3 -1 roll add
+ dict .copydict begin
+ counttomark 2 idiv { def } repeat pop % pop the mark
+ currentdict end /Category defineresource pop
+ } bind def
+
+/ColorRendering mark /InstanceType /dicttype .definecategory
+% ColorSpace is defined below
+% Encoding is defined below
+% Font is defined below
+/Form mark /InstanceType /dicttype .definecategory
+/Halftone mark /InstanceType /dicttype .definecategory
+/Pattern mark /InstanceType /dicttype .definecategory
+/ProcSet mark /InstanceType /dicttype .definecategory
+% Added since the Red Book:
+/ControlLanguage mark /InstanceType /dicttype .definecategory
+/HWOptions mark /InstanceType /dicttype .definecategory
+/Localization mark /InstanceType /dicttype .definecategory
+/OutputDevice mark /InstanceType /dicttype .definecategory
+/PDL mark /InstanceType /dicttype .definecategory
+% CIDFont, CIDMap, and CMap are defined in gs_cidfn.ps
+% FontSet is defined in gs_cff.ps
+% IdiomSet is defined in gs_ll3.ps
+% InkParams and TrapParams are defined in gs_trap.ps
+
+(END MISC) VMDEBUG
+
+% Define the ColorSpace category.
+
+/.defaultcsnames mark
+ /DefaultGray 0
+ /DefaultRGB 1
+ /DefaultCMYK 2
+.dicttomark readonly def
+
+% The "hooks" are no-ops here, redefined in LL3.
+/.definedefaultcs { % <index> <value> .definedefaultcs -
+ pop pop
+} bind def
+/.undefinedefaultcs { % <index> .undefinedefaultcs -
+ pop
+} bind def
+
+/ColorSpace mark
+
+/InstanceType /arraytype
+
+% We keep track of whether there are any local definitions for any of
+% the Default keys. This information must get saved and restored in
+% parallel with the local instance dictionary, so it must be stored in
+% local VM.
+userdict /.localcsdefaults false put
+
+/DefineResource {
+ 2 copy /Generic /Category findresource /DefineResource get exec
+ exch pop
+ exch //.defaultcsnames exch .knownget {
+ 1 index .definedefaultcs
+ currentglobal not { .userdict /.localcsdefaults true put } if
+ } if
+} bind
+
+/UndefineResource {
+ dup /Generic /Category findresource /UndefineResource get exec
+ //.defaultcsnames 1 index .knownget {
+ % Stack: resname index
+ currentglobal {
+ .undefinedefaultcs pop
+ } {
+ % We removed the local definition, but there might be a global one.
+ exch .GetInstance {
+ 0 get .definedefaultcs
+ } {
+ .undefinedefaultcs
+ } ifelse
+ % Recompute .localcsdefaults by scanning. This is rarely needed.
+ .userdict /.localcsdefaults false //.defaultcsnames {
+ pop .LocalInstances exch known { pop true exit } if
+ } forall put
+ } ifelse
+ } {
+ pop
+ } ifelse
+} bind
+
+.definecategory % ColorSpace
+
+% Define the Encoding category.
+
+/Encoding mark
+
+/InstanceType /arraytype
+
+% Handle already-registered encodings, including lazily loaded encodings
+% that aren't loaded yet.
+
+/.Instances mark
+ EncodingDirectory
+ { dup length 256 eq { [ exch readonly 0 -1 ] } { pop [null 2 -1] } ifelse
+ } forall
+.dicttomark
+
+/.ResourceFileDict mark
+ EncodingDirectory
+ { dup length 256 eq { pop pop } { 0 get } ifelse
+ } forall
+.dicttomark
+
+/ResourceFileName
+ { .ResourceFileDict 2 index .knownget
+ { exch copy exch pop }
+ { /Generic /Category findresource /ResourceFileName get exec }
+ ifelse
+ } bind
+
+.definecategory % Encoding
+
+% Make placeholders in level2dict for the redefined Encoding operators,
+% so that they will be swapped properly when we switch language levels.
+
+/.findencoding /.findencoding load def
+/findencoding /findencoding load def
+/.defineencoding /.defineencoding load def
+
+(END ENCODING) VMDEBUG
+
+% Define the Font category.
+
+/.fontstatus { % <fontname> .fontstatus <fontname> <found>
+ { % Create a loop context just so we can exit it early.
+ % Check Fontmap.
+ Fontmap 1 index .knownget {
+ {
+ dup type /nametype eq {
+ .fontstatus { pop null exit } if
+ } {
+ dup type /stringtype eq {
+ findlibfile { closefile pop null exit } if pop
+ } {
+ % Procedure, assume success.
+ pop null exit
+ } ifelse
+ } ifelse
+ } forall dup null eq { pop true exit } if
+ } if
+ % Convert names to strings; give up on other types.
+ dup type /nametype eq { .namestring } if
+ dup type /stringtype ne { false exit } if
+ % Check the resource directory.
+ dup .fonttempstring /FontResourceDir getsystemparam .genericrfn
+ status {
+ pop pop pop pop true exit
+ } if
+ % Check for a file on the search path with the same name
+ % as the font.
+ findlibfile { closefile true exit } if
+ % Scan a FONTPATH directory and try again.
+ .scannextfontdir not { false exit } if
+ } loop
+} bind def
+
+/Font mark
+
+/InstanceType /dicttype
+
+/DefineResource
+ { 2 copy //definefont exch pop
+ /Generic /Category findresource /DefineResource get exec
+ } bind
+/UndefineResource
+ { dup //undefinefont
+ /Generic /Category findresource /UndefineResource get exec
+ } bind
+/FindResource {
+ dup .getvminstance {
+ exch pop 0 get
+ } {
+ dup ResourceStatus {
+ pop 1 gt { .loadfontresource } { .GetInstance pop 0 get } ifelse
+ } {
+ .loadfontresource
+ } ifelse
+ } ifelse
+} bind
+/ResourceForAll {
+ { .scannextfontdir not { exit } if } loop
+ /Generic /Category findresource /ResourceForAll get exec
+} bind
+/.ResourceFileStatus {
+ .fontstatus { pop 2 -1 true } { pop false } ifelse
+} bind
+
+/.loadfontresource {
+ dup vmstatus pop exch pop exch
+ % Hack: rebind .currentresourcefile so that all calls of
+ % definefont will know these are built-in fonts.
+ currentfile {pop //findfont exec} .execasresource % (findfont is a procedure)
+ exch vmstatus pop exch pop exch sub
+ % stack: name font vmused
+ % findfont has the prerogative of not calling definefont
+ % in certain obscure cases of font substitution.
+ 2 index .getvminstance {
+ dup 1 1 put
+ 2 3 -1 roll put
+ } {
+ pop
+ } ifelse exch pop
+} bind
+
+/.Instances FontDirectory length 2 mul dict
+
+.definecategory % Font
+
+% Redefine font "operators".
+/.definefontmap
+ { /Font /Category findresource /.Instances get
+ dup 3 index known
+ { pop
+ }
+ { 2 index
+ % Make sure we create the array in global VM.
+ .currentglobal true .setglobal
+ [null 2 -1] exch .setglobal
+ .growput
+ }
+ ifelse
+ //.definefontmap exec
+ } bind def
+
+% Make sure the old definitions are still in systemdict so that
+% they will get bound properly.
+systemdict begin
+ /.origdefinefont /definefont load def
+ /.origundefinefont /undefinefont load def
+ /.origfindfont /findfont load def
+end
+/definefont {
+ { /Font defineresource } stopped {
+ /definefont cvx $error /errorname get signalerror
+ } if
+} bind odef
+/undefinefont {
+ /Font undefineresource
+} bind odef
+% The Red Book requires that findfont be a procedure, not an operator,
+% but it still needs to restore the stacks reliably if it fails.
+/.findfontop {
+ { /Font findresource } stopped {
+ pop /findfont $error /errorname get signalerror
+ } if
+} bind odef
+/findfont {
+ .findfontop
+} bind def % Must be a procedure, not an operator
+
+% Remove initialization utilities.
+currentdict /.definecategory .undef
+currentdict /.emptydict .undef
+
+end % level2dict
+
+% Convert deferred resources after we finally switch to Level 2.
+
+/.fixresources {
+ % Encoding resources
+ EncodingDirectory
+ { dup length 256 eq
+ { /Encoding defineresource pop }
+ { pop pop }
+ ifelse
+ } forall
+ /.findencoding {
+ { /Encoding findresource } stopped {
+ pop /findencoding $error /errorname get signalerror
+ } if
+ } bind def
+ /findencoding /.findencoding load def % must be a procedure
+ /.defineencoding { /Encoding defineresource pop } bind def
+ % ColorRendering resources and ProcSet
+ systemdict /ColorRendering .knownget {
+ /ColorRendering exch /ProcSet defineresource pop
+ systemdict /ColorRendering undef
+ /DefaultColorRendering currentcolorrendering /ColorRendering defineresource pop
+ } if
+ % ColorSpace resources
+ systemdict /CIEsRGB .knownget {
+ /sRGB exch /ColorSpace defineresource pop
+ systemdict /CIEsRGB undef
+ } if
+ % ColorSpaceFamily resources
+ colorspacedict { pop dup /ColorSpaceFamily defineresource pop } forall
+ % Filter resources
+ filterdict { pop dup /Filter defineresource pop } forall
+ % FontType and FMapType resources
+ buildfontdict { pop dup /FontType defineresource pop } forall
+ mark
+ buildfontdict 0 known { 2 3 4 5 6 7 8 } if
+ buildfontdict 9 known { 9 } if
+ counttomark { dup /FMapType defineresource pop } repeat pop
+ % FormType resources
+ .formtypes { pop dup /FormType defineresource pop } forall
+ % HalftoneType resources
+ .halftonetypes { pop dup /HalftoneType defineresource pop } forall
+ % ColorRenderingType resources
+ .colorrenderingtypes {pop dup /ColorRenderingType defineresource pop} forall
+ % ImageType resources
+ .imagetypes { pop dup /ImageType defineresource pop } forall
+ % PatternType resources
+ .patterntypes { pop dup /PatternType defineresource pop } forall
+ % Make the fixed resource categories immutable.
+ /.shadingtypes where {
+ pop .shadingtypes { pop dup /ShadingType defineresource pop } forall
+ } if
+ [ /ColorSpaceFamily /Emulator /Filter /IODevice /ColorRenderingType
+ /FMapType /FontType /FormType /HalftoneType /ImageType /PatternType
+ /.shadingtypes where { pop /ShadingType } if
+ ] {
+ /Category findresource
+ dup /.Instances get readonly pop
+ .LocalInstances readonly pop
+ readonly pop
+ } forall
+ % clean up
+ systemdict /.fixresources undef
+} bind def
+
+%% Replace 1 (gs_resmp.ps)
+(gs_resmp.ps) dup runlibfile VMDEBUG