home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 April / PCWorld_2001-04_cd.bin / Software / Vyzkuste / gs / gs650w32.exe / gs6.50 / lib / gs_fonts.ps < prev    next >
Text File  |  2000-12-05  |  33KB  |  1,044 lines
  1. %    Copyright (C) 1990, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of AFPL Ghostscript.
  4. % 
  5. % AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6. % distributor accepts any responsibility for the consequences of using it, or
  7. % for whether it serves any particular purpose or works at all, unless he or
  8. % she says so in writing.  Refer to the Aladdin Free Public License (the
  9. % "License") for full details.
  10. % 
  11. % Every copy of AFPL Ghostscript must include a copy of the License, normally
  12. % in a plain ASCII text file named PUBLIC.  The License grants you the right
  13. % to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14. % conditions described in the License.  Among other things, the License
  15. % requires that the copyright notice and this notice be preserved on all
  16. % copies.
  17.  
  18. % $Id: gs_fonts.ps,v 1.9 2000/09/19 18:29:11 lpd Exp $
  19. % Font initialization and management code.
  20.  
  21. % Define the default font.
  22. /defaultfontname /Courier def
  23.  
  24. % Define the name of the font map file.
  25. /defaultfontmap (Fontmap) def
  26.  
  27. % ------ End of editable parameters ------ %
  28.  
  29. % Define the UniqueIDs and organization XUID assigned to Aladdin.
  30. % UniqueIDs 5,066,501 - 5,066,580 are assigned as follows:
  31. %   01 and 02 for shareware Cyrillic
  32. %   33 through 67 for Type 1 versions of the Hershey fonts
  33. % UniqueIDs 5,115,501 - 5,115,600 are currently unassigned.
  34. /AladdinEnterprisesXUID 107 def
  35.  
  36. % If SUBSTFONT is defined, make it the default font.
  37. /SUBSTFONT where { pop /defaultfontname /SUBSTFONT load def } if
  38.  
  39. % Define a reliable way of accessing FontDirectory in systemdict.
  40. /.FontDirectory
  41. { /FontDirectory .systemvar
  42. } .bind odef
  43.  
  44. % If DISKFONTS is true, we load individual CharStrings as they are needed.
  45. % (This is intended primarily for machines with very small memories.)
  46. % In this case, we define another dictionary, parallel to FontDirectory,
  47. % that retains an open file for every font loaded.
  48. /FontFileDirectory 10 dict def
  49.  
  50. % Define a temporary string for local use, since using =string
  51. % interferes with some PostScript programs.
  52. /.fonttempstring 128 string def
  53.  
  54. % Split up a search path into individual directories or files.
  55. /.pathlist        % <path> .pathlist <dir1|file1> ...
  56.  {  { dup length 0 eq { pop exit } if
  57.       .filenamelistseparator search not { exit } if
  58.       exch pop exch
  59.     }
  60.    loop
  61.  } bind def
  62.  
  63. % Load a font name -> font file name map.
  64. userdict /Fontmap .FontDirectory maxlength dict put
  65. /.loadFontmap {        % <file> .loadFontmap -
  66.         % We would like to simply execute .definefontmap as we read,
  67.         % but we have to maintain backward compatibility with an older
  68.         % specification that makes later entries override earlier
  69.         % ones within the same file.
  70.    50 dict exch .readFontmap
  71.     { .definefontmap } forall
  72. } bind def
  73. /.readFontmap {        % <dict> <file> .readFontmap <dict>
  74.     { dup token not { closefile exit } if
  75.         % stack: dict file fontname
  76.       % This is a hack to get around the absurd habit of MS-DOS editors
  77.       % of adding an EOF character at the end of the file.
  78.       dup (\032) eq { pop closefile exit } if
  79.       1 index token not
  80.        { (Fontmap entry for ) print dup =only
  81.      ( has no associated file or alias name!  Giving up.) = flush
  82.      {.readFontmap} 0 get 1 .quit
  83.        } if
  84.       dup type dup /stringtype eq exch /nametype eq or not
  85.        { (Fontmap entry for ) print 1 index =only
  86.      ( has an invalid file or alias name!  Giving up.) = flush
  87.      {.readFontmap} 0 get 1 .quit
  88.        } if
  89.         % stack: dict file fontname filename|aliasname
  90.       1 index type /stringtype eq
  91.       1 index type /nametype eq and 1 index xcheck and
  92.       1 index /run eq 2 index /.runlibfile eq or and {
  93.         % This is an inclusion entry.
  94.     pop findlibfile { exch pop } { file } ifelse
  95.     2 index exch .readFontmap pop
  96.       } {
  97.         % This is a real entry.
  98.         % Read and pop tokens until a semicolon.
  99.        { 2 index token not
  100.       { (Fontmap entry for ) print 1 index =only
  101.         ( ends prematurely!  Giving up.) = flush
  102.         {.loadFontmap} 0 get 1 .quit
  103.       } if
  104.      dup /; eq { pop 3 index 3 1 roll .growput exit } if
  105.      pop
  106.        } loop
  107.       } ifelse
  108.     } loop
  109. } bind def
  110. % Add an entry in Fontmap.  We redefine this if the Level 2
  111. % resource machinery is loaded.
  112. /.definefontmap            % <fontname> <file|alias> .definefontmap -
  113.  {        % Since Fontmap is global, make sure the values are storable.
  114.    .currentglobal 3 1 roll true .setglobal
  115.    dup type /stringtype eq
  116.     { dup .gcheck not { dup length string copy } if
  117.     }
  118.    if
  119.    Fontmap 3 -1 roll 2 copy .knownget
  120.     {        % Add an element to the end of the existing value,
  121.         % unless it's the same as the current last element.
  122.       mark exch aload pop counttomark 4 add -1 roll
  123.       2 copy eq { cleartomark pop pop } { ] readonly .growput } ifelse
  124.     }
  125.     {        % Make a new entry.
  126.       mark 4 -1 roll ] readonly .growput
  127.     }
  128.    ifelse .setglobal
  129.  } bind def
  130.  
  131. % Parse a font file just enough to find the FontName or FontType.
  132. /.findfontvalue {    % <file> <key> .findfontvalue <value> true
  133.             % <file> <key> .findfontvalue false
  134.             % Closes the file in either case.
  135.   exch dup read not { -1 } if
  136.   2 copy unread 16#80 eq {
  137.     dup (xxxxxx) readstring pop pop        % skip .PFB header
  138.   } if
  139.   {        % Stack: key file
  140.         % Protect ourselves against syntax errors here.
  141.     dup { token } stopped { pop false exit } if
  142.     not { false exit } if        % end of file
  143.     dup /eexec eq { pop false exit } if        % reached eexec section
  144.     dup /Subrs eq { pop false exit } if        % Subrs without eexec
  145.     dup /CharStrings eq { pop false exit } if    % CharStrings without eexec
  146.     dup 3 index eq
  147.      { xcheck not { dup token exit } if }    % found key
  148.      { pop }
  149.     ifelse
  150.   } loop
  151.         % Stack: key file value true   (or)
  152.         % Stack: key file false
  153.   dup { 4 } { 3 } ifelse -2 roll closefile pop
  154. } bind def
  155. /.findfontname
  156.  { /FontName .findfontvalue
  157.  } bind def
  158.  
  159. % If there is no FONTPATH, try to get one from the environment.
  160. NOFONTPATH { /FONTPATH () def } if
  161. /FONTPATH where
  162.  { pop }
  163.  { /FONTPATH (GS_FONTPATH) getenv not { () } if def }
  164. ifelse
  165. FONTPATH length 0 eq { (%END FONTPATH) .skipeof } if
  166. /FONTPATH [ FONTPATH .pathlist ] def
  167.  
  168. % Scan directories looking for plausible fonts.  "Plausible" means that
  169. % the file begins with %!PS-AdobeFont or %!FontType1, or with \200\001
  170. % followed by four arbitrary bytes and then either of these strings.
  171. % To speed up the search, we skip any file whose name appears in
  172. % the Fontmap (with any extension and upper/lower case variation) already,
  173. % and any file whose extension definitely indicates it is not a font.
  174. %
  175. % NOTE: The current implementation of this procedure is somewhat Unix/DOS-
  176. % specific.  It assumes that '/' and '\' are directory separators, and that
  177. % the part of a file name following the last '.' is the extension.
  178. %
  179. /.lowerstring        % <string> .lowerstring <lowerstring>
  180.  { 0 1 2 index length 1 sub
  181.     { 2 copy get dup 65 ge exch 90 le and
  182.        { 2 copy 2 copy get 32 add put }
  183.      if pop
  184.     }
  185.    for
  186.  } bind def
  187. /.splitfilename {    % <dir.../base.extn> .basename <base> <extn>
  188.         % Make the file name read-only to detect aliasing bugs.
  189.         % We really don't like doing this, but we've had one
  190.         % such bug already.
  191.   readonly {
  192.     (/) search { true } { (\\) search } ifelse { pop pop } { exit } ifelse
  193.   } loop
  194.   dup { (.) search { pop pop } { exit } ifelse } loop
  195.   2 copy eq {
  196.     pop ()
  197.   } {
  198.     exch dup length 2 index length 1 add sub 0 exch getinterval exch
  199.   } ifelse
  200. } bind def
  201. /.scanfontdict 1 dict def        % establish a binding
  202. /.scanfontbegin
  203.  {    % Construct the table of all file names already in Fontmap.
  204.    currentglobal true setglobal
  205.    .scanfontdict dup maxlength Fontmap length 2 add .max .setmaxlength
  206.    Fontmap
  207.     { exch pop
  208.        { dup type /stringtype eq
  209.       { .splitfilename pop .fonttempstring copy .lowerstring cvn
  210.         .scanfontdict exch true put
  211.       }
  212.       { pop
  213.       }
  214.      ifelse
  215.        }
  216.       forall
  217.     }
  218.    forall
  219.    setglobal
  220.  } bind def
  221. /.scanfontskip mark
  222.         % Strings are converted to names anyway, so....
  223.   /afm true
  224.   /bat true
  225.   /c true
  226.   /cmd true
  227.   /com true
  228.   /dir true
  229.   /dll true
  230.   /doc true
  231.   /drv true
  232.   /exe true
  233.   /fon true
  234.   /fot true
  235.   /h true
  236.   /o true
  237.   /obj true
  238.   /pfm true
  239.   /pss true        % Adobe Multiple Master font instances
  240.   /txt true
  241. .dicttomark def
  242. /.scan1fontstring 128 string def
  243. % %%BeginFont: is not per Adobe documentation, but a few fonts have it.
  244. /.scanfontheaders [(%!PS-Adobe*) (%!FontType*) (%%BeginFont:*)] def
  245. 0 .scanfontheaders { length max } forall 6 add    % extra for PFB header
  246. /.scan1fontfirst exch string def
  247. /.scanfontdir        % <dirname> .scanfontdir -
  248.  { currentglobal exch true setglobal
  249.    QUIET not { (Scanning ) print dup print ( for fonts...) print flush } if
  250.    (*) 2 copy .filenamedirseparator
  251.    dup (\\) eq { pop (\\\\) } if    % double \ for pattern match
  252.    exch concatstrings concatstrings
  253.    0 0 0 4 -1 roll    % found scanned files
  254.     {        % stack: <fontcount> <scancount> <filecount> <filename>
  255.       exch 1 add exch                   % increment filecount
  256.       dup .splitfilename .fonttempstring copy .lowerstring
  257.         % stack: <fontcount> <scancount> <filecount+1> <filename>
  258.         %    <BASE> <ext>
  259.       .scanfontskip exch known exch .scanfontdict exch known or
  260.        { pop
  261.         % stack: <fontcount> <scancount> <filecount+1>
  262.        }
  263.        { 3 -1 roll 1 add 3 1 roll
  264.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  265.      dup (r) { file } .internalstopped
  266.       { pop pop null ()
  267.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  268.         %    null ()
  269.       }
  270.       {
  271.         % On some platforms, the file operator will open directories,
  272.         % but an error will occur if we try to read from one.
  273.         % Handle this possibility here.
  274.         dup .scan1fontfirst { readstring } .internalstopped
  275.          { pop pop () }
  276.          { pop }
  277.         ifelse
  278.         % stack: <fontcount> <scancount+1> <filecount+1>
  279.         %    <filename> <file> <header>
  280.       }
  281.      ifelse
  282.         % Check for PFB file header.
  283.      dup (\200\001????*) .stringmatch
  284.       { dup length 6 sub 6 exch getinterval }
  285.      if
  286.         % Check for font file headers.
  287.      false .scanfontheaders
  288.       { 2 index exch .stringmatch or
  289.       }
  290.      forall exch pop
  291.       {    % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  292.         %    <file>
  293.         dup 0 setfileposition .findfontname
  294.          { dup Fontmap exch known
  295.         { pop pop
  296.         }
  297.         { exch copystring exch
  298.           DEBUG { ( ) print dup =only flush } if
  299.           1 index .definefontmap
  300.           .splitfilename pop true .scanfontdict 3 1 roll .growput
  301.             % Increment fontcount.
  302.           3 -1 roll 1 add 3 1 roll
  303.         }
  304.            ifelse
  305.          }
  306.          { pop
  307.          }
  308.         ifelse
  309.       }
  310.         % .findfontname will have done a closefile in the above case.
  311.       { dup null eq { pop } { closefile } ifelse pop
  312.       }
  313.      ifelse
  314.        }
  315.       ifelse
  316.     }
  317.    .scan1fontstring filenameforall
  318.    QUIET
  319.     { pop pop pop }
  320.     { ( ) print =only ( files, ) print =only ( scanned, ) print
  321.       =only ( new fonts.) = flush
  322.     }
  323.    ifelse
  324.    setglobal
  325.  } bind def
  326.  
  327. %END FONTPATH
  328.  
  329. % Create the dictionary that registers the .buildfont procedure (called by
  330. % definefont) for each FontType.
  331. /buildfontdict 20 dict def
  332.  
  333. % Register Type 3 fonts, which are always supported, for definefont.
  334. buildfontdict 3 /.buildfont3 cvx put
  335.  
  336. % Register Type 0 fonts if they are supported.  Strictly speaking,
  337. % we should do this in its own file (gs_type0.ps), but since this is
  338. % the only thing that would be in that file, it's simpler to put it here.
  339. /.buildfont0 where { pop buildfontdict 0 /.buildfont0 cvx put } if
  340.  
  341. % Define definefont.  This is a procedure built on a set of operators
  342. % that do all the error checking and key insertion.
  343. /.growfontdict
  344.  {    % Grow the font dictionary, if necessary, to ensure room for an
  345.     % added entry, making sure there is at least one slot left for FID.
  346.    dup maxlength 1 index length sub 2 lt
  347.     { dup dup wcheck
  348.        { .growdict }
  349.        { .growdictlength dict .copydict }
  350.       ifelse
  351.     }
  352.     { dup wcheck not { dup maxlength dict .copydict } if
  353.     }
  354.    ifelse
  355.  } bind def 
  356. /.completefont {
  357.   {        % Check for disabled platform fonts.
  358.       NOPLATFONTS
  359.        {    % Make sure we leave room for FID.
  360.      .growfontdict dup /ExactSize 0 put
  361.        }
  362.        {    % Hack: if the Encoding looks like it might be the
  363.         % Symbol or Dingbats encoding, load those now (for the
  364.         % benefit of platform font matching) just in case
  365.         % the font didn't actually reference them.
  366.         % Note that some types of font don't have an Encoding.
  367.      dup /Encoding .knownget {
  368.        dup length 65 ge {
  369.          64 get
  370.          dup /congruent eq { SymbolEncoding pop } if
  371.          /a9 eq { DingbatsEncoding pop } if
  372.        } {
  373.          pop
  374.        } ifelse
  375.      } if
  376.        }
  377.       ifelse
  378.       true exch
  379.         % If this is a CIDFont, CIDFontType takes precedence
  380.         % over FontType.
  381.       dup /CIDFontType known {
  382.     /.buildcidfont where {
  383.       pop exch not exch    % true => false
  384.     } if
  385.       } if
  386.       exch {
  387.     dup /FontType get //buildfontdict exch get exec
  388.       } {
  389.     .buildcidfont
  390.       } ifelse
  391.  
  392.       DISKFONTS
  393.        { FontFileDirectory 2 index known
  394.       { dup /FontFile FontFileDirectory 4 index get .growput
  395.       }
  396.      if
  397.        }
  398.       if
  399.       readonly        % stack: name fontdict
  400.   } stopped { /invalidfont signalerror } if
  401. } bind odef
  402. /definefont
  403.  { .completefont
  404.         % If the current allocation mode is global, also enter
  405.         % the font in LocalFontDirectory.
  406.    .currentglobal
  407.     { //systemdict /LocalFontDirectory .knownget
  408.        { 2 index 2 index .growput }
  409.       if
  410.     }
  411.    if
  412.    dup .FontDirectory 4 -2 roll .growput
  413.         % If the font originated as a resource, register it.
  414.    currentfile .currentresourcefile eq { dup .registerfont } if
  415.  } odef
  416.  
  417. % Define a procedure for defining aliased fonts.
  418. % We use this only for explicitly aliased fonts, not substituted fonts:
  419. % we think this matches the observed behavior of Adobe interpreters.
  420. /.aliasfont        % <name> <font> .aliasfont <newFont>
  421.  { .currentglobal 3 1 roll dup .gcheck .setglobal
  422.    dup length 2 add dict
  423.    dup 3 -1 roll { 1 index /FID eq { pop pop } { put dup } ifelse } forall
  424.         % Stack: global fontname newfont newfont.
  425.         % We might be defining a global font whose FontName
  426.         % is a local string.  This is weird, but legal,
  427.         % and doesn't cause problems anywhere else:
  428.         % to avoid any possible problems in this case, do a cvn.
  429.         % We might also be defining (as an alias) a global font
  430.         % whose FontName is a local non-string, if someone passed a
  431.         % garbage value to findfont.  In this case, just don't
  432.         % call definefont at all.
  433.    2 index dup type /stringtype eq exch .gcheck or 1 index .gcheck not or
  434.     { /FontName 3 index dup type /stringtype eq { cvn } if put
  435.         % Don't bind in definefont, since Level 2 redefines it.
  436.       /definefont .systemvar exec
  437.     }
  438.     { .completefont pop exch pop
  439.     }
  440.    ifelse exch .setglobal
  441.  } odef        % so findfont will bind it
  442.  
  443. % Define .loadfontfile for loading a font.  If we recognize Type 1 and/or
  444. % TrueType fonts, gs_type1.ps and/or gs_ttf.ps will redefine this.
  445. /.loadfontfile {
  446.         % According to Ed Taft, Adobe interpreters push userdict
  447.         % before loading a font, and pop it afterwards.
  448.   userdict begin
  449.     cvx exec
  450.   end
  451. } bind def
  452. /.loadfont
  453.  {        % Some buggy fonts leave extra junk on the stack,
  454.         % so we have to make a closure that records the stack depth
  455.         % in a fail-safe way.
  456.    {{.loadfontfile} .execasresource} count 1 sub 2 .execn
  457.    count exch sub { pop } repeat
  458.  } bind def
  459.  
  460. % Find an alternate font to substitute for an unknown one.
  461. % We go to some trouble to parse the font name and extract
  462. % properties from it.  Later entries take priority over earlier.
  463. /.substitutefaces [
  464.     % Guess at suitable substitutions for random unknown fonts.
  465.   [(Chancery) /ZapfChancery-MediumItalic 0]
  466.   [(Grot) /Times 0]
  467.   [(Roman) /Times 0]
  468.   [(Book) /NewCenturySchlbk 0]
  469.     % If the family name appears in the font name,
  470.     % use a font from that family.
  471.   [(Arial) /Helvetica 0]
  472.   [(Avant) /AvantGarde 0]
  473.   [(Bookman) /Bookman 0]
  474.   [(Century) /NewCenturySchlbk 0]
  475.   [(Cour) /Courier 0]
  476.   [(Frut) /Helvetica 0]
  477.   [(Garamond) /Palatino 0]
  478.   [(Geneva) /Helvetica 0]
  479.   [(Helv) /Helvetica 0]
  480.   [(NewYork) /Bookman 0]
  481.   [(Pala) /Palatino 0]
  482.   [(Schlbk) /NewCenturySchlbk 0]
  483.   [(Swiss) /Helvetica 0]
  484.   [(Symbol) /Symbol 0]
  485.   [(Times) /Times 0]
  486.   [(Univers) /Helvetica 0]
  487.     % Substitute for Adobe Multiple Master fonts.
  488.   [(Minion) /Times 0]
  489.   [(Myriad) /Helvetica 0]
  490.     % If the font wants to be monospace, use Courier.
  491.   [(Monospace) /Courier 0]
  492.   [(Typewriter) /Courier 0]
  493.     % Define substitutes for the other Adobe PostScript 3 fonts.
  494.     % For some of them, the substitution is pretty bad!
  495.   [(Albertus) /NewCenturySchlbk 0]
  496.   [(AntiqueOlive) /Helvetica 0]
  497.   [(Bodoni) /Palatino 0]
  498.   [(Chicago) /Helvetica 2]
  499.   [(Clarendon) /Bookman 0]
  500.   [(Cooper) /NewCenturySchlbk 0]
  501.   [(Copperplate) /AvantGarde 0]    % inappropriate, small-cap font
  502.   [(Coronet) /ZapfChancery-MediumItalic 0]
  503.   [(Eurostile) /AvantGarde 0]    % inappropriate
  504.   [(Geneva) /Courier 2]        % should be fixed-pitch sans demi
  505.   [(GillSans) /AvantGarde 2]
  506.   [(GillSans-Light) /AvantGarde 0]
  507.   [(Goudy) /Palatino 0]
  508.   [(Hoefler) /NewCenturySchlbk 0]
  509.   [(Joanna) /Times 0]
  510.   [(LetterGothic) /Courier 0]    % should be fixed-pitch sans
  511.   [(LubalinGraph-Book) /Bookman 2]
  512.   [(LubalinGraph-Demi) /Bookman 0]
  513.   [(Marigold) /ZapfChancery-MediumItalic 0]
  514.   [(MonaLisa-Recut) /Palatino 0]    % inappropriate
  515.   [(Monaco) /Courier 2]        % should be fixed-pitch sans demi
  516.   [(Optima) /Helvetica 0]
  517.   [(Oxford) /ZapfChancery-MediumItalic 0]
  518.   [(Tekton) /AvantGarde 0]
  519.   [(Univers) /AvantGarde 0]
  520. ] readonly def
  521. /.substituteproperties [
  522.   [(It) 9] [(Oblique) 1]
  523.   [(Black) 2] [(Bd) 2] [(Bold) 2] [(bold) 2] [(Demi) 2] [(Heavy) 2] [(Sb) 2]
  524.   [(Cn) 4] [(Cond) 4] [(Narrow) 4] [(Pkg) 4]
  525.   [(Serif) 8] [(Sans) -8]
  526. ] readonly def
  527. /.fontnameproperties {        % <int> <string|name> .fontnameproperties
  528.                 %   <int'>
  529.   .fontnamestring
  530.   .substituteproperties {
  531.     2 copy 0 get search {
  532.       pop pop pop dup length 1 sub 1 exch getinterval 3 -1 roll exch {
  533.     dup 0 ge { or } { neg not and } ifelse
  534.       } forall exch
  535.     } {
  536.       pop pop
  537.     } ifelse
  538.   } forall pop
  539. } bind def
  540. /.substitutefamilies mark
  541.   /AvantGarde
  542.     {/AvantGarde-Book /AvantGarde-BookOblique
  543.      /AvantGarde-Demi /AvantGarde-DemiOblique}
  544.   /Bookman
  545.     {/Bookman-Demi /Bookman-DemiItalic /Bookman-Light /Bookman-LightItalic}
  546.   /Courier
  547.     {/Courier /Courier-Oblique /Courier-Bold /Courier-BoldOblique}
  548.   /Helvetica
  549.     {/Helvetica /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique
  550.      /Helvetica-Narrow /Helvetica-Narrow-Oblique
  551.      /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique}
  552.   /NewCenturySchlbk
  553.     {/NewCenturySchlbk-Roman /NewCenturySchlbk-Italic
  554.      /NewCenturySchlbk-Bold /NewCenturySchlbk-BoldItalic}
  555.   /Palatino
  556.     {/Palatino-Roman /Palatino-Italic /Palatino-Bold /Palatino-BoldItalic}
  557.   /Symbol
  558.     {/Symbol /Symbol /Symbol /Symbol}
  559.   /Times
  560.     {/Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic}
  561.   /ZapfChancery-MediumItalic
  562.     {/ZapfChancery-MediumItalic}
  563. .dicttomark readonly def
  564. /.nametostring {        % <name> .nametostring <string>
  565.                 % <other> .nametostring <other>
  566.   dup type /nametype eq { .namestring } if
  567. } bind def
  568. /.fontnamestring {        % <fontname> .fontnamestring <string|name>
  569.   dup type dup /nametype eq {
  570.     pop .namestring
  571.   } {
  572.     /stringtype ne { pop () } if
  573.   } ifelse
  574. } bind def
  575. /.substitutefontname {        % <fontname> <properties> .substitutefontname
  576.                 %   <altname|null>
  577.     % Look for properties and/or a face name in the font name.
  578.     % If we find any, use Times (serif) or Helvetica (sans) as the
  579.     % base font; otherwise, use the default font.
  580.     % Note that the "substituted" font name may be the same as
  581.     % the requested one; the caller must check this.
  582.   exch .fontnamestring {
  583.     defaultfontname /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique
  584.     /Helvetica-Narrow /Helvetica-Narrow-Oblique
  585.     /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique
  586.     /Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic
  587.     /Helvetica-Narrow /Helvetica-Narrow-Oblique
  588.     /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique
  589.   } 3 1 roll
  590.     % Stack: facelist properties fontname
  591.     % Look for a face name.
  592.   .substitutefaces {
  593.     2 copy 0 get search {
  594.       pop pop pop
  595.     % Stack: facelist properties fontname [(pattern) family properties]
  596.       dup 2 get 4 -1 roll or 3 1 roll
  597.       1 get .substitutefamilies exch get
  598.       4 -1 roll pop 3 1 roll
  599.     } {
  600.       pop pop
  601.     } ifelse
  602.   } forall pop
  603.   1 index length mod get exec
  604. } bind def
  605. /.substitutefont {        % <fontname> .substitutefont <altname>
  606.   dup 0 exch .fontnameproperties .substitutefontname
  607.     % Only accept fonts known in the Fontmap.
  608.    Fontmap 1 index known not { pop defaultfontname } if
  609. } bind def
  610.  
  611. % If requested, make (and recognize) fake entries in FontDirectory for fonts
  612. % present in Fontmap but not actually loaded.  Thanks to Ray Johnston for
  613. % the idea behind this code.
  614. FAKEFONTS not { (%END FAKEFONTS) .skipeof } if
  615.  
  616. % We use the presence or absence of the FontMatrix key to indicate whether
  617. % a font is real or fake.  We must pop the arguments at the very end,
  618. % so that stack protection will be effective.
  619.  
  620. /definefont {        % <name> <font> definefont <font>
  621.   dup /FontMatrix known {
  622.     //definefont
  623.   } {
  624.     2 copy /FontName get findfont //definefont exch pop exch pop
  625.   } ifelse
  626. } bind odef
  627.  
  628. /scalefont {        % <font> <scale> scalefont <font>
  629.   1 index /FontMatrix known {
  630.     //scalefont
  631.   } {
  632.     1 index /FontName get findfont 1 index //scalefont
  633.     exch pop exch pop
  634.   } ifelse
  635. } bind odef
  636.  
  637. /makefont {        % <font> <matrix> makefont <font>
  638.   1 index /FontMatrix known {
  639.     //makefont
  640.   } {
  641.     1 index /FontName get findfont 1 index //makefont
  642.     exch pop exch pop
  643.   } ifelse
  644. } bind odef
  645.  
  646. /setfont {        % <font> setfont -
  647.   dup /FontMatrix known {
  648.     //setfont
  649.   } {
  650.     dup /FontName get findfont //setfont pop
  651.   } ifelse
  652. } bind odef
  653.  
  654. %END FAKEFONTS
  655.  
  656. % Define findfont so it tries to load a font if it's not found.
  657. % The Red Book requires that findfont be a procedure, not an operator,
  658. % but it still needs to restore the stacks reliably if it fails,
  659. % so we do all the work in an operator.
  660. /.findfont {
  661.   mark 1 index
  662.   //systemdict begin .dofindfont
  663.     % Define any needed aliases.
  664.   counttomark 1 sub { .aliasfont } repeat end
  665.   exch pop exch pop
  666. } odef
  667. /findfont {
  668.   .findfont
  669. } bind def
  670. % Check whether the font name we are about to look for is already on the list
  671. % of aliases we're accumulating; if so, cause an error.
  672. /.checkalias        % -mark- <alias1> ... <name> .checkalias <<same>>
  673.  { counttomark 1 sub -1 1
  674.     { index 1 index eq
  675.        { pop QUIET not
  676.       { (Unable to substitute for font.) = flush
  677.       } if
  678.      /findfont cvx /invalidfont signalerror
  679.        }
  680.       if
  681.     }
  682.    for
  683.  } bind def
  684. % Get a (non-fake) font if present in a FontDirectory.
  685. /.fontknownget        % <fontdir> <fontname> .fontknownget <font> true
  686.             % <fontdir> <fontname> .fontknownget false
  687.  { .knownget
  688.     { FAKEFONTS
  689.        { dup /FontMatrix known { true } { pop false } ifelse }
  690.        { true }
  691.       ifelse
  692.     }
  693.     { false
  694.     }
  695.    ifelse
  696.  } bind def
  697. % This is the standard procedure for handling font substitution.
  698. % Its location is per an Adobe newsgroup posting.
  699. % It is called with the font name on the stack, standing in for findfont.
  700. /.stdsubstfont {    % mark <alias1> ... <fontname> .stdsubstfont <font>
  701.       /SUBSTFONT where {
  702.     pop QUIET not {
  703.       (Substituting for font ) print dup =only
  704.       (.) = flush
  705.     } if
  706.             % No aliasing.
  707.     cleartomark mark defaultfontname
  708.       } {
  709.     dup .substitutefont
  710.     2 copy eq { pop defaultfontname } if
  711.     .checkalias
  712.     QUIET not {
  713.       SHORTERRORS {
  714.         (%%[) print 1 index =only
  715.         ( not found, substituting ) print dup =only (]%%)
  716.       } {
  717.         (Substituting font ) print dup =only
  718.         ( for ) print 1 index =only (.)
  719.       } ifelse = flush
  720.     } if
  721.             % Remove all the accumulated aliases.
  722.     counttomark 1 add 1 roll cleartomark mark exch
  723.       } ifelse
  724.   .dofindfont
  725. } bind def
  726. $error /SubstituteFont { .stdsubstfont } put
  727. % Scan the next directory on FONTPATH.
  728. /.scannextfontdir {    % - .scannextfontdir <bool>
  729.             % If we haven't scanned all the directories in
  730.             % FONTPATH, scan the next one.
  731.   null 0 1 FONTPATH length 1 sub {
  732.     FONTPATH 1 index get null ne { exch pop exit } if pop
  733.   } for dup null ne {
  734.     dup 0 eq { .scanfontbegin } if
  735.     FONTPATH 1 index get .scanfontdir
  736.     FONTPATH exch null put true
  737.   } {
  738.     pop false
  739.   } ifelse
  740. } bind def
  741. % Do the work of findfont, including substitution, defaulting, and
  742. % scanning of FONTPATH.
  743. /.dofindfont {        % <fontname> .dofindfont <font>
  744.   .tryfindfont not {
  745.             % We didn't find the font.  If we haven't scanned
  746.             % all the directories in FONTPATH, scan the next one
  747.             % now and look for the font again.
  748.     .scannextfontdir {
  749.             % Start over with an empty alias list.
  750.       counttomark 1 sub { pop } repeat
  751.       .dofindfont
  752.     } {
  753.             % No luck.  Make sure we're not already
  754.             % looking for the default font.
  755.       dup defaultfontname eq {
  756.     QUIET not {
  757.       (Unable to load default font ) print
  758.       dup =only (!  Giving up.) = flush
  759.     } if
  760.     /findfont cvx /invalidfont signalerror
  761.       } if
  762.             % Substitute for the font.  Don't alias.
  763.       $error /SubstituteFont get exec
  764.     } ifelse
  765.   } if
  766. } bind def
  767. % Try to find a font using only the present contents of Fontmap.
  768. /.tryfindfont {        % <fontname> .tryfindfont <font> true
  769.             % <fontname> .tryfindfont false
  770.   .FontDirectory 1 index .fontknownget
  771.     {            % Already loaded
  772.       exch pop true
  773.     }
  774.     { dup Fontmap exch .knownget not
  775.        {        % Unknown font name.  Look for a file with the
  776.             % same name as the requested font.
  777.      .tryloadfont
  778.        }
  779.        {        % Try each element of the Fontmap in turn.
  780.      false exch    % (in case we exhaust the list)
  781.             % Stack: fontname false fontmaplist
  782.      { exch pop
  783.        dup type /nametype eq
  784.         {            % Font alias
  785.           .checkalias .tryfindfont exit
  786.         }
  787.         { dup dup type dup /arraytype eq exch /packedarraytype eq or exch xcheck and
  788.            {        % Font with a procedural definition
  789.          exec        % The procedure will load the font.
  790.                 % Check to make sure this really happened.
  791.          .FontDirectory 1 index .knownget
  792.           { exch pop true exit }
  793.          if
  794.            }
  795.            {        % Font file name
  796.          .loadfontloop { true exit } if
  797.            }
  798.           ifelse
  799.         }
  800.        ifelse false
  801.      }
  802.      forall
  803.             % Stack: font true -or- fontname false
  804.      { true
  805.      }
  806.      {            % None of the Fontmap entries worked.
  807.                 % Try loading a file with the same name
  808.                 % as the requested font.
  809.        .tryloadfont
  810.      }
  811.     ifelse
  812.        }
  813.       ifelse
  814.     }
  815.    ifelse
  816.  } bind def
  817. % Attempt to load a font from a file.
  818. /.tryloadfont {        % <fontname> .tryloadfont <font> true
  819.             % <fontname> .tryloadfont false
  820.   dup .nametostring
  821.         % Hack: check for the presence of the resource machinery.
  822.   /.genericrfn where {
  823.     pop
  824.     2 copy .fonttempstring /FontResourceDir getsystemparam .genericrfn
  825.     .loadfontloop {
  826.       exch pop exch pop true
  827.     } {
  828.       dup .nametostring .loadfontloop
  829.     } ifelse
  830.   } {
  831.     .loadfontloop
  832.   } ifelse
  833. } bind def
  834. /.loadfontloop {    % <fontname> <filename> .loadfontloop
  835.             %   <font> true
  836.             % -or-
  837.             %   <fontname> false
  838.             % See above regarding the use of 'loop'.
  839.     {
  840.             % Is the font name a string?
  841.     dup type /stringtype ne
  842.      { QUIET not
  843.         { (Can't find font with non-string name: ) print dup =only (.) = flush
  844.         }
  845.        if pop false exit
  846.      }
  847.     if
  848.             % Can we open the file?
  849.     findlibfile not
  850.      { QUIET not
  851.         { (Can't find \(or can't open\) font file ) print dup print
  852.           (.) = flush
  853.         }
  854.        if pop false exit
  855.      }
  856.     if
  857.  
  858.             % Stack: fontname fontfilename fontfile
  859.     DISKFONTS
  860.      { .currentglobal true .setglobal
  861.        2 index (r) file
  862.        FontFileDirectory exch 5 index exch .growput
  863.        .setglobal
  864.      }
  865.     if
  866.     QUIET not
  867.      { (Loading ) print 2 index =only
  868.        ( font from ) print 1 index print (... ) print flush
  869.      }
  870.     if
  871.     % If LOCALFONTS isn't set, load the font into local or global
  872.     % VM according to FontType; if LOCALFONTS is set, load the font
  873.     % into the current VM, which is what Adobe printers (but not
  874.     % DPS or CPSI) do.
  875.     LOCALFONTS { false } { /setglobal where } ifelse
  876.      { pop /FontType .findfontvalue { 1 eq } { false } ifelse
  877.         % .setglobal, like setglobal, aliases FontDirectory to
  878.         % GlobalFontDirectory if appropriate.  However, we mustn't
  879.         % allow the current version of .setglobal to be bound in,
  880.         % because it's different depending on language level.
  881.        .currentglobal exch /.setglobal .systemvar exec
  882.         % Remove the fake definition, if any.
  883.        .FontDirectory 3 index .undef
  884.        1 index (r) file .loadfont .FontDirectory exch
  885.        /.setglobal .systemvar exec
  886.      }
  887.      { .loadfont .FontDirectory
  888.      }
  889.     ifelse
  890.         % Stack: fontname fontfilename fontdirectory
  891.     QUIET not
  892.      { //systemdict /level2dict known
  893.         { .currentglobal false .setglobal vmstatus
  894.           true .setglobal vmstatus 3 -1 roll pop
  895.           6 -1 roll .setglobal 5
  896.         }
  897.         { vmstatus 3
  898.         }
  899.        ifelse { =only ( ) print } repeat
  900.        (done.) = flush
  901.      } if
  902.  
  903.         % Check to make sure the font was actually loaded.
  904.     dup 3 index .fontknownget
  905.      { 4 1 roll pop pop pop true exit } if
  906.  
  907.         % Maybe the file had a different FontName.
  908.         % See if we can get a FontName from the file, and if so,
  909.         % whether a font by that name exists now.
  910.     exch (r) file .findfontname
  911.      { 2 copy .fontknownget
  912.         {    % Yes.  Stack: origfontname fontdirectory filefontname fontdict
  913.           3 -1 roll pop exch
  914.           QUIET
  915.            { pop
  916.            }
  917.            { (Using ) print =only
  918.              ( font for ) print 1 index =only
  919.              (.) = flush
  920.            }
  921.           ifelse true exit
  922.         }
  923.        if pop
  924.      }
  925.     if pop
  926.  
  927.         % The font definitely did not load correctly.
  928.     QUIET not
  929.      { (Loading ) print dup =only
  930.        ( font failed.) = flush
  931.      } if
  932.     false exit
  933.  
  934.     } loop        % end of loop
  935.  
  936.  } bind def
  937.  
  938. % Define a procedure to load all known fonts.
  939. % This isn't likely to be very useful.
  940. /loadallfonts
  941.  { Fontmap { pop findfont pop } forall
  942.  } bind def
  943.  
  944. % If requested, load all the fonts defined in the Fontmap into FontDirectory
  945. % as "fake" fonts i.e., font dicts with only FontName and FontType defined.
  946. % (We define FontType only for the sake of some questionable code in the
  947. % Apple Printer Utility 2.0 font inquiry code.)
  948. %
  949. % Note that this procedure only creates fake fonts in the FontDirectory
  950. % associated with the current VM.  This is because in multi-context systems,
  951. % creating the fake fonts in local VM leads to undesirable complications.
  952. /.definefakefonts
  953.     {
  954.     }
  955.     {
  956.       (gs_fonts FAKEFONTS) VMDEBUG
  957.       Fontmap {
  958.     pop dup type /stringtype eq { cvn } if
  959.     .FontDirectory 1 index known not {
  960.       2 dict dup /FontName 3 index put
  961.       dup /FontType 1 put
  962.       .FontDirectory 3 1 roll put
  963.     } {
  964.       pop
  965.     } ifelse
  966.       } forall
  967.     }
  968. FAKEFONTS { exch } if pop def    % don't bind, .current/setglobal get redefined
  969.  
  970. % Install initial fonts from Fontmap.
  971. /.loadinitialfonts
  972.  { NOFONTMAP not
  973.     { /FONTMAP where
  974.       { pop [ FONTMAP .pathlist ]
  975.          { dup VMDEBUG findlibfile
  976.         { exch pop .loadFontmap }
  977.         { /undefinedfilename signalerror }
  978.            ifelse
  979.          }
  980.       }
  981.       { LIBPATH
  982.          { defaultfontmap 2 copy .filenamedirseparator
  983.            exch concatstrings concatstrings dup VMDEBUG
  984.            (r) { file } .internalstopped
  985.         { pop pop } { .loadFontmap } ifelse
  986.          }
  987.       }
  988.      ifelse forall
  989.     }
  990.    if
  991.    .definefakefonts    % current VM is global
  992.  } def            % don't bind, .current/setglobal get redefined
  993.  
  994. % ---------------- Synthetic font support ---------------- %
  995.  
  996. % Create a new font by modifying an existing one.  paramdict contains
  997. % entries with the same keys as the ones found in a Type 1 font;
  998. % it should also contain enough empty entries to allow adding the
  999. % corresponding non-overridden entries from the original font dictionary,
  1000. % including FID.  If paramdict includes a FontInfo entry, this will
  1001. % also override the original font's FontInfo, entry by entry;
  1002. % again, it must contain enough empty entries.
  1003.  
  1004. % Note that this procedure does not perform a definefont.
  1005.  
  1006. /.makemodifiedfont    % <fontdict> <paramdict> .makemodifiedfont <fontdict'>
  1007.  { exch
  1008.     {            % Stack: destdict key value
  1009.       1 index /FID ne
  1010.        { 2 index 2 index known
  1011.       {        % Skip fontdict entry supplied in paramdict, but
  1012.             % handle FontInfo specially.
  1013.         1 index /FontInfo eq
  1014.          { 2 index 2 index get        % new FontInfo
  1015.            1 index                % old FontInfo
  1016.         {    % Stack: destdict key value destinfo key value
  1017.           2 index 2 index known
  1018.            { pop pop }
  1019.            { 2 index 3 1 roll put }
  1020.           ifelse
  1021.         }
  1022.            forall pop
  1023.          }
  1024.         if
  1025.       }
  1026.       {        % No override, copy the fontdict entry.
  1027.         2 index 3 1 roll put
  1028.         dup dup    % to match pop pop below
  1029.       }
  1030.      ifelse
  1031.        }
  1032.       if
  1033.       pop pop
  1034.     } forall
  1035.  } bind def
  1036.  
  1037. % Make a modified font and define it.  Note that unlike definefont,
  1038. % this does not leave the font on the operand stack.
  1039.  
  1040. /.definemodifiedfont    % <fontdict> <paramdict> .definemodifiedfont -
  1041.  { .makemodifiedfont
  1042.    dup /FontName get exch definefont pop
  1043.  } bind def
  1044.