%    Copyright (C) 1990, 1995, 1996 Aladdin Enterprises.  All rights reserved.
% 
% This file is part of Aladdin Ghostscript.
% 
% Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
% or distributor accepts any responsibility for the consequences of using it,
% or for whether it serves any particular purpose or works at all, unless he
% or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
% License (the "License") for full details.
% 
% Every copy of Aladdin Ghostscript must include a copy of the License,
% normally in a plain ASCII text file named PUBLIC.  The License grants you
% the right to copy, modify and redistribute Aladdin Ghostscript, but only
% under certain conditions described in the License.  Among other things, the
% License requires that the copyright notice and this notice be preserved on
% all copies.

% Font initialization and management code.

% Define the default font.
/defaultfontname /Courier def

% Define the name of the font map file.
/defaultfontmap (Fontmap) def

% ------ End of editable parameters ------ %

% If DISKFONTS is true, we load individual CharStrings as they are needed.
% (This is intended primarily for machines with very small memories.)
% In this case, we define another dictionary, parallel to FontDirectory,
% that retains an open file for every font loaded.
/FontFileDirectory 10 dict def

% Split up a search path into individual directories or files.
/.pathlist		% <path> .pathlist <dir1|file1> ...
 {  { dup length 0 eq { pop exit } if
      .filenamelistseparator search not { exit } if
      exch pop exch
    }
   loop
 } bind def

% Load a font name -> font file name map.
userdict /Fontmap FontDirectory maxlength dict put
/.loadFontmap		% <file> .loadFontmap -
 {		% We would like to simply execute .definefontmap as we read,
		% but we have to maintain backward compatibility with an older
		% specification that makes later entries override earlier.
   50 dict exch
    { dup token not { closefile exit } if
		% stack: <file> fontname
      % This is a hack to get around the absurd habit of MS-DOS editors
      % of adding an EOF character at the end of the file.
      dup (\032) eq { pop closefile exit } if
      1 index token not
       { (Fontmap entry for ) print dup =only
	 ( has no associated file or alias name!  Giving up.\n) print flush
	 {.loadFontmap} 0 get 1 .quit
       } if
      dup type dup /stringtype eq exch /nametype eq or not
       { (Fontmap entry for ) print 1 index =only
	 ( has an invalid file or alias name!  Giving up.\n) print flush
	 {.loadFontmap} 0 get 1 .quit
       } if
		% stack: dict file fontname filename|aliasname
		% Read and pop tokens until a semicolon.
       { 2 index token not
	  { (Fontmap entry for ) print 1 index =only
	    ( ends prematurely!  Giving up.\n) print flush
	    {.loadFontmap} 0 get 1 .quit
	  } if
	 dup /; eq { pop 3 index 3 1 roll .growput exit } if
	 pop
       } loop
    } loop
    { .definefontmap } forall
 } bind def
% Add an entry in Fontmap.  We redefine this if the Level 2
% resource machinery is loaded.
/.definefontmap			% <fontname> <file|alias> .definefontmap -
 {		% Since Fontmap is global, make sure the values are storable.
   .currentglobal 3 1 roll true .setglobal
   dup type /stringtype eq
    { dup .gcheck not { dup length string copy } if
    }
   if
   Fontmap 3 -1 roll 2 copy .knownget
    {		% Add an element to the end of the existing value,
		% unless it's the same as the current last element.
      mark exch aload pop counttomark 4 add -1 roll
      2 copy eq { cleartomark pop pop } { ] readonly .growput } ifelse
    }
    {		% Make a new entry.
      mark 4 -1 roll ] readonly .growput
    }
   ifelse .setglobal
 } bind def

% Parse a font file just enough to find the FontName or FontType.
/.findfontvalue		% <file> <key> .findfontvalue <value> true
			% <file> <key> .findfontvalue false
			% Closes the file in either case.
 { exch dup read not { -1 } if
   2 copy unread 16#80 eq
    { dup (xxxxxx) readstring pop pop }		% skip .PFB header
   if
		% Stack: key file
    { dup token not { false exit } if		% end of file
      dup /eexec eq { pop false exit } if	% reached eexec section
      dup /Subrs eq { pop false exit } if	% Subrs without eexec
      dup /CharStrings eq { pop false exit } if	% CharStrings without eexec
      dup 3 index eq
       { xcheck not { dup token exit } if }	% found key
       { pop }
      ifelse
    } loop
		% Stack: key file value true   (or)
		% Stack: key file false
   dup { 4 } { 3 } ifelse -2 roll closefile pop
 } bind def
/.findfontname
 { /FontName .findfontvalue
 } bind def

% If there is no FONTPATH, try to get one from the environment.
NOFONTPATH { /FONTPATH () def } if
/FONTPATH where
 { pop }
 { /FONTPATH (GS_FONTPATH) getenv not { () } if def }
