Path: gmdzi!unido!mcsun!uunet!!decwrl!!!zwicky
From: (Elizabeth Zwicky)
Newsgroups: comp.text.tex
Subject: TeX Font Hints
Message-ID: <>
Date: 27 Jun 91 03:34:19 GMT
Organization: SRI International, Menlo Park, CA
Lines: 905

This document is somewhat out of date now, but nevertheless answers a
fair number of the recent questions about fonts. Enjoy...

TeX Font Management Hints

   By  Elizabeth Zwicky <zwi...@erg.sri.COM>,
       Scott Simpson    <>.

  Edited, introduced, and augmented by Jerry Sweet <>

  See also ``The New Font Family Selection---User Interface
  to Standard LaTeX'' by Frank Mittelbach and Rainer Schopf
  in TUGboat, Volume 11 (1990), No. 1.

  Perl script contributed by Andy Fyfe <>

  This document is in the public domain, and may be reproduced
  freely, provided that this and all preceding notices are retained.

1. Introduction

As an end user, if you stick to the basic stuff in TeX or LaTeX,
you'll almost never need to mess with fonts much beyond that.  Your
friendly, smiling, helpful system administrator will have created all
the fonts you're likely to need.

$Revision: 1.3 $ $Date: 90/05/23 18:54:11 $
But every once in a while, a TeX document can't be printed.  Why is
that?  Because one of the stupid fonts is missing!  (There are other
possible reasons, but missing fonts is the big gotcha.)  How do you
know it's a missing font?  Because the printer driver or the previewer
will complain that file ``cmssm9.746gf'', or something like that,
can't be opened.  What to do?  What does it mean?  Helllp!  If you're
a system administrator, and one of your constituents, in desperation
about missing fonts, has his nose and upper lip flat against your
office window, revealing coffee-stained, plaque-encrusted teeth, and
smearing skin oil and saliva on the glass, what can you do?

Okay, now that you've gotten all that screaming out of your system,
sit back down in your chair and read this document.  It'll tell you at
least some of what you need to know to fix things, at least on a UNIX
  Please send complaints, corrections, additions, and suggestions
  to Jerry Sweet (address above).

This note assumes that you have at least rudimentary knowledge of TeX,
and some understanding of UNIX.

2. What Fonts Are Available

TeX can use any fonts, provided that the appropriate data files are
around, and provided that the appropriate TeX constructs have been
defined.  It just so happens that TeX is almost always installed in
such a way as to use the set of public-domain fonts supplied with the
UNIX TeX software distribution.  These fonts are called the Computer
Modern (``cm'') fonts.

There are other kinds of fonts, such as the Adobe fonts, used
primarily by PostScript printers such as the Apple LaserWriter.  Other
popular fonts include the commercially available BitStream fonts.
There may also be varying font cartridges installed on printers such
as the Hewlett-Packard LaserJet.  Such fonts cannot be used without
extra effort on someone's part---mostly the system administrator's,
but also on the end user's part.

Font definitions such as for \rm, \bf, \it, \sf, and so on, are made
in the file ``lfonts.tex'' for LaTeX, or in a file such as
``psfonts.sty'' to define PostScript fonts for use with LaTeX.
(For purposes of this discussion, TeX and LaTeX are treated
identically, except where LaTeX is specifically mentioned.)

Some additional font selection abstractions are compiled into the .fmt
files.  The .fmt files are ``compiled'' macros, such as plain.fmt
(used by Plain TeX) and lplain.fmt (used by LaTeX).

The .fmt files are *not* compatible among different machines, or
different releases of TeX. When you install a new release of TeX, or
install TeX on a new machine type, you will have to redump plain,
splain and lplain.

The .fmt files are typically kept in a directory of their own, not
with the font data files.

3. Font Data File Types

A previewer or printer driver program requires fonts in one of these
formats: gf (generic font), pk (packed), or pxl (pixel). 

TeX itself, as opposed to the drivers and previewers, is primarily
interested in the height and width of each character in a font, not in
the form of the character.  As far as TeX is concerned, each character
is a little square blob to be placed on the page according to the
directions given.  It is only after TeX has produced a dvi file, and
it comes time to print the results, that the form of each character
becomes important.

