diff options
Diffstat (limited to 'Master/tlpkg/tlgs/Resource/Init/gs_fonts.ps')
-rw-r--r-- | Master/tlpkg/tlgs/Resource/Init/gs_fonts.ps | 1288 |
1 files changed, 1288 insertions, 0 deletions
diff --git a/Master/tlpkg/tlgs/Resource/Init/gs_fonts.ps b/Master/tlpkg/tlgs/Resource/Init/gs_fonts.ps new file mode 100644 index 00000000000..a3da615cb3f --- /dev/null +++ b/Master/tlpkg/tlgs/Resource/Init/gs_fonts.ps @@ -0,0 +1,1288 @@ +% Copyright (C) 2001-2012 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., 7 Mt. Lassen Drive - Suite A-134, San Rafael, +% CA 94903, U.S.A., +1(415)492-9861, for further information. +% + +% 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 Artifex. +% 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 +userdict /.nativeFontmap .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. +/.definefontmapaux % <bool> <fontname> <file|alias> .definefontmapaux - + { % 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 //== exec flush } if + cvn exch cvn .definefontmapaux % 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 + + 4 -1 roll {.nativeFontmap}{Fontmap} ifelse + 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 + +/.definefontmap % <fontname> <file|alias> .definefontmap - +{ + //false 3 1 roll //.definefontmapaux exec +} bind def + +/.definenativefontmap % <fontname> <file|alias> .definenativefontmap - +{ + //true 3 1 roll //.definefontmapaux exec +} 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 { //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 .nativeFontmap exch known + { pop pop + } + { exch copystring exch + DEBUG { ( ) print dup =only flush } if + 1 index .definenativefontmap + .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 +systemdict /NONATIVEFONTMAP known .setnativefontmapbuilt +/.buildnativefontmap { % - .buildnativefontmap <bool> + systemdict /.nativefontmapbuilt .knownget not + { //false} if + + {//false} + { + 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 } .internalstopped + { + % skip the entry if we can't open the returned path + pop pop pop + }{ + % we could open the font file + mark 2 1 roll + {.findfontname} .internalstopped + { + cleartomark + pop + } + { + counttomark 1 add -1 roll pop + 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 .definenativefontmap + } ifelse + } ifelse + } forall + } if + % record that we've been run + //true .setnativefontmapbuilt + } ifelse +} 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 [ + % Define substitutes for the fonts we define in Fontmap.GS + [(Charter) /Times 0] + [(Utopia) /Times 0] + [(Antiqua) /Times 0] + [(Calligraphic) /Helvetica 0] + [(Hershey) /Times 0] + % 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) 1] [(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 + { + .nativeFontmap 1 index known not + {pop defaultfontname } if + } 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. + .buildnativefontmap { + % 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 + { //true //true } + { % Unknown font name. Look for a file with the + % same name as the requested font. + dup .tryloadfont + { exch pop //true //false } + { + % if we can't load by name check the native font map + dup .nativeFontmap exch .knownget + { //true //true } + { //false //false } ifelse + } ifelse + } ifelse + + { % Try each element of the Fontmap in turn. + pop + //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 + //true .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 + } + if + } + 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 + {//false .loadfontloop} .internalstopped {//false} if { + //true + } { + dup .nametostring + {//true .loadfontloop} .internalstopped {//false} if + } ifelse + } { + {//true .loadfontloop} .internalstopped {//false} if + } ifelse +} bind def + +/.loadfontloop { % <fontname> <filename> <libflag> .loadfontloop + % <font> true + % -or- + % <fontname> false + % See above regarding the use of 'loop'. + { % Is the font name a string? + 1 index type /stringtype ne + { pop + QUIET not + { (Can't find font with non-string name: ) print dup =only (.) = flush + } + if pop //false exit + } if + + % check <libflag> + { + findlibfile not + } { + dup (r) { file } stopped { + pop pop //true + } { + //false + } ifelse + } ifelse { + 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 + % Stack: origfontname filefontname fontdict + dup /FontName get dup FontDirectory exch .forceundef + GlobalFontDirectory exch .forceundef + dup length dict .copydict dup 3 index /FontName exch put + 2 index exch definefont + exch + 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 .nativeFontmap] { { pop findfont pop } forall } 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 .nativeFontmap ] + { + { + 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 + } 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 |