home *** CD-ROM | disk | FTP | other *** search
/ swCHIP 1991 January / swCHIP_95-1.bin / utility / gs333ini / gs3.33 / gs_fonts.ps < prev    next >
Text File  |  1995-12-09  |  21KB  |  664 lines
  1. %    Copyright (C) 1990, 1995 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % Font initialization and management code.
  19.  
  20. % Define the default font.
  21. /defaultfontname /Courier def
  22.  
  23. % Define the name of the font map file.
  24. /fontmapname (Fontmap) def
  25.  
  26. % If DISKFONTS is true, we load individual CharStrings as they are needed.
  27. % (This is intended primarily for machines with very small memories.)
  28. % In this case, we define another dictionary, parallel to FontDirectory,
  29. % that retains an open file for every font loaded.
  30. /FontFileDirectory 10 dict def
  31.  
  32. % Load the font name -> font file name map.
  33. userdict /Fontmap FontDirectory maxlength dict put
  34. /.loadFontmap        % <file> .loadFontmap -
  35.  {  { dup token not { closefile exit } if
  36.         % stack: <file> fontname
  37.       1 index token not
  38.        { (File or alias name missing in Fontmap!  Giving up.\n) print flush
  39.          {.loadFontmap} 0 get 1 .quit
  40.        } if
  41.       dup type dup /stringtype eq exch /nametype eq or not
  42.        { (Invalid file or alias name in Fontmap!  Giving up.\n) print flush
  43.          {.loadFontmap} 0 get 1 .quit
  44.        } if
  45.         % stack: <file> fontname filename|aliasname
  46.         % Read and pop tokens until a semicolon.
  47.        { 2 index token not
  48.       { (Semicolon missing in Fontmap!  Giving up.\n) print flush
  49.         {.loadFontmap} 0 get 1 .quit
  50.       } if
  51.      dup /; eq { pop .definefontmap exit } if
  52.      pop
  53.        } loop
  54.     } loop 
  55.  } bind def
  56. % Make an entry in Fontmap.  We redefine this if the Level 2
  57. % resource machinery is loaded.
  58. /.definefontmap            % <fontname> <file|alias> .definefontmap -
  59.  { Fontmap 3 1 roll .growput
  60.  } bind def
  61.  
  62. % If there is no FONTPATH, get one from the environment.
  63. /FONTPATH where
  64.  { pop }
  65.  { (GS_FONTPATH) getenv { /FONTPATH exch def } if }
  66. ifelse
  67.  
  68. % If we can't find a Fontmap, try using the FONTPATH.
  69. fontmapname findlibfile
  70.  { exch pop .loadFontmap }
  71.  { pop /FONTPATH where
  72.     { pop }
  73.     { fontmapname /undefinedfilename signalerror }
  74.    ifelse
  75.  }
  76. ifelse
  77.  
  78. % Parse a font file just enough to find the FontName or FontType.
  79. /.findfontvalue        % <file> <key> .findfontvalue <name> true
  80.             % <file> <key> .findfontvalue false
  81.             % Closes the file in either case.
  82.  { exch dup read not { -1 } if
  83.    2 copy unread 16#80 eq
  84.     { dup (xxxxxx) readstring pop pop }        % skip .PFB header
  85.    if
  86.     { dup token not { false exit } if        % end of file
  87.       dup /eexec eq { pop false exit } if    % reached eexec section
  88.       dup /Subrs eq { pop false exit } if    % Subrs without eexec
  89.       dup /CharStrings eq { pop false exit } if    % CharStrings without eexec
  90.       dup 3 index eq
  91.        { xcheck not { dup token exit } if }    % found key
  92.        { pop }
  93.       ifelse
  94.     } loop
  95.    dup { 4 } { 3 } ifelse -2 roll closefile pop
  96.  } bind def
  97. /.findfontname
  98.  { /FontName .findfontvalue
  99.  } bind def
  100.  
  101. /FONTPATH where not { (%END FONTPATH) .skipeof } if
  102. pop
  103.  
  104. % Scan directories looking for plausible fonts.  "Plausible" means that
  105. % the file begins with %!PS-AdobeFont- or %!FontType1-, or with \200\001
  106. % followed by four arbitrary bytes and then either of these strings.
  107. % To speed up the search, we skip any file whose name appears in
  108. % the Fontmap (with any extension and upper/lower case variation) already,
  109. % and any file whose extension definitely indicates it is not a font.
  110. %
  111. % NOTE: The current implementation of this procedure is Unix/DOS-
  112. % specific.  It assumes that '/' and '\' are directory separators; that
  113. % the part of a file name following the last '.' is the extension;
  114. % that ';' cannot appear in a file name; and that ':' can appear in a
  115. % file name only if the file name doesn't begin with '/', '\', or '.'.
  116. % (this is so that Unix systems can use ':' as the separator).
  117. %
  118. /.lowerstring        % <string> .lowerstring <lowerstring>
  119.  { 0 1 2 index length 1 sub
  120.     { 2 copy get dup 65 ge exch 90 le and
  121.        { 2 copy 2 copy get 32 add put }
  122.      if pop
  123.     }
  124.    for
  125.  } bind def
  126. /.splitfilename        % <dir.../base.extn> .basename <base> <extn>
  127.  {  { (/) search { true } { (\\) search } ifelse
  128.        { pop pop }
  129.        { exit }
  130.       ifelse
  131.     }
  132.    loop
  133.    dup { (.) search { pop pop } { exit } ifelse } loop
  134.    2 copy eq
  135.     { pop () }
  136.     { exch dup length 2 index length 1 add sub 0 exch getinterval exch }
  137.    ifelse
  138. % Following is debugging code.
  139. %   (*** Split => ) print 2 copy exch ==only ( ) print ==only
  140. %   ( ***\n) print flush
  141.  } bind def
  142. /.scanfontdict Fontmap maxlength dict def
  143. /.scanfontbegin
  144.  {    % Construct the table of all file names already in Fontmap.
  145.    Fontmap
  146.     { exch pop dup type /stringtype eq
  147.        { .splitfilename pop =string copy .lowerstring cvn
  148.          .scanfontdict exch true .growput
  149.        }
  150.        { pop
  151.        }
  152.       ifelse
  153.     }
  154.    forall
  155.  } bind def
  156. /.scanfontskip mark
  157.         % Strings are converted to names anyway, so....
  158.   /afm true
  159.   /bat true
  160.   /c true
  161.   /cmd true
  162.   /com true
  163.   /dll true
  164.   /doc true
  165.   /exe true
  166.   /h true
  167.   /o true
  168.   /obj true
  169.   /pfm true
  170.   /txt true
  171. .dicttomark def
  172. /.scan1fontstring 128 string def
  173. /.fontheaders [(%!PS-AdobeFont-*) (%!FontType1-*)] def
  174. 0 .fontheaders { length max } forall 6 add    % extra for PFB header
  175. /.scan1fontfirst exch string def
  176. /.scan1fontdir        % <dirname> .scan1fontdir -
  177.  { QUIET not { (Scanning ) print dup print ( for fonts...) print flush } if
  178.    (/*) concatstrings 0 0 0 4 -1 roll    % found scanned files
  179.     {        % stack: <fontcount> <scancount> <filecount> <filename>
  180.       exch 1 add exch                   % increment filecount
  181.       dup .splitfilename .lowerstring
  182.         % stack: <fontcount> <scancount> <filecount+1> <filename>
  183.         %    <BASE> <ext>
  184.       .scanfontskip exch known exch .scanfontdict exch known or
  185.        { pop
  186.         % stack: <fontcount> <scancount> <filecount+1>
  187.        }
  188.        { 3 -1 roll 1 add 3 1 roll
  189.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  190.          dup (r) { file } stopped
  191.       { pop pop null () 
  192.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  193.         %    null ()
  194.           }
  195.       { 
  196.         % On some platforms, the file operator will open directories,
  197.         % but an error will occur if we try to read from one.
  198.         % Handle this possibility here.
  199.         dup .scan1fontfirst { readstring } stopped
  200.          { pop pop () }
  201.          { pop }
  202.         ifelse 
  203.         % stack: <fontcount> <scancount+1> <filecount+1>
  204.         %    <filename> <file> <header>
  205.           }
  206.      ifelse
  207.         % Check for PFB file header.
  208.      dup (\200\001????*) .stringmatch
  209.       { dup length 6 sub 6 exch getinterval }
  210.      if
  211.         % Check for font file headers.
  212.      false .fontheaders { 2 index exch .stringmatch or } forall exch pop
  213.       {    % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  214.         %    <file>
  215.             dup 0 setfileposition .findfontname
  216.          { dup Fontmap exch known
  217.         { pop pop
  218.         }
  219.         { exch copystring exch
  220.           DEBUG { ( ) print dup =only } if
  221.           1 index .definefontmap
  222.           .splitfilename pop true .scanfontdict 3 1 roll .growput
  223.             % Increment fontcount.
  224.           3 -1 roll 1 add 3 1 roll
  225.         }
  226.            ifelse
  227.          }
  228.         if
  229.       }
  230.         % .findfontname will have done a closefile in the above case.
  231.       { dup null eq { pop } { closefile } ifelse pop 
  232.           }
  233.      ifelse
  234.        }
  235.       ifelse
  236.     }
  237.    .scan1fontstring filenameforall
  238.    QUIET
  239.     { pop pop pop }
  240.     { ( ) print =only ( files, ) print =only ( scanned, ) print
  241.       =only ( new fonts.\n) print flush
  242.     }
  243.    ifelse
  244.  } bind def
  245. % Scan all the directories mentioned in FONTPATH (or GS_FONTPATH).
  246. /FONTPATH where
  247.  { pop .scanfontbegin
  248.     % Parsing the list of dictionaries is messy, since we have to
  249.     % handle both the Unix : and the other-system ; as separators.
  250.     % See the earlier comment for the restrictions that make this work.
  251.    FONTPATH
  252.     { dup length 0 eq { pop exit } if
  253.       (;) search
  254.        { exch pop
  255.        }
  256.        { dup 0 1 getinterval (/\\.) exch search
  257.           { pop pop pop (:) search
  258.          { exch pop }
  259.          { () exch }
  260.         ifelse
  261.       }
  262.       { pop () exch
  263.       }
  264.      ifelse
  265.        }
  266.       ifelse .scan1fontdir
  267.     }
  268.    loop
  269.  }
  270. if
  271.  
  272. %END FONTPATH
  273.  
  274. % Define definefont.  This is a procedure built on a set of operators
  275. % that do all the error checking and key insertion.
  276. mark
  277.     /.buildfont0 where { pop 0 /.buildfont0 cvx } if
  278.     /.buildfont1 where { pop 1 /.buildfont1 cvx } if
  279.     /.buildfont3 where { pop 3 /.buildfont3 cvx } if
  280. .dicttomark /.buildfontdict exch def
  281. /.growfontdict
  282.  {    % Grow the font dictionary, if necessary, to ensure room for an
  283.     % added entry, making sure there is at least one slot left for FID.
  284.    dup maxlength 1 index length sub 2 lt
  285.     { dup dup wcheck
  286.        { .growdict }
  287.        { .growdictlength dict copy }
  288.       ifelse
  289.     }
  290.     { dup wcheck not { dup maxlength dict copy } if
  291.     }
  292.    ifelse
  293.  } bind def  
  294. /definefont
  295.  { 1 dict begin count /d exch def    % save stack depth in case of error
  296.     {        % Check for disabled platform fonts.
  297.       NOPLATFONTS
  298.        {    % Make sure we leave room for FID.
  299.      .growfontdict dup /ExactSize 0 put
  300.        }
  301.        {    % Hack: if the Encoding looks like it might be the
  302.         % Symbol or Dingbats encoding, load those now (for the
  303.         % benefit of platform font matching) just in case
  304.         % the font didn't actually reference them.
  305.      dup /Encoding get length 65 ge
  306.       { dup /Encoding get 64 get
  307.         dup /congruent eq { SymbolEncoding pop } if
  308.         /a9 eq { DingbatsEncoding pop } if
  309.       }
  310.      if
  311.        }
  312.       ifelse
  313.       dup /FontType get //.buildfontdict exch get exec
  314.       DISKFONTS
  315.        { FontFileDirectory 2 index known
  316.           { dup /FontFile FontFileDirectory 4 index get .growput
  317.       }
  318.      if
  319.        }
  320.       if
  321.       readonly
  322.     }
  323.    stopped
  324.     { count d sub { pop } repeat end /invalidfont signalerror
  325.     }
  326.     { end        % stack: name fontdict
  327.         % If the current allocation mode is global, also enter
  328.         % the font in LocalFontDirectory.
  329.       .currentglobal
  330.        { systemdict /LocalFontDirectory .knownget
  331.       { 2 index 2 index .growput }
  332.      if
  333.        }
  334.       if
  335.       dup FontDirectory 4 -2 roll .growput
  336.     }
  337.    ifelse
  338.  } odef
  339.  
  340. % Define a procedure for defining aliased fonts.
  341. % We can't just copy the font (or even use the same font unchanged),
  342. % because a significant number of PostScript files assume that
  343. % the FontName of a font is the same as the font resource name or
  344. % the key in [Shared]FontDirectory; on the other hand, some Adobe files
  345. % rely on the FontName of a substituted font *not* being the same as
  346. % the requested resource name.  We address this issue heuristically:
  347. % we substitute the new name iff the font name doesn't have MM in it.
  348. /.aliasfont        % <name> <font> .aliasfont <newFont>
  349.  { .currentglobal 3 1 roll dup .gcheck .setglobal
  350.    dup length 2 add dict
  351.    dup 3 -1 roll { 1 index /FID eq { pop pop } { put dup } ifelse } forall
  352.         % Stack: global fontname newfont newfont.
  353.         % We might be defining a global font whose FontName
  354.         % is a local string.  This is weird, but legal,
  355.         % and doesn't cause problems anywhere else.
  356.         % To avoid any possible problems, do a cvn.
  357.    2 index =string cvs (MM) search
  358.     { pop pop pop pop
  359.     }
  360.     { /FontName exch dup type /stringtype eq { cvn } if put
  361.     }
  362.    ifelse
  363.    systemdict /definefont get exec    % Don't bind, since Level 2
  364.                     % redefines definefont
  365.    exch .setglobal
  366.  } odef        % so findfont will bind it
  367.  
  368. % Define .loadfont for loading a font.  If we recognize Type 1 fonts,
  369. % gs_type1.ps will redefine this.
  370. /.loadfont { cvx exec } bind def
  371.  
  372. % Find an alternate font to substitute for an unknown one.
  373. % We go to some trouble to parse the font name and extract
  374. % properties from it.
  375. /.substitutefaces [
  376.     % Condensed or narrow fonts map to the only narrow family we have.
  377.   [(Condensed) /Helvetica-Narrow]
  378.   [(Narrow) /Helvetica-Narrow]
  379.     % If the family name appears in the font name,
  380.     % use a font from that family.
  381.   [(Avant) /AvantGarde]
  382.   [(Bookman) /Bookman]
  383.   [(Cour) /Courier]
  384.   [(Helv) /Helvetica]
  385.   [(Pala) /Palatino]
  386.   [(Schlbk) /NewCenturySchlbk]
  387.   [(Times) /Times]
  388.     % Guess at suitable substitutions for other fonts.
  389.   [(Grot) /Times]
  390.   [(Roman) /Times]
  391.   [(Book) /NewCenturySchlbk]
  392. ] readonly def
  393. /.substituteproperties [
  394.   [(Italic) 1] [(Oblique) 1]
  395.   [(Bold) 2] [(bold) 2] [(Demi) 2]
  396. ] readonly def
  397. /.substitutefamilies mark
  398.   /AvantGarde
  399.     {/AvantGarde-Book /AvantGarde-BookOblique
  400.      /AvantGarde-Demi /AvantGarde-DemiOblique}
  401.   /Bookman
  402.     {/Bookman-Demi /Bookman-DemiItalic /Bookman-Light /Bookman-LightItalic}
  403.   /Courier
  404.     {/Courier /Courier-Oblique /Courier-Bold /Courier-BoldOblique}
  405.   /Helvetica
  406.     {/Helvetica /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique}
  407.   /Helvetica-Narrow
  408.     {/Helvetica-Narrow /Helvetica-Narrow-Oblique
  409.      /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique}
  410.   /NewCenturySchlbk
  411.     {/NewCenturySchlbk-Roman /NewCenturySchlbk-Italic
  412.      /NewCenturySchlbk-Bold /NewCenturySchlbk-BoldItalic}
  413.   /Palatino
  414.     {/Palatino-Roman /Palatino-Italic /Palatino-Bold /Palatino-BoldItalic}
  415.   /Times
  416.     {/Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic}
  417. .dicttomark readonly def
  418. /.substitutefont        % <fontname> .substitutefont <altname>
  419.  {    % Look for properties and/or a face name in the font name.
  420.     % If we find any, use Helvetica as the base font;
  421.     % otherwise, use the default font.
  422.     % Note that the "substituted" font name may be the same as
  423.     % the requested one; the caller must check this.
  424.    dup length string cvs
  425.     {defaultfontname /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique}
  426.    exch 0 exch    % stack: fontname facelist properties fontname
  427.     % Look for a face name.
  428.    .substitutefaces
  429.     { 2 copy 0 get search
  430.        { pop pop pop 1 get .substitutefamilies exch get
  431.      4 -1 roll pop 3 1 roll
  432.        }
  433.        { pop pop
  434.        }
  435.       ifelse
  436.     }
  437.    forall
  438.    .substituteproperties
  439.     { 2 copy 0 get search
  440.        { pop pop pop 1 get 3 -1 roll or exch }
  441.        { pop pop }
  442.       ifelse
  443.     }
  444.    forall pop get exec
  445.     % Only accept fonts known in the Fontmap.
  446.    Fontmap 1 index known not { pop defaultfontname } if
  447.  } bind def
  448. % Substitute for a font, or indicate an error.
  449. /.findsubstfont        % -mark- <alias>* <fontname> .findsubstfont
  450.             %   -mark- <alias>* <fontname> <substname>
  451.  {        % If we're already trying to substitute for this name, give up.
  452.    counttomark 1 sub -1 1
  453.     { index 1 index eq
  454.        { QUIET not
  455.       { (Unable to substitute for font ) print dup cvx =only
  456.         (.\n) print flush
  457.       } if
  458.      /findfont cvx /invalidfont signalerror
  459.        }
  460.       if
  461.     }
  462.    for
  463.    dup .substitutefont
  464.    QUIET not
  465.     { (Substituting font ) print dup cvx =only
  466.       ( for ) print 1 index cvx = flush
  467.     } if
  468.  } bind def
  469.  
  470. % If requested, make (and recognize) fake entries in FontDirectory for fonts
  471. % present in Fontmap but not actually loaded.  Thanks to Ray Johnston for
  472. % the idea behind this code.
  473. FAKEFONTS not { (%END FAKEFONTS) .skipeof } if
  474.  
  475. % We use the presence or absence of the FontMatrix key to indicate whether
  476. % a font is real or fake.
  477.  
  478. /definefont        % <name> <font> definefont <font>
  479.  { dup /FontMatrix known not { /FontName get findfont } if
  480.    //definefont
  481.  } bind odef
  482.  
  483. /scalefont        % <font> <scale> scalefont <font>
  484.  { exch dup /FontMatrix known not { /FontName get findfont } if
  485.    exch //scalefont
  486.  } bind odef
  487.  
  488. /makefont        % <font> <matrix> makefont <font>
  489.  { exch dup /FontMatrix known not { /FontName get findfont } if
  490.    exch //makefont
  491.  } bind def
  492.  
  493. /setfont        % <font> setfont -
  494.  { dup /FontMatrix known not { /FontName get findfont } if
  495.    //setfont
  496.  } bind odef
  497.  
  498. % Now load all the fonts defined in the Fontmap into FontDirectory
  499. % as "fake" fonts i.e., font dicts with only FontName defined.
  500. Fontmap
  501.  { pop
  502.    FontDirectory 1 index known not
  503.     { 1 dict dup /FontName 3 index put        
  504.       FontDirectory 3 1 roll put
  505.     }
  506.    if
  507.  } forall
  508.  
  509. %END FAKEFONTS
  510.  
  511. % Define findfont so it tries to load a font if it's not found.
  512. % The Red Book requires that findfont be a procedure, not an operator.
  513. /findfont
  514.  {    % Since PostScript has no concept of goto, or even blocks with
  515.     % exits, we use a loop as a way to get an exitable scope.
  516.     % The loop is never executed more than once.
  517.    mark exch
  518.     { .findfontloop
  519.     } stopped
  520.     { counttomark 1 sub { pop } repeat exch pop stop
  521.     }
  522.     {    % Define any needed aliases.
  523.       counttomark 1 sub { .aliasfont } repeat
  524.       exch pop
  525.     }
  526.    ifelse
  527.  } bind def
  528. /.findfontloop
  529.  {  {        % Stack: mark <alias>* fontname
  530.  
  531.     dup FontDirectory exch .knownget    % Already loaded?
  532.      { FAKEFONTS { dup /FontMatrix known } { true } ifelse
  533.         { exch pop exit
  534.         }
  535.         {                % In FontDirectory, but fake.
  536.           pop FontDirectory 1 index undef
  537.         }
  538.        ifelse
  539.      }
  540.     if
  541.  
  542.     dup Fontmap exch .knownget not        % Unknown font name.
  543.      { dup defaultfontname eq
  544.         { (Default font ) print dup cvx =only
  545.           ( not found in Fontmap!  Giving up.\n) print flush
  546.           /findfont cvx /invalidfont signalerror
  547.         } if
  548.        .findsubstfont .findfontloop exit
  549.      }
  550.     if
  551.  
  552.     % Check for a font alias.
  553.     dup type /nametype eq
  554.      { .findfontloop exit
  555.      }
  556.     if
  557.  
  558.     % Check for a font with a procedural definition.
  559.     dup dup type dup /arraytype eq exch /packedarraytype eq or exch xcheck and
  560.      {    % The procedure will load the font.
  561.        exec .findfontloop exit
  562.      }
  563.     if
  564.  
  565.     % If we can't open the file, substitute for the font.
  566.     findlibfile
  567.      {    % Stack: fontname fontfilename fontfile
  568.        DISKFONTS
  569.         { .currentglobal true .setglobal
  570.           2 index (r) file
  571.           FontFileDirectory exch 4 index exch .growput
  572.           .setglobal
  573.         }
  574.        if
  575.        QUIET not
  576.         { (Loading ) print 2 index =only
  577.           ( font from ) print 1 index print (... ) print flush
  578.         }
  579.        if
  580.        % Load the font into local or global VM according to FontType.
  581.        /setglobal where
  582.         { pop /FontType .findfontvalue { 1 eq } { false } ifelse
  583.           currentglobal exch setglobal
  584.           1 index (r) file .loadfont FontDirectory exch
  585.           setglobal
  586.         }
  587.         { .loadfont FontDirectory
  588.         }
  589.        ifelse
  590.  
  591.         % Stack: fontname fontfilename fontdirectory
  592.        QUIET not
  593.         { systemdict /level2dict known
  594.            { .currentglobal false .setglobal vmstatus
  595.              true .setglobal vmstatus 3 -1 roll pop
  596.          6 -1 roll .setglobal 5
  597.            }
  598.            { vmstatus 3
  599.            }
  600.           ifelse { =only ( ) print } repeat
  601.           (done.\n) print flush
  602.         } if
  603.  
  604.        % Check to make sure the font was actually loaded.
  605.        dup 3 index known { pop pop .findfontloop exit } if
  606.  
  607.        % Maybe the file had a different FontName.
  608.        % See if we can get a FontName from the file, and if so,
  609.        % whether a font by that name exists now.
  610.        exch (r) file .findfontname
  611.         { 2 copy .knownget
  612.            {    % Yes.  Stack: origfontname fontdirectory filefontname fontdict
  613.          3 -1 roll pop exch
  614.          QUIET
  615.           { pop
  616.           }
  617.           { (Using ) print cvx =only
  618.             ( font for ) print 1 index cvx =only
  619.             (.\n) print flush
  620.           }
  621.          ifelse exit
  622.            }
  623.           if pop
  624.         }
  625.        if pop
  626.  
  627.        % The font definitely did not load correctly.
  628.        QUIET not
  629.         { (Loading ) print dup cvx =only
  630.           ( font failed.\n) print flush
  631.         } if
  632.        .findsubstfont .findfontloop exit
  633.      }
  634.     if
  635.  
  636.     % findlibfile failed, substitute the default font.
  637.     % Stack: fontname fontfilename
  638.     (Can't find \(or can't open\) font file )
  639.     2 index defaultfontname eq
  640.      { print print ( for default font \() print cvx =only
  641.        (\)!  Giving up.\n) print flush
  642.        /findfont cvx /invalidfont signalerror
  643.      }
  644.      { QUIET
  645.         { pop pop
  646.         }
  647.         { print print (.\n) print flush
  648.         }
  649.        ifelse
  650.        .findsubstfont .findfontloop
  651.      }
  652.     ifelse
  653.     exit
  654.  
  655.     } loop        % end of loop
  656.  
  657.  } bind def
  658.  
  659. % Define a procedure to load all known fonts.
  660. % This isn't likely to be very useful.
  661. /loadallfonts
  662.  { Fontmap { pop findfont pop } forall
  663.  } bind def
  664.