The information about each character blob's height and width is stored
in tfm (TeX Font Metric) files, one tfm file for every font used in
the document.  The tfm files are neither necessary or sufficient to
print the document; the tfm files contain only information about the
sizes of each character blob.  

Where do tfm files come from?  They are produced by MetaFont from mf
(MetaFont) files.  MetaFont is a language for describing the shapes of
characters and building data files for use by other programs, such as
TeX, dvi previewers, and printer drivers.  Refer to the MetaFontbook
by Donald Knuth for information about that language.  It is also
possible to derive tfm files from PostScript fonts if you have the afm
(Adobe Font Metric) files, using the afm2tfm program.  Where do the
afm files come from?  From Adobe, or an authorized licensee thereof.

There is also a program called gf2tfm that is used to produce tfm
files from gf files.  Where do the gf files come from?  They are
produced by MetaFont at the same time that the tfm files are

The kinds of font data files needed to see a document depend on the
program used to translate the dvi file to a format for the output
device.  Examples of such programs include dvipage, to preview in a
SunView window, and dvijep, to print on an HP LaserJet Series II.  The
previewer or printer driver may require pxl, pk, or gf files,
depending on how old or how new the program is.

Pxl fonts are obsolete.  If pxl fonts don't exist on your system, you
may have some trouble in creating them.  They came from an old version
of MetaFont, called MetaFont79.  The MetaFont language definition has
changed since 1979, so old MetaFont programs can't be used with the
new MetaFont implementations.  It is better to find newer programs
that use gf files.

The pk font formats can be produced from gf fonts using the gf2pk
program; note that gf2pk takes only one argument. To process a bunch
of fonts through it, use a foreach loop.

4. Where Font Files Are

As a system administrator, you will have compiled TeX to use the font
data files in /usr/local/lib/tex/fonts, or someplace similar.
All programs that use TeX fonts, whether as pxl, pk, gf, or tfm,
should look for them below /usr/local/lib/tex/fonts/something.

Here are three possible methods for managing directories of font files:

    1) Shove them all into /usr/local/lib/tex/fonts. Avoid this.
    You will end up with a directory too large to even think about.
    2) Subdivide /usr/local/lib/tex/fonts by font (usually by the
    name of the .mf file from which the font files were produced, so that
    you have /usr/local/lib/tex/fonts/cmr12 /usr/local/lib/tex/fonts/cmr10
    /usr/local/lib/tex/fonts/cmbx9). This makes for nice, small
    subdirectories, but has two problems:

	- not all programs can cope with it;
	- you may have two output devices with the same resolution but
            different marking engines, resulting in different font files
            with the same names.
    3) Subdivide /usr/local/lib/tex/fonts by type of font file.
    For instance, put tfm files in one directory, pk files at screen
    resolution in another, pk files at printer resolution for one printer
    type in another. This will leave you with large subdirectories, and
    may lead to uncomfortable directory names (SRI uses
    /usr/local/lib/tex/fonts/300-write-black, for instance). On the other
    hand, all programs can cope with it.

Most implementations of TeX will also check for tfm files in any
directories specified by the environment variable TEXFONTS, e.g.

	setenv TEXFONTS /usr/local/lib/tex/fonts:/users/project/fonts

(By convention, a ':' separates each path given in the string value of
an environment variable.)

System administrators should *never* define environment variables
named TEXFORMATS, TEXINPUTS, or TEXFONTS, because that makes it very
easy to install TeX so that it works only for the administrator (when,
say, TEXFORMATS is correct, but the compiled path is not).

Postprocessors like dvitool and dvi2ps differ in the available
environment variables. Some of them use TEXFONTS, in which case if you
wish to override it for the postprocessor you must be sure to include
the system default for tfm files as well as the override for the files
the postprocessor wants.  For instance, if you have your own .pk
files, you do this:

	setenv TEXFONTS /usr/local/lib/tex/fonts/tfm:/my/pk/fonts

unless you also want the system .pk files, in which case it would be

	setenv TEXFONTS /usr/local/lib/tex/fonts/tfm:\

More sensible programs provide a separate environment variable
(DVIFONTS, for instance). Less sensible programs provide no override
at all.

5. Font File Names

The gf, pk, and pxl font file names all have these general forms:


Example:	cmr10.240pk

	<font> ::= font family, e.g. cmr for Computer Modern Roman
	<size> ::= design size of font (the point size at which it looks best)
	<mag>  ::= magnification (means different things according to type)
	<type> ::= data type, e.g. pk for ``packed'' format

In the example above, "cmr" represents Computer Modern Roman. The "10"
indicates that the font was designed to be printed as a ten point
font.  The size does not necessarily indicate that any part of the
font is exactly ten points high.

Fonts are normally designed with a particular size in mind.  For
example, although cmr10.300gf and cmr5.600gf are both ten points high
on a 300 dpi device, the cmr5 font is a magnified five point font that
looks crummy at twice its regular size.  The version designed for ten
points has its characters thinned out and looks better at the size for
which it was intended.  Some fonts look good at any magnification and
have the <size> parts of their files names omitted.

The ways that font file names are selected are defined in several
layers of TeX macro abstraction, but they eventually come down to
external names with prefixes such as those below:

	family	series	shape(s)		external names


		[Computer Modern Roman Family]

	cmr	m	n, it, sl, sc, u	cmr10, cmti10,
						cmsl10, cmcsc10,

		bx	n, it, sl		cmbx10, cmbxti10, 

		b	n			cmb10


		[Computer Modern Sans Serif Family]

	cmss	m	n, sl			cmss10, cmssi10

		bx	n			cmssbx10

		sbc	n			cmssdc10


		[Computer Modern Typewriter Family]

	cmt	m	n, it, sl, sc		cmtt10, cmitt10, 
						cmsltt, cmtcsc10


	Key: cm            = computer modern
	     r, ss, tt     = roman, sans serif, typewriter
	     m, bx, b      = medium, bold expanded, bold
	     n, it, sl, sc = normal, italic, slanted, small caps
	     10		   = design size: ten points

TeX gets a lot of its fonts by using a font designed for 12 point at
some other point size. It specifies these by giving what is called a
"magstep". Font foo at magstep bar is font foo enlarged by 1.2 to the
bar.  Now, some things talk about font foo at magnification zot,
instead of font foo at magstep bar. Magnification zot is 1000 at
magstep bar. So:

    - cmr12 at magstep 0 is plain old cmr12 (1.2**0 = 1);
         this is cmr12 at magnification 1000.

    - cmr12 at magstep 1 is 1.2 times as big as cmr12 is;
         this is cmr12 at magnification 1200.

    - cmr12 at magstep 2 is 1.44 times as big as cmr12 is;
         this is cmr12 at magnification 1440.

Now that you are totally confused, it is time to point out that the
<mag> number on the end of the font name is not necessarily the
magstep or the magnification; for pk and gf font formats it represents
the dots per inch at the magstep.

    - cmr12.gf300 is cmr12 at 300 dpi at magstep 0 (magnification 1000)
    - cmr12.gf360 is cmr12 at 300 dpi at magstep 1 (magnification 1200)
    - cmr12.gf432 is cmr12 at 300 dpi at magstep 2 (magnification 1440)

For pxl format, the magic number is 1000 times the true size at 200
dpi.  This means that if your pxl font is designed to print at 200

    - cmr12.pxl12000 is cmr12 at magstep 0 (12 * (1.2 ** 0) * 1000 = 12000);
    - cmr12.pxl14400 is cmr12 at magstep 1 (12 * (1.2 ** 1) * 1000 = 14400).

If your pxl font is *not* designed to print at 200 dpi, life is much
more interesting; all you have to do is figure out what size it would
be when printed at 200 dpi, so that 

    - cmr12.pxl6000 is cmr12 at magstep 0 at 100 dpi 

(100 is half of 200, so a 12 point font with 100 dots per inch printed
at 200 dots per inch should be a 6 point font, and 6 * (1.2 ** 0) *
1000 = 6000). God save you from having to calculate this for 72 dpi!)

Two notes: You will want a table of magnification and extension
numbers for various magsteps if you have to do much of this,
especially if you are dealing with half magsteps.

You will also need to realize that MetaFont's arithmetic is not always
perfect, so, for instance, cmr12 at 300 dpi at magstep 8 should be
cmr12.gf1290 by calculator, but any extension between about 1285 and
about 1295 could be expected.

