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