summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlgs/lib/gs_fonts.ps
diff options
context:
space:
mode:
Diffstat (limited to 'Master/tlpkg/tlgs/lib/gs_fonts.ps')
-rw-r--r--Master/tlpkg/tlgs/lib/gs_fonts.ps1223
1 files changed, 0 insertions, 1223 deletions
diff --git a/Master/tlpkg/tlgs/lib/gs_fonts.ps b/Master/tlpkg/tlgs/lib/gs_fonts.ps
deleted file mode 100644
index 781619f72ab..00000000000
--- a/Master/tlpkg/tlgs/lib/gs_fonts.ps
+++ /dev/null
@@ -1,1223 +0,0 @@
-% Copyright (C) 1990-2003 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.
-%
-% 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_fonts.ps 8022 2007-06-05 22:23:38Z giles $
-% Font initialization and management code.
-
-% Define the default font.
-/defaultfontname /Courier def
-
-% Define the name of the font map file.
-% Note that the "%%Replace " comment below provides the font map file name
-% for compiling initialization files into executable. Most likely it should be
-% consistent with the one specified here.
-/defaultfontmap (Fontmap) def
-
-/defaultfontmap_content 50 dict
-1 dict begin
-/; { 2 index 3 1 roll .growput } bind def
-%% Replace 0 (Fontmap)
-end def
-
-% ------ End of editable parameters ------ %
-
-% Define the UniqueIDs and organization XUID assigned to Aladdin.
-% UniqueIDs 5,066,501 - 5,066,580 are assigned as follows:
-% 01 and 02 for shareware Cyrillic
-% 33 through 67 for Type 1 versions of the Hershey fonts
-% UniqueIDs 5,115,501 - 5,115,600 are currently unassigned.
-/AladdinEnterprisesXUID 107 def
-
-% If SUBSTFONT is defined, make it the default font.
-/SUBSTFONT where { pop /defaultfontname /SUBSTFONT load def } if
-
-% Define a reliable way of accessing FontDirectory in systemdict.
-/.FontDirectory
-{ /FontDirectory .systemvar
-} .bind odef
-
-% If DISKFONTS is true, we load individual CharStrings as they are needed.
-% (This is intended primarily for machines with very small memories.)
-% In this case, we define another dictionary, parallel to FontDirectory,
-% that retains an open file for every font loaded.
-/FontFileDirectory 10 dict def
-
-% Define a temporary string for local use, since using =string
-% interferes with some PostScript programs.
-/.fonttempstring 8192 string def
-
-% Split up a search path into individual directories or files.
-/.pathlist % <path> .pathlist <dir1|file1> ...
- { { dup length 0 eq { pop exit } if
- .filenamelistseparator search not { exit } if
- exch pop exch
- }
- loop
- } bind def
-
-% Load a font name -> font file name map.
-userdict /Fontmap .FontDirectory maxlength dict put
-/.loadFontmap { % <file> .loadFontmap -
- % We would like to simply execute .definefontmap as we read,
- % but we have to maintain backward compatibility with an older
- % specification that makes later entries override earlier
- % ones within the same file.
- 50 dict exch .readFontmap
- { .definefontmap } forall
-} bind def
-/.readFontmap { % <dict> <file> .readFontmap <dict>
- { dup token not { closefile exit } if
- % stack: dict file fontname
- % This is a hack to get around the absurd habit of MS-DOS editors
- % of adding an EOF character at the end of the file.
- dup (\032) eq { pop closefile exit } if
- 1 index token not
- { (Fontmap entry for ) print dup =only
- ( has no associated file or alias name! Giving up.) = flush
- {.readFontmap} 0 get 1 .quit
- } if
- dup type dup /stringtype eq exch /nametype eq or not
- { (Fontmap entry for ) print 1 index =only
- ( has an invalid file or alias name! Giving up.) = flush
- {.readFontmap} 0 get 1 .quit
- } if
- % stack: dict file fontname filename|aliasname
- 1 index type /stringtype eq
- 1 index type /nametype eq and 1 index xcheck and
- 1 index /run eq 2 index /.runlibfile eq or and {
- % This is an inclusion entry.
- pop findlibfile { exch pop } { file } ifelse
- 2 index exch .readFontmap pop
- } {
- % This is a real entry.
- % Read and pop tokens until a semicolon.
- { 2 index token not
- { (Fontmap entry for ) print 1 index =only
- ( ends prematurely! Giving up.) = flush
- {.loadFontmap} 0 get 1 .quit
- } if
- dup /; eq { pop 3 index 3 1 roll .growput exit } if
- pop
- } loop
- } ifelse
- } loop
-} bind def
-% Add an entry in Fontmap. We redefine this if the Level 2
-% resource machinery is loaded.
-/.definefontmap % <fontname> <file|alias> .definefontmap -
- { % Since Fontmap is global, make sure the values are storable.
- % If the fontname contains Unicode (first byte == \000) and
- % this is not an alias definition, define an alias using ASCII
- % (stripping out the high \000 bytes). Observed with some TT fonts.
- 1 index 100 string cvs
- dup length 0 gt {
- 0 get 0 eq 1 index type /nametype ne and {
- 1 index 100 string cvs dup length 2 div cvi string true exch
- 0 1 2 index length 1 sub {
- % stack: fontname filename fontnamestring addflag newstring index
- dup 4 index exch 2 mul get 0 ne {
- % High byte of pair is not \000
- pop pop false exch
- exit
- } if
- dup 4 index exch 2 mul 1 add get 2 index 3 1 roll put
- } for
- exch {
- DEBUG { (\nAdding alias for: ) print 1 index ==only ( as: ) print dup == flush } if
- cvn exch cvn .definefontmap % recurse with an alias
- } {
- pop pop % discard the name
- } ifelse
- } if
- } {
- pop
- } ifelse
- .currentglobal 3 1 roll true .setglobal
- dup type /stringtype eq
- { dup .gcheck not { dup length string copy } if
- }
- if
- Fontmap 3 -1 roll 2 copy .knownget
- { % Add an element to the end of the existing value,
- % unless it's the same as the current last element.
- mark exch aload pop counttomark 4 add -1 roll
- 2 copy eq { cleartomark pop pop } { ] readonly .growput } ifelse
- }
- { % Make a new entry.
- mark 4 -1 roll ] readonly .growput
- }
- ifelse .setglobal
- } bind def
-
-% Parse a font file just enough to find the FontName or FontType.
-/.findfontvalue { % <file> <key> .findfontvalue <value> true
- % <file> <key> .findfontvalue false
- % Closes the file in either case.
- exch dup read {
- 2 copy unread 16#80 eq {
- dup (xxxxxx) readstring pop pop % skip .PFB header
- } if
- { % Stack: key file
- % Protect ourselves against syntax errors here.
- dup { token } stopped { pop false exit } if
- not { false exit } if % end of file
- dup /eexec eq { pop false exit } if % reached eexec section
- dup /Subrs eq { pop false exit } if % Subrs without eexec
- dup /CharStrings eq { pop false exit } if % CharStrings without eexec
- dup 3 index eq
- { xcheck not { dup token exit } if } % found key
- { pop }
- ifelse
- } loop
- % Stack: key file value true (or)
- % Stack: key file false
- dup { 4 } { 3 } ifelse -2 roll closefile pop
- } { closefile pop false } ifelse
-} bind def
-/.findfontname
- { /FontName .findfontvalue
- } bind def
-
-% If there is no FONTPATH, try to get one from the environment.
-NOFONTPATH { /FONTPATH () def } if
-/FONTPATH where
- { pop }
- { /FONTPATH (GS_FONTPATH) getenv not { () } if def }
-ifelse
-FONTPATH length 0 eq { (%END FONTPATH) .skipeof } if
-/FONTPATH [ FONTPATH .pathlist ] def
-
-% Scan directories looking for plausible fonts. "Plausible" means that
-% the file begins with %!PS-AdobeFont or %!FontType1, or with \200\001
-% followed by four arbitrary bytes and then either of these strings.
-% To speed up the search, we skip any file whose name appears in
-% the Fontmap (with any extension and upper/lower case variation) already,
-% and any file whose extension definitely indicates it is not a font.
-%
-% NOTE: The current implementation of this procedure is somewhat Unix/DOS-
-% specific. It assumes that '/' and '\' are directory separators, and that
-% the part of a file name following the last '.' is the extension.
-%
-/.lowerstring % <string> .lowerstring <lowerstring>
- { 0 1 2 index length 1 sub
- { 2 copy get dup 65 ge exch 90 le and
- { 2 copy 2 copy get 32 add put }
- if pop
- }
- for
- } bind def
-/.splitfilename { % <dir.../base.extn> .basename <base> <extn>
- % Make the file name read-only to detect aliasing bugs.
- % We really don't like doing this, but we've had one
- % such bug already.
- readonly {
- (/) search { true } { (\\) search } ifelse { pop pop } { exit } ifelse
- } loop
- dup { (.) search { pop pop } { exit } ifelse } loop
- 2 copy eq {
- pop ()
- } {
- exch dup length 2 index length 1 add sub 0 exch getinterval exch
- } ifelse
-} bind def
-/.scanfontdict 1 dict def % establish a binding
-/.scanfontbegin
- { % Construct the table of all file names already in Fontmap.
- currentglobal true setglobal
- .scanfontdict dup maxlength Fontmap length 2 add .max .setmaxlength
- Fontmap
- { exch pop
- { dup type /stringtype eq
- { .splitfilename pop .fonttempstring copy .lowerstring cvn
- .scanfontdict exch true put
- }
- { pop
- }
- ifelse
- }
- forall
- }
- forall
- setglobal
- } bind def
-/.scanfontskip mark
- % Strings are converted to names anyway, so....
- /afm true
- /bat true
- /c true
- /cmd true
- /com true
- /dir true
- /dll true
- /doc true
- /drv true
- /exe true
- /fon true
- /fot true
- /h true
- /o true
- /obj true
- /pfm true
- /pss true % Adobe Multiple Master font instances
- /txt true
-.dicttomark def
-/.scan1fontstring 8192 string def
-% %%BeginFont: is not per Adobe documentation, but a few fonts have it.
-/.scanfontheaders [(%!PS-Adobe*) (%!FontType*) (%%BeginFont:*)] def
-0 .scanfontheaders { length .max } forall 6 add % extra for PFB header
-/.scan1fontfirst exch string def
-/.scanfontdir % <dirname> .scanfontdir -
- { currentglobal exch true setglobal
- QUIET not { (Scanning ) print dup print ( for fonts...) print flush } if
- [ 1 index ] (*) .generate_dir_list_templates
- 0 0 0 4 -1 roll % found scanned files
- { % stack: <fontcount> <scancount> <filecount> <filename>
- exch 1 add exch % increment filecount
- dup .splitfilename .fonttempstring copy .lowerstring
- % stack: <fontcount> <scancount> <filecount+1> <filename>
- % <BASE> <ext>
- .scanfontskip exch known exch .scanfontdict exch known or
- { pop
- % stack: <fontcount> <scancount> <filecount+1>
- }
- { 3 -1 roll 1 add 3 1 roll
- % stack: <fontcount> <scancount+1> <filecount+1> <filename>
- dup (r) { file } .internalstopped
- { pop pop null ()
- % stack: <fontcount> <scancount+1> <filecount+1> <filename>
- % null ()
- }
- {
- % On some platforms, the file operator will open directories,
- % but an error will occur if we try to read from one.
- % Handle this possibility here.
- dup .scan1fontfirst { readstring } .internalstopped
- { pop pop () }
- { pop }
- ifelse
- % stack: <fontcount> <scancount+1> <filecount+1>
- % <filename> <file> <header>
- }
- ifelse
- % Check for PFB file header.
- dup (\200\001????*) .stringmatch
- { dup length 6 sub 6 exch getinterval }
- if
- % Check for font file headers.
- false .scanfontheaders
- { 2 index exch .stringmatch or
- }
- forall exch pop
- { % stack: <fontcount> <scancount+1> <filecount+1> <filename>
- % <file>
- dup 0 setfileposition .findfontname
- { dup Fontmap exch known
- { pop pop
- }
- { exch copystring exch
- DEBUG { ( ) print dup =only flush } if
- 1 index .definefontmap
- .splitfilename pop true .scanfontdict 3 1 roll .growput
- % Increment fontcount.
- 3 -1 roll 1 add 3 1 roll
- }
- ifelse
- }
- { pop
- }
- ifelse
- }
- % .findfontname will have done a closefile in the above case.
- { dup null eq { pop } { closefile } ifelse pop
- }
- ifelse
- }
- ifelse
- }
- .scan1fontstring filenameforall
- QUIET
- { pop pop pop }
- { ( ) print =only ( files, ) print =only ( scanned, ) print
- =only ( new fonts.) = flush
- }
- ifelse
- pop
- setglobal
- } bind def
-
-%END FONTPATH
-
-% Try to enumerate native fonts registered with the os
-% and add them to the fontmap. This relies on a custom
-% operator which calls platform-specific C code. It
-% returns an array of arrays, each containing a pair
-% of strings: what the system thinks is the ps name,
-% and the access path.
-/.setnativefontmapbuilt { % set whether we've been run
- systemdict exch /.nativefontmapbuilt exch .forceput
-} .bind executeonly def
-false .setnativefontmapbuilt
-/.buildnativefontmap { % - .buildnativefontmap <bool>
- QUIET not {
- (Querying operating system for font files...\n)
- print flush
- } if
- .getnativefonts dup
- {
- exch
- {
- % stack: [ (name) (path) ]
- % verify the font name ourselves
- dup 1 get (r) { file } stopped
- {
- % skip the entry if we can't open the returned path
- pop pop pop
- }{
- % we could open the font file
- .findfontname
- not { dup 0 get } if % stack: (newname) [ (name) (path) ]
- % DEBUG { ( found ) print dup print (\n) print flush } if
- % add entry to the fontmap
- 1 index exch 0 exch dup type /nametype ne {cvn} if put
- aload pop .definefontmap
- } ifelse
- } forall
- } if
- % record that we've been run
- true .setnativefontmapbuilt
-} bind def
-
-% Create the dictionary that registers the .buildfont procedure
-% (called by definefont) for each FontType.
-/buildfontdict 20 dict def
-
-% Register Type 3 fonts, which are always supported, for definefont.
-buildfontdict 3 /.buildfont3 cvx put
-
-% Register Type 0 fonts if they are supported. Strictly speaking,
-% we should do this in its own file (gs_type0.ps), but since this is
-% the only thing that would be in that file, it's simpler to put it here.
-/.buildfont0 where { pop buildfontdict 0 /.buildfont0 cvx put } if
-
-% Define definefont. This is a procedure built on a set of operators
-% that do all the error checking and key insertion.
-/.growfontdict
- { % Grow the font dictionary, if necessary, to ensure room for an
- % added entry, making sure there is at least one slot left for FID.
- dup maxlength 1 index length sub 2 lt
- { dup dup wcheck
- { .growdict }
- { .growdictlength dict .copydict }
- ifelse
- }
- { dup wcheck not { dup maxlength dict .copydict } if
- }
- ifelse
- } bind def
-/.completefont {
- { % Check for disabled platform fonts.
- NOPLATFONTS
- { % Make sure we leave room for FID.
- .growfontdict dup /ExactSize 0 put
- }
- { % Hack: if the Encoding looks like it might be the
- % Symbol or Dingbats encoding, load those now (for the
- % benefit of platform font matching) just in case
- % the font didn't actually reference them.
- % Note that some types of font don't have an Encoding.
- dup /Encoding .knownget {
- dup length 65 ge {
- 64 get
- dup /congruent eq { SymbolEncoding pop } if
- /a9 eq { DingbatsEncoding pop } if
- } {
- pop
- } ifelse
- } if
- }
- ifelse
- dup /OrigFont known not {
- dup dup /OrigFont exch .growput
- } if
- true exch
- % If this is a CIDFont, CIDFontType takes precedence
- % over FontType.
- dup /CIDFontType known {
- /.buildcidfont where {
- pop exch not exch % true => false
- } if
- } if
- exch {
- dup /FontType get //buildfontdict exch get
- } {
- {.buildcidfont} % so it gets bound
- } ifelse
- } stopped { $error /command get /invalidfont signalerror } if
-
- % Execute the .buildxxxfontx outside the 'stopped', because we don't
- % want its errors converted to invalidfont.
- exec
-
- {
-
- DISKFONTS {
- FontFileDirectory 2 index known {
- dup /FontFile FontFileDirectory 4 index get .growput
- } if
- } if
- systemdict /ProvideUnicode .knownget not { false } if {
- /FontEmulationProcs /ProcSet findresource
- /ProvideUnicodeDecoding get exec
- } if
- readonly % stack: name fontdict
- } stopped { $error /command get /invalidfont signalerror } if
-} bind def
-/definefont
- { dup rcheck not {
- /definefont cvx /invalidaccess signalerror
- } if
- /definefont cvx {.completefont} .errorexec
- % If the current allocation mode is global, also enter
- % the font in LocalFontDirectory.
- .currentglobal
- { //systemdict /LocalFontDirectory .knownget
- { 2 index 2 index { .growput } //superexec } % readonly
- if
- }
- if
- dup .FontDirectory 4 -2 roll { .growput } //superexec % readonly
- % If the font originated as a resource, register it.
- currentfile .currentresourcefile eq { dup .registerfont } if
- readonly
- } odef
-
-% Define a procedure for defining aliased fonts.
-% We use this only for explicitly aliased fonts, not substituted fonts:
-% we think this matches the observed behavior of Adobe interpreters.
-/.aliasfont % <name> <font> .aliasfont <newFont>
- { .currentglobal 3 1 roll dup .gcheck .setglobal
- % <bool> <name> <font>
- dup length 2 add dict % <bool> <name> <font> <dict>
- dup 3 -1 roll % <bool> <name> <dict> <dict> <font>
- { 1 index /FID eq { pop pop } { put dup } ifelse } forall
- % <bool> <name> <dict> <dict>
- % Stack: global fontname newfont newfont.
- % We might be defining a global font whose FontName
- % is a local string. This is weird, but legal,
- % and doesn't cause problems anywhere else:
- % to avoid any possible problems in this case, do a cvn.
- % We might also be defining (as an alias) a global font
- % whose FontName is a local non-string, if someone passed a
- % garbage value to findfont. In this case, just don't
- % call definefont at all.
- 2 index dup type /stringtype eq exch .gcheck or 1 index .gcheck not or
- { pop % <bool> <name> <dict>
- 1 index dup type /stringtype eq { cvn } if
- % <bool> <name> <dict> <name1>
- % HACK:
- % We want to know whether we alias a font,
- % because in this case its FontName to be replaced with the alias.
- % There is no simple way to know that at this point.
- % But if the original font has defaultfontname,
- % we probably substitute it rather than alias.
- % Using such condition as an approximation to the strong condition.
- %
- % Note it works wrongly if Fontmap maps something to defaultfontname like this :
- % /Courier /NimbusMonL-Regu ;
- % /Something /Courier ;
- % The FontName of Something will not be /Something. It will be /Courier .
- %
- 1 index /FontName get defaultfontname ne {
- 2 copy /FontName exch put
- } if
- 1 index exch /.Alias exch put % <bool> <name> <dict>
- dup dup /OrigFont exch .growput
- % Don't bind in definefont, since Level 2 redefines it.
- /definefont .systemvar exec
- }
- { /findfont cvx {.completefont} .errorexec pop exch pop
- }
- ifelse
- exch .setglobal
- } odef % so findfont will bind it
-
-% Define .loadfontfile for loading a font. If we recognize Type 1 and/or
-% TrueType fonts, gs_type1.ps and/or gs_ttf.ps will redefine this.
-/.loadfontfile {
- % According to Ed Taft, Adobe interpreters push userdict
- % before loading a font, and pop it afterwards.
- userdict begin
- cvx exec
- end
-} bind def
-/.setloadingfont {
- //systemdict /.loadingfont 3 -1 roll .forceput
-} .bind odef % .forceput must be bound and hidden
-/.loadfont
- { % Some buggy fonts leave extra junk on the stack,
- % so we have to make a closure that records the stack depth
- % in a fail-safe way.
- true .setloadingfont
- { /FAPI_hook_disable pop % gs_fapi accesses this with execstack_lookup - don't remove !
- {{.loadfontfile} .execasresource} count 1 sub 2 .execn
- count exch sub { pop } repeat
- exit
- } loop % this loop is a pattern for execstack_lookup, don't remove !
- false .setloadingfont
- } bind def
-
-% Find an alternate font to substitute for an unknown one.
-% We go to some trouble to parse the font name and extract
-% properties from it. Later entries take priority over earlier.
-/.substitutefaces [
- % Guess at suitable substitutions for random unknown fonts.
- [(Book) /NewCenturySchlbk 0]
- [(Grot) /Helvetica 0]
- [(Roman) /Times 0]
- [(Chancery) /ZapfChancery-MediumItalic 0]
- % If the family name appears in the font name,
- % use a font from that family.
- [(Arial) /Helvetica 0]
- [(Avant) /AvantGarde 0]
- [(Bookman) /Bookman 0]
- [(Century) /NewCenturySchlbk 0]
- [(Cour) /Courier 0]
- [(Frut) /Helvetica 0]
- [(Garamond) /Palatino 0]
- [(Geneva) /Helvetica 0]
- [(Helv) /Helvetica 0]
- [(NewYork) /Bookman 0]
- [(Pala) /Palatino 0]
- [(Schlbk) /NewCenturySchlbk 0]
- [(Swiss) /Helvetica 0]
- [(Symbol) /Symbol 0]
- [(Times) /Times 0]
- % Substitute for Adobe Multiple Master fonts.
- [(Minion) /Times 0]
- [(Myriad) /Helvetica 0]
- % If the font wants to be monospace, use Courier.
- [(Monospace) /Courier 0]
- [(Typewriter) /Courier 0]
- % Define substitutes for the other Adobe PostScript 3 fonts.
- % For some of them, the substitution is pretty bad!
- [(Albertus) /Palatino 0]
- [(AntiqueOlive) /Helvetica 0]
- [(Bodoni) /NewCenturySchlbk 0]
- [(Chicago) /Helvetica 2]
- [(Clarendon) /Bookman 0]
- [(Cooper) /NewCenturySchlbk 0]
- [(Copperplate) /AvantGarde 0] % inappropriate, small-cap font
- [(Coronet) /ZapfChancery-MediumItalic 0]
- [(Eurostile) /Helvetica 0]
- [(Geneva) /Courier 2] % should be fixed-pitch sans demi
- [(GillSans) /Helvetica 2]
- [(GillSans-Light) /Helvetica 0]
- [(Goudy) /Palatino 0]
- [(Hoefler) /NewCenturySchlbk 0]
- [(Joanna) /Times 0]
- [(LetterGothic) /Courier 0] % should be fixed-pitch sans
- [(LubalinGraph-Book) /Bookman 2]
- [(LubalinGraph-Demi) /Bookman 0]
- [(Marigold) /ZapfChancery-MediumItalic 0]
- [(MonaLisa-Recut) /Palatino 0] % inappropriate
- [(Monaco) /Courier 2] % should be fixed-pitch sans demi
- [(Optima) /Helvetica 0]
- [(Oxford) /ZapfChancery-MediumItalic 0]
- [(Tekton) /Helvetica 0]
- [(Univers) /Helvetica 0]
-] readonly def
-/.substituteproperties [
- [(It) 9] [(Oblique) 1]
- [(Black) 2] [(Bd) 2] [(Bold) 2] [(bold) 2] [(Demi) 2] [(Heavy) 2] [(Sb) 2]
- [(Cn) 4] [(Cond) 4] [(Narrow) 4] [(Pkg) 4] [(Compr) 4]
- [(Serif) 8] [(Sans) -8]
-] readonly def
-/.fontnameproperties { % <int> <string|name> .fontnameproperties
- % <int'>
- .fontnamestring
- .substituteproperties {
- 2 copy 0 get search {
- pop pop pop dup length 1 sub 1 exch getinterval 3 -1 roll exch {
- dup 0 ge { or } { neg not and } ifelse
- } forall exch
- } {
- pop pop
- } ifelse
- } forall pop
-} bind def
-/.substitutefamilies mark
- /AvantGarde
- {/AvantGarde-Book /AvantGarde-BookOblique
- /AvantGarde-Demi /AvantGarde-DemiOblique}
- /Bookman
- {/Bookman-Demi /Bookman-DemiItalic /Bookman-Light /Bookman-LightItalic}
- /Courier
- {/Courier /Courier-Oblique /Courier-Bold /Courier-BoldOblique}
- /Helvetica
- {/Helvetica /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique
- /Helvetica-Narrow /Helvetica-Narrow-Oblique
- /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique}
- /NewCenturySchlbk
- {/NewCenturySchlbk-Roman /NewCenturySchlbk-Italic
- /NewCenturySchlbk-Bold /NewCenturySchlbk-BoldItalic}
- /Palatino
- {/Palatino-Roman /Palatino-Italic /Palatino-Bold /Palatino-BoldItalic}
- /Symbol
- {/Symbol /Symbol /Symbol /Symbol}
- /Times
- {/Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic}
- /ZapfChancery-MediumItalic
- {/ZapfChancery-MediumItalic}
-.dicttomark readonly def
-/.nametostring { % <name> .nametostring <string>
- % <other> .nametostring <other>
- dup type /nametype eq { .namestring } if
-} bind def
-/.fontnamestring { % <fontname> .fontnamestring <string|name>
- dup type dup /nametype eq {
- pop .namestring
- } {
- /stringtype ne { pop () } if
- } ifelse
-} bind def
-/.substitutefontname { % <fontname> <properties> .substitutefontname
- % <altname|null>
- % Look for properties and/or a face name in the font name.
- % If we find any, use Times (serif) or Helvetica (sans) as the
- % base font; otherwise, use the default font.
- % Note that the "substituted" font name may be the same as
- % the requested one; the caller must check this.
- exch .fontnamestring {
- defaultfontname /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique
- /Helvetica-Narrow /Helvetica-Narrow-Oblique
- /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique
- /Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic
- /Helvetica-Narrow /Helvetica-Narrow-Oblique
- /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique
- } 3 1 roll
- % Stack: facelist properties fontname
- % Look for a face name.
- .substitutefaces {
- 2 copy 0 get search {
- pop pop pop
- % Stack: facelist properties fontname [(pattern) family properties]
- dup 2 get 4 -1 roll or 3 1 roll
- 1 get .substitutefamilies exch get
- 4 -1 roll pop 3 1 roll
- } {
- pop pop
- } ifelse
- } forall pop
- 1 index length mod get exec
-} bind def
-/.substitutefont { % <fontname> .substitutefont <altname>
- dup 0 exch .fontnameproperties .substitutefontname
- % Only accept fonts known in the Fontmap.
- Fontmap 1 index known not { pop defaultfontname } if
-} bind def
-
-% If requested, make (and recognize) fake entries in FontDirectory for fonts
-% present in Fontmap but not actually loaded. Thanks to Ray Johnston for
-% the idea behind this code.
-FAKEFONTS not { (%END FAKEFONTS) .skipeof } if
-
-% We use the presence or absence of the FontMatrix key to indicate whether
-% a font is real or fake. We must pop the arguments at the very end,
-% so that stack protection will be effective.
-
-/definefont { % <name> <font> definefont <font>
- dup /FontMatrix known {
- //definefont
- } {
- 2 copy /FontName get findfont //definefont exch pop exch pop
- } ifelse
-} bind odef
-
-/scalefont { % <font> <scale> scalefont <font>
- 1 index /FontMatrix known {
- //scalefont
- } {
- 1 index /FontName get findfont 1 index //scalefont
- exch pop exch pop
- } ifelse
-} bind odef
-
-/makefont { % <font> <matrix> makefont <font>
- 1 index /FontMatrix known {
- //makefont
- } {
- 1 index /FontName get findfont 1 index //makefont
- exch pop exch pop
- } ifelse
-} bind odef
-
-/setfont { % <font> setfont -
- dup /FontMatrix known {
- //setfont
- } {
- dup /FontName get findfont //setfont pop
- } ifelse
-} bind odef
-
-%END FAKEFONTS
-
-% Define findfont so it tries to load a font if it's not found.
-% The Red Book requires that findfont be a procedure, not an operator,
-% but it still needs to restore the stacks reliably if it fails,
-% so we do all the work in an operator.
-/.findfont { % <fontname> .findfont <font>
- mark 1 index % <fontname> mark <fontname>
- //systemdict begin .dofindfont
- % <fontname> mark <alias> ... <font>
- % Define any needed aliases.
- counttomark 1 sub { .aliasfont } repeat end
- % <fontname> mark <font>
- exch pop exch pop
-} odef
-/findfont {
- .findfont
-} bind def
-% Check whether the font name we are about to look for is already on the list
-% of aliases we're accumulating; if so, cause an error.
-/.checkalias % -mark- <alias1> ... <name> .checkalias <<same>>
- { counttomark 1 sub -1 1
- { index 1 index eq
- { pop QUIET not
- { (Unable to substitute for font.) = flush
- } if
- /findfont cvx /invalidfont signalerror
- }
- if
- }
- for
- } bind def
-% Get a (non-fake) font if present in a FontDirectory.
-/.fontknownget % <fontdir> <fontname> .fontknownget <font> true
- % <fontdir> <fontname> .fontknownget false
- { .knownget
- { FAKEFONTS
- { dup /FontMatrix known { true } { pop false } ifelse }
- { true }
- ifelse
- }
- { false
- }
- ifelse
- } bind def
-% This is the standard procedure for handling font substitution.
-% Its location is per an Adobe newsgroup posting.
-% It is called with the font name on the stack, standing in for findfont.
-/.stdsubstfont { % mark <alias1> ... <fontname> .stdsubstfont mark <alias1> ... <aliasN> <font>
- /SUBSTFONT where {
- pop QUIET not {
- (Substituting for font ) print dup =only
- (.) = flush
- } if
- % No aliasing.
- % This mode is incompatible with high level devices.
- cleartomark mark defaultfontname
- } {
- dup .substitutefont
- 2 copy eq { pop defaultfontname } if
- .checkalias
- QUIET not {
- SHORTERRORS {
- (%%[) print 1 index =only
- ( not found, substituting ) print dup =only (]%%)
- } {
- (Substituting font ) print dup =only
- ( for ) print 1 index =only (.)
- } ifelse = flush
- } if
- } ifelse
- /Font findresource
-} bind def
-
-% Default font substitution does {pop /Courier} om many implementations.
-% GS post-process font substitution in .stdsubstfont and uses {} for
-% backward compatibility
-$error /SubstituteFont { } put
-
-% Scan the next directory on FONTPATH.
-/.scannextfontdir { % - .scannextfontdir <bool>
- % If we haven't scanned all the directories in
- % FONTPATH, scan the next one.
- null 0 1 FONTPATH length 1 sub {
- FONTPATH 1 index get null ne { exch pop exit } if pop
- } for dup null ne {
- dup 0 eq { .scanfontbegin } if
- FONTPATH 1 index get .scanfontdir
- FONTPATH exch null put true
- } {
- pop false
- } ifelse
-} bind def
-% Do the work of findfont, including substitution, defaulting, and
-% scanning of FONTPATH.
-/.dofindfont { % mark <fontname> .dofindfont % mark <alias> ... <font>
- .tryfindfont not {
- % We didn't find the font. If we haven't scanned
- % all the directories in FONTPATH, scan the next one
- % now and look for the font again.
- .scannextfontdir {
- % Start over with an empty alias list.
- counttomark 1 sub { pop } repeat % mark <fontname>
- .dofindfont
- } {
- % No more directories to scan. Try building the native
- % font map entries if we haven't already done so.
- systemdict /.nativefontmapbuilt get not { .buildnativefontmap } { false } ifelse {
- % Same stack as at the beginning of .dofindfont.
- .dofindfont % start over
- } {
- % No luck. Make sure we're not already
- % looking for the default font.
- QUIET not {
- (Didn't find this font on the system!\n)
- print
- } if
- dup defaultfontname eq {
- QUIET not {
- (Unable to load default font ) print
- dup =only (! Giving up.) = flush
- } if
- /findfont cvx /invalidfont signalerror
- } if
- % Substitute for the font. Don't alias.
- % Same stack as at the beginning of .dofindfont.
- $error /SubstituteFont get exec
- %
- % igorm: I guess the surrounding code assumes that .stdsubstfont
- % must ADD an alias to allow .checkalias and .findfont to work properly.
- % Also I guess that a trailing recursion is
- % used in .dofindfont and through .stdsubstfont
- % just to represent a simple iteration,
- % which accumulates the aliases after the mark.
- .stdsubstfont
- } ifelse
- } ifelse
- } if
-} bind def
-% Try to find a font using only the present contents of Fontmap.
-/.tryfindfont { % <fontname> .tryfindfont <font> true
- % <fontname> .tryfindfont false
- .FontDirectory 1 index .fontknownget
- { % Already loaded
- exch pop true
- }
- { dup Fontmap exch .knownget not
- { % Unknown font name. Look for a file with the
- % same name as the requested font.
- .tryloadfont
- }
- { % Try each element of the Fontmap in turn.
- false exch % (in case we exhaust the list)
- % Stack: fontname false fontmaplist
- { exch pop
- dup type /nametype eq
- { % Font alias
- .checkalias .tryfindfont exit
- }
- { dup dup type dup /arraytype eq exch /packedarraytype eq or exch xcheck and
- { % Font with a procedural definition
- exec % The procedure will load the font.
- % Check to make sure this really happened.
- .FontDirectory 1 index .knownget
- { exch pop true exit }
- if
- }
- { % Font file name
- .loadfontloop { true exit } if
- }
- ifelse
- }
- ifelse false
- }
- forall
- % Stack: font true -or- fontname false
- { true
- }
- { % None of the Fontmap entries worked.
- % Try loading a file with the same name
- % as the requested font.
- .tryloadfont
- }
- ifelse
- }
- ifelse
- }
- ifelse
- } bind def
-
-% any user of .putgstringcopy must use bind and executeonly
-/.putgstringcopy % <dict> <name> <string> .putgstringcopy -
-{ 2 index gcheck currentglobal
- 2 copy eq {
- pop pop .forceput
- } {
- 5 1 roll setglobal
- dup length string copy
- .forceput setglobal
- } ifelse
-} .bind odef % must be bound and hidden for .forceput
-
-
-% Attempt to load a font from a file.
-/.tryloadfont { % <fontname> .tryloadfont <font> true
- % <fontname> .tryloadfont false
- dup .nametostring
- % Hack: check for the presence of the resource machinery.
- /.genericrfn where {
- pop
- pop dup .fonttempstring /FontResourceDir getsystemparam .genericrfn
- .loadfontloop {
- //true
- } {
- dup .nametostring .loadfontloop
- } ifelse
- } {
- .loadfontloop
- } ifelse
-} bind def
-/.loadfontloop { % <fontname> <filename> .loadfontloop
- % <font> true
- % -or-
- % <fontname> false
- % See above regarding the use of 'loop'.
- { % Is the font name a string?
- dup type /stringtype ne
- { QUIET not
- { (Can't find font with non-string name: ) print dup =only (.) = flush
- }
- if pop false exit
- }
- if
- % Can we open the file?
- findlibfile not
- { QUIET not
- { (Can't find \(or can't open\) font file ) print dup print
- (.) = flush
- }
- if pop false exit
- }
- if
-
- % Stack: fontname fontfilename fontfile
- DISKFONTS
- { .currentglobal true .setglobal
- 2 index (r) file
- FontFileDirectory exch 5 index exch .growput
- .setglobal
- }
- if
- QUIET not
- { (Loading ) print 2 index =only
- ( font from ) print 1 index print (... ) print flush
- }
- if
- % If LOCALFONTS isn't set, load the font into local or global
- % VM according to FontType; if LOCALFONTS is set, load the font
- % into the current VM, which is what Adobe printers (but not
- % DPS or CPSI) do.
- LOCALFONTS { false } { /setglobal where } ifelse
- { pop /FontType .findfontvalue { 1 eq } { false } ifelse
- % .setglobal, like setglobal, aliases FontDirectory to
- % GlobalFontDirectory if appropriate. However, we mustn't
- % allow the current version of .setglobal to be bound in,
- % because it's different depending on language level.
- .currentglobal exch /.setglobal .systemvar exec
- % Remove the fake definition, if any.
- .FontDirectory 3 index .forceundef % readonly
- 1 index (r) file .loadfont .FontDirectory exch
- /.setglobal .systemvar exec
- }
- { .loadfont .FontDirectory
- }
- ifelse
- % Stack: fontname fontfilename fontdirectory
- QUIET not
- { //systemdict /level2dict known
- { .currentglobal false .setglobal vmstatus
- true .setglobal vmstatus 3 -1 roll pop
- 6 -1 roll .setglobal 5
- }
- { vmstatus 3
- }
- ifelse { =only ( ) print } repeat
- (done.) = flush
- } if
-
- % Check to make sure the font was actually loaded.
- dup 3 index .fontknownget
- { dup /PathLoad 4 index //.putgstringcopy exec
- 4 1 roll pop pop pop true exit
- } if
-
- % Maybe the file had a different FontName.
- % See if we can get a FontName from the file, and if so,
- % whether a font by that name exists now.
- exch dup % Stack: origfontname fontdirectory path path
- (r) file .findfontname
- { % Stack: origfontname fontdirectory path filefontname
- 2 index 1 index .fontknownget
- { % Yes. Stack: origfontname fontdirectory path filefontname fontdict
- dup 4 -1 roll /PathLoad exch //.putgstringcopy exec
- % Stack: origfontname fontdirectory filefontname fontdict
- 3 -1 roll pop exch
- % Stack: origfontname fontdict filefontname
- QUIET
- { pop
- }
- { (Using ) print =only
- ( font for ) print 1 index =only
- (.) = flush
- }
- ifelse % Stack: origfontname fontdict
- exch pop true exit
- % Stack: fontdict
- }
- if pop % Stack: origfontname fontdirectory path
- }
- if pop pop % Stack: origfontname
-
- % The font definitely did not load correctly.
- QUIET not
- { (Loading ) print dup =only
- ( font failed.) = flush
- } if
- false exit
-
- } loop % end of loop
-
- } bind executeonly def % must be bound and hidden for .putgstringcopy
-
-currentdict /.putgstringcopy .undef
-
-% Define a procedure to load all known fonts.
-% This isn't likely to be very useful.
-/loadallfonts
- { Fontmap { pop findfont pop } forall
- } bind def
-
-% If requested, load all the fonts defined in the Fontmap into FontDirectory
-% as "fake" fonts i.e., font dicts with only FontName and FontType defined.
-% (We define FontType only for the sake of some questionable code in the
-% Apple Printer Utility 2.0 font inquiry code.)
-%
-% Note that this procedure only creates fake fonts in the FontDirectory
-% associated with the current VM. This is because in multi-context systems,
-% creating the fake fonts in local VM leads to undesirable complications.
-/.definefakefonts
- {
- }
- {
- (gs_fonts FAKEFONTS) VMDEBUG
- Fontmap {
- pop dup type /stringtype eq { cvn } if
- .FontDirectory 1 index known not {
- 2 dict dup /FontName 3 index put
- dup /FontType 1 put
- .FontDirectory 3 1 roll { put } //superexec % readonly
- } {
- pop
- } ifelse
- } forall
- }
-FAKEFONTS { exch } if pop def % don't bind, .current/setglobal get redefined
-
-% Install initial fonts from Fontmap.
-/.loadinitialfonts
- { NOFONTMAP not
- { /FONTMAP where
- { pop [ FONTMAP .pathlist ]
- { dup VMDEBUG findlibfile
- { exch pop .loadFontmap }
- { /undefinedfilename signalerror }
- ifelse
- }
- }
- { LIBPATH
- { defaultfontmap
- false .file_name_combine
- {
- dup VMDEBUG
- (r) { file } .internalstopped {
- pop pop
- defaultfontmap_content { .definefontmap } forall
- } {
- .loadFontmap
- } ifelse
- } {
- pop pop
- } ifelse
- }
- }
- ifelse forall
- }
- if
- userdict /defaultfontmap_content .undef
- .definefakefonts % current VM is global
- } def % don't bind, .current/setglobal get redefined
-
-% ---------------- Synthetic font support ---------------- %
-
-% Create a new font by modifying an existing one. paramdict contains
-% entries with the same keys as the ones found in a Type 1 font;
-% it should also contain enough empty entries to allow adding the
-% corresponding non-overridden entries from the original font dictionary,
-% including FID. If paramdict includes a FontInfo entry, this will
-% also override the original font's FontInfo, entry by entry;
-% again, it must contain enough empty entries.
-
-% Note that this procedure does not perform a definefont.
-
-/.makemodifiedfont % <fontdict> <paramdict> .makemodifiedfont <fontdict'>
- { exch
- { % Stack: destdict key value
- 1 index /FID ne
- { 2 index 2 index known
- { % Skip fontdict entry supplied in paramdict, but
- % handle FontInfo specially.
- 1 index /FontInfo eq
- { 2 index 2 index get % new FontInfo
- 1 index % old FontInfo
- { % Stack: destdict key value destinfo key value
- 2 index 2 index known
- { pop pop }
- { 2 index 3 1 roll put }
- ifelse
- }
- forall pop
- }
- if
- }
- { % No override, copy the fontdict entry.
- 2 index 3 1 roll put
- dup dup % to match pop pop below
- }
- ifelse
- }
- if
- pop pop
- } forall
- } bind def
-
-% Make a modified font and define it. Note that unlike definefont,
-% this does not leave the font on the operand stack.
-
-/.definemodifiedfont % <fontdict> <paramdict> .definemodifiedfont -
- { .makemodifiedfont
- dup /FontName get exch definefont pop
- } bind def