An example of such a table for normal font magnifications is:

	<mag>	magnification	reason

	150	     .5		half size
	208	     .69444	-\magstep2
	250	     .83333	-\magstep1
	274	     .91287	-\magstephalf
	300	    1.0		normal size
	329	    1.09544	\magstephalf
	360	    1.2		\magstep1
	432	    1.44	\magstep2
	450	    1.5		1.5 * normal size
	518	    1.728	\magstep3
	600	    2.0		twice normal size
	622	    2.0736	\magstep4
	746	    2.48832	\magstep5

To create the gf files, run the MetaFont program on an mf (MetaFont)
file.  The names of the mf files do not necessarily require the .mf
extension.  The files define sizes and outlines independent of the
dots-per-inch that your printer or graphics device can print.  All you
have to do is figure out the magic incantation to turn into
zot.gfwhatever.  That incantation is

cmmf '\mode:=foo;' '\mag:=magstep(bar);' '\batchmode;' input zot

The \mode entry says what the printer looks like. Some sites have cmmf
preload a definition for various ``modes'' such as "screenfont" (72
dpi) and "dplzr" (300 dpi write-white). It automatically knows about
"lowres" (200 dpi write-black).

NOTE: Not all printers use the same mode, even if they are all 300
dots-per-inch (dpi) printers.  For example, the DataProducts laser
printer creates a ``negative'' (it marks all the places on the page
black except those that should be white)---it's a write-white printer;
while the Apple LaserWriter marks all the places on the page that
should be black---it's a write-black printer. All printers mark more
area than they should, with the result that a write-white printer
makes fonts skinnier than they should be, and a write-black printer
makes fonts fatter than they should be.  

The same tfm files may be used for write-black and write-white
printers although the gf files may differ.

The widths in a tfm file are simply scaled if you magnify a font, so
the same tfm file is written no matter what magnification you give to
MetaFont.  Consequently, there is only one tfm file for every font
although there may be many gf files at different magnifications.

6. PostScript Fonts

Metafont and PostScript both store descriptions of fonts as outlines.
However, the normal way to design fonts for the two languages differ.
It is traditional to design separate MetaFont definitions for fonts at
different sizes, while it is traditional to make a single PostScript
definition with instructions on how to modify it for different sizes.
(The MetaFont theory is more classical, and will produce more
beautiful fonts, especially at extreme sizes. The PostScript theory is
easier to use in practice, and quite satisfactory, particularly in
normal text sizes.)  A scaled 10 point PostScript cmr font scaled to
12 points is not the same as a 12 point cmr MetaFont font because
fonts normally do not scale proportionally.

To use PostScript fonts, you need:

	- tfm files for the PostScript/Adobe fonts;
	- a dvi printer driver that knows about using fonts in the printer
		(instead of rolling its own);
	- a printer with the desired fonts;
	- appropriate TeX font selection code.

The dvi2ps program creates TeX-encoded fonts out of PostScript fonts
under new names (for instance, what PostScript knows as
``Times-Roman'', dvi2ps knows as ``trom''; Times-Roman-Oblique becomes
tromobl). It insists on having the name of every font you are going to
use from PostScript hard-coded into it; give it a name it doesn't
recognize and it assumes that it should have a pk file, and
substitutes the next one in alphabetical order if it fails to find
one. This leads to fascinating failure modes, as the font which
alphabetically follows *all* fonts with PostScript names is the circle

The program dvips (not to be confused with psdvi) can also use the
resident PostScript fonts, and there are yet other DVI to
Postscript drivers available commercially or in the public domain.

The problem of telling TeX to use PostScript fonts can be solved in
any of several ways, two of which are:

	1. Edit the font calls in lfonts.tex (for LaTeX),
		plain.tex (for TeX), or sfonts.tex (for SliTeX),
		dump a new .fmt file and make a new shell script
 		that uses the appropriate .fmt file. 

	2. Obtain or write a LaTeX document style option to override
 		the definitions that were present in the lfonts file.
  		This buys you nothing in Plain TeX,
		which doesn't know about LaTeX document styles, 
		and may do nothing for you in SliTeX.

7. Font Declarations in LaTeX

If you want to use a font that is not preloaded, you will need to
declare it. If you already have a pk file, you can calculate from its
name how to declare the font in several ways. First, you can figure
what magstep it is at, and use that. For instance, to make "bigfont"
be cmr10 at magstep5:

	\newfont{\bigfont}{cmr10 scaled \magstep 5}

You can also use the magnification, which you can calculate from the
extension with the equation 5 * r / 1.5, where r is the resolution
(e.g. 300 or 600 dpi). For example, if the largest cmr10 font is
cmr10.746gf (i.e. \magstep5), then you can declare this font in TeX

	\newfont{\bigfont}{cmr10 scaled 2487}

Finally, you can declare it by the size at which it will print out,
which you can calculate from the extension with the equation 
d * r / 300, where d is the design size (e.g. 10 or 12), and r is the
resolution as previously.  For example, you could also declare the
same cmr10 font with:

	\newfont{\bigfont}{cmr10 at 24.866pt}

8. More About MetaFont

Metafont is installed much like TeX; mf and cmmf are shell scripts
which call virmf on /usr/local/lib/mf/bases/plain.base (for example)
and /usr/local/lib/mf/bases/cmplain.base, respectively.  The base
files are created by using inimf on .mf files, which are stored in

The difference between mf and cmmf is that cmmf has the information on
which all the Computer Modern fonts are based in the base file.  Some
versions of the cmmf program are rumored to work incorrectly on some
CMR fonts.

An example of a MetaFont file appropriate for a 300 dpi
Imagen printer might be:

    mode_def imagen =		% Imagen 8/300 mode (Canon engine)
      proofing := 0;		% no, we're not making proofs
      fontmaking := 1;		% yes, we're making a font
      tracingtitles := 0;	% no, don't show titles in the log
      pixels_per_inch := 300;
      blacker := 0;		% Canon engine is black enough,
      fillin := .2;		% and it tends to fill in diagonals.
      o_correction := .6;

You should be sure to load a local file when creating cmmf, and you
should be sure that that local file contains a definition for
localfont, unless you want to by default create fonts for a 200 dpi

If no magnification is done, the extension on the gf file name will be
the sames as the pixels_per_inch for the mode you used. If you get a
.2602gf file, you have used a bad mode, or have not specified a mode,
and it has reverted to its default proofing mode. You should check the
extensions to make certain that you are indeed getting the resolution
you intended.

The parameters blacker, fillin, and o_correction are used to turn on
or off a small number of bits on certain characters to account for the
discrepancies between write-white and write-black print engines.  Such
discrepancies are somewhat noticable at 300 dpi, more so at lower
resolutions, and less so at higher resolutions.

A sample MetaFont run involving the given above might be:

	mf '\mode := localfont;' input cmr10

This creates the Computer Modern Roman 10 point font for the 300 dpi
Imagen.  As MetaFont runs, the collating sequence number of each
character generated is displayed.  At the end of the run, three
files will have been created: cmr10.log, cmr10.tfm, and cmr10.300gf.

The gf file may be converted to a pk file by using gftopk.

MetaFont has the ability to display characters on-line for certain
types of displays.  The terminals supported are site-dependent, but
typically include SunView and X windows.

9. Other Sources of Information

The UNIX TeX distribution originates at University of Washington; both
it and back issues of TeXHax are available on
for anonymous ftp. There are usually copies available on The collections of style files are currently
available at Clarkson, from via anonymous ftp.

Local copies of the style files are often installed in
/usr/local/lib/tex/macros or /usr/local/lib/tex/inputs.

TeXHax is posted to comp.text, and is very, very useful.  Refer also
to comp.text.tex.

The most useful part of the LaTeX book is Appendix C. 

PostScript data and information may also be obtained from Adobe's
automatic mail server.  See Appendix C of this document.

Appendix A.  The makefont Csh Script.

# This would probably be prettier in Perl, and could definitely use
# some docs. Give it a fontname, a type of number, and number, and
# it will create a font for your default output device. "type of
# number is "mag" or "magstep" for the magstep, "scaled" for the
# so-called magnification (1000 at the given magstep) or "ext" for
# the font extension. Given the error message "Cannot find cmr12
# scaled 1242", you say "makefont cmr12 scaled 1242"
# Written by Elizabeth D. Zwicky, ITSTD, SRI International
# (