ifelse
FONTPATH length 0 eq { (%END FONTPATH) .skipeof } if
/FONTPATH [ FONTPATH .pathlist ] def

% Scan directories looking for plausible fonts.  "Plausible" means that
% the file begins with %!PS-AdobeFont or %!FontType1, or with \200\001
% followed by four arbitrary bytes and then either of these strings.
% To speed up the search, we skip any file whose name appears in
% the Fontmap (with any extension and upper/lower case variation) already,
% and any file whose extension definitely indicates it is not a font.
%
% NOTE: The current implementation of this procedure is somewhat Unix/DOS-
% specific.  It assumes that '/' and '\' are directory separators, and that
% the part of a file name following the last '.' is the extension.
%
/.lowerstring		% <string> .lowerstring <lowerstring>
 { 0 1 2 index length 1 sub
    { 2 copy get dup 65 ge exch 90 le and
       { 2 copy 2 copy get 32 add put }
     if pop
    }
   for
 } bind def
/.splitfilename		% <dir.../base.extn> .basename <base> <extn>
 {  { (/) search { true } { (\\) search } ifelse
       { pop pop }
       { exit }
      ifelse
    }
   loop
   dup { (.) search { pop pop } { exit } ifelse } loop
   2 copy eq
    { pop () }
    { exch dup length 2 index length 1 add sub 0 exch getinterval exch }
   ifelse
% Following is debugging code.
%   (*** Split => ) print 2 copy exch ==only ( ) print ==only
%   ( ***\n) print flush
 } bind def
/.scanfontdict 1 dict def		% establish a binding
/.scanfontbegin
 {	% Construct the table of all file names already in Fontmap.
   currentglobal true setglobal
   .scanfontdict dup maxlength Fontmap length 2 add .max .setmaxlength
   Fontmap
    { exch pop
       { dup type /stringtype eq
	  { .splitfilename pop =string copy .lowerstring cvn
	    .scanfontdict exch true put
	  }
	  { pop
	  }
	 ifelse
       }
      forall
    }
   forall
   setglobal
 } bind def
/.scanfontskip mark
		% Strings are converted to names anyway, so....
  /afm true
  /bat true
  /c true
  /cmd true
  /com true
  /dll true
  /doc true
  /drv true
  /exe true
  /fon true
  /fot true
  /h true
  /o true
  /obj true
  /pfm true
  /txt true
.dicttomark def
/.scan1fontstring 128 string def
/.scanfontheaders [(%!PS-AdobeFont*) (%!FontType1*)] def
0 .scanfontheaders { length max } forall 6 add	% extra for PFB header
/.scan1fontfirst exch string def
/.scanfontdir		% <dirname> .scanfontdir -
 { currentglobal exch true setglobal
   QUIET not { (Scanning ) print dup print ( for fonts...) print flush } if
   (*) 2 copy .filenamedirseparator
   dup (\\) eq { pop (\\\\) } if	% double \ for pattern match
   exch concatstrings concatstrings
   0 0 0 4 -1 roll	% found scanned files
    {		% stack: <fontcount> <scancount> <filecount> <filename>
      exch 1 add exch                   % increment filecount
      dup .splitfilename .lowerstring
		% stack: <fontcount> <scancount> <filecount+1> <filename>
		%	<BASE> <ext>
      .scanfontskip exch known exch .scanfontdict exch known or
       { pop
		% stack: <fontcount> <scancount> <filecount+1>
       }
       { 3 -1 roll 1 add 3 1 roll
		% stack: <fontcount> <scancount+1> <filecount+1> <filename>
	 dup (r) { file } .internalstopped
	  { pop pop null ()
		% stack: <fontcount> <scancount+1> <filecount+1> <filename>
		%	null ()
	  }
	  {
		% On some platforms, the file operator will open directories,
		% but an error will occur if we try to read from one.
		% Handle this possibility here.
	    dup .scan1fontfirst { readstring } .internalstopped
	     { pop pop () }
	     { pop }
	    ifelse
		% stack: <fontcount> <scancount+1> <filecount+1>
		%	<filename> <file> <header>
	  }
	 ifelse
		% Check for PFB file header.
	 dup (\200\001????*) .stringmatch
	  { dup length 6 sub 6 exch getinterval }
	 if
		% Check for font file headers.
	 false .scanfontheaders
	  { 2 index exch .stringmatch or
	  }
	 forall exch pop
	  {	% stack: <fontcount> <scancount+1> <filecount+1> <filename>
		%	<file>
	    dup 0 setfileposition .findfontname
	     { dup Fontmap exch known
		{ pop pop
		}
		{ exch copystring exch
		  DEBUG { ( ) print dup =only } if
		  1 index .definefontmap
		  .splitfilename pop true .scanfontdict 3 1 roll .growput
			% Increment fontcount.
		  3 -1 roll 1 add 3 1 roll
		}
	       ifelse
	     }
	     { pop
	     }
	    ifelse
	  }
		% .findfontname will have done a closefile in the above case.
	  { dup null eq { pop } { closefile } ifelse pop
	  }
	 ifelse
       }
      ifelse
    }
   .scan1fontstring filenameforall
   QUIET
    { pop pop pop }
    { ( ) print =only ( files, ) print =only ( scanned, ) print
      =only ( new fonts.\n) print flush
    }
   ifelse
   setglobal
 } bind def

%END FONTPATH

% Define definefont.  This is a procedure built on a set of operators
% that do all the error checking and key insertion.
mark
	/.buildfont0 where { pop 0 /.buildfont0 cvx } if
	/.buildfont1 where { pop 1 /.buildfont1 cvx } if
	/.buildfont3 where { pop 3 /.buildfont3 cvx } if
	/.buildfont4 where { pop 4 /.buildfont4 cvx } if
	/.buildfont42 where { pop 42 /.buildfont42 cvx } if
.dicttomark /buildfontdict exch def
/.growfontdict
 {	% Grow the font dictionary, if necessary, to ensure room for an
	% added entry, making sure there is at least one slot left for FID.
   dup maxlength 1 index length sub 2 lt
    { dup dup wcheck
       { .growdict }
       { .growdictlength dict .copydict }
      ifelse
    }
    { dup wcheck not { dup maxlength dict .copydict } if
    }
   ifelse
 } bind def 
/definefont
 { 1 dict begin count /d exch def	% save stack depth in case of error
    {		% Check for disabled platform fonts.
      NOPLATFONTS
       {	% Make sure we leave room for FID.
	 .growfontdict dup /ExactSize 0 put
       }
       {	% Hack: if the Encoding looks like it might be the
		% Symbol or Dingbats encoding, load those now (for the
		% benefit of platform font matching) just in case
		% the font didn't actually reference them.
	 dup /Encoding get length 65 ge
	  { dup /Encoding get 64 get
	    dup /congruent eq { SymbolEncoding pop } if
	    /a9 eq { DingbatsEncoding pop } if
	  }
	 if
       }
      ifelse
      dup /FontType get //buildfontdict exch get exec
      DISKFONTS
       { FontFileDirectory 2 index known
	  { dup /FontFile FontFileDirectory 4 index get .growput
	  }
	 if
       }
      if
      readonly
    }
   stopped
    { count d sub { pop } repeat end /invalidfont signalerror
    }
    { end		% stack: name fontdict
		% If the current allocation mode is global, also enter
		% the font in LocalFontDirectory.
      .currentglobal
       { //systemdict /LocalFontDirectory .knownget
	  { 2 index 2 index .growput }
	 if
       }
      if
      dup FontDirectory 4 -2 roll .growput
    }
   ifelse
 } odef

% Define a procedure for defining aliased fonts.
% We can't just copy the font (or even use the same font unchanged),
% because a significant number of PostScript files assume that
% the FontName of a font is the same as the font resource name or
% the key in [Shared]FontDirectory; on the other hand, some Adobe files
% rely on the FontName of a substituted font *not* being the same as
% the requested resource name.  We address this issue heuristically:
% we substitute the new name iff the font name doesn't have MM in it.
/.aliasfont		% <name> <font> .aliasfont <newFont>
 { .currentglobal 3 1 roll dup .gcheck .setglobal
   dup length 2 add dict
   dup 3 -1 roll { 1 index /FID eq { pop pop } { put dup } ifelse } forall
		% Stack: global fontname newfont newfont.
		% We might be defining a global font whose FontName
		% is a local string.  This is weird, but legal,
		% and doesn't cause problems anywhere else.
		% To avoid any possible problems, do a cvn.
   2 index =string cvs (MM) search
    { pop pop pop pop
    }
    { /FontName exch dup type /stringtype eq { cvn } if put
    }
   ifelse
   //systemdict /definefont get exec	% Don't bind, since Level 2
					% redefines definefont
   exch .setglobal
 } odef		% so findfont will bind it

% Define .loadfontfile for loading a font.  If we recognize Type 1 and/or
% TrueType fonts, gs_type1.ps and/or gs_ttf.ps will redefine this.
/.loadfontfile { cvx exec } bind def
/.loadfont
 {		% Some buggy fonts leave extra junk on the stack,
		% so we have to make a closure that records the stack depth
		% in a fail-safe way.
   /.loadfontfile cvx count 1 sub 2 packedarray cvx exec