Current File : //proc/thread-self/root/proc/self/root/usr/share/ghostscript/Resource/Init/gs_res.ps
% Copyright (C) 2001-2019 Artifex Software, Inc.
% All Rights Reserved.
%
% This software is provided AS-IS with no warranty, either express or
% implied.
%
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc., 1305 Grant Avenue - Suite 200, Novato,
% CA 94945, U.S.A., +1(415)492-9861, for further information.
%
% 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 /localinstancedict 5 dict
.forceput % localinstancedict is local, systemdict is global
//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 / .forceput later to replace the dummy,
% empty .Instances dictionary with the real one later.
readonly
}{
/defineresource cvx /typecheck signaloperror
} ifelse
} bind executeonly odef
/FindResource % (redefined below)
{ .Instances exch get 0 get
} bind executeonly 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 exec } ifelse
/FindResource //.resourceexec exec 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
} bind executeonly odef
/defineresource { % <key> <instance> <category> defineresource <instance>
2 .argindex 2 index 2 index % catch stackunderflow
% See above re .errorexec.
/defineresource cvx {
//.findcategory exec
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 exec
4 1 roll pop pop pop
} .errorexec
} bind executeonly 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 exec
/ResourceForAll load
% Stack: <template> <proc> <scratch> <category> proc
exch pop % pop the category
exec end
} bind executeonly def
/resourceforall { % <template> <proc> <scratch> <category> resourceforall1 -
//resourceforall1 exec % see above
} bind executeonly 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 exec /ResourceStatus //.resourceexec exec
{ 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 executeonly odef
/undefineresource { % <key> <category> undefineresource -
0 .argindex type /nametype ne {
/undefinedresource cvx /typecheck signaloperror
} if
1 .argindex 1 index % catch stackunderflow
{ //.findcategory exec /UndefineResource //.resourceexec exec 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 executeonly odef
% Define the system parameters used for the Generic implementation of
% ResourceFileName.
systemdict begin
% - .default_resource_dir <string>
/.default_resource_dir {
/LIBPATH .systemvar {
dup .file_name_current eq {
pop
} {
(Resource) search {
exch concatstrings
exch pop
.file_name_separator concatstrings exit
} {
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 exec
/FontResourceDir (Font) //.resource_dir_name exec
readonly currentdict 3 1 roll .forceput % pssys'params is r-o
/GenericResourceDir () //.resource_dir_name exec
readonly currentdict 3 1 roll .forceput % pssys'params is r-o
pop % .default_resource_dir
/GenericResourcePathSep
.file_name_separator readonly currentdict 3 1 roll .forceput % pssys'params is r-o
currentdict (%diskFontResourceDir) cvn (/Resource/Font/) readonly .forceput % pssys'params is r-o
currentdict (%diskGenericResourceDir) cvn (/Resource/) readonly .forceput % 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
pssystemparams dup /GenericResourceDir get exch /GenericResourcePathSep get
(Init) exch (gs_init.ps) concatstrings concatstrings concatstrings
status {
pop pop pop pop
} {
(\n*** Warning: GenericResourceDir doesn't point to a valid resource directory.) =
( the -sGenericResourceDir=... option can be used to set this.\n) =
flush
} ifelse
% 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 exec } { 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 exec
} {
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 exec } ifelse
} ifelse
} bind def
/DefineResource dup {
.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 .forceput here.
currentdict /.Instances 2 index .forceput % Category dict is read-only
} executeonly if
} executeonly
{ .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 exec pop
dup 4 1 roll put exch pop exch pop
} executeonly
{ /defineresource cvx /typecheck signaloperror
}
ifelse
} .bind executeonly .makeoperator % executeonly to prevent access to .forceput
/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 executeonly
% 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 exec {
exch pop 0 get
} {
dup ResourceStatus {
pop 1 gt {
.DoLoadResource //.getvminstance exec not {
/findresource cvx //.undefinedresource exec
} if 0 get
} {
.GetInstance pop 0 get
} ifelse
} {
/findresource cvx //.undefinedresource exec
} ifelse
} ifelse
} bind executeonly
% 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 executeonly
/.ResourceFileStatus {
.ResourceFile { closefile 2 -1 //true } { pop //false } ifelse
} bind executeonly
/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)
1 index 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
] 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
3 index add
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 executeonly
/ResourceFileName { % /in (scr) --> (p/c/n)
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 1 index % (scr) (c/n) (p/) (c/n)
concatstrings % (scr) (c/n) (p/c/n)
dup status {
pop pop pop pop exch pop % (scr) (p/c/n)
} {
exch
.libfile
{//true}
{
pop dup .libfile
{//true}
{//false}
ifelse
} ifelse
{
dup .filename pop
exch closefile
exch pop
}
{pop}
ifelse
} ifelse
exch copy % (p/c/n)
} bind executeonly
% 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 executeonly odef
/.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 exec not {
pop dup //.undefinedresource exec % 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 exec }
{ //true setglobal { //.runresource exec } stopped //false setglobal { stop } if }
ifelse
}
{ dup //.undefinedresource exec
}
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 exec {
cleartomark //false
} {
(r) { file } //.internalstopped exec {
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 { <00> search { exch pop cvn exch }{ cvn exit } ifelse } .bind loop //.packtomark exec
/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 exec
pop pop pop //.packtomark exec
4 1 roll put
//.clearerror exec
% 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 executeonly
/UndefineResource
{ /undefineresource cvx /invalidaccess signaloperror } bind executeonly
/FindResource
{ .Instances 1 index .knownget
{ exch pop }
{ /findresource cvx //.undefinedresource exec }
ifelse
} bind executeonly
/ResourceStatus
{ .Instances exch known { 0 0 //true } { //false } ifelse } bind executeonly
/ResourceForAll
/Generic //.findcategory exec /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
/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 OutputDevice category.
/OutputDevice mark
/InstanceType /dicttype
/.Instances mark
%% devicedict is not created yet so here we employ a technique similar to
%% that used to create it, in order to get the device names. We run a loop
%% executing .getdevice with incremental numbers until we get an error.
%% The devicedict creation only stops on a rangecheck, we stop on any error.
%% We need to use .internalstopped, not stopped or we get an invalidacces
%% later in this file. Instances of /OutputDevice are dictionaries, and the
%% only required key is a /PageSize. The array of 4 numbers are minimum to
%% maximum and are matches for the Adobe Acrobat Distiller values.
0
{
{dup .getdevice .devicename cvn 1 dict dup /PageSize [1 1 14400 14400] put [exch readonly 0 -1] 3 -1 roll 1 add} loop
} //.internalstopped exec pop
%% Remove the count, and the duplicate, from the stack
pop pop
.dicttomark
.definecategory
% 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 exec
currentglobal not { .userdict /.localcsdefaults //true put } if
} if
} bind executeonly
/UndefineResource {
dup /Generic /Category findresource /UndefineResource get exec
//.defaultcsnames 1 index .knownget {
% Stack: resname index
currentglobal {
//.undefinedefaultcs exec pop
} {
% We removed the local definition, but there might be a global one.
exch .GetInstance {
0 get //.definedefaultcs exec
} {
//.undefinedefaultcs exec
} 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 executeonly
.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 executeonly
.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.
/.fontstatusaux { % <fontname> .fontstatusaux <fontname> <found>
{ % Create a loop context just so we can exit it early.
% Check Fontmap.
Fontmap 1 index .knownget
{ //true }
{ .nativeFontmap 1 index .knownget } ifelse
{
{
dup type /nametype eq {
.fontstatus { pop //null exit } if
} {
dup type /dicttype eq {/Path .knownget pop} 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
dup / eq { //false exit } if % / throws an error from findlibfile
% 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 exec not { //false exit } if
} loop
} bind def
/.fontstatus { % <fontname> .fontstatus <fontname> <found>
//.fontstatusaux exec
{ //true }
{
.buildnativefontmap
{ //.fontstatusaux exec }
{ //false } ifelse
} ifelse
} bind executeonly def
currentdict /.fontstatusaux .undef
/Font mark
/InstanceType /dicttype
/DefineResource
{ 2 copy //definefont exch pop
/Generic /Category findresource /DefineResource get exec
} bind executeonly
/UndefineResource
{ dup //undefinefont
/Generic /Category findresource /UndefineResource get exec
} bind executeonly
/FindResource {
dup //.getvminstance exec {
exch pop 0 get
} {
dup ResourceStatus {
pop 1 gt { .loadfontresource } { .GetInstance pop 0 get } ifelse
} {
.loadfontresource
} ifelse
} ifelse
} bind executeonly
/ResourceForAll {
{ //.scannextfontdir exec not { exit } if } loop
/Generic /Category findresource /ResourceForAll get exec
} bind executeonly
/.ResourceFileStatus {
.fontstatus { pop 2 -1 //true } { pop //false } ifelse
} bind executeonly
/.loadfontresource {
dup //.vmused 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 //.vmused exch sub
% stack: name font vmused
% findfont has the prerogative of not calling definefont
% in certain obscure cases of font substitution.
2 index //.getvminstance exec {
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.
% NOTE: Mystery code... I can't just delete this, but don't understand why.
% Instead we will undef these three operators in gs_init.ps after all the initialization is done.
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 executeonly odef
/undefinefont {
/Font undefineresource
} bind executeonly 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 executeonly odef
/findfont {
.findfontop
} bind executeonly 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
systemdict /CIEsRGBICC .knownget {
/sRGBICC exch /ColorSpace defineresource pop
systemdict /CIEsRGBICC undef
} if
systemdict /CIEsGRAYICC .knownget {
/sGrayICC exch /ColorSpace defineresource pop
systemdict /CIEsGRAYICC undef
} if
systemdict /CIEesRGBICC .knownget {
/esRGBICC exch /ColorSpace defineresource pop
systemdict /CIEesRGBICC undef
} if
systemdict /CIErommRGBICC .knownget {
/rommRGBICC exch /ColorSpace defineresource pop
systemdict /CIErommRGBICC 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
[
/.default_resource_dir
/.resource_dir_name
/.fonttempstring /.scannextfontdir % from gs_fonts.ps
]
{systemdict exch .forceundef} forall
[
/.definedefaultcs
/.undefinedefaultcs
/.defaultcsnames
/.enumerateresource
/.externalresourceforall
/.getvminstance
/.globalresourceforall
/.localresourceforall
/resourceforall1
/.resourceexec
/.undefinedresource
/.vmused
]
{level2dict exch .forceundef} forall
Mini Shell