set offbyone = 0

if ($#argv == 4) then
    set device = $1
    set font = $2
    set ntype = $3
    set number = $4
    else if ($#argv == 3) then
 	set device = "localfont"
	set font = $1
	set ntype = $2
	set number = $3
	    echo "Usage: makefont [device] font numbertype number"
	    exit (1)

switch ($device)
    case localfont:
    case imagen:
	set resolution = 300

    case dvitool:
	set resolution = 110

	echo "Unknown device: $device Use device imagen or dvitool."
	exit (1)

switch ($ntype)
    case scaled:
	switch ($number)
	    case 1000:
		 set magstep = 0
	    case 1095:
		 set magstep = .5
	    case 1200:
		 set magstep = 1
	    case 1314:
		 set magstep = 1.5
	    case 1440:
		 set magstep = 2
	    case 1577:
		 set magstep = 2.5
	    case 1728:
		 set magstep = 3
	    case 1893:
		 set magstep = 3.5
	    case 2074:
		 set magstep = 4
	    case 2272:
		 set magstep = 4.5
	    case 2488:
		 set magstep = 5
	    case 2726:
		 set magstep = 5.5
	    case 2488:
		 set magstep = 6
	    case 3271:
		 set magstep = 6.5
	    case 3583:
		 set magstep = 7
		 echo "Unknown size $number"
		exit (1)
    case magstep:
    case mag:
	 set magstep = $number
    case ext:
    case extension:
	switch ($resolution)
	     case 300:
		switch ($number)
		    case 300:
			 set magstep = 0
	            case 328:
			 set magstep = .5 
			 set offbyone = 1
		    case 329: 
			set magstep = .5
		    case 360:
			 set magstep = 1
	            case 394:
			 set magstep = 1.5
		    case 432:
			 set magstep = 2
		    case 473:
			 set magstep = 2.5
		    case 518:
			 set magstep = 3
		    case 568:
			 set magstep = 3.5
		    case 622:
			 set magstep = 4
		    case 681:
			 set magstep = 4.5
	            case 746:
			 set magstep = 5
		    case 818:
			 set magstep = 5.5
		    case 896:
			 set magstep = 6
		    case 981:
			 set magstep = 6.5
		    case 1075:
			 set magstep = 7
			 echo "Unknown size $number"
			 exit (1)
	     case 110:
		switch ($number)
		    case 110:
			 set magstep = 0
		    case 120:
			 set magstep = .5
		    case 132:
			 set magstep = 1
		    case 144:
			 set magstep = 1.5
		    case 158:
			 set magstep = 2
		    case 173:
			 set magstep = 2.5
			 echo "Unknown size $number"
			 exit (1)
		    echo "Unknown resolution $resolution"
	echo "Unknown numbertype $ntype"
	exit (1)

echo "Magstep is $magstep, device is $device, font is $font"
echo "There will be a long pause while metafont runs."
cmmf '\mode:='$device';' '\mag:=magstep('$magstep');' '\batchmode;' input $font
gftopk $font*gf
rm -f $font*gf $font*log $font*tfm
if ($offbyone == 1) then
	mv $font*pk $font.${number}pk

Appendix B.  The makefont Perl Script

eval 'exec /usr/local/bin/perl -S $0 "$@"'
	if $running_under_some_shell;

# The script takes font names, such as "cmr10.360pk", decides that,
# at 300dpi, this font is at magstep 1, calls metafont, and then gftopk.
# Andy Fyfe
#  Usage:  MakeFont [-c cmd] [-m mode] [-d dpi] <name_1> ...
#  <name> is something like "cmr10.360gf" or "cmbx12.432pk".
#  The type must be "pk" or "gf".
#  The appropriate mag step will be worked out from the magnification
#  value in the font name and the dpi number (given below).
#  newer metafonts, if linked to "xyz", will automatically load
#  "xyz.base".  if so, then the command need only be xyz.  if not,
#  then metafont must be started as "virmf '&xyz'".  in this case
#  cmd can still be the just the base name "xyz" if you uncomment
#  the line with "virmf" in it below.

($prog = $0) =~ s/.*\///;

do "" || die "$prog: Unable to load getopts package\n" ;
&Getopts("c:m:d:") || die "Usage: $prog [-c cmd] [-m mode] [-d dpi] font...\n";

$mf = $opt_c ? $opt_c : "cmmf";		# metafont command name
# $mf = "virmf '&$mf'";			# older metafonts won't autoload base
$mode = $opt_m ? $opt_m : "imagen";	# device type to make font for
$dpi = $opt_d ? $opt_d : 300;		# device resolution in dots per inch

print "$prog: Using \"$mf\" to make fonts for \"$mode\" at $dpi dpi\n";

$tfmdir = "/usr/local/lib/tex/fonts/tfm";
$gfdir = "/usr/local/lib/tex/fonts/gf";
$pkdir = "/usr/local/lib/tex/fonts/pk";

sub execute {
    local ($cmd) = @_;
    print "$cmd\n";
    system "$cmd";

chdir "/usr/tmp";

$| = 1;

foreach $font (@ARGV) {
    ($base,$size,$type) = $font =~ /(.*)\.([0-9]*)(.*)/;
    if ($type ne "gf" && $type ne "pk") {
	warn "unknown font type for $font -- must be \"gf\" or \"pk\"\n";
    $magstep = "none";
    $mag = 1;
    for (0..16) {
	if ($size == int($dpi * $mag + .5)) {
	    $magstep = $_/2;
	elsif ($size == int($dpi / $mag + .5)) {
	    $magstep = - $_/2;
	$mag *= sqrt(1.2);

    if ($magstep eq "none") {
	$mag = "'mag:=$size/$dpi;'";
    else {
	$mag = ($magstep != 0) ? "'mag:=magstep($magstep);'" : "";
    do execute("$mf '\\mode:=$mode;' 'scrollmode;' $mag input $base");
    if ($type eq "pk") {
	do execute("gftopk -v $base.${size}gf $base.${size}pk");
	do execute("rm -f $base.${size}gf");
	do execute("cp $base.${size}pk $pkdir");
    else {
	do execute("cp $base.${size}gf $gfdir");
    do execute("cmp -s $base.tfm $tfmdir/$base.tfm || cp $base.tfm $tfmdir");
#   do execute("rm -f $base.tfm $base.$size$type $base.log");

Appendix C.  The Adobe PostScript File Server

Date: Thu, 17 May 90 11:22:49 PDT
Subject: How to use the PostScript File Server
From: Adobe PostScript File Server <ps-file-ser...@adobe.COM>

This message comes to you from the PostScript file server at Adobe Systems, It received a message from you asking for help.

The file server is a mail-response program. That means that you mail it a
request, and it mails back the response. (Note: the server is entirely
automated, and the mail is read by programs, not humans.)

The file server understands these commands:  help, index, send, path

A command must be the first word on a line. More than one command can
be sent in a message. (Though you shuld be very careful on the amount of
data that is requested in a single message. See the message;
instructions below.) The Subject: line is treated as a message line.
Any line that does not begin with a command is ignored.

    help            Returns this message. 
                    All other requests are ignored.
    index           Returns a list of categories.
                    All other send requests are ignored.
    index <category>  Returns list files available under <category>.
    send <category> <file>   Sends you the requested file. More than 
                          one file may be requested, though most mail
                          systems have a 100k limit on return messages.
    path <mailpath>  Forces server to use <mailpath> as the return path.

These are the current available categories:


To get more help, send another message to the server with:
"send Documents"

	Do not send requests from "root" accounts.  The server will reject 
	them in order to prevent long mail loops when mail bounces.

	Several short requests always work better than one large request.


Thanks for your inquiry, and good luck using the server. If you can't
get it to work at all, you can try sending mail to:
Mail to that account will be sent to a person instead of a program.

			  SCO's Case Against IBM

November 12, 2003 - Jed Boal from Eyewitness News KSL 5 TV provides an
overview on SCO's case against IBM. Darl McBride, SCO's president and CEO,
talks about the lawsuit's impact and attacks. Jason Holt, student and 
Linux user, talks about the benefits of code availability and the merits 
of the SCO vs IBM lawsuit. See SCO vs IBM.

Note: The materials and information included in these Web pages are not to
be used for any other purpose other than private study, research, review
or criticism.