% Copyright (C) 1990, 1991 Aladdin Enterprises. All rights reserved.
% Distributed by Free Software Foundation, Inc.
%
% This file is part of Ghostscript.
%
% Ghostscript is distributed in the hope that it will be useful, but
% WITHOUT ANY WARRANTY. No author or distributor accepts responsibility
% to anyone for the consequences of using it or for whether it serves any
% particular purpose or works at all, unless he says so in writing. Refer
% to the Ghostscript General Public License for full details.
%
% Everyone is granted permission to copy, modify and redistribute
% Ghostscript, but only under the conditions described in the Ghostscript
% General Public License. A copy of this license is supposed to have been
% given to you along with Ghostscript so you can know your rights and
% responsibilities. It should be in a file named COPYING. Among other
% things, the copyright notice and this notice must be preserved on all
% copies.
% Initialization file for Ghostscript Level 2 functions.
% When this is run, systemdict is still writable.
% ------ Miscellaneous ------ %
% We aren't fully Level 2 compatible yet!
%/languagelevel 2 def
% ------ Painting ------ %
% A straightforward definition of execform that doesn't actually
% do any caching.
/execform
{ dup /Implementation known not
{ dup /FormType get 1 ne { /rangecheck signalerror } if
dup /Implementation null put readonly
} if
gsave dup /Matrix get concat
dup /BBox get aload pop
exch 3 index sub exch 2 index sub rectclip
dup /PaintProc get exec
grestore
} odef
% Recognize the dictionary form of image and imagemask.
/image
{ dup type /dicttype eq { .dictimage } { image } ifelse
} bind odef % bind now to incorporate old image
/imagemask
{ dup type /dicttype eq { .dictimagemask } { imagemask } ifelse
} bind odef % bind now to incorporate old imagemask
% ------ Virtual memory ------ %
/currentglobal /currentshared load def
/gcheck /scheck load def
/globaldict /shareddict load def
% ------ Resources ------ %
% Currently, we don't implement resource unloading or global/local
% instance sets, and resourceforall only enumerates loaded instances.
% The standard implementation of resource categories is
% simply to have another entry in the resource dictionary, called Instances,
% that keeps track of all the instances.
% Note that the dictionary that defines a resource category is stored
% in global memory. The PostScript manual says that each category must
% manage global and local instances separately. However, objects in
% global memory can't reference objects in local memory. 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, there must be a parallel
% structure in local memory for each resource category. Needless to
% say, we haven't implemented this yet.
% Define the Category category, except for most of the procedures.
% The dictionary we're about to create will become the Category
% category definition dictionary.
10 dict begin
/Category /Category def
/CheckResource
{ true
{ /DefineResource /FindResource /ResourceForAll /ResourceStatus
/UndefineResource }
{ 2 index exch known and }
forall exch pop } bind def
/DefineResource
{ dup CheckResource
{ dup /Category 3 index put Instances 3 1 roll put }
{ /typecheck signalerror }
ifelse } bind def
/FindResource % temporary
{ Instances exch get } bind def
/Instances 25 dict def
/InstanceType /dicttype def
Instances /Category currentdict put
Instances end begin % so we can name the Category definition
% Define the resource operators.
mark
/defineresource
{ /Category findresource dup begin
/InstanceType known
{ dup type InstanceType ne
{ dup type /packedarraytype eq InstanceType /arraytype eq and
not { /typecheck signalerror } if } if } if
DefineResource end
}
/findresource
{ dup /Category eq
{ pop //Category } { /Category findresource } ifelse
begin FindResource end }
/resourceforall
{ /Category findresource begin ResourceForAll end }
/resourcestatus
{ /Category findresource begin ResourceStatus end }
/undefineresource
{ /Category findresource begin UndefineResource end }
end % Instances
counttomark 2 idiv { bind def } repeat pop
% Define the Generic category.
12 dict dup begin
/Instances 0 dict def
/CheckResource % not a standard entry
{ pop true } def
/DefineResource
{ dup CheckResource
{ Instances 3 1 roll put }
{ /typecheck signalerror }
ifelse
} bind def
/FindResource
{ dup ResourceStatus
{ pop 1 gt { dup ResourceFile run } if
Instances exch get }
{ /undefinedresource signalerror }
ifelse } bind def
/ResourceFile % not a standard entry
{ currentdict /ResourceFileName get 100 string exch exec
(r) file } bind def
/ResourceForAll
{ % We construct a new procedure so we don't have to use
% static resources to hold the iteration state.
3 1 roll cvlit 3 1 roll cvlit 3 1 roll
{ % Stack contains: key, instance, template, proc, scratch
4 index 3 index stringmatch
{ 4 index type dup /stringtype eq exch /nametype eq or
{ 4 index exch cvs exch 5 2 roll pop pop pop }
{ pop exch pop exch pop }
ifelse exec }
{ 5 { pop } repeat }
ifelse
} /exec cvx 5 packedarray cvx
Instances exch forall } bind def
/ResourceStatus
{ dup Instances exch known
{ pop 1 0 true }
{ mark exch { ResourceFile } stopped
{ cleartomark false } { closefile cleartomark 0 true }
ifelse
} ifelse
} bind def
/UndefineResource
{ Instances exch undef } bind def
end
/Generic exch /Category defineresource
% Fill in the rest of the Category category.
/Category /Category findresource dup
/Generic /Category findresource begin
{ /FindResource /ResourceStatus /ResourceForAll }
{ dup load put dup } forall
pop pop end
% Define the fixed categories.
7 dict begin % 5 procedures, Category, Instances
/DefineResource
{ /invalidaccess signalerror } bind def
/FindResource
{ Instances exch get } bind def
/ResourceForAll
/Generic /Category findresource /ResourceForAll get def
/ResourceStatus
{ Instances exch known { 0 0 true } { false } ifelse } bind def
/UndefineResource
{ /invalidaccess signalerror } bind def
mark
% Things other than types
/ColorSpaceFamily {/DeviceRGB /DeviceGray}
/Emulator {}
/Filter
[ .filterdict { pop } forall ]
/IODevice {(%os%)}
% Types
/ColorRenderingType {}
/FMapType {2 3 4 5 6 7 8}
/FontType {1 3}
/FormType {1}
/HalftoneType {}
/ImageType {1}
/PatternType {}
counttomark 2 idiv
{ currentdict dup maxlength dict copy begin
dup length dict dup begin exch { dup def } forall end readonly
/Instances exch def
currentdict /Category defineresource
currentdict end readonly pop
} repeat pop end
% Define the other built-in categories.
mark
/ColorRendering /dicttype /ColorSpace /arraytype /Encoding /arraytype
/Font /dicttype /Form /dicttype /Halftone /dicttype /Pattern /dicttype
/ProcSet /dicttype
counttomark 2 idiv
{ /Generic /Category findresource dup maxlength dict copy begin
/InstanceType exch def
/Instances 10 dict def
currentdict end /Category defineresource
} repeat pop
% Complete the Encoding category.
/findencoding
{ /Encoding findresource } bind def
/ISOLatin1Encoding ISOLatin1Encoding /Encoding defineresource
/StandardEncoding StandardEncoding /Encoding defineresource
/SymbolEncoding SymbolEncoding /Encoding defineresource
% Complete the Font category.
% INCOMPLETE.
/Font /Category findresource begin
/..definefont /definefont load def
/..findfont /findfont load def
/DefineResource
{ 2 copy ..definefont exch pop 2 copy
Instances 3 1 roll put exch pop
} bind def
/FindResource
{ ..findfont
} bind def
end
/definefont
{ /Font defineresource } bind def
/findfont
{ /Font findresource } bind def
/undefinefont
{ /Font undefineresource } bind def
