summaryrefslogtreecommitdiff
path: root/Build/source/texk/web2c/omegaware/opl2ofm.web
diff options
context:
space:
mode:
authorPeter Breitenlohner <peb@mppmu.mpg.de>2009-05-29 11:31:46 +0000
committerPeter Breitenlohner <peb@mppmu.mpg.de>2009-05-29 11:31:46 +0000
commit030c7d295204835a00a4084ca59b1f712afb39fe (patch)
treecaca6301bdaf276428e3cb513231f92407a1299c /Build/source/texk/web2c/omegaware/opl2ofm.web
parentf17356b770f3dd2fa28b8d5632d20e0e0f5542d7 (diff)
revive Web2C versions of omega font utils
some cleanup git-svn-id: svn://tug.org/texlive/trunk@13517 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/texk/web2c/omegaware/opl2ofm.web')
-rw-r--r--Build/source/texk/web2c/omegaware/opl2ofm.web4363
1 files changed, 4363 insertions, 0 deletions
diff --git a/Build/source/texk/web2c/omegaware/opl2ofm.web b/Build/source/texk/web2c/omegaware/opl2ofm.web
new file mode 100644
index 00000000000..df91a25dfee
--- /dev/null
+++ b/Build/source/texk/web2c/omegaware/opl2ofm.web
@@ -0,0 +1,4363 @@
+%
+% This file is part of the Omega project, which
+% is based in the web2c distribution of TeX.
+%
+% Copyright (c) 1994--2000 John Plaice and Yannis Haralambous
+% applies only to the changes to the original pltotf.web
+%
+% This program by D. E. Knuth is not copyrighted and can be used freely.
+% Version 0 was implemented in January 1982.
+% In February 1982 a new restriction on ligature steps was added.
+% In June 1982 the routines were divided into smaller pieces for IBM people.
+% Hex was added in September 1982, and the result became "Version 1".
+% Version 1.1 fixed a bug in section 28 (since eoln is undefined after eof).
+% Slight changes were made in October, 1982, for version 0.6 of TeX.
+% Version 1.2 fixed a bug in section 115 (TOP, MID, and BOT can be zero)
+% Version 1.3 (April 1983) blanked out unused BCPL header bytes
+% Version 2 (July 1983) was released with TeX version 0.999.
+% Version 2.1 (September 1983) changed TEXINFO to FONTDIMEN.
+% Version 2.2 (May 1985) added checksum computation to match METAFONT.
+% Version 2.3 (August 1985) introduced `backup' to fix a minor bug.
+% Version 3 (October 1989) introduced extended ligature features.
+% Version 3.1 (November 1989) fixed two bugs (notably min_nl:=0).
+% Version 3.2 (December 1989) improved `shorten', increased max_letters.
+% Version 3.3 (September 1990) fixed `nonexistent char 0' (John Gourlay).
+% Version 3.4 (March 1991) has more robust `out_scaled' (Wayne Sullivan).
+% Version 3.5 (March 1995) initialized lk_step_ended (Armin K\"ollner).
+
+% Version 1.0 of OPL2OFM (March 1997) allows one to read OPL files
+% and generate OFM files.
+
+% Here is TeX material that gets inserted after \input webmac
+\def\hang{\hangindent 3em\indent\ignorespaces}
+\font\ninerm=cmr9
+\let\mc=\ninerm % medium caps for names like SAIL
+\def\PASCAL{Pascal}
+\font\logo=logo10 % for the METAFONT logo
+\def\MF{{\logo METAFONT}}
+
+\def\(#1){} % this is used to make section names sort themselves better
+\def\9#1{} % this is used for sort keys in the index
+
+\def\title{OPL2OFM}
+\def\contentspagenumber{301}
+\def\topofcontents{\null
+ \def\titlepage{F} % include headline on the contents page
+ \def\rheader{\mainfont\hfil \contentspagenumber}
+ \vfill
+ \centerline{\titlefont The {\ttitlefont OPL2OFM} processor}
+ \vskip 15pt
+ \centerline{(Version 1.11, February 2000)}
+ \vfill}
+\def\botofcontents{\vfill
+ \centerline{\hsize 5in\baselineskip9pt
+ \vbox{\ninerm\noindent
+ The preparation of the original report
+ was supported in part by the National Science
+ Foundation under grants IST-8201926 and MCS-8300984,
+ and by the System Development Foundation. `\TeX' is a
+ trademark of the American Mathematical Society.}}}
+\pageno=\contentspagenumber \advance\pageno by 1
+
+@* Introduction.
+The \.{OPL2OFM} utility program converts property-list (``\.{PL}''
+and (``\.{OPL}'') files into equivalent \TeX\ and $\Omega$ font metric
+(``\.{TFM}'' and ``\.{OFM}) files. It also makes a thorough check of
+the given \.{PL} or \.{OPL} file, so that the \.{TFM} or \.{OFM} file
+should be acceptable to \TeX\ or $\Omega$.
+
+The first \.{PLtoTF} program was designed by Leo Guibas in the summer of
+1978. Contributions by Frank Liang, Doug Wyatt, and Lyle Ramshaw
+also had a significant effect on the evolution of the present code.
+
+Extensions for an enhanced ligature mechanism were added by D. E. Knuth
+in 1989.
+
+Extensions to handle extended font metric files (``\.{OFM}'') were
+added by John Plaice in December 1995 and January 1996, resulting in the
+new program \.{OPLtoOFM}. In the following documentation, all unchanged
+references to the \.{PLtoTF} program and to \.{TFM} and \.{PL} files also
+apply to the \.{OPLtoOFM} program and to \.{OFM} and \.{OPL} files.
+
+The |banner| string defined here should be changed whenever \.{OPLtoOFM}
+gets modified.
+
+@d banner=='This is OPL2OFM, Version 1.11'
+
+@ This program is written entirely in standard \PASCAL, except that
+it has to do some slightly system-dependent character code conversion
+on input. Furthermore, lower case letters are used in error messages;
+they could be converted to upper case if necessary. The input is read
+from |pl_file|, and the output is written on |tfm_file|; error messages and
+other remarks are written on the |output| file, which the user may
+choose to assign to the terminal if the system permits it.
+@^system dependencies@>
+
+The term |print| is used instead of |write| when this program writes on
+the |output| file, so that all such output can be easily deflected.
+
+@d print(#)==write(#)
+@d print_ln(#)==write_ln(#)
+
+@p program OPL2OFM(@!pl_file,@!tfm_file,@!output);
+const @<Constants in the outer block@>@/
+type @<Types in the outer block@>@/
+var @<Globals in the outer block@>@/
+procedure initialize; {this procedure gets things started properly}
+ var @<Local variables for initialization@>@/
+ begin print_ln(banner);@/
+ @<Set initial values@>@/
+ end;
+
+@ The following parameters can be changed at compile time to extend or
+reduce \.{PLtoTF}'s capacity.
+
+@<Constants...@>=
+@!buf_size=60; {length of lines displayed in error messages}
+@!max_header_bytes=100; {four times the maximum number of words allowed in
+ the \.{TFM} file header block, must be 1024 or less}
+@!max_param_words=100; {the maximum number of \.{fontdimen} parameters allowed}
+@!max_lig_steps=800000;
+ {maximum length of ligature program, must be at most $32767-257=32510$}
+@!xmax_label=800001;
+@!max_kerns=50000; {the maximum number of distinct kern values}
+@!hash_size=130003; {preferably a prime number, a bit larger than the number
+ of character pairs in lig/kern steps}
+@!hash_mult=16007; {another prime}
+@!tfm_size=2000000; {maximum length of |tfm| data, in bytes}
+@!lig_size=800000; {maximum length of |lig_kern| program, in words}
+@!max_char=65535; {the largest character number in a font}
+@!xmax_char=65536; {|max_char|+1}
+@!xxmax_char=65537;{|max_char|+2}
+@!xxxmax_char=65538;{|max_char|+3}
+@!mem_size=262144; {|max_char|*4+8}
+@!max_width=65535; {the largest character width number}
+@!max_height=255; {the largest character height number}
+@!max_depth=255; {the largest character depth number}
+@!max_italic=255; {the largest character italic correction number}
+
+@ Here are some macros for common programming idioms.
+
+@d incr(#) == #:=#+1 {increase a variable by unity}
+@d decr(#) == #:=#-1 {decrease a variable by unity}
+@d do_nothing == {empty statement}
+
+@* Property list description of font metric data.
+The idea behind \.{PL} files is that precise details about fonts, i.e., the
+facts that are needed by typesetting routines like \TeX, sometimes have to
+be supplied by hand. The nested property-list format provides a reasonably
+convenient way to do this.
+
+A good deal of computation is necessary to parse and process a
+\.{PL} file, so it would be inappropriate for \TeX\ itself to do this
+every time it loads a font. \TeX\ deals only with the compact descriptions
+of font metric data that appear in \.{TFM} files. Such data is so compact,
+however, it is almost impossible for anybody but a computer to read it.
+The purpose of \.{PLtoTF} is to convert from a human-oriented file of text
+to a computer-oriented file of binary numbers.
+
+@<Glob...@>=
+@!pl_file:text;
+
+@ @<Set init...@>=
+reset(pl_file);
+
+@ A \.{PL} file is a list of entries of the form
+$$\.{(PROPERTYNAME VALUE)}$$
+where the property name is one of a finite set of names understood by
+this program, and the value may itself in turn be a property list.
+The idea is best understood by looking at an example, so let's consider
+a fragment of the \.{PL} file for a hypothetical font.
+$$\vbox{\halign{\.{#}\hfil\cr
+(FAMILY NOVA)\cr
+(FACE F MIE)\cr
+(CODINGSCHEME ASCII)\cr
+(DESIGNSIZE D 10)\cr
+(DESIGNUNITS D 18)\cr
+(COMMENT A COMMENT IS IGNORED)\cr
+(COMMENT (EXCEPT THIS ONE ISN'T))\cr
+(COMMENT (ACTUALLY IT IS, EVEN THOUGH\cr
+\qquad\qquad IT SAYS IT ISN'T))\cr
+(FONTDIMEN\cr
+\qquad (SLANT R -.25)\cr
+\qquad (SPACE D 6)\cr
+\qquad (SHRINK D 2)\cr
+\qquad (STRETCH D 3)\cr
+\qquad (XHEIGHT R 10.55)\cr
+\qquad (QUAD D 18)\cr
+\qquad )\cr
+(LIGTABLE\cr
+\qquad (LABEL C f)\cr
+\qquad (LIG C f O 200)\cr
+\qquad (SKIP D 1)\cr
+\qquad (LABEL O 200)\cr
+\qquad (LIG C i O 201)\cr
+\qquad (KRN O 51 R 1.5)\cr
+\qquad (/LIG C ? C f)\cr
+\qquad (STOP)\cr
+\qquad )\cr
+(CHARACTER C f\cr
+\qquad (CHARWD D 6)\cr
+\qquad (CHARHT R 13.5)\cr
+\qquad (CHARIC R 1.5)\cr
+\qquad )\cr}}$$
+This example says that the font whose metric information is being described
+belongs to the hypothetical
+\.{NOVA} family; its face code is medium italic extended;
+and the characters appear in ASCII code positions. The design size is 10 points,
+and all other sizes in this \.{PL} file are given in units such that 18 units
+equals the design size. The font is slanted with a slope of $-.25$ (hence the
+letters actually slant backward---perhaps that is why the family name is
+\.{NOVA}). The normal space between words is 6 units (i.e., one third of
+the 18-unit design size), with glue that shrinks by 2 units or stretches by 3.
+The letters for which accents don't need to be raised or lowered are 10.55
+units high, and one em equals 18 units.
+
+The example ligature table is a bit trickier. It specifies that the
+letter \.f followed by another \.f is changed to code @'200, while
+code @'200 followed by \.i is changed to @'201; presumably codes @'200
+and @'201 represent the ligatures `ff' and `ffi'. Moreover, in both cases
+\.f and @'200, if the following character is the code @'51 (which is a
+right parenthesis), an additional 1.5 units of space should be inserted
+before the @'51. (The `\.{SKIP}~\.D~\.1' skips over one \.{LIG} or
+\.{KRN} command, which in this case is the second \.{LIG}; in this way
+two different ligature/kern programs can come together.)
+Finally, if either \.f or @'200 is followed by a question mark,
+the question mark is replaced by \.f and the ligature program is
+started over. (Thus, the character pair `\.{f?}' would actually become
+the ligature `ff', and `\.{ff?}' or `\.{f?f}' would become `fff'. To
+avoid this restart procedure, the \.{/LIG} command could be replaced
+by \.{/LIG>}; then `\.{f?} would become `f\kern0ptf' and `\.{f?f}'
+would become `f\kern0ptff'.)
+
+Character \.f itself is 6 units wide and 13.5 units tall, in this example.
+Its depth is zero (since \.{CHARDP} is not given), and its italic correction
+is 1.5 units.
+
+@ The example above illustrates most of the features found in \.{PL} files.
+Note that some property names, like \.{FAMILY} or \.{COMMENT}, take a
+string as their value; this string continues until the first unmatched
+right parenthesis. But most property names, like \.{DESIGNSIZE} and \.{SLANT}
+and \.{LABEL}, take a number as their value. This number can be expressed in
+a variety of ways, indicated by a prefixed code; \.D stands for decimal,
+\.H for hexadecimal, \.O for octal, \.R for real, \.C for character, and
+\.F for ``face.'' Other property names, like \.{LIG}, take two numbers as
+their value. And still other names, like \.{FONTDIMEN} and \.{LIGTABLE} and
+\.{CHARACTER}, have more complicated values that involve property lists.
+
+A property name is supposed to be used only in an appropriate property
+list. For example, \.{CHARWD} shouldn't occur on the outer level or
+within \.{FONTDIMEN}.
+
+The individual property-and-value pairs in a property list can appear in
+any order. For instance, `\.{SHRINK}' precedes `\.{STRETCH}' in the above
+example, although the \.{TFM} file always puts the stretch parameter first.
+One could even give the information about characters like `\.f' before
+specifying the number of units in the design size, or before specifying the
+ligature and kerning table. However, the \.{LIGTABLE} itself is an exception
+to this rule; the individual elements of the \.{LIGTABLE} property list
+can be reordered only to a certain extent without changing the meaning
+of that table.
+
+If property-and-value pairs are omitted, a default value is used. For example,
+we have already noted that the default for \.{CHARDP} is zero. The default
+for {\sl every\/} numeric value is, in fact, zero, unless otherwise stated
+below.
+
+If the same property name is used more than once, \.{PLtoTF} will not notice
+the discrepancy; it simply uses the final value given. Once again, however, the
+\.{LIGTABLE} is an exception to this rule; \.{PLtoTF} will complain if there
+is more than one label for some character. And of course many of the
+entries in the \.{LIGTABLE} property list have the same property name.
+
+From these rules, you can guess (correctly) that \.{PLtoTF} operates in four
+main steps. First it assigns the default values to all properties; then it scans
+through the \.{PL} file, changing property values as new ones are seen; then
+it checks the information and corrects any problems; and finally it outputs
+the \.{TFM} file.
+
+@ Instead of relying on a hypothetical example, let's consider a complete
+grammar for \.{PL} files. At the outer level, the following property names
+are valid:
+
+\yskip\hang\.{CHECKSUM} (four-byte value). The value, which should be a
+nonnegative integer less than $2^{32}$, is used to identify a particular
+version of a font; it should match the check sum value stored with the font
+itself. An explicit check sum of zero is used to bypass
+check sum testing. If no checksum is specified in the \.{PL} file,
+\.{PLtoTF} will compute the checksum that \MF\ would compute from the
+same data.
+
+\yskip\hang\.{DESIGNSIZE} (numeric value, default is 10). The value, which
+should be a real number in the range |1.0<=x<2048|, represents the default
+amount by which all quantities will be scaled if the font is not loaded
+with an `\.{at}' specification. For example, if one says
+`\.{\\font\\A=cmr10 at 15pt}' in \TeX\ language, the design size in the \.{TFM}
+file is ignored and effectively replaced by 15 points; but if one simply
+says `\.{\\font\\A=cmr10}' the stated design size is used. This quantity is
+always in units of printer's points.
+
+\yskip\hang\.{DESIGNUNITS} (numeric value, default is 1). The value
+should be a positive real number; it says how many units equals the design
+size (or the eventual `\.{at}' size, if the font is being scaled). For
+example, suppose you have a font that has been digitized with 600 pixels per
+em, and the design size is one em; then you could say `\.{(DESIGNUNITS R 600)}'
+if you wanted to give all of your measurements in units of pixels.
+
+\yskip\hang\.{CODINGSCHEME} (string value, default is `\.{UNSPECIFIED}').
+The string should not contain parentheses, and its length must be less than 40.
+It identifies the correspondence between the numeric codes and font characters.
+(\TeX\ ignores this information, but other software programs make use of it.)
+
+\yskip\hang\.{FAMILY} (string value, default is `\.{UNSPECIFIED}').
+The string should not contain parentheses, and its length must be less than 20.
+It identifies the name of the family to which this font belongs, e.g.,
+`\.{HELVETICA}'. (\TeX\ ignores this information; but it is needed, for
+example, when converting \.{DVI} files to \.{PRESS} files for Xerox
+equipment.)
+
+\yskip\hang\.{FACE} (one-byte value). This number, which must lie between
+0 and 255 inclusive, is a subsidiary ident\-ifi\-ca\-tion of the font within its
+family. For example, bold italic condensed fonts might have the same family name
+as light roman extended fonts, differing only in their face byte. (\TeX\
+ignores this information; but it is needed, for example, when converting
+\.{DVI} files to \.{PRESS} files for Xerox equipment.)
+
+\yskip\hang\.{SEVENBITSAFEFLAG} (string value, default is `\.{FALSE}'). The
+value should start with either `\.T' (true) or `\.F' (false). If true, character
+codes less than 128 cannot lead to codes of 128 or more via ligatures or
+charlists or extensible characters. (\TeX82 ignores this flag, but older
+versions of \TeX\ would only accept \.{TFM} files that were seven-bit safe.)
+\.{PLtoTF} computes the correct value of this flag and gives an error message
+only if a claimed ``true'' value is incorrect.
+
+\yskip\hang\.{HEADER} (a one-byte value followed by a four-byte value).
+The one-byte value should be between 18 and a maximum limit that can be
+raised or lowered depending on the compile-time setting of |max_header_bytes|.
+The four-byte value goes into the header word whose index is the one-byte
+value; for example, to set |header[18]:=1|, one may write
+`\.{(HEADER D 18 O 1)}'. This notation is used for header information that
+is presently unnamed. (\TeX\ ignores it.)
+
+\yskip\hang\.{FONTDIMEN} (property list value). See below for the names
+allowed in this property list.
+
+\yskip\hang\.{LIGTABLE} (property list value). See below for the rules
+about this special kind of property list.
+
+\yskip\hang\.{BOUNDARYCHAR} (integer value). If this character appears in
+a \.{LIGTABLE} command, it matches ``end of word'' as well as itself.
+If no boundary character is given and no \.{LABEL} \.{BOUNDARYCHAR} occurs
+within \.{LIGTABLE}, word boundaries will not affect ligatures or kerning.
+
+\yskip\hang\.{CHARACTER}. The value is an integer followed by
+a property list. The integer represents the number of a character that is
+present in the font; the property list of a character is defined below.
+The default is an empty property list.
+
+@ Numeric property list values can be given in various forms identified by
+a prefixed letter.
+
+\yskip\hang\.C denotes an ASCII character, which should be a standard visible
+character that is not a parenthesis. The numeric value will therefore be
+between @'41 and @'176 but not @'50 or @'51.
+
+\yskip\hang\.D denotes a decimal integer, which must be nonnegative and
+less than 256. (Use \.R for larger values or for negative values.)
+
+\yskip\hang\.F denotes a three-letter Xerox face code; the admissible codes
+are \.{MRR}, \.{MIR}, \.{BRR}, \.{BIR}, \.{LRR}, \.{LIR}, \.{MRC}, \.{MIC},
+\.{BRC}, \.{BIC}, \.{LRC}, \.{LIC}, \.{MRE}, \.{MIE}, \.{BRE}, \.{BIE},
+\.{LRE}, and \.{LIE}, denoting the integers 0 to 17, respectively.
+
+\yskip\hang\.O denotes an unsigned octal integer, which must be less than
+$2^{32}$, i.e., at most `\.{O 37777777777}'.
+
+\yskip\hang\.H denotes an unsigned hexadecimal integer, which must be less than
+$2^{32}$, i.e., at most `\.{H FFFFFFFF}'.
+
+\yskip\hang\.R denotes a real number in decimal notation, optionally preceded
+by a `\.+' or `\.-' sign, and optionally including a decimal point. The
+absolute value must be less than 2048.
+
+@ The property names allowed in a \.{FONTDIMEN} property list correspond to
+various \TeX\ parameters, each of which has a (real) numeric value. All
+of the parameters except \.{SLANT} are in design units. The admissible
+names are \.{SLANT}, \.{SPACE}, \.{STRETCH}, \.{SHRINK}, \.{XHEIGHT},
+\.{QUAD}, \.{EXTRASPACE}, \.{NUM1}, \.{NUM2}, \.{NUM3}, \.{DENOM1},
+\.{DENOM2}, \.{SUP1}, \.{SUP2}, \.{SUP3}, \.{SUB1}, \.{SUB2}, \.{SUPDROP},
+\.{SUBDROP}, \.{DELIM1}, \.{DELIM2}, and \.{AXISHEIGHT}, for parameters
+1~to~22. The alternate names \.{DEFAULTRULETHICKNESS},
+\.{BIGOPSPACING1}, \.{BIGOPSPACING2}, \.{BIGOPSPACING3},
+\.{BIGOPSPACING4}, and \.{BIGOPSPACING5}, may also be used for parameters
+8 to 13.
+
+The notation `\.{PARAMETER} $n$' provides another way to specify the
+$n$th parameter; for example, `\.{(PARAMETER} \.{D 1 R -.25)}' is another way
+to specify that the \.{SLANT} is $-0.25$. The value of $n$ must be positive
+and less than |max_param_words|.
+
+@ The elements of a \.{CHARACTER} property list can be of six different types.
+
+\yskip\hang\.{CHARWD} (real value) denotes the character's width in
+design units.
+
+\yskip\hang\.{CHARHT} (real value) denotes the character's height in
+design units.
+
+\yskip\hang\.{CHARDP} (real value) denotes the character's depth in
+design units.
+
+\yskip\hang\.{CHARIC} (real value) denotes the character's italic correction in
+design units.
+
+\yskip\hang\.{NEXTLARGER} (integer value), specifies the character that
+follows the present one in a ``charlist.'' The value must be the number of a
+character in the font, and there must be no infinite cycles of supposedly
+larger and larger characters.
+
+\yskip\hang\.{VARCHAR} (property list value), specifies an extensible character.
+This option and \.{NEXTLARGER} are mutually exclusive; i.e., they cannot
+both be used within the same \.{CHARACTER} list.
+
+\yskip\noindent
+The elements of a \.{VARCHAR} property list are either \.{TOP}, \.{MID},
+\.{BOT} or \.{REP}; the values are integers, which must be zero or the number
+of a character in the font. A zero value for \.{TOP}, \.{MID}, or \.{BOT} means
+that the corresponding piece of the extensible character is absent. A nonzero
+value, or a \.{REP} value of zero, denotes the character code used to make
+up the top, middle, bottom, or replicated piece of an extensible character.
+
+@ A \.{LIGTABLE} property list contains elements of four kinds, specifying a
+program in a simple command language that \TeX\ uses for ligatures and kerns.
+If several \.{LIGTABLE} lists appear, they are effectively concatenated into
+a single list.
+
+\yskip\hang\.{LABEL} (integer value) means that the program for the
+stated character value starts here. The integer must be the number of a
+character in the font; its \.{CHARACTER} property list must not have a
+\.{NEXTLARGER} or \.{VARCHAR} field. At least one \.{LIG} or \.{KRN} step
+must follow.
+
+\yskip\hang\.{LABEL} \.{BOUNDARYCHAR} means that the program for
+beginning-of-word ligatures starts here.
+
+\yskip\hang\.{LIG} (two integer values). The instruction `\.{(LIG} $c$ $r$\.)'
+means, ``If the next character is $c$, then insert character~$r$ and
+possibly delete the current character and/or~$c$;
+otherwise go on to the next instruction.''
+Characters $r$ and $c$ must be present in the font. \.{LIG} may be immediately
+preceded or followed by a slash, and then immediately followed by \.>
+characters not exceeding the number of slashes. Thus there are eight
+possible forms:
+$$\hbox to .8\hsize{\.{LIG}\hfil\.{/LIG}\hfil\.{/LIG>}\hfil
+\.{LIG/}\hfil\.{LIG/>}\hfil\.{/LIG/}\hfil\.{/LIG/>}\hfil\.{/LIG/>>}}$$
+The slashes specify retention of the left or right original character; the
+\.> signs specify passing over the result without further ligature processing.
+
+\yskip\hang\.{KRN} (an integer value and a real value). The instruction
+`\.{(KRN} $c$ $r$\.)' means, ``If the next character is $c$, then insert
+a blank space of width $r$ between the current character character and $c$;
+otherwise go on to the next intruction.'' The value of $r$, which is in
+units of the design size, is often negative. Character code $c$ must exist
+in the font.
+
+\yskip\hang\.{STOP} (no value). This instruction ends a ligature/kern program.
+It must follow either a \.{LIG} or \.{KRN} instruction, not a \.{LABEL}
+or \.{STOP} or \.{SKIP}.
+
+\yskip\hang\.{SKIP} (value in the range |0..127|). This instruction specifies
+continuation of a ligature/kern program after the specified number of \.{LIG}
+or \.{KRN} has been skipped over. The number of subsequent \.{LIG} and \.{KRN}
+instructions must therefore exceed this specified amount.
+
+@ In addition to all these possibilities, the property name \.{COMMENT} is
+allowed in any property list. Such comments are ignored.
+
+@ So that is what \.{PL} files hold. The next question is, ``What about
+\.{TFM} files?'' A complete answer to that question appears in the
+documentation of the companion program, \.{TFtoPL}, so it will not
+be repeated here. Suffice it to say that a \.{TFM} file stores all of the
+relevant font information in a sequence of 8-bit bytes. The number of
+bytes is always a multiple of 4, so we could regard the \.{TFM} file
+as a sequence of 32-bit words; but \TeX\ uses the byte interpretation,
+and so does \.{PLtoTF}. Note that the bytes are considered to be unsigned
+numbers.
+
+@<Glob...@>=
+@!tfm_file:packed file of 0..255;
+
+@ On some systems you may have to do something special to write a
+packed file of bytes. For example, the following code didn't work
+when it was first tried at Stanford, because packed files have to be
+opened with a special switch setting on the \PASCAL\ that was used.
+@^system dependencies@>
+
+@<Set init...@>=
+rewrite(tfm_file);
+
+@* Basic input routines.
+For the purposes of this program, a |byte| is an unsigned 16-bit quantity,
+and an |ASCII_code| is an integer between @'40 and @'177. Such ASCII codes
+correspond to one-character constants like \.{"A"} in \.{WEB} language.
+
+@<Types...@>=
+@!byte=0..65535; {unsigned sixteen-bit quantity}
+@!ASCII_code=@'40..@'177; {standard ASCII code numbers}
+
+@ One of the things \.{PLtoTF} has to do is convert characters of strings
+to ASCII form, since that is the code used for the family name and the
+coding scheme in a \.{TFM} file. An array |xord| is used to do the
+conversion from |char|; the method below should work with little or no change
+on most \PASCAL\ systems.
+@^system dependencies@>
+
+@d first_ord=0 {ordinal number of the smallest element of |char|}
+@d last_ord=127 {ordinal number of the largest element of |char|}
+
+@<Global...@>=
+@!xord:array[char] of ASCII_code; {conversion table}
+
+@ @<Local variables for init...@>=
+@!k:integer; {all-purpose initialization index}
+
+@ Characters that should not appear in \.{PL} files (except in comments)
+are mapped into @'177.
+
+@d invalid_code=@'177 {code deserving an error message}
+
+@<Set init...@>=
+for k:=first_ord to last_ord do xord[chr(k)]:=invalid_code;
+xord[' ']:=" "; xord['!']:="!"; xord['"']:=""""; xord['#']:="#";
+xord['$']:="$"; xord['%']:="%"; xord['&']:="&"; xord['''']:="'";
+xord['(']:="("; xord[')']:=")"; xord['*']:="*"; xord['+']:="+"; xord[',']:=",";
+xord['-']:="-"; xord['.']:="."; xord['/']:="/"; xord['0']:="0"; xord['1']:="1";
+xord['2']:="2"; xord['3']:="3"; xord['4']:="4"; xord['5']:="5"; xord['6']:="6";
+xord['7']:="7"; xord['8']:="8"; xord['9']:="9"; xord[':']:=":"; xord[';']:=";";
+xord['<']:="<"; xord['=']:="="; xord['>']:=">"; xord['?']:="?";
+xord['@@']:="@@"; xord['A']:="A"; xord['B']:="B"; xord['C']:="C";
+xord['D']:="D"; xord['E']:="E"; xord['F']:="F"; xord['G']:="G"; xord['H']:="H";
+xord['I']:="I"; xord['J']:="J"; xord['K']:="K"; xord['L']:="L"; xord['M']:="M";
+xord['N']:="N"; xord['O']:="O"; xord['P']:="P"; xord['Q']:="Q"; xord['R']:="R";
+xord['S']:="S"; xord['T']:="T"; xord['U']:="U"; xord['V']:="V"; xord['W']:="W";
+xord['X']:="X"; xord['Y']:="Y"; xord['Z']:="Z"; xord['[']:="["; xord['\']:="\";
+xord[']']:="]"; xord['^']:="^"; xord['_']:="_"; xord['`']:="`"; xord['a']:="a";
+xord['b']:="b"; xord['c']:="c"; xord['d']:="d"; xord['e']:="e"; xord['f']:="f";
+xord['g']:="g"; xord['h']:="h"; xord['i']:="i"; xord['j']:="j"; xord['k']:="k";
+xord['l']:="l"; xord['m']:="m"; xord['n']:="n"; xord['o']:="o"; xord['p']:="p";
+xord['q']:="q"; xord['r']:="r"; xord['s']:="s"; xord['t']:="t"; xord['u']:="u";
+xord['v']:="v"; xord['w']:="w"; xord['x']:="x"; xord['y']:="y"; xord['z']:="z";
+xord['{']:="{"; xord['|']:="|"; xord['}']:="}"; xord['~']:="~";
+
+@ In order to help catch errors of badly nested parentheses, \.{PLtoTF}
+assumes that the user will begin each line with a number of blank spaces equal
+to some constant times the number of open parentheses at the beginning of
+that line. However, the program doesn't know in advance what the constant
+is, nor does it want to print an error message on every line for a user
+who has followed no consistent pattern of indentation.
+
+Therefore the following strategy is adopted: If the user has been consistent
+with indentation for ten or more lines, an indentation error will be
+reported. The constant of indentation is reset on every line that should
+have nonzero indentation.
+
+@<Glob...@>=
+@!line:integer; {the number of the current line}
+@!good_indent:integer; {the number of lines since the last bad indentation}
+@!indent: integer; {the number of spaces per open parenthesis, zero if unknown}
+@!level: integer; {the current number of open parentheses}
+
+@ @<Set init...@>=
+line:=0; good_indent:=0; indent:=0; level:=0;
+
+@ The input need not really be broken into lines of any maximum length, and
+we could read it character by character without any buffering. But we shall
+place it into a small buffer so that offending lines can be displayed in error
+messages.
+
+@<Glob...@>=
+@!left_ln,@!right_ln:boolean; {are the left and right ends of the buffer
+ at end-of-line marks?}
+@!limit:0..buf_size; {position of the last character present in the buffer}
+@!loc:0..buf_size; {position of the last character read in the buffer}
+@!buffer:array[1..buf_size] of char;
+@!input_has_ended:boolean; {there is no more input to read}
+
+@ @<Set init...@>=
+limit:=0; loc:=0; left_ln:=true; right_ln:=true; input_has_ended:=false;
+
+@ Just before each \.{CHARACTER} property list is evaluated, the character
+code is printed in octal notation. Up to eight such codes appear on a line;
+so we have a variable to keep track of how many are currently there.
+
+@<Glob...@>=
+@!chars_on_line:0..8; {the number of characters printed on the current line}
+
+@ @<Set init...@>=
+chars_on_line:=0;
+
+@ The following routine prints an error message and an indication of
+where the error was detected. The error message should not include any
+final punctuation, since this procedure supplies its own.
+
+@d err_print(#)==begin if chars_on_line>0 then print_ln(' ');
+ print(#); show_error_context;
+ end
+
+@p procedure show_error_context; {prints the current scanner location}
+var k:0..buf_size; {an index into |buffer|}
+begin print_ln(' (line ',line:1,').');
+if not left_ln then print('...');
+for k:=1 to loc do print(buffer[k]); {print the characters already scanned}
+print_ln(' ');
+if not left_ln then print(' ');
+for k:=1 to loc do print(' '); {space out the second line}
+for k:=loc+1 to limit do print(buffer[k]); {print the characters yet unseen}
+if right_ln then print_ln(' ')@+else print_ln('...');
+chars_on_line:=0;
+end;
+
+@ Here is a procedure that does the right thing when we are done
+reading the present contents of the buffer. It keeps |buffer[buf_size]|
+empty, in order to avoid range errors on certain \PASCAL\ compilers.
+
+An infinite sequence of right parentheses is placed at the end of the
+file, so that the program is sure to get out of whatever level of nesting
+it is in.
+
+On some systems it is desirable to modify this code so that tab marks
+in the buffer are replaced by blank spaces. (Simply setting
+|xord[chr(@'11)]:=" "| would not work; for example, two-line
+error messages would not come out properly aligned.)
+@^system dependencies@>
+
+@p procedure fill_buffer;
+begin left_ln:=right_ln; limit:=0; loc:=0;
+if left_ln then begin
+ if line>0 then read_ln(pl_file);
+ incr(line);
+ end;
+if eof(pl_file) then begin
+ limit:=1; buffer[1]:=')'; right_ln:=false; input_has_ended:=true;
+ end
+else begin
+ while (limit<buf_size-1)and(not eoln(pl_file)) do begin
+ incr(limit); read(pl_file,buffer[limit]);
+ end;
+ buffer[limit+1]:=' '; right_ln:=eoln(pl_file);
+ if left_ln then @<Set |loc| to the number of leading blanks in
+ the buffer, and check the indentation@>;
+ end;
+end;
+
+@ The interesting part about |fill_buffer| is the part that learns what
+indentation conventions the user is following, if any.
+
+@d bad_indent(#)==begin if good_indent>=10 then err_print(#);
+ good_indent:=0; indent:=0;
+ end
+
+@<Set |loc|...@>=
+begin while (loc<limit)and(buffer[loc+1]=' ') do incr(loc);
+if loc<limit then begin
+ if level=0 then
+ if loc=0 then incr(good_indent)
+ else bad_indent('Warning: Indented line occurred at level zero')
+@.Warning: Indented line...@>
+ else if indent=0 then
+ if loc mod level=0 then begin
+ indent:=loc div level; good_indent:=1;
+ end
+ else good_indent:=0
+ else if indent*level=loc then incr(good_indent)
+ else bad_indent('Warning: Inconsistent indentation; ',
+@.Warning: Inconsistent indentation...@>
+ 'you are at parenthesis level ',level:1);
+ end;
+end
+
+@* Basic scanning routines.
+The global variable |cur_char| holds the ASCII code corresponding to the
+character most recently read from the input buffer, or to a character that
+has been substituted for the real one.
+
+@<Global...@>=
+@!cur_char:ASCII_code; {we have just read this}
+
+@ Here is a procedure that sets |cur_char| to an ASCII code for the
+next character of input, if that character is a letter or digit or slash
+or \.>. Otherwise
+it sets |cur_char:=" "|, and the input system will be poised to reread the
+character that was rejected, whether or not it was a space.
+Lower case letters are converted to upper case.
+
+@p procedure get_keyword_char;
+begin while (loc=limit)and(not right_ln) do fill_buffer;
+if loc=limit then cur_char:=" " {end-of-line counts as a delimiter}
+else begin
+ cur_char:=xord[buffer[loc+1]];
+ if cur_char>="a" then cur_char:=cur_char-@'40;
+ if ((cur_char>="0")and(cur_char<="9")) then incr(loc)
+ else if ((cur_char>="A")and(cur_char<="Z")) then incr(loc)
+ else if cur_char="/" then incr(loc)
+ else if cur_char=">" then incr(loc)
+ else cur_char:=" ";
+ end;
+end;
+
+@ The following procedure sets |cur_char| to the next character code,
+and converts lower case to upper case. If the character is a left or
+right parenthesis, it will not be ``digested''; the character will
+be read again and again, until the calling routine does something
+like `|incr(loc)|' to get past it. Such special treatment of parentheses
+insures that the structural information they contain won't be lost in
+the midst of other error recovery operations.
+
+@d backup==begin if (cur_char>")")or(cur_char<"(") then decr(loc);
+ end {undoes the effect of |get_next|}
+
+@p procedure get_next; {sets |cur_char| to next, balks at parentheses}
+begin while loc=limit do fill_buffer;
+incr(loc); cur_char:=xord[buffer[loc]];
+if cur_char>="a" then
+ if cur_char<="z" then cur_char:=cur_char-@'40 {uppercasify}
+ else begin
+ if cur_char=invalid_code then begin
+ err_print('Illegal character in the file');
+@.Illegal character...@>
+ cur_char:="?";
+ end;
+ end
+else if (cur_char<=")")and(cur_char>="(") then decr(loc);
+end;
+
+@ The next procedure is used to ignore the text of a comment, or to pass over
+erroneous material. As such, it has the privilege of passing parentheses.
+It stops after the first right parenthesis that drops the level below
+the level in force when the procedure was called.
+
+@p procedure skip_to_end_of_item;
+var l:integer; {initial value of |level|}
+begin l:=level;
+while level>=l do begin
+ while loc=limit do fill_buffer;
+ incr(loc);
+ if buffer[loc]=')' then decr(level)
+ else if buffer[loc]='(' then incr(level);
+ end;
+if input_has_ended then err_print('File ended unexpectedly: No closing ")"');
+@.File ended unexpectedly...@>
+cur_char:=" "; {now the right parenthesis has been read and digested}
+end;
+
+@ Sometimes we merely want to skip past characters in the input until we
+reach a left or a right parenthesis. For example, we do this whenever we
+have finished scanning a property value and we hope that a right parenthesis
+is next (except for possible blank spaces).
+
+@d skip_to_paren==repeat get_next@;@+ until (cur_char="(")or(cur_char=")")
+@d skip_error(#)==begin err_print(#); skip_to_paren;
+ end {this gets to the right parenthesis if something goes wrong}
+@d flush_error(#)==begin err_print(#); skip_to_end_of_item;
+ end {this gets past the right parenthesis if something goes wrong}
+
+@ After a property value has been scanned, we want to move just past the
+right parenthesis that should come next in the input (except for possible
+blank spaces).
+
+@p procedure finish_the_property; {do this when the value has been scanned}
+begin while cur_char=" " do get_next;
+if cur_char<>")" then err_print('Junk after property value will be ignored');
+@.Junk after property value...@>
+skip_to_end_of_item;
+end;
+
+@* Scanning property names.
+We have to figure out the meaning of names that appear in the \.{PL} file,
+by looking them up in a dictionary of known keywords. Keyword number $n$
+appears in locations |start[n]| through |start[n+1]-1| of an array called
+|dictionary|.
+
+@d max_name_index=300 {upper bound on the number of keywords}
+@d max_letters=3000 {upper bound on the total length of all keywords}
+
+@<Global...@>=
+@!start:array[1..max_name_index] of 0..max_letters;
+@!dictionary:array[0..max_letters] of ASCII_code;
+@!start_ptr:0..max_name_index; {the first available place in |start|}
+@!dict_ptr:0..max_letters; {the first available place in |dictionary|}
+
+@ @<Set init...@>=
+start_ptr:=1; start[1]:=0; dict_ptr:=0;
+
+@ When we are looking for a name, we put it into the |cur_name| array.
+When we have found it, the corresponding |start| index will go into
+the global variable |name_ptr|.
+
+@d longest_name=20 {length of \.{DEFAULTRULETHICKNESS}}
+
+@<Glob...@>=
+@!cur_name:array[1..longest_name] of ASCII_code; {a name to look up}
+@!name_length:0..longest_name; {its length}
+@!name_ptr:0..max_name_index; {its ordinal number in the dictionary}
+
+@ A conventional hash table with linear probing (cf.\ Algorithm 6.4L
+in {\sl The Art of Computer Pro\-gram\-ming\/}) is used for the dictionary
+operations. If |nhash[h]=0|, the table position is empty, otherwise |nhash[h]|
+points into the |start| array.
+
+@d hash_prime=307 {size of the hash table}
+
+@<Glob...@>=
+@!nhash:array[0..hash_prime-1] of 0..max_name_index;
+@!cur_hash:0..hash_prime-1; {current position in the hash table}
+
+@ @<Local...@>=
+@!h:0..hash_prime-1; {runs through the hash table}
+
+@ @<Set init...@>=
+for h:=0 to hash_prime-1 do nhash[h]:=0;
+
+@ Since there is no chance of the hash table overflowing, the procedure
+is very simple. After |lookup| has done its work, |cur_hash| will point
+to the place where the given name was found, or where it should be inserted.
+
+@p procedure lookup; {finds |cur_name| in the dictionary}
+var k:0..longest_name; {index into |cur_name|}
+@!j:0..max_letters; {index into |dictionary|}
+@!not_found:boolean; {clumsy thing necessary to avoid |goto| statement}
+@!cur_hash_reset:boolean;
+begin @<Compute the hash code, |cur_hash|, for |cur_name|@>;
+not_found:=true;
+cur_hash_reset:=false;
+while not_found do begin
+ if (cur_hash=0) and (cur_hash_reset) then
+ not_found:=false
+ else begin
+ if cur_hash=0 then begin
+ cur_hash:=hash_prime-1;
+ cur_hash_reset:=true
+ end
+ else decr(cur_hash);
+ if nhash[cur_hash]=0 then not_found:=false
+ else begin
+ j:=start[nhash[cur_hash]];
+ if start[nhash[cur_hash]+1]=j+name_length then begin
+ not_found:=false;
+ for k:=1 to name_length do
+ if dictionary[j+k-1]<>cur_name[k] then not_found:=true;
+ end
+ end
+ end
+ end;
+name_ptr:=nhash[cur_hash];
+end;
+
+@ @<Compute the hash...@>=
+cur_hash:=cur_name[1];
+for k:=2 to name_length do
+ cur_hash:=(cur_hash+cur_hash+cur_name[k]) mod hash_prime
+
+@ The ``meaning'' of the keyword that begins at |start[k]| in the
+dictionary is kept in |equiv[k]|. The numeric |equiv| codes are given
+symbolic meanings by the following definitions.
+
+@d comment_code=0
+@d check_sum_code=1
+@d design_size_code=2
+@d design_units_code=3
+@d coding_scheme_code=4
+@d family_code=5
+@d face_code=6
+@d seven_bit_safe_flag_code=7
+@d header_code= 8
+@d font_dimen_code=9
+@d lig_table_code=10
+@d boundary_char_code=11
+@d font_dir_code=14
+@d n_font_dir_code=15
+@d character_code=16
+@d parameter_code=30
+@d char_info_code=70
+@d width=1
+@d height=2
+@d depth=3
+@d italic=4
+@d sec_width=5
+@d sec_height=6
+@d sec_depth=7
+@d sec_italic=8
+@d accent=9
+@d prim_top_axis=10
+@d prim_top_axis_bis=11
+@d prim_bot_axis=12
+@d prim_bot_axis_bis=13
+@d prim_mid_hor=14
+@d prim_mid_vert=15
+@d prim_base_slant=16
+@d sec_top_axis=17
+@d sec_top_axis_bis=18
+@d sec_bot_axis=19
+@d sec_bot_axis_bis=20
+@d sec_mid_hor=21
+@d sec_mid_vert=22
+@d sec_base_slant=23
+@d char_wd_code=char_info_code+width
+@d char_ht_code=char_info_code+height
+@d char_dp_code=char_info_code+depth
+@d char_ic_code=char_info_code+italic
+@d sec_width_code=char_info_code+sec_width
+@d sec_height_code=char_info_code+sec_height
+@d sec_depth_code=char_info_code+sec_depth
+@d sec_italic_code=char_info_code+sec_italic
+@d accent_code=char_info_code+accent
+@d prim_top_axis_code=char_info_code+prim_top_axis
+@d prim_top_axis_bis_code=char_info_code+prim_top_axis_bis
+@d prim_bot_axis_code=char_info_code+prim_bot_axis
+@d prim_bot_axis_bis_code=char_info_code+prim_bot_axis_bis
+@d prim_mid_hor_code=char_info_code+prim_mid_hor
+@d prim_mid_vert_code=char_info_code+prim_mid_vert
+@d prim_base_slant_code=char_info_code+prim_base_slant
+@d sec_top_axis_code=char_info_code+sec_top_axis
+@d sec_top_axis_bis_code=char_info_code+sec_top_axis_bis
+@d sec_bot_axis_code=char_info_code+sec_bot_axis
+@d sec_bot_axis_bis_code=char_info_code+sec_bot_axis_bis
+@d sec_mid_hor_code=char_info_code+sec_mid_hor
+@d sec_mid_vert_code=char_info_code+sec_mid_vert
+@d sec_base_slant_code=char_info_code+sec_base_slant
+@d next_larger_code=100
+@d var_char_code=102
+@d label_code=130
+@d stop_code=131
+@d skip_code=132
+@d krn_code=133
+@d lig_code=134
+@d ofm_level_code=140
+@d char_repeat_code=150
+@d char_ivalue_code=151
+@d char_fvalue_code=152
+@d char_mvalue_code=153
+@d char_rule_code=154
+@d char_glue_code=155
+@d char_penalty_code=156
+@d font_rule_code=160
+@d rule_code=161
+@d rule_width_code=162
+@d rule_height_code=163
+@d rule_depth_code=164
+@d font_glue_code=170
+@d glue_code=171
+@d glue_type_code=172
+@d glue_stretch_order_code=173
+@d glue_shrink_order_code=174
+@d glue_width_code=175
+@d glue_stretch_code=176
+@d glue_shrink_code=177
+@d glue_char_code=178
+@d glue_rule_code=179
+@d order_unit_code=181
+@d order_fi_code=182
+@d order_fil_code=183
+@d order_fill_code=184
+@d order_filll_code=185
+@d type_normal_code=186
+@d type_aleaders_code=187
+@d type_cleaders_code=188
+@d type_xleaders_code=189
+@d font_penalty_code=190
+@d penalty_code=191
+@d penalty_val_code=192
+@d font_mvalue_code=200
+@d mvalue_code=201
+@d mvalue_val_code=202
+@d font_fvalue_code=210
+@d fvalue_code=211
+@d fvalue_val_code=212
+@d font_ivalue_code=220
+@d ivalue_code=221
+@d ivalue_val_code=222
+@d clabel_code=231
+@d cpen_code=232
+@d cglue_code=233
+@d cpenglue_code=234
+@d ckrn_code=235
+@d TL_dir_code=240
+@d LT_dir_code=241
+@d TR_dir_code=242
+@d LB_dir_code=243
+@d BL_dir_code=244
+@d RT_dir_code=245
+@d BR_dir_code=246
+@d RB_dir_code=247
+
+
+@<Glo...@>=
+@!equiv:array[0..max_name_index] of byte;
+@!cur_code:byte; {equivalent most recently found in |equiv|}
+
+@ We have to get the keywords into the hash table and into the dictionary in
+the first place (sigh). The procedure that does this has the desired
+|equiv| code as a parameter. In order to facilitate \.{WEB} macro writing
+for the initialization, the keyword being initialized is placed into the
+last positions of |cur_name|, instead of the first positions.
+
+@p procedure enter_name(v:byte); {|cur_name| goes into the dictionary}
+var k:0..longest_name;
+begin for k:=1 to name_length do
+ cur_name[k]:=cur_name[k+longest_name-name_length];
+{now the name has been shifted into the correct position}
+lookup; {this sets |cur_hash| to the proper insertion place}
+nhash[cur_hash]:=start_ptr; equiv[start_ptr]:=v;
+for k:=1 to name_length do
+ begin dictionary[dict_ptr]:=cur_name[k]; incr(dict_ptr);
+ end;
+incr(start_ptr); start[start_ptr]:=dict_ptr;
+end;
+
+@ Here are the macros to load a name of up to 20 letters into the
+dictionary. For example, the macro |load5| is used for five-letter keywords.
+
+@d tail(#)==enter_name(#)
+@d t20(#)==cur_name[20]:=#;tail
+@d t19(#)==cur_name[19]:=#;t20
+@d t18(#)==cur_name[18]:=#;t19
+@d t17(#)==cur_name[17]:=#;t18
+@d t16(#)==cur_name[16]:=#;t17
+@d t15(#)==cur_name[15]:=#;t16
+@d t14(#)==cur_name[14]:=#;t15
+@d t13(#)==cur_name[13]:=#;t14
+@d t12(#)==cur_name[12]:=#;t13
+@d t11(#)==cur_name[11]:=#;t12
+@d t10(#)==cur_name[10]:=#;t11
+@d t9(#)==cur_name[9]:=#;t10
+@d t8(#)==cur_name[8]:=#;t9
+@d t7(#)==cur_name[7]:=#;t8
+@d t6(#)==cur_name[6]:=#;t7
+@d t5(#)==cur_name[5]:=#;t6
+@d t4(#)==cur_name[4]:=#;t5
+@d t3(#)==cur_name[3]:=#;t4
+@d t2(#)==cur_name[2]:=#;t3
+@d t1(#)==cur_name[1]:=#;t2
+@d load2==name_length:=2;t19
+@d load3==name_length:=3;t18
+@d load4==name_length:=4;t17
+@d load5==name_length:=5;t16
+@d load6==name_length:=6;t15
+@d load7==name_length:=7;t14
+@d load8==name_length:=8;t13
+@d load9==name_length:=9;t12
+@d load10==name_length:=10;t11
+@d load11==name_length:=11;t10
+@d load12==name_length:=12;t9
+@d load13==name_length:=13;t8
+@d load14==name_length:=14;t7
+@d load15==name_length:=15;t6
+@d load16==name_length:=16;t5
+@d load17==name_length:=17;t4
+@d load18==name_length:=18;t3
+@d load19==name_length:=19;t2
+@d load20==name_length:=20;t1
+
+@ (Thank goodness for keyboard macros in the text editor used to create this
+\.{WEB} file.)
+
+@<Enter all of the names and their equivalents, except the parameter names@>=
+equiv[0]:=comment_code; {this is used after unknown keywords}
+load8("C")("H")("E")("C")("K")("S")("U")("M")(check_sum_code);@/
+load10("D")("E")("S")("I")("G")("N")("S")("I")("Z")("E")(design_size_code);@/
+load11("D")("E")("S")("I")("G")("N")
+ ("U")("N")("I")("T")("S")(design_units_code);@/
+load12("C")("O")("D")("I")("N")("G")
+ ("S")("C")("H")("E")("M")("E")(coding_scheme_code);@/
+load6("F")("A")("M")("I")("L")("Y")(family_code);@/
+load4("F")("A")("C")("E")(face_code);@/
+load16("S")("E")("V")("E")("N")("B")("I")("T")@/@t\hskip2em@>
+ ("S")("A")("F")("E")("F")("L")("A")("G")(seven_bit_safe_flag_code);@/
+load6("H")("E")("A")("D")("E")("R")(header_code);@/
+load9("F")("O")("N")("T")("D")("I")("M")("E")("N")(font_dimen_code);@/
+load8("L")("I")("G")("T")("A")("B")("L")("E")(lig_table_code);@/
+load12("B")("O")("U")("N")("D")("A")("R")("Y")("C")("H")("A")("R")
+ (boundary_char_code);@/
+load9("C")("H")("A")("R")("A")("C")("T")("E")("R")(character_code);@/
+load9("P")("A")("R")("A")("M")("E")("T")("E")("R")(parameter_code);@/
+load6("C")("H")("A")("R")("W")("D")(char_wd_code);@/
+load6("C")("H")("A")("R")("H")("T")(char_ht_code);@/
+load6("C")("H")("A")("R")("D")("P")(char_dp_code);@/
+load6("C")("H")("A")("R")("I")("C")(char_ic_code);@/
+load5("S")("E")("C")("W")("D")(sec_width_code);@/
+load5("S")("E")("C")("H")("T")(sec_height_code);@/
+load5("S")("E")("C")("D")("P")(sec_depth_code);@/
+load5("S")("E")("C")("I")("C")(sec_italic_code);@/
+load6("A")("C")("C")("E")("N")("T")(accent_code);@/
+load11("P")("R")("I")("M")("T")("O")("P")("A")("X")("I")("S")(prim_top_axis_code);@/
+load14("P")("R")("I")("M")("T")("O")("P")("A")("X")("I")("S")("B")("I")("S")(prim_top_axis_bis_code);@/
+load11("P")("R")("I")("M")("B")("O")("T")("A")("X")("I")("S")(prim_bot_axis_code);@/
+load14("P")("R")("I")("M")("B")("O")("T")("A")("X")("I")("S")("B")("I")("S")(prim_bot_axis_bis_code);@/
+load10("P")("R")("I")("M")("M")("I")("D")("H")("O")("R")(prim_mid_hor_code);@/
+load10("P")("R")("I")("M")("M")("I")("D")("V")("E")("R")(prim_mid_vert_code);@/
+load13("P")("R")("I")("M")("B")("A")("S")("E")("S")("L")("A")("N")("T")(prim_base_slant_code);@/
+load10("S")("E")("C")("T")("O")("P")("A")("X")("I")("S")(sec_top_axis_code);@/
+load13("S")("E")("C")("T")("O")("P")("A")("X")("I")("S")("B")("I")("S")(sec_top_axis_bis_code);@/
+load10("S")("E")("C")("B")("O")("T")("A")("X")("I")("S")(sec_bot_axis_code);@/
+load13("S")("E")("C")("B")("O")("T")("A")("X")("I")("S")("B")("I")("S")(sec_bot_axis_bis_code);@/
+load9("S")("E")("C")("M")("I")("D")("H")("O")("R")(sec_mid_hor_code);@/
+load9("S")("E")("C")("M")("I")("D")("V")("E")("R")(sec_mid_vert_code);@/
+load12("S")("E")("C")("B")("A")("S")("E")("S")("L")("A")("N")("T")(sec_base_slant_code);@/
+load10("N")("E")("X")("T")("L")("A")("R")("G")("E")("R")(next_larger_code);@/
+load7("V")("A")("R")("C")("H")("A")("R")(var_char_code);@/
+load3("T")("O")("P")(var_char_code+1);@/
+load3("M")("I")("D")(var_char_code+2);@/
+load3("B")("O")("T")(var_char_code+3);@/
+load3("R")("E")("P")(var_char_code+4);@/
+load3("E")("X")("T")(var_char_code+4); {compatibility with older \.{PL} format}
+load7("C")("O")("M")("M")("E")("N")("T")(comment_code);@/
+load5("L")("A")("B")("E")("L")(label_code);@/
+load4("S")("T")("O")("P")(stop_code);@/
+load4("S")("K")("I")("P")(skip_code);@/
+load3("K")("R")("N")(krn_code);@/
+load3("L")("I")("G")(lig_code);@/
+load4("/")("L")("I")("G")(lig_code+2);@/
+load5("/")("L")("I")("G")(">")(lig_code+6);@/
+load4("L")("I")("G")("/")(lig_code+1);@/
+load5("L")("I")("G")("/")(">")(lig_code+5);@/
+load5("/")("L")("I")("G")("/")(lig_code+3);@/
+load6("/")("L")("I")("G")("/")(">")(lig_code+7);@/
+load7("/")("L")("I")("G")("/")(">")(">")(lig_code+11);@/
+load6("C")("L")("A")("B")("E")("L")(clabel_code);@/
+load4("C")("P")("E")("N")(cpen_code);@/
+load5("C")("G")("L")("U")("E")(cglue_code);@/
+load8("C")("P")("E")("N")("G")("L")("U")("E")(cpenglue_code);@/
+load4("C")("K")("R")("N")(ckrn_code);@/
+load8("O")("F")("M")("L")("E")("V")("E")("L")(ofm_level_code);@/
+load7("F")("O")("N")("T")("D")("I")("R")(font_dir_code);@/
+load8("N")("F")("O")("N")("T")("D")("I")("R")(n_font_dir_code);@/
+load10("C")("H")("A")("R")("R")("E")("P")("E")("A")("T")(char_repeat_code);@/
+load10("C")("H")("A")("R")("I")("V")("A")("L")("U")("E")(char_ivalue_code);@/
+load10("C")("H")("A")("R")("F")("V")("A")("L")("U")("E")(char_fvalue_code);@/
+load10("C")("H")("A")("R")("M")("V")("A")("L")("U")("E")(char_mvalue_code);@/
+load8("C")("H")("A")("R")("R")("U")("L")("E")(char_rule_code);@/
+load8("C")("H")("A")("R")("G")("L")("U")("E")(char_glue_code);@/
+load11("C")("H")("A")("R")("P")("E")("N")("A")("L")("T")("Y")(char_penalty_code);@/
+load8("F")("O")("N")("T")("R")("U")("L")("E")(font_rule_code);@/
+load4("R")("U")("L")("E")(rule_code);@/
+load6("R")("U")("L")("E")("W")("D")(rule_width_code);@/
+load6("R")("U")("L")("E")("H")("T")(rule_height_code);@/
+load6("R")("U")("L")("E")("D")("P")(rule_depth_code);@/
+load8("F")("O")("N")("T")("G")("L")("U")("E")(font_glue_code);@/
+load4("G")("L")("U")("E")(glue_code);@/
+load8("G")("L")("U")("E")("T")("Y")("P")("E")(glue_type_code);@/
+load16("G")("L")("U")("E")("S")("T")("R")("E")("T")("C")("H")("O")("R")("D")("E")("R")(glue_stretch_order_code);@/
+load15("G")("L")("U")("E")("S")("H")("R")("I")("N")("K")("O")("R")("D")("E")("R")(glue_shrink_order_code);@/
+load8("G")("L")("U")("E")("R")("U")("L")("E")(glue_rule_code);@/
+load8("G")("L")("U")("E")("C")("H")("A")("R")(glue_char_code);@/
+load6("G")("L")("U")("E")("W")("D")(glue_width_code);@/
+load11("G")("L")("U")("E")("S")("T")("R")("E")("T")("C")("H")(glue_stretch_code);@/
+load10("G")("L")("U")("E")("S")("H")("R")("I")("N")("K")(glue_shrink_code);@/
+load4("U")("N")("I")("T")(order_unit_code);@/
+load2("F")("I")(order_fi_code);@/
+load3("F")("I")("L")(order_fil_code);@/
+load4("F")("I")("L")("L")(order_fill_code);@/
+load5("F")("I")("L")("L")("L")(order_filll_code);@/
+load6("N")("O")("R")("M")("A")("L")(type_normal_code);@/
+load8("A")("L")("E")("A")("D")("E")("R")("S")(type_aleaders_code);@/
+load8("C")("L")("E")("A")("D")("E")("R")("S")(type_cleaders_code);@/
+load8("X")("L")("E")("A")("D")("E")("R")("S")(type_xleaders_code);@/
+load11("F")("O")("N")("T")("P")("E")("N")("A")("L")("T")("Y")(font_penalty_code);@/
+load7("P")("E")("N")("A")("L")("T")("Y")(penalty_code);@/
+load10("P")("E")("N")("A")("L")("T")("Y")("V")("A")("L")(penalty_val_code);@/
+load10("F")("O")("N")("T")("M")("V")("A")("L")("U")("E")(font_mvalue_code);@/
+load6("M")("V")("A")("L")("U")("E")(mvalue_code);@/
+load9("M")("V")("A")("L")("U")("E")("V")("A")("L")(mvalue_val_code);@/
+load10("F")("O")("N")("T")("F")("V")("A")("L")("U")("E")(font_fvalue_code);@/
+load6("F")("V")("A")("L")("U")("E")(fvalue_code);@/
+load9("F")("V")("A")("L")("U")("E")("V")("A")("L")(fvalue_val_code);@/
+load10("F")("O")("N")("T")("I")("V")("A")("L")("U")("E")(font_ivalue_code);@/
+load6("I")("V")("A")("L")("U")("E")(ivalue_code);@/
+load9("I")("V")("A")("L")("U")("E")("V")("A")("L")(ivalue_val_code);@/
+load2("T")("L")(TL_dir_code);
+load2("L")("T")(LT_dir_code);
+load2("T")("R")(TR_dir_code);
+load2("L")("B")(LB_dir_code);
+load2("B")("L")(BL_dir_code);
+load2("R")("T")(RT_dir_code);
+load2("B")("R")(BR_dir_code);
+load2("R")("B")(RB_dir_code);
+
+@ @<Enter the parameter names@>=
+load5("S")("L")("A")("N")("T")(parameter_code+1);@/
+load5("S")("P")("A")("C")("E")(parameter_code+2);@/
+load7("S")("T")("R")("E")("T")("C")("H")(parameter_code+3);@/
+load6("S")("H")("R")("I")("N")("K")(parameter_code+4);@/
+load7("X")("H")("E")("I")("G")("H")("T")(parameter_code+5);@/
+load4("Q")("U")("A")("D")(parameter_code+6);@/
+load10("E")("X")("T")("R")("A")("S")("P")("A")("C")("E")(parameter_code+7);@/
+load4("N")("U")("M")("1")(parameter_code+8);@/
+load4("N")("U")("M")("2")(parameter_code+9);@/
+load4("N")("U")("M")("3")(parameter_code+10);@/
+load6("D")("E")("N")("O")("M")("1")(parameter_code+11);@/
+load6("D")("E")("N")("O")("M")("2")(parameter_code+12);@/
+load4("S")("U")("P")("1")(parameter_code+13);@/
+load4("S")("U")("P")("2")(parameter_code+14);@/
+load4("S")("U")("P")("3")(parameter_code+15);@/
+load4("S")("U")("B")("1")(parameter_code+16);@/
+load4("S")("U")("B")("2")(parameter_code+17);@/
+load7("S")("U")("P")("D")("R")("O")("P")(parameter_code+18);@/
+load7("S")("U")("B")("D")("R")("O")("P")(parameter_code+19);@/
+load6("D")("E")("L")("I")("M")("1")(parameter_code+20);@/
+load6("D")("E")("L")("I")("M")("2")(parameter_code+21);@/
+load10("A")("X")("I")("S")("H")("E")("I")("G")("H")("T")(parameter_code+22);@/
+load20("D")("E")("F")("A")("U")("L")("T")("R")("U")("L")("E")@/@t\hskip2em@>
+ ("T")("H")("I")("C")("K")("N")("E")("S")("S")(parameter_code+8);@/
+load13("B")("I")("G")("O")("P")
+ ("S")("P")("A")("C")("I")("N")("G")("1")(parameter_code+9);@/
+load13("B")("I")("G")("O")("P")
+ ("S")("P")("A")("C")("I")("N")("G")("2")(parameter_code+10);@/
+load13("B")("I")("G")("O")("P")
+ ("S")("P")("A")("C")("I")("N")("G")("3")(parameter_code+11);@/
+load13("B")("I")("G")("O")("P")
+ ("S")("P")("A")("C")("I")("N")("G")("4")(parameter_code+12);@/
+load13("B")("I")("G")("O")("P")
+ ("S")("P")("A")("C")("I")("N")("G")("5")(parameter_code+13);@/
+
+@ When a left parenthesis has been scanned, the following routine
+is used to interpret the keyword that follows, and to store the
+equivalent value in |cur_code|.
+
+@p procedure get_name;
+begin incr(loc); incr(level); {pass the left parenthesis}
+cur_char:=" ";
+while cur_char=" " do get_next;
+if (cur_char>")")or(cur_char<"(") then decr(loc); {back up one character}
+name_length:=0; get_keyword_char; {prepare to scan the name}
+while cur_char<>" " do begin
+ if name_length=longest_name then cur_name[1]:="X" {force error}
+ else incr(name_length);
+ cur_name[name_length]:=cur_char;
+ get_keyword_char;
+ end;
+lookup;
+if name_ptr=0 then err_print('Sorry, I don''t know that property name');
+@.Sorry, I don't know...@>
+cur_code:=equiv[name_ptr];
+end;
+
+@* Scanning numeric data.
+The next thing we need is a trio of subroutines to read the one-byte,
+four-byte, and real numbers that may appear as property values.
+These subroutines are careful to stick to numbers between $-2^{31}$
+and $2^{31}-1$, inclusive, so that a computer with two's complement
+32-bit arithmetic will not be interrupted by overflow.
+
+@ The first number scanner, which returns a one-byte value, surely has
+no problems of arithmetic overflow.
+
+@p function get_byte:byte; {scans a one-byte property value}
+var acc:integer; {an accumulator}
+@!t:ASCII_code; {the type of value to be scanned}
+begin repeat get_next;
+until cur_char<>" "; {skip the blanks before the type code}
+t:=cur_char; acc:=0;
+repeat get_next;
+until cur_char<>" "; {skip the blanks after the type code}
+if t="C" then @<Scan an ASCII character code@>
+else if t="D" then @<Scan a small decimal number@>
+else if t="O" then @<Scan a small octal number@>
+else if t="H" then @<Scan a small hexadecimal number@>
+else if t="F" then @<Scan a face code@>
+else skip_error('You need "C" or "D" or "O" or "H" or "F" here');
+@.You need "C" or "D" ...here@>
+cur_char:=" "; get_byte:=acc;
+end;
+
+@ The |get_next| routine converts lower case to upper case, but it leaves
+the character in the buffer, so we can unconvert it.
+
+@<Scan an ASCII...@>=
+if (cur_char>=@'41)and(cur_char<=@'176)and
+ ((cur_char<"(")or(cur_char>")")) then
+ acc:=xord[buffer[loc]]
+else skip_error('"C" value must be standard ASCII and not a paren')
+@:C value}\.{"C" value must be...@>
+
+@ @<Scan a small dec...@>=
+begin while (cur_char>="0")and(cur_char<="9") do begin
+ acc:=acc*10+cur_char-"0";
+ if acc>65535 then begin
+ skip_error('This value shouldn''t exceed 65535');
+@.This value shouldn't...@>
+ acc:=0; cur_char:=" ";
+ end
+ else get_next;
+ end;
+backup;
+end
+
+@ @<Scan a small oct...@>=
+begin while (cur_char>="0")and(cur_char<="7") do
+ begin acc:=acc*8+cur_char-"0";
+ if acc>65535 then begin
+ skip_error('This value shouldn''t exceed ''177777');
+@.This value shouldn't...@>
+ acc:=0; cur_char:=" ";
+ end
+ else get_next;
+ end;
+backup;
+end
+
+@ @<Scan a small hex...@>=
+begin while ((cur_char>="0")and(cur_char<="9"))or
+ ((cur_char>="A")and(cur_char<="F")) do begin
+ if cur_char>="A" then cur_char:=cur_char+"0"+10-"A";
+ acc:=acc*16+cur_char-"0";
+ if acc>65535 then begin
+ skip_error('This value shouldn''t exceed "FFFF');
+@.This value shouldn't...@>
+ acc:=0; cur_char:=" ";
+ end
+ else get_next;
+ end;
+backup;
+end
+
+@ @<Scan a face...@>=
+begin if cur_char="B" then acc:=2
+else if cur_char="L" then acc:=4
+else if cur_char<>"M" then acc:=18;
+get_next;
+if cur_char="I" then incr(acc)
+else if cur_char<>"R" then acc:=18;
+get_next;
+if cur_char="C" then acc:=acc+6
+else if cur_char="E" then acc:=acc+12
+else if cur_char<>"R" then acc:=18;
+if acc>=18 then begin
+ skip_error('Illegal face code, I changed it to MRR');
+@.Illegal face code...@>
+ acc:=0;
+ end;
+end
+
+@ The routine that scans a four-byte value puts its output into |cur_bytes|,
+which is a record containing (yes, you guessed it) four bytes.
+
+@<Types...@>=
+@!four_bytes=record @!b0:byte;@+@!b1:byte;@+@!b2:byte;@+@!b3:byte;@+end;
+
+@ @d c0==cur_bytes.b0
+@d c1==cur_bytes.b1
+@d c2==cur_bytes.b2
+@d c3==cur_bytes.b3
+
+@<Glob...@>=
+@!cur_bytes:four_bytes; {a four-byte accumulator}
+@!zero_bytes:four_bytes; {four bytes all zero}
+
+@ @<Set init...@>=
+zero_bytes.b0:=0; zero_bytes.b1:=0; zero_bytes.b2:=0; zero_bytes.b3:=0;
+
+@ Since the |get_four_bytes| routine is used very infrequently, no attempt
+has been made to make it fast; we only want it to work.
+This is no longer the case, but we hope that it is not too slow.
+
+@p procedure get_four_bytes; {scans an unsigned constant and sets |four_bytes|}
+var c:integer; {leading byte}
+@!r:integer; {radix}
+begin repeat get_next;
+until cur_char<>" "; {skip the blanks before the type code}
+r:=0; cur_bytes:=zero_bytes; {start with the accumulator zero}
+if cur_char="H" then r:=16
+else if cur_char="O" then r:=8
+else if cur_char="D" then r:=10
+else skip_error('Decimal ("D"), octal ("O") or hex ("H") value is needed here');
+@.Decimal ("D"), octal ("O") or hex ("H")...@>
+if r>0 then begin
+ repeat get_next;
+ until cur_char<>" "; {skip the blanks after the type code}
+ while ((cur_char>="0")and(cur_char<="9"))or@|
+ ((cur_char>="A")and(cur_char<="F")) do
+ @<Multiply by |r|, add |cur_char-"0"|, and |get_next|@>;
+ end;
+end;
+
+function get_integer:integer; {scans an integer property value}
+begin get_four_bytes;
+get_integer:=(c0*@"1000000)+(c1*@"10000)+(c2*@"100)+c3;
+end;
+
+@ @<Multiply by |r|...@>=
+begin if cur_char>="A" then cur_char:=cur_char+"0"+10-"A";
+if cur_char>="0"+r then skip_error('Illegal digit')
+@.Illegal digit@>
+else begin
+ c:=c3*r+cur_char-"0"; c3:=c mod 256;@/
+ c:=c2*r+c div 256; c2:=c mod 256;@/
+ c:=c1*r+c div 256; c1:=c mod 256;@/
+ c:=c0*r+c div 256;
+ if c<256 then c0:=c
+ else begin
+ cur_bytes:=zero_bytes;
+ if r=8 then
+ skip_error('Sorry, the maximum octal value is O 37777777777')
+@.Sorry, the maximum...@>
+ else if r=10 then
+ skip_error('Sorry, the maximum decimal value is D 4294967295')
+ else skip_error('Sorry, the maximum hex value is H FFFFFFFF');
+ end;
+ get_next;
+ end;
+end
+
+@ The remaining scanning routine is the most interesting. It scans a real
+constant and returns the nearest |fix_word| approximation to that constant.
+A |fix_word| is a 32-bit integer that represents a real value that
+has been multiplied by $2^{20}$. Since \.{PLtoTF} restricts the magnitude
+of reals to 2048, the |fix_word| will have a magnitude less than $2^{31}$.
+
+@d unity==@'4000000 {$2^{20}$, the |fix_word| 1.0}
+
+@<Types...@>=
+@!fix_word=integer; {a scaled real value with 20 bits of fraction}
+@!unsigned_integer=integer;
+
+@ When a real value is desired, we might as well treat `\.D' and `\.R'
+formats as if they were identical.
+
+@p function get_fix:fix_word; {scans a real property value}
+var negative:boolean; {was there a minus sign?}
+@!acc:integer; {an accumulator}
+@!int_part:integer; {the integer part}
+@!j:0..7; {the number of decimal places stored}
+begin repeat get_next;
+until cur_char<>" "; {skip the blanks before the type code}
+negative:=false; acc:=0; {start with the accumulators zero}
+if (cur_char<>"R")and(cur_char<>"D") then
+ skip_error('An "R" or "D" value is needed here')
+@.An "R" or "D" ... needed here@>
+else begin
+ @<Scan the blanks and/or signs after the type code@>;
+ while (cur_char>="0") and (cur_char<="9") do
+ @<Multiply by 10, add |cur_char-"0"|, and |get_next|@>;
+ int_part:=acc; acc:=0;
+ if cur_char="." then @<Scan the fraction part and put it in |acc|@>;
+ if (acc>=unity)and(int_part=2047) then
+ skip_error('Real constants must be less than 2048')
+@.Real constants must be...@>
+ else acc:=int_part*unity+acc;
+ end;
+if negative then get_fix:=-acc@+else get_fix:=acc;
+end;
+
+@ @<Scan the blanks...@>=
+repeat get_next;
+if cur_char="-" then begin
+ cur_char:=" "; negative:=true;
+ end
+else if cur_char="+" then cur_char:=" ";
+until cur_char<>" "
+
+@ @<Multiply by 10...@>=
+begin acc:=acc*10+cur_char-"0";
+if acc>=2048 then begin
+ skip_error('Real constants must be less than 2048');
+@.Real constants must be...@>
+ acc:=0; cur_char:=" ";
+ end
+else get_next;
+end
+
+@ To scan the fraction $.d_1d_2\ldots\,$, we keep track of up to seven
+of the digits $d_j$. A correct result is obtained if we first compute
+$f^\prime=\lfloor 2^{21}(d_1\ldots d_j)/10^j\rfloor$, after which
+$f=\lfloor(f^\prime+1)/2\rfloor$. It is possible to have $f=1.0$.
+
+@<Glob...@>=
+@!fraction_digits:array[1..7] of integer; {$2^{21}$ times $d_j$}
+
+@ @<Scan the frac...@>=
+begin j:=0; get_next;
+while (cur_char>="0")and(cur_char<="9") do begin
+ if j<7 then begin
+ incr(j); fraction_digits[j]:=@'10000000*(cur_char-"0");
+ end;
+ get_next;
+ end;
+acc:=0;
+while j>0 do begin
+ acc:=fraction_digits[j]+(acc div 10); decr(j);
+ end;
+acc:=(acc+10) div 20;
+end
+
+@* Storing the property values.
+When property values have been found, they are squirreled away in a bunch
+of arrays. The header information is unpacked into bytes in an array
+called |header_bytes|. The ligature/kerning program is stored in an array
+of type |four_bytes|.
+Another |four_bytes| array holds the specifications of extensible characters.
+The kerns and parameters are stored in separate arrays of |fix_word| values.
+
+Instead of storing the design size in the header array, we will keep it
+in a |fix_word| variable until the last minute. The number of units in the
+design size is also kept in a |fix_word|.
+
+@<Glob...@>=
+@!header_bytes:array[header_index] of byte; {the header block}
+@!header_ptr:header_index; {the number of header bytes in use}
+@!design_size:fix_word; {the design size}
+@!design_units:fix_word; {reciprocal of the scaling factor}
+@!seven_bit_safe_flag:boolean; {does the file claim to be seven-bit-safe?}
+@!lig_kern:array[0..max_lig_steps] of four_bytes; {the ligature program}
+@!nl:unsigned_integer; {the number of ligature/kern instructions so far}
+@!min_nl:unsigned_integer; {the final value of |nl| must be at least this}
+@!kern:array[0..max_kerns] of fix_word; {the distinct kerning amounts}
+@!nk:0..max_kerns; {the number of entries of |kern|}
+@!exten:array[char_type] of four_bytes; {extensible character specs}
+@!ne:xchar_type; {the number of extensible characters}
+@!param:array[1..max_param_words] of fix_word; {\.{FONTDIMEN} parameters}
+@!np:0..max_param_words; {the largest parameter set nonzero}
+@!check_sum_specified:boolean; {did the user name the check sum?}
+@!bchar:xchar_type; {the right boundary character, or 256 if unspecified}
+@!font_dir:integer; {font direction}
+
+@ @<Types...@>=
+@!char_type=0..max_char;
+@!xchar_type=0..xmax_char;
+@!xxchar_type=0..xxmax_char;
+@!xxxchar_type=0..xxxmax_char;
+@!header_index=0..max_header_bytes;
+@!indx=xxchar_type;
+
+@ @<Local...@>=
+@!d:header_index; {an index into |header_bytes|}
+
+@ We start by setting up the default values.
+
+@d check_sum_loc=0
+@d design_size_loc=4
+@d coding_scheme_loc=8
+@d family_loc=coding_scheme_loc+40
+@d seven_flag_loc=family_loc+20
+@d face_loc=seven_flag_loc+3
+
+@<Set init...@>=
+for d:=0 to 18*4-1 do header_bytes[d]:=0;
+header_bytes[8]:=11; header_bytes[9]:="U";
+header_bytes[10]:="N";
+header_bytes[11]:="S";
+header_bytes[12]:="P";
+header_bytes[13]:="E";
+header_bytes[14]:="C";
+header_bytes[15]:="I";
+header_bytes[16]:="F";
+header_bytes[17]:="I";
+header_bytes[18]:="E";
+header_bytes[19]:="D";
+@.UNSPECIFIED@>
+for d:=family_loc to family_loc+11 do header_bytes[d]:=header_bytes[d-40];
+design_size:=10*unity; design_units:=unity; seven_bit_safe_flag:=false;@/
+header_ptr:=18*4; nl:=0; min_nl:=0; nk:=0; ne:=0; np:=0;@/
+check_sum_specified:=false; bchar:=xmax_char;
+font_dir:=0;
+
+@ Most of the dimensions, however, go into the |memory| array. There are
+at most |max_char+2| widths, |max_char+2| heights, |max_char+2| depths,
+and |max_char+2| italic corrections, since the value 0 is required but
+it need not be used. So |memory| has room for |4*max_char+8| entries,
+each of which is a |fix_word|. An auxiliary table called |link| is
+used to link these words together in linear lists, so that sorting and
+other operations can be done conveniently.
+
+We also add four ``list head'' words to the |memory| and |link| arrays;
+these are in locations |width| through |italic|, i.e., 1 through 4.
+For example, |link[height]| points to the smallest element in
+the sorted list of distinct heights that have appeared so far, and
+|memory[height]| is the number of distinct heights.
+
+@<Types...@>=
+@!pointer=0..mem_size; {an index into memory}
+
+@ The arrays |char_wd|, |char_ht|, |char_dp|, and |char_ic| contain
+pointers to the |memory| array entries where the corresponding dimensions
+appear. Two other arrays, |char_tag| and |char_remainder|, hold
+the other information that \.{TFM} files pack into a |char_info_word|.
+
+@d no_tag=0 {vanilla character}
+@d lig_tag=1 {character has a ligature/kerning program}
+@d list_tag=2 {character has a successor in a charlist}
+@d ext_tag=3 {character is extensible}
+@d bchar_label==char_remainder[xmax_char]
+ {beginning of ligature program for left boundary}
+
+@<Glob...@>=
+@!memory:array[pointer] of fix_word; {character dimensions and kerns}
+@!mem_ptr:pointer; {largest |memory| word in use}
+@!link:array[pointer] of pointer; {to make lists of |memory| items}
+@!char_wd:array[char_type] of pointer; {pointers to the widths}
+@!char_ht:array[char_type] of pointer; {pointers to the heights}
+@!char_dp:array[char_type] of pointer; {pointers to the depths}
+@!char_ic:array[char_type] of pointer; {pointers to italic corrections}
+@!char_tag:array[char_type] of no_tag..ext_tag; {character tags}
+@!char_remainder:array[xchar_type] of xchar_type;
+ {pointers to ligature labels,
+ next larger characters, or extensible characters}
+@!top_width,@!top_height,@!top_depth,@!top_italic:integer;
+
+@ @<Local...@>=
+@!c:integer; {runs through all character codes}
+
+@ @<Set init...@>=
+bchar_label:=xmax_label;
+for c:=0 to max_char do begin
+ char_wd[c]:=0; char_ht[c]:=0; char_dp[c]:=0; char_ic[c]:=0;@/
+ char_tag[c]:=no_tag; char_remainder[c]:=0;
+ end;
+memory[0]:=@'17777777777; {an ``infinite'' element at the end of the lists}
+memory[width]:=0; link[width]:=0; {width list is empty}
+memory[height]:=0; link[height]:=0; {height list is empty}
+memory[depth]:=0; link[depth]:=0; {depth list is empty}
+memory[italic]:=0; link[italic]:=0; {italic list is empty}
+mem_ptr:=italic;
+
+@ As an example of these data structures, let us consider the simple
+routine that inserts a potentially new element into one of the dimension
+lists. The first parameter indicates the list head (i.e., |h=width| for
+the width list, etc.); the second parameter is the value that is to be
+inserted into the list if it is not already present. The procedure
+returns the value of the location where the dimension appears in |memory|.
+The fact that |memory[0]| is larger than any legal dimension makes the
+algorithm particularly short.
+
+We do have to handle two somewhat subtle situations. A width of zero must be
+put into the list, so that a zero-width character in the font will not appear
+to be nonexistent (i.e., so that its |char_wd| index will not be zero), but
+this does not need to be done for heights, depths, or italic corrections.
+Furthermore, it is necessary to test for memory overflow even though we
+have provided room for the maximum number of different dimensions in any
+legal font, since the \.{PL} file might foolishly give any number of
+different sizes to the same character.
+
+@p function sort_in(@!h:pointer;@!d:fix_word):pointer; {inserts into list}
+var p:pointer; {the current node of interest}
+begin if (d=0)and(h<>width) then sort_in:=0
+else begin
+ p:=h;
+ while d>=memory[link[p]] do p:=link[p];
+ if (d=memory[p])and(p<>h) then sort_in:=p
+ else if mem_ptr=mem_size then
+ begin err_print('Memory overflow: too many widths, etc');
+@.Memory overflow...@>
+ print_ln('Congratulations! It''s hard to make this error.');
+ sort_in:=p;
+ end
+ else begin
+ incr(mem_ptr); memory[mem_ptr]:=d;
+ link[mem_ptr]:=link[p]; link[p]:=mem_ptr; incr(memory[h]);
+ sort_in:=mem_ptr;
+ end;
+ end;
+end;
+
+@ When these lists of dimensions are eventually written to the \.{OFM}
+file, we may have to do some rounding of values, because the \.{OFM} file
+allows at most 65536 widths, 256 heights, 256 depths, and 256 italic
+corrections. The following procedure takes a given list head |h| and a
+given dimension |d|, and returns the minimum $m$ such that the elements
+of the list can be covered by $m$ intervals of width $d$. It also sets
+|next_d| to the smallest value $d^\prime>d$ such that the covering found
+by this procedure would be different. In particular, if $d=0$ it computes
+the number of elements of the list, and sets |next_d| to the smallest
+distance between two list elements. (The covering by intervals of width
+|next_d| is not guaranteed to have fewer than $m$ elements, but in
+practice this seems to happen most of the time.)
+
+@<Glob...@>=
+@!next_d:fix_word; {the next larger interval that is worth trying}
+
+@ Once again we can make good use of the fact that |memory[0]| is ``infinite.''
+
+@p function min_cover(@!h:pointer;@!d:fix_word):integer;
+var p:pointer; {the current node of interest}
+@!l:fix_word; {the least element covered by the current interval}
+@!m:integer; {the current size of the cover being generated}
+begin m:=0; p:=link[h]; next_d:=memory[0];
+while p<>0 do begin
+ incr(m); l:=memory[p];
+ while memory[link[p]]<=l+d do p:=link[p];
+ p:=link[p];
+ if memory[p]-l<next_d then next_d:=memory[p]-l;
+ end;
+min_cover:=m;
+end;
+
+@ The following procedure uses |min_cover| to determine the smallest $d$
+such that a given list can be covered with at most a given number of
+intervals.
+
+@p function shorten(@!h:pointer;m:integer):fix_word; {finds best way to round}
+var d:fix_word; {the current trial interval length}
+@!k:integer; {the size of a minimum cover}
+begin if memory[h]>m then begin
+ excess:=memory[h]-m;
+ k:=min_cover(h,0); d:=next_d; {now the answer is at least |d|}
+ repeat d:=d+d; k:=min_cover(h,d);
+ until k<=m; {first we ascend rapidly until finding the range}
+ d:=d div 2; k:=min_cover(h,d); {now we run through the feasible steps}
+ while k>m do begin
+ d:=next_d; k:=min_cover(h,d);
+ end;
+ shorten:=d;
+ end
+else shorten:=0;
+end;
+
+@ When we are nearly ready to output the \.{TFM} file, we will set
+|index[p]:=k| if the dimension in |memory[p]| is being rounded to the
+|k|th element of its list.
+
+@<Glob...@>=
+@!index:array[pointer] of byte;
+@!excess:byte; {number of words to remove, if list is being shortened}
+
+@ Here is the procedure that sets the |index| values. It also shortens
+the list so that there is only one element per covering interval;
+the remaining elements are the midpoints of their clusters.
+
+@p procedure set_indices(@!h:pointer;@!d:fix_word);
+ {reduces and indexes a list}
+var p:pointer; {the current node of interest}
+@!q:pointer; {trails one step behind |p|}
+@!m:byte; {index number of nodes in the current interval}
+@!l:fix_word; {least value in the current interval}
+begin q:=h; p:=link[q]; m:=0;
+while p<>0 do begin
+ incr(m); l:=memory[p]; index[p]:=m;
+ while memory[link[p]]<=l+d do begin
+ p:=link[p]; index[p]:=m; decr(excess);
+ if excess=0 then d:=0;
+ end;
+ link[q]:=p; memory[p]:=l+(memory[p]-l) div 2; q:=p; p:=link[p];
+ end;
+memory[h]:=m;
+end;
+
+@* The input phase.
+We're ready now to read and parse the \.{PL} file, storing property
+values as we go.
+
+@<Glob...@>=
+@!c:integer; {the current character or byte being processed}
+@!cprime:char_type; {Processing for several characters together}
+@!crange:char_type; {ditto}
+
+@ @<Read all the input@>=
+cur_char:=" ";
+repeat while cur_char=" " do get_next;
+if cur_char="(" then @<Read a font property value@>
+else if (cur_char=")")and not input_has_ended then begin
+ err_print('Extra right parenthesis');
+ incr(loc); cur_char:=" ";
+ end
+@.Extra right parenthesis@>
+else if not input_has_ended then junk_error;
+until input_has_ended
+
+@ The |junk_error| routine just referred to is called when something
+appears in the forbidden area between properties of a property list.
+
+@p procedure junk_error; {gets past no man's land}
+begin err_print('There''s junk here that is not in parentheses');
+@.There's junk here...@>
+skip_to_paren;
+end;
+
+@ For each font property, we are supposed to read the data from the
+left parenthesis that is the current value of |cur_char| to the right
+parenthesis that matches it in the input. The main complication is
+to recover with reasonable grace from various error conditions that
+might arise.
+
+@<Read a font property value@>=
+begin get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if (cur_code<110) and (cur_code>character_code) then
+ flush_error('This property name doesn''t belong on the outer level')
+else if (cur_code>=110) and ((cur_code mod 10)<>0) then
+ flush_error('This property name doesn''t belong on the outer level')
+@.This property name doesn't belong...@>
+else begin @<Read the font property value specified by |cur_code|@>;
+ finish_the_property;
+ end;
+end
+
+@ @<Read the font property value spec...@>=
+case cur_code of
+ check_sum_code: begin
+ check_sum_specified:=true;
+ read_four_bytes(check_sum_loc);
+ end;
+ design_size_code: @<Read the design size@>;
+ design_units_code: @<Read the design units@>;
+ coding_scheme_code: read_BCPL(coding_scheme_loc,40);
+ family_code: read_BCPL(family_loc,20);
+ face_code: begin
+ c:=get_byte; if c>255 then
+ begin err_print('FACE clipped to 255'); c:=255 end;
+ header_bytes[face_loc]:=c
+ end;
+ seven_bit_safe_flag_code: @<Read the seven-bit-safe flag@>;
+ header_code: @<Read an indexed header word@>;
+ font_dimen_code: @<Read font parameter list@>;
+ lig_table_code: read_lig_kern;
+ boundary_char_code: bchar:=get_byte;
+ character_code: read_char_info;
+ ofm_level_code: @<Read OFM level code@>;
+ font_dir_code: @<Read font direction code@>;
+ n_font_dir_code: @<Read natural font direction code@>;
+ char_repeat_code: read_repeated_character_info;
+ font_rule_code: read_font_rule_list;
+ font_glue_code: read_font_glue_list;
+ font_penalty_code: read_font_penalty_list;
+ font_mvalue_code: read_font_mvalue_list;
+ font_fvalue_code: read_font_fvalue_list;
+ font_ivalue_code: read_font_ivalue_list;
+ end
+
+@ The |case| statement just given makes use of two subroutines that we
+haven't defined yet. The first of these puts a 32-bit octal quantity
+into four specified bytes of the header block.
+
+@p procedure read_four_bytes(l:header_index);
+begin get_four_bytes;
+header_bytes[l]:=c0;
+header_bytes[l+1]:=c1;
+header_bytes[l+2]:=c2;
+header_bytes[l+3]:=c3;
+end;
+
+@ The second little procedure is used to scan a string and to store it in
+the ``{\mc BCPL} format'' required by \.{TFM} files. The string is supposed
+to contain at most |n| bytes, including the first byte (which holds the
+length of the rest of the string).
+
+@p procedure read_BCPL(l:header_index;n:byte);
+var k:header_index;
+begin k:=l;
+while cur_char=" " do get_next;
+while (cur_char<>"(")and(cur_char<>")") do begin
+ if k<l+n then incr(k);
+ if k<l+n then header_bytes[k]:=cur_char;
+ get_next;
+ end;
+if k=l+n then begin
+ err_print('String is too long; its first ',n-1:1,
+@.String is too long...@>
+ ' characters will be kept'); decr(k);
+ end;
+header_bytes[l]:=k-l;
+while k<l+n-1 do begin {tidy up the remaining bytes by setting them to nulls}
+ incr(k); header_bytes[k]:=0;
+ end;
+end;
+
+@ @<Read the design size@>=
+begin next_d:=get_fix;
+if next_d<unity then
+ err_print('The design size must be at least 1')
+@.The design size must...@>
+else design_size:=next_d;
+end
+
+@ @<Read the design units@>=
+begin next_d:=get_fix;
+if next_d<=0 then
+ err_print('The number of units per design size must be positive')
+@.The number of units...@>
+else design_units:=next_d;
+end
+
+@ @<Read the seven-bit-safe...@>=
+begin while cur_char=" " do get_next;
+if cur_char="T" then seven_bit_safe_flag:=true
+else if cur_char="F" then seven_bit_safe_flag:=false
+else err_print('The flag value should be "TRUE" or "FALSE"');
+@.The flag value should be...@>
+skip_to_paren;
+end
+
+@ @<Read an indexed header word@>=
+begin c:=get_byte;
+if c<18 then skip_error('HEADER indices should be 18 or more')
+@.HEADER indices...@>
+else if 4*c+4>max_header_bytes then
+ skip_error('This HEADER index is too big for my present table size')
+@.This HEADER index is too big...@>
+else begin
+ while header_ptr<4*c+4 do begin
+ header_bytes[header_ptr]:=0; incr(header_ptr);
+ end;
+ read_four_bytes(4*c);
+ end;
+end
+
+@ The remaining kinds of font property values that need to be read are
+those that involve property lists on higher levels. Each of these has a
+loop similar to the one that was used at level zero. Then we put the
+right parenthesis back so that `|finish_the_property|' will be happy;
+there is probably a more elegant way to do this.
+
+@d finish_inner_property_list==begin decr(loc); incr(level); cur_char:=")";
+ end
+
+@<Read font parameter list@>=
+begin while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a parameter value@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a parameter value@>=
+begin get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if (cur_code<parameter_code)or(cur_code>=char_wd_code) then
+ flush_error('This property name doesn''t belong in a FONTDIMEN list')
+@.This property name doesn't belong...@>
+else begin
+ if cur_code=parameter_code then c:=get_integer
+ else c:=cur_code-parameter_code;
+ if c=0 then flush_error('PARAMETER index must not be zero')
+@.PARAMETER index must not...@>
+ else if c>max_param_words then
+ flush_error('This PARAMETER index is too big for my present table size')
+@.This PARAMETER index is too big...@>
+ else begin
+ while np<c do begin
+ incr(np); param[np]:=0;
+ end;
+ param[c]:=get_fix;
+ finish_the_property;
+ end;
+ end;
+end
+
+@ @<Read ligature/kern list@>=
+begin lk_step_ended:=false;
+while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then read_lig_kern_command
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a ligature/kern command@>=
+begin get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if (cur_code>=label_code) and (cur_code<=(lig_code+11)) then begin
+ case cur_code of
+ label_code:@<Read a label step@>;
+ stop_code:@<Read a stop step@>;
+ skip_code:@<Read a skip step@>;
+ krn_code:@<Read a kerning step@>;
+ lig_code,lig_code+1,lig_code+2,lig_code+3,lig_code+5,
+ lig_code+6,lig_code+7,lig_code+11:@<Read a ligature step@>;
+ end; {there are no other cases |>=label_code|}
+ finish_the_property;
+end
+else if (cur_code>=clabel_code) and (cur_code<=cpenglue_code) then begin
+ case cur_code of
+ clabel_code:@<Read an extended label step@>;
+ cpen_code:@<Read an extended penalty step@>;
+ cglue_code:@<Read an extended glue step@>;
+ cpenglue_code:@<Read an extended penalty/glue step@>;
+ ckrn_code:@<Read an extended kern step@>;
+ end; {there are no other cases |>=label_code|}
+ finish_the_property;
+end
+else flush_error('This property name doesn''t belong in a LIGTABLE list');
+@.This property name doesn't belong...@>
+end
+
+@ When a character is about to be tagged, we call the following
+procedure so that an error message is given in case of multiple tags.
+
+@p procedure check_tag(c:integer); {print error if |c| already tagged}
+begin case char_tag[c] of
+ no_tag: do_nothing;
+ lig_tag: err_print('This character already appeared in a LIGTABLE LABEL');
+@.This character already...@>
+ list_tag: err_print('This character already has a NEXTLARGER spec');
+ ext_tag: err_print('This character already has a VARCHAR spec');
+ end;
+end;
+
+@ @<Read a label step@>=
+begin while cur_char=" " do get_next;
+if cur_char="B" then begin
+ bchar_label:=nl; skip_to_paren; {\.{LABEL BOUNDARYCHAR}}
+ end
+else begin
+ backup; c:=get_byte;
+ check_tag(c); char_tag[c]:=lig_tag; char_remainder[c]:=nl;
+ end;
+if min_nl<=nl then min_nl:=nl+1;
+lk_step_ended:=false;
+end
+
+@ @d stop_flag=128 {value indicating `\.{STOP}' in a lig/kern program}
+@d kern_flag=128 {op code for a kern step}
+
+@<Globals...@>=
+@!lk_step_ended:boolean;
+ {was the last \.{LIGTABLE} property \.{LIG} or \.{KRN}?}
+@!krn_ptr:0..max_kerns; {an index into |kern|}
+
+@ @<Read a stop step@>=
+if not lk_step_ended then
+ err_print('STOP must follow LIG or KRN')
+@.STOP must follow LIG or KRN@>
+else begin
+ lig_kern[nl-1].b0:=lig_kern[nl-1].b0 div 256 * 256 + stop_flag;
+ lk_step_ended:=false;
+ end
+
+@ @<Read a skip step@>=
+if not lk_step_ended then
+ err_print('SKIP must follow LIG or KRN')
+@.SKIP must follow LIG or KRN@>
+else begin
+ c:=get_byte;
+ if c>=128 then err_print('Maximum SKIP amount is 127')
+@.Maximum SKIP amount...@>
+ else if nl+c>=max_lig_steps then
+ err_print('Sorry, LIGTABLE too long for me to handle')
+@.Sorry, LIGTABLE too long...@>
+ else begin
+ lig_kern[nl-1].b0:=c;
+ if min_nl<=nl+c then min_nl:=nl+c+1;
+ end;
+ lk_step_ended:=false;
+ end
+
+@ @<Read a ligature step@>=
+begin lig_kern[nl].b0:=0;
+lig_kern[nl].b2:=cur_code-lig_code;
+lig_kern[nl].b1:=get_byte;
+lig_kern[nl].b3:=get_byte;
+if nl>=max_lig_steps-1 then
+ err_print('Sorry, LIGTABLE too long for me to handle')
+@.Sorry, LIGTABLE too long...@>
+else incr(nl);
+lk_step_ended:=true;
+end
+
+@ @<Read a kerning step@>=
+begin lig_kern[nl].b0:=0; lig_kern[nl].b1:=get_byte;
+kern[nk]:=get_fix; krn_ptr:=0;
+while kern[krn_ptr]<>kern[nk] do incr(krn_ptr);
+if krn_ptr=nk then begin
+ if nk<max_kerns then incr(nk)
+ else begin
+ err_print('Sorry, too many different kerns for me to handle');
+@.Sorry, too many different kerns...@>
+ decr(krn_ptr);
+ end;
+ end;
+if ofm_level=-1 then begin
+ lig_kern[nl].b2:=kern_flag+(krn_ptr div 256);
+ lig_kern[nl].b3:=krn_ptr mod 256;
+ end
+else begin
+ lig_kern[nl].b2:=kern_flag+(krn_ptr div 65536);
+ lig_kern[nl].b3:=krn_ptr mod 65536;
+ end;
+if nl>=max_lig_steps-1 then
+ err_print('Sorry, LIGTABLE too long for me to handle')
+@.Sorry, LIGTABLE too long...@>
+else incr(nl);
+lk_step_ended:=true;
+end
+
+@ @<Global...@>=
+@!category_remainders:array[0..256] of integer;
+@!ivalue_category,@!max_ivalue_category:integer;
+@!glue_category,@!max_glue_category:integer;
+@!penalty_category,@!max_penalty_category:integer;
+
+@ @<Set init...@>=
+for ivalue_category:=0 to 256 do begin
+ category_remainders[ivalue_category]:=-1;
+ end;
+max_ivalue_category:=-1;
+max_glue_category:=-1;
+max_penalty_category:=-1;
+
+@ @<Read an extended label step@>=
+begin
+c:=get_byte;
+category_remainders[c]:=nl;
+if max_ivalue_category<c then max_ivalue_category:=c;
+if min_nl<=nl then min_nl:=nl+1;
+lk_step_ended:=false;
+end
+
+@ @<Read an extended penalty step@>=
+begin lig_kern[nl].b0:=256; lig_kern[nl].b1:=get_byte;
+lig_kern[nl].b2:=17;
+penalty_category:=get_byte;
+if max_penalty_category<penalty_category then
+ max_penalty_category:=penalty_category;
+lig_kern[nl].b3:=penalty_category;
+if nl>=max_lig_steps-1 then
+ err_print('Sorry, LIGTABLE too long for me to handle')
+@.Sorry, LIGTABLE too long...@>
+else incr(nl);
+lk_step_ended:=true;
+end
+
+@ @<Read an extended glue step@>=
+begin lig_kern[nl].b0:=256; lig_kern[nl].b1:=get_byte;
+lig_kern[nl].b2:=18;
+glue_category:=get_byte;
+if max_glue_category<glue_category then
+ max_glue_category:=glue_category;
+lig_kern[nl].b3:=glue_category;
+if nl>=max_lig_steps-1 then
+ err_print('Sorry, LIGTABLE too long for me to handle')
+@.Sorry, LIGTABLE too long...@>
+else incr(nl);
+lk_step_ended:=true;
+end
+
+@ @<Read an extended penalty/glue step@>=
+begin lig_kern[nl].b0:=256; lig_kern[nl].b1:=get_byte;
+lig_kern[nl].b2:=19;
+penalty_category:=get_byte;
+if max_penalty_category<penalty_category then
+ max_penalty_category:=penalty_category;
+glue_category:=get_byte;
+if max_glue_category<glue_category then
+ max_glue_category:=glue_category;
+lig_kern[nl].b3:=penalty_category*256+glue_category;
+if nl>=max_lig_steps-1 then
+ err_print('Sorry, LIGTABLE too long for me to handle')
+@.Sorry, LIGTABLE too long...@>
+else incr(nl);
+lk_step_ended:=true;
+end
+
+@ @<Read an extended kern step@>=
+begin lig_kern[nl].b0:=256; lig_kern[nl].b1:=get_byte;
+lig_kern[nl].b2:=20;
+kern[nk]:=get_fix; krn_ptr:=0;
+while kern[krn_ptr]<>kern[nk] do incr(krn_ptr);
+if krn_ptr=nk then begin
+ if nk<max_kerns then incr(nk)
+ else begin
+ err_print('Sorry, too many different kerns for me to handle');
+@.Sorry, too many different kerns...@>
+ decr(krn_ptr);
+ end;
+ end;
+if krn_ptr>65535 then
+ err_print('Sorry, too many different kerns for me to handle');
+lig_kern[nl].b3:=krn_ptr;
+if nl>=max_lig_steps-1 then
+ err_print('Sorry, LIGTABLE too long for me to handle')
+@.Sorry, LIGTABLE too long...@>
+else incr(nl);
+lk_step_ended:=true;
+end
+
+@ @<Globals...@>=
+@!char_extended_tag:array [char_type] of boolean;
+
+@ @<Set init...@>=
+for c:=0 to max_char do
+ char_extended_tag[c]:=false;
+
+@ @<Finish up the extended font stuff@>=
+begin
+if max_penalty_category>0 then begin
+ if nkp=0 then
+ err_print('No PENALTY table')
+ else if npp[0]<max_penalty_category then
+ err_print('Not enough PENALTY entries');
+ end;
+if max_glue_category>0 then begin
+ if nkg=0 then
+ err_print('No GLUE table')
+ else if npg[0]<max_glue_category then
+ err_print('Not enough GLUE entries');
+ end;
+if max_ivalue_category>0 then begin
+ if nki=0 then
+ err_print('No IVALUE table')
+ else if npi[0]<max_ivalue_category then
+ err_print('Not enough IVALUE entries')
+ else begin
+ for c:=0 to max_char do begin
+ if (char_wd[c]<>0) then begin
+ for j:=0 to max_ivalue_category do
+ if char_table[c,0]=j then begin
+ if category_remainders[j]<>-1 then begin
+ if char_tag[c]<>0 then
+ err_print('Character already has a tag')
+ else begin
+ char_extended_tag[c]:=true;
+ char_remainder[c]:=category_remainders[j];
+ end;
+ end;
+ end;
+ end;
+ end;
+ end;
+ end;
+end
+
+@ @<Global...@>=
+tables_read:boolean;
+
+@ @<Set init...@>=
+tables_read:=false;
+
+@ Finally we come to the part of \.{PLtoTF}'s input mechanism
+that is used most, the processing of individual character data.
+
+@<Read character info list@>=
+begin
+if not tables_read then begin
+ compute_new_header_ofm;
+ tables_read:=true;
+ end;
+c:=get_byte; {read the character code that is being specified}
+@<Print |c| in hex notation@>;
+while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then read_character_property
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+if char_wd[c]=0 then char_wd[c]:=sort_in(width,0); {legitimatize |c|}
+finish_inner_property_list;
+end
+
+@ @<Globals...@>=
+@!char_original:array [0..max_char] of integer;
+@!char_repeats:array [0..max_char] of integer;
+@!diff:boolean;
+@!needed_space,@!extra_bytes:integer;
+
+@ @<Set init...@>=
+for ch_entry:=0 to max_char do begin
+ char_original[ch_entry]:=ch_entry;
+ char_repeats[ch_entry]:=0;
+ end;
+
+@ @<Read repeated character info@>=
+begin
+if not tables_read then begin
+ @<Compute the new header information for OFM files@>;
+ tables_read:=true;
+ end;
+c:=get_byte; {read the character code that is being specified}
+@<Print |c| in hex notation@>;
+crange:=get_byte; {read how many characters are being defined}
+if (crange<0) then begin
+ err_print('Character ranges must be positive');
+ crange:=0;
+ end;
+if ((c+crange)>max_char) then begin
+ err_print('Character range too large');
+ crange:=0;
+ end;
+print('-'); print_hex(c+crange);
+while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then read_character_property
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+if char_wd[c]=0 then char_wd[c]:=sort_in(width,0); {legitimatize |c|}
+finish_inner_property_list;
+cprime:=c;
+for c:=(cprime+1) to (cprime+crange) do begin
+ char_wd[c]:=char_wd[cprime];
+ char_ht[c]:=char_ht[cprime];
+ char_dp[c]:=char_dp[cprime];
+ char_ic[c]:=char_ic[cprime];
+ for tab:=0 to (nki+nkf+nkr+nkg+nkp-1) do begin
+ char_table[c,tab]:= char_table[cprime,tab];
+ end;
+ end;
+end
+
+@ Tables for character parameters
+
+@d char_param_tables==8
+
+@<Globals...@>=
+@!char_table:array [0..max_char,0..char_param_tables] of integer;
+@!ch_table,@!ch_entry:integer;
+@!temp_value:integer;
+
+@ @<Set init...@>=
+for c:=0 to max_char do
+ for ch_table:=0 to char_param_tables do
+ char_table[c,ch_table]:=0;
+
+@ @<Read a character property@>=
+begin get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if (cur_code<char_wd_code)or
+ ((cur_code>var_char_code)and
+ ((cur_code<char_ivalue_code)or(cur_code>char_penalty_code)))
+then
+ flush_error('This property name doesn''t belong in a CHARACTER list')
+@.This property name doesn't belong...@>
+else begin
+ case cur_code of
+ char_wd_code:char_wd[c]:=sort_in(width,get_fix);
+ char_ht_code:char_ht[c]:=sort_in(height,get_fix);
+ char_dp_code:char_dp[c]:=sort_in(depth,get_fix);
+ char_ic_code:char_ic[c]:=sort_in(italic,get_fix);
+ sec_width_code:temp_value:=get_fix;
+ sec_height_code:temp_value:=get_fix;
+ sec_depth_code:temp_value:=get_fix;
+ sec_italic_code:temp_value:=get_fix;
+ accent_code:temp_value:=get_fix;
+ prim_top_axis_code:temp_value:=get_fix;
+ prim_top_axis_bis_code:temp_value:=get_fix;
+ prim_bot_axis_code:temp_value:=get_fix;
+ prim_bot_axis_bis_code:temp_value:=get_fix;
+ prim_mid_hor_code:temp_value:=get_fix;
+ prim_mid_vert_code:temp_value:=get_fix;
+ prim_base_slant_code:temp_value:=get_fix;
+ sec_top_axis_code:temp_value:=get_fix;
+ sec_top_axis_bis_code:temp_value:=get_fix;
+ sec_bot_axis_code:temp_value:=get_fix;
+ sec_bot_axis_bis_code:temp_value:=get_fix;
+ sec_mid_hor_code:temp_value:=get_fix;
+ sec_mid_vert_code:temp_value:=get_fix;
+ sec_base_slant_code:temp_value:=get_fix;
+ next_larger_code:begin check_tag(c); char_tag[c]:=list_tag;
+ char_remainder[c]:=get_byte;
+ end;
+ var_char_code:@<Read an extensible recipe for |c|@>;
+ char_ivalue_code: begin
+ ch_table:=get_integer;
+ ch_entry:=get_integer;
+ char_table[c,ch_table]:=ch_entry;
+ if ch_table>nkci then nkci:=ch_table;
+ end;
+ char_fvalue_code: begin
+ ch_table:=get_integer+nki;
+ ch_entry:=get_integer;
+ char_table[c,ch_table]:=ch_entry;
+ if ch_table>nkcf then nkcf:=ch_table;
+ end;
+ char_mvalue_code: begin
+ ch_table:=get_integer+nki+nkf;
+ ch_entry:=get_integer;
+ char_table[c,ch_table]:=ch_entry;
+ if ch_table>nkcm then nkcm:=ch_table;
+ end;
+ char_rule_code: begin
+ ch_table:=get_integer+nki+nkf+nkm;
+ ch_entry:=get_integer;
+ char_table[c,ch_table]:=ch_entry;
+ if ch_table>nkcr then nkcr:=ch_table;
+ end;
+ char_glue_code: begin
+ ch_table:=get_integer+nki+nkf+nkm+nkr;
+ ch_entry:=get_integer;
+ char_table[c,ch_table]:=ch_entry;
+ if ch_table>nkcg then nkcg:=ch_table;
+ end;
+ char_penalty_code: begin
+ ch_table:=get_integer+nki+nkf+nkm+nkr+nkg;
+ ch_entry:=get_integer;
+ char_table[c,ch_table]:=ch_entry;
+ if ch_table>nkcp then nkcp:=ch_table;
+ end;
+ end;@/
+ finish_the_property;
+ end;
+end
+
+@ @<Read an extensible r...@>=
+begin if ne=xmax_char then
+ err_print('Sorry, too many VARCHAR specs')
+@.Sorry, too many VARCHAR specs@>
+else begin
+ check_tag(c); char_tag[c]:=ext_tag; char_remainder[c]:=ne;@/
+ exten[ne]:=zero_bytes;
+ while level=2 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read an extensible piece@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+ incr(ne);
+ finish_inner_property_list;
+ end;
+end
+
+@ @<Read an extensible p...@>=
+begin get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if (cur_code<var_char_code+1)or(cur_code>var_char_code+4) then
+ flush_error('This property name doesn''t belong in a VARCHAR list')
+@.This property name doesn't belong...@>
+else begin
+ case cur_code-(var_char_code+1) of
+ 0:exten[ne].b0:=get_byte;
+ 1:exten[ne].b1:=get_byte;
+ 2:exten[ne].b2:=get_byte;
+ 3:exten[ne].b3:=get_byte;
+ end;@/
+ finish_the_property;
+ end;
+end
+
+@ The input routine is now complete except for the following code,
+which prints a progress report as the file is being read.
+@<Glob...@>=
+@!ASCII_04,@!ASCII_10,@!ASCII_14,HEX: packed array [1..32] of char;
+ {strings for output in the user's external character set}
+@!MBL_string,@!RI_string,@!RCE_string:packed array [1..3] of char;
+ {handy string constants for |face| codes}
+
+@ @<Set init...@>=
+ASCII_04:=' !"#$%&''()*+,-./0123456789:;<=>?';@/
+ASCII_10:='@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_';@/
+ASCII_14:='`abcdefghijklmnopqrstuvwxyz{|}~ ';@/
+HEX:='0123456789ABCDEF';@/
+MBL_string:='MBL'; RI_string:='RI '; RCE_string:='RCE';
+
+@ The array |dig| will hold a sequence of digits to be output.
+
+@<Glob...@>=
+@!dig:array[0..32] of integer;
+
+@ Here, in fact, are two procedures that output
+|dig[j-1]|$\,\ldots\,$|dig[0]|, given $j>0$.
+
+@p procedure out_digs(j:integer); {outputs |j| digits}
+begin repeat decr(j); out(HEX[1+dig[j]]);
+until j=0;
+end;
+@#
+procedure print_digs(j:integer); {prints |j| digits}
+begin repeat decr(j); print(HEX[1+dig[j]]);
+until j=0;
+end;
+
+
+@ The |print_number| procedure indicates how |print_digs| can be used.
+This procedure can print in octal, decimal or hex notation.
+
+@d print_hex(#)==print_number(#,16)
+@d print_octal(#)==print_number(#,8)
+@d print_decimal(#)==print_number(#,10)
+
+@p procedure print_number(c:integer; form:integer); {prints value of |c|}
+var j:0..32; {index into |dig|}
+begin
+j:=0;
+if (c<0) then begin
+ print_ln('Internal error: print_number (negative value)');
+ c:=0
+ end;
+if form=8 then
+ print('''') {an apostrophe indicates the octal notation}
+else if form=16 then
+ print('"') { a double apostrophe indicates the hexadecimal notation}
+else if form<>10 then begin
+ print_ln('Internal error: print_number');
+ form:=10
+ end;
+while (c>0) or (j=0) do begin
+ dig[j]:=c mod form; c:=c div form;
+ j:=j+1;
+ end;
+print_digs(j);
+end;
+
+
+@ @<Print |c| in hex...@>=
+begin if chars_on_line=8 then begin
+ print_ln(' '); chars_on_line:=1;
+ end
+else begin
+ if chars_on_line>0 then print(' ');
+ incr(chars_on_line);
+ end;
+print_hex(c); {progress report}
+end
+
+@* The checking and massaging phase.
+Once the whole \.{PL} file has been read in, we must check it for consistency
+and correct any errors. This process consists mainly of running through
+the characters that exist and seeing if they refer to characters that
+don't exist. We also compute the true value of |seven_unsafe|; we make sure
+that the charlists and ligature programs contain no loops; and we
+shorten the lists of widths, heights, depths, and italic corrections,
+if necessary, to keep from exceeding the required maximum sizes.
+
+@<Glob...@>=
+@!seven_unsafe:boolean; {do seven-bit characters generate eight-bit ones?}
+
+@ @<Correct and check the information@>=
+if nl>0 then @<Make sure the ligature/kerning program ends appropriately@>;
+seven_unsafe:=false;
+for c:=0 to max_char do if char_wd[c]<>0 then
+ @<For all characters |g| generated by |c|,
+ make sure that |char_wd[g]| is nonzero, and
+ set |seven_unsafe| if |c<128<=g|@>;
+if bchar_label<xmax_label then begin
+ c:=xmax_char; @<Check ligature program of |c|@>;
+ end;
+if seven_bit_safe_flag and seven_unsafe then
+ print_ln('The font is not really seven-bit-safe!');
+@.The font is not...safe@>
+@<Check for infinite ligature loops@>;
+@<Doublecheck the lig/kern commands and the extensible recipes@>;
+finish_extended_font;
+for c:=0 to max_char do
+ @<Make sure that |c| is not the largest element of a charlist cycle@>;
+@<Put the width, height, depth, and italic lists into final form@>
+
+@ The checking that we need in several places is accomplished by three
+macros that are only slightly tricky.
+
+@d existence_tail(#)==begin char_wd[g]:=sort_in(width,0);
+ print(#,' '); print_hex(c);
+ print_ln(' had no CHARACTER spec.');
+ end;
+ end
+@d check_existence_and_safety(#)==begin g:=#;
+ if (g>=128)and(c<128) then seven_unsafe:=true;
+ if char_wd[g]=0 then existence_tail
+@d check_existence(#)==begin g:=#;
+ if char_wd[g]=0 then existence_tail
+
+@<For all characters |g| generated by |c|...@>=
+case char_tag[c] of
+ no_tag: do_nothing;
+ lig_tag: @<Check ligature program of |c|@>;
+ list_tag: check_existence_and_safety(char_remainder[c])
+ ('The character NEXTLARGER than');
+@.The character NEXTLARGER...@>
+ ext_tag:@<Check the pieces of |exten[c]|@>;
+ end
+
+@ @<Check the pieces...@>=
+begin if exten[char_remainder[c]].b0>0 then
+ check_existence_and_safety(exten[char_remainder[c]].b0)
+ ('TOP piece of character');
+@.TOP piece of character...@>
+if exten[char_remainder[c]].b1>0 then
+ check_existence_and_safety(exten[char_remainder[c]].b1)
+ ('MID piece of character');
+@.MID piece of character...@>
+if exten[char_remainder[c]].b2>0 then
+ check_existence_and_safety(exten[char_remainder[c]].b2)
+ ('BOT piece of character');
+@.BOT piece of character...@>
+check_existence_and_safety(exten[char_remainder[c]].b3)
+ ('REP piece of character');
+@.REP piece of character...@>
+end
+
+@ @<Make sure that |c| is not the largest element of a charlist cycle@>=
+if char_tag[c]=list_tag then begin
+ g:=char_remainder[c];
+ while (g<c)and(char_tag[g]=list_tag) do g:=char_remainder[g];
+ if g=c then begin
+ char_tag[c]:=no_tag;
+ print('A cycle of NEXTLARGER characters has been broken at ');
+@.A cycle of NEXTLARGER...@>
+ print_hex(c); print_ln('.');
+ end;
+ end
+
+@ @<Global...@>=
+@!delta:fix_word; {size of the intervals needed for rounding}
+
+@ @d round_message(#)==if delta>0 then print_ln('I had to round some ',
+@.I had to round...@>
+ #,'s by ',(((delta+1) div 2)/@'4000000):1:7,' units.')
+
+@<Put the width, height, depth, and italic lists into final form@>=
+case ofm_level of
+ -1: begin
+ top_width:=255; top_depth:=15; top_height:=15; top_italic:=63;
+ end;
+ 0: begin
+ top_width:=65535; top_depth:=255; top_height:=255; top_italic:=255;
+ end;
+ 1: begin
+ top_width:=65535; top_depth:=255; top_height:=255; top_italic:=255;
+ end;
+ end;
+delta:=shorten(width,top_width); set_indices(width,delta);
+ round_message('width');@/
+delta:=shorten(height,top_height); set_indices(height,delta);
+ round_message('height');@/
+delta:=shorten(depth,top_depth); set_indices(depth,delta);
+ round_message('depth');@/
+delta:=shorten(italic,top_italic); set_indices(italic,delta);
+ round_message('italic correction');
+
+@ @d clear_lig_kern_entry== {make an unconditional \.{STOP}}
+ lig_kern[nl].b0:=255; lig_kern[nl].b1:=0;
+ lig_kern[nl].b2:=0; lig_kern[nl].b3:=0
+
+@<Make sure the ligature/kerning program ends...@>=
+begin if bchar_label<xmax_label then {make room for it} begin
+ clear_lig_kern_entry; incr(nl);
+ end; {|bchar_label| will be stored later}
+while min_nl>nl do begin
+ clear_lig_kern_entry; incr(nl);
+ end;
+if (lig_kern[nl-1].b0 mod 256)=0 then
+ lig_kern[nl-1].b0:=lig_kern[nl-1].b0 div 256 * 256 + stop_flag;
+end
+
+@ It's not trivial to check for infinite loops generated by repeated
+insertion of ligature characters. But fortunately there is a nice
+algorithm for such testing, copied here from the program \.{TFtoPL}
+where it is explained further.
+
+@d simple=0 {$f(x,y)=z$}
+@d left_z=1 {$f(x,y)=f(z,y)$}
+@d right_z=2 {$f(x,y)=f(x,z)$}
+@d both_z=3 {$f(x,y)=f(f(x,z),y)$}
+@d pending=4 {$f(x,y)$ is being evaluated}
+
+
+@ @<Glo...@>=
+@!lig_ptr:0..max_lig_steps; {an index into |lig_kern|}
+@!hash:array[0..hash_size] of integer;
+@!class:array[0..hash_size] of simple..pending;
+@!lig_z:array[0..hash_size] of xxchar_type;
+@!hash_ptr:0..hash_size; {the number of nonzero entries in |hash|}
+@!hash_list:array[0..hash_size] of 0..hash_size; {list of those nonzero entries}
+@!h,@!hh:0..hash_size; {indices into the hash table}
+@!tt:indx; {temporary register}
+@!x_lig_cycle,@!y_lig_cycle:xchar_type; {problematic ligature pair}
+
+@ @<Set init...@>=
+hash_ptr:=0; y_lig_cycle:=xmax_char;
+for k:=0 to hash_size do hash[k]:=0;
+
+@ @d lig_exam==lig_kern[lig_ptr].b1
+@d lig_gen==lig_kern[lig_ptr].b3
+
+@<Check lig...@>=
+begin lig_ptr:=char_remainder[c];
+if (lig_kern[lig_ptr].b0 div 256)=0 then
+begin
+repeat if hash_input(lig_ptr,c) then begin
+ if lig_kern[lig_ptr].b2<kern_flag then begin
+ if lig_exam<>bchar then
+ check_existence(lig_exam)('LIG character examined by');
+@.LIG character examined...@>
+ check_existence(lig_gen)('LIG character generated by');
+@.LIG character generated...@>
+ if lig_gen>=128 then if(c<128)or(c=bchar) then
+ if(lig_exam<128)or(lig_exam=bchar) then seven_unsafe:=true;
+ end
+ else if lig_exam<>bchar then
+ check_existence(lig_exam)('KRN character examined by');
+@.KRN character examined...@>
+ end;
+if (lig_kern[lig_ptr].b0 mod 256)>=stop_flag then lig_ptr:=nl
+else lig_ptr:=lig_ptr+1+lig_kern[lig_ptr].b0;
+until lig_ptr>=nl;
+end;
+end
+
+@ The |hash_input| procedure is copied from \.{TFtoPL}, but it is made
+into a boolean function that returns |false| if the ligature command
+was masked by a previous one.
+
+@p function hash_input(@!p,@!c:indx):boolean;
+ {enter data for character |c| and command in location |p|, unless it isn't new}
+label 30; {go here for a quick exit}
+var @!cc:simple..both_z; {class of data being entered}
+@!zz:char_type; {function value or ligature character being entered}
+@!y:char_type; {the character after the cursor}
+@!key:integer; {value to be stored in |hash|}
+@!t:integer; {temporary register for swapping}
+begin if hash_ptr=hash_size then
+ begin hash_input:=false; goto 30;@+end;
+@<Compute the command parameters |y|, |cc|, and |zz|@>;
+key:=xmax_char*c+y+1; h:=(hash_mult*(key mod hash_size)) mod hash_size;
+while hash[h]>0 do begin
+ if hash[h]<=key then begin
+ if hash[h]=key then begin
+ hash_input:=false; goto 30; {unused ligature command}
+ end;
+ t:=hash[h]; hash[h]:=key; key:=t; {do ordered-hash-table insertion}
+ t:=class[h]; class[h]:=cc; cc:=t; {namely, do a swap}
+ t:=lig_z[h]; lig_z[h]:=zz; zz:=t;
+ end;
+ if h>0 then decr(h)@+else h:=hash_size;
+ end;
+hash[h]:=key; class[h]:=cc; lig_z[h]:=zz;
+incr(hash_ptr); hash_list[hash_ptr]:=h;
+hash_input:=true;
+30:end;
+
+@ @<Compute the command param...@>=
+y:=lig_kern[p].b1; t:=lig_kern[p].b2; cc:=simple;
+zz:=lig_kern[p].b3;
+if t>=kern_flag then zz:=y
+else begin
+ case t of
+ 0,6:do_nothing; {\.{LIG},\.{/LIG>}}
+ 5,11:zz:=y; {\.{LIG/>}, \.{/LIG/>>}}
+ 1,7:cc:=left_z; {\.{LIG/}, \.{/LIG/>}}
+ 2:cc:=right_z; {\.{/LIG}}
+ 3:cc:=both_z; {\.{/LIG/}}
+ end; {there are no other cases}
+ end
+
+@ (More good stuff from \.{TFtoPL}.)
+
+@p function f(@!h,@!x,@!y:indx):indx; forward;@t\2@>
+ {compute $f$ for arguments known to be in |hash[h]|}
+function eval(@!x,@!y:indx):indx; {compute $f(x,y)$ with hashtable lookup}
+var @!key:integer; {value sought in hash table}
+begin key:=xmax_char*x+y+1; h:=(hash_mult*key) mod hash_size;
+while hash[h]>key do
+ if h>0 then decr(h)@+else h:=hash_size;
+if hash[h]<key then eval:=y {not in ordered hash table}
+else eval:=f(h,x,y);
+end;
+
+@ Pascal's beastly convention for |forward| declarations prevents us from
+saying |function f(h,x,y:indx):indx| here.
+
+@p function f;
+begin
+case class[h] of
+ simple: do_nothing;
+ left_z: begin class[h]:=pending; lig_z[h]:=eval(lig_z[h],y); class[h]:=simple;
+ end;
+ right_z: begin class[h]:=pending; lig_z[h]:=eval(x,lig_z[h]); class[h]:=simple;
+ end;
+ both_z: begin class[h]:=pending; lig_z[h]:=eval(eval(x,lig_z[h]),y);
+ class[h]:=simple;
+ end;
+ pending: begin x_lig_cycle:=x; y_lig_cycle:=y;
+ lig_z[h]:=xxmax_char; class[h]:=simple;
+ end; {the value |xxmax_char| will break all cycles,
+ since it's not in |hash|}
+ end; {there are no other cases}
+f:=lig_z[h];
+end;
+
+@ @<Check for infinite...@>=
+if hash_ptr<hash_size then for hh:=1 to hash_ptr do begin
+ tt:=hash_list[hh];
+ if class[tt]>simple then {make sure $f$ is well defined}
+ tt:=f(tt,(hash[tt]-1)div xmax_char,(hash[tt]-1)mod xmax_char);
+ end;
+if(hash_ptr=hash_size)or(y_lig_cycle<xmax_char) then begin
+ if hash_ptr<hash_size then begin
+ print('Infinite ligature loop starting with ');
+@.Infinite ligature loop...@>
+ if x_lig_cycle=xmax_char
+ then print('boundary')@+else print_hex(x_lig_cycle);
+ print(' and '); print_hex(y_lig_cycle); print_ln('!');
+ end
+ else print_ln('Sorry, I haven''t room for so many ligature/kern pairs!');
+@.Sorry, I haven't room...@>
+ print_ln('All ligatures will be cleared.');
+ for c:=0 to max_char do if char_tag[c]=lig_tag then begin
+ char_tag[c]:=no_tag; char_remainder[c]:=0;
+ end;
+ nl:=0; bchar:=xmax_char; bchar_label:=xmax_label;
+ end
+
+@ The lig/kern program may still contain references to nonexistent characters,
+if parts of that program are never used. Similarly, there may be extensible
+characters that are never used, because they were overridden by
+\.{NEXTLARGER}, say. This would produce an invalid \.{TFM} file; so we
+must fix such errors.
+
+@d double_check_tail(#)==@t\1@>if char_wd[0]=0
+ then char_wd[0]:=sort_in(width,0);
+ print('Unused ',#,' refers to nonexistent character ');
+ print_hex(c); print_ln('!');
+ end;
+ end
+@d double_check_lig(#)==begin c:=lig_kern[lig_ptr].#;
+ if char_wd[c]=0 then if c<>bchar then
+ begin lig_kern[lig_ptr].#:=0; double_check_tail
+@d double_check_ext(#)==begin c:=exten[g].#;
+ if c>0 then if char_wd[c]=0 then
+ begin exten[g].#:=0; double_check_tail
+@d double_check_rep(#)==begin c:=exten[g].#;
+ if char_wd[c]=0 then
+ begin exten[g].#:=0; double_check_tail
+
+@<Doublecheck...@>=
+if nl>0 then for lig_ptr:=0 to nl-1 do
+ if (lig_kern[lig_ptr].b0 div 256)=0 then begin
+ if lig_kern[lig_ptr].b2<kern_flag then begin
+ if lig_kern[lig_ptr].b0<255 then begin
+ double_check_lig(b1)('LIG step'); double_check_lig(b3)('LIG step');
+ end;
+ end
+ else double_check_lig(b1)('KRN step');
+ end;
+@.Unused LIG step...@>
+@.Unused KRN step...@>
+if ne>0 then for g:=0 to ne-1 do begin
+ double_check_ext(b0)('VARCHAR TOP');
+ double_check_ext(b1)('VARCHAR MID');
+ double_check_ext(b2)('VARCHAR BOT');
+ double_check_rep(b3)('VARCHAR REP');
+@.Unused VARCHAR...@>
+ end
+
+@* The output phase.
+Now that we know how to get all of the font data correctly stored in
+\.{PLtoTF}'s memory, it only remains to write the answers out.
+
+First of all, it is convenient to have an abbreviation for output to the
+\.{TFM} file:
+
+@d out(#)==write(tfm_file,#)
+
+@ The general plan for producing \.{TFM} files is long but simple:
+
+@<Do the font metric output@>=
+compute_subfile_sizes;
+output_subfile_sizes;
+@<Output the header block@>;
+output_new_information_ofm;
+output_character_info;
+@<Output the dimensions themselves@>;
+@<Output the ligature/kern program@>;
+@<Output the extensible character recipes@>;
+@<Output the parameters@>;
+
+@ A \.{TFM} file begins with 12 numbers that tell how big its subfiles are.
+We already know most of these numbers; for example, the number of distinct
+widths is |memory[width]+1|, where the $+1$ accounts for the zero width that
+is always supposed to be present. But we still should compute the beginning
+and ending character codes (|bc| and |ec|), the number of header words (|lh|),
+and the total number of words in the \.{TFM} file (|lf|).
+
+@<Gl...@>=
+@!bc:byte; {the smallest character code in the font}
+@!ec:byte; {the largest character code in the font}
+@!lh:byte; {the number of words in the header block}
+@!lf:unsigned_integer; {the number of words in the entire \.{TFM} file}
+@!not_found:boolean; {has a font character been found?}
+@!temp_width:fix_word; {width being used to compute a check sum}
+@!ncw,@!nco,@!npc:integer;
+
+@ It might turn out that no characters exist at all. But \.{PLtoTF} keeps
+going and writes the \.{TFM} anyway. In this case |ec| will be~0 and |bc|
+will be~1.
+
+@<Compute the subfile sizes@>=
+case ofm_level of
+ -1: begin
+ lh:=header_ptr div 4;@/
+ not_found:=true; bc:=0;
+ while not_found do
+ if (char_wd[bc]>0)or(bc=255) then not_found:=false
+ else incr(bc);
+ not_found:=true; ec:=255;
+ while not_found do
+ if (char_wd[ec]>0)or(ec=0) then not_found:=false
+ else decr(ec);
+ if bc>ec then bc:=1;
+ incr(memory[width]); incr(memory[height]); incr(memory[depth]);
+ incr(memory[italic]);@/
+ @<Compute the ligature/kern program offset@>;
+ lf:=6+lh+(ec-bc+1)+memory[width]+memory[height]+memory[depth]+
+ memory[italic]+nl+lk_offset+nk+ne+np;
+ end;
+ 0: begin
+ lh:=header_ptr div 4;@/
+ not_found:=true; bc:=0;
+ while not_found do
+ if (char_wd[bc]>0)or(bc=max_char) then not_found:=false
+ else incr(bc);
+ not_found:=true; ec:=max_char;
+ while not_found do
+ if (char_wd[ec]>0)or(ec=0) then not_found:=false
+ else decr(ec);
+ if bc>ec then bc:=1;
+ incr(memory[width]); incr(memory[height]); incr(memory[depth]);
+ incr(memory[italic]);@/
+ @<Compute the ligature/kern program offset@>;
+ lf:=14+lh+2*(ec-bc+1)+memory[width]+memory[height]+memory[depth]+
+ memory[italic]+2*nl+lk_offset+nk+2*ne+np;
+ end;
+ 1: begin
+ lh:=header_ptr div 4;@/
+ not_found:=true; bc:=0;
+ while not_found do
+ if (char_wd[bc]>0)or(bc=max_char) then not_found:=false
+ else incr(bc);
+ not_found:=true; ec:=max_char;
+ while not_found do
+ if (char_wd[ec]>0)or(ec=0) then not_found:=false
+ else decr(ec);
+ if bc>ec then bc:=1;
+ incr(memory[width]); incr(memory[height]); incr(memory[depth]);
+ incr(memory[italic]);@/
+ @<Compute the ligature/kern program offset@>;
+ @<Compute the character info size@>;
+ lf:=29+lh+ncw+memory[width]+memory[height]+memory[depth]+
+ memory[italic]+2*(nl+lk_offset)+nk+2*ne+np+
+ nki+nwi+nkf+nwf+nkm+nwm++nkr+nwr+nkg+nwg+nkp+nwp;
+ nco:=29+lh+nki+nwi+nkf+nwf+nkm+nwm++nkr+nwr+nkg+nwg+nkp+nwp;
+ end;
+ end;
+
+@ @d out_size(#)==out((#) div 256); out((#) mod 256)
+ @d out_integer(#)==out((#) div @"1000000);
+ out(((#) mod @"1000000) div @"10000);
+ out(((#) mod @"10000) div @"100);
+ out((#) mod @"100)
+
+@<Output the subfile sizes@>=
+case ofm_level of
+ -1: begin
+ out_size(lf); out_size(lh); out_size(bc); out_size(ec);
+ out_size(memory[width]); out_size(memory[height]);
+ out_size(memory[depth]); out_size(memory[italic]);
+ out_size(nl+lk_offset); out_size(nk); out_size(ne); out_size(np);
+ end;
+ 0: begin
+ out_integer(0);
+ out_integer(lf); out_integer(lh); out_integer(bc); out_integer(ec);
+ out_integer(memory[width]); out_integer(memory[height]);
+ out_integer(memory[depth]); out_integer(memory[italic]);
+ out_integer(nl+lk_offset); out_integer(nk);
+ out_integer(ne); out_integer(np); out_integer(font_dir);
+ end;
+ 1: begin
+ out_integer(1);
+ out_integer(lf); out_integer(lh);
+ out_integer(bc); out_integer(ec);
+ out_integer(memory[width]); out_integer(memory[height]);
+ out_integer(memory[depth]); out_integer(memory[italic]);
+ out_integer(nl+lk_offset); out_integer(nk);
+ out_integer(ne); out_integer(np); out_integer(font_dir);
+ out_integer(nco); out_integer(ncw); out_integer(npc);
+ out_integer(nki); out_integer(nwi); out_integer(nkf); out_integer(nwf);
+ out_integer(nkm); out_integer(nwm); out_integer(nkr); out_integer(nwr);
+ out_integer(nkg); out_integer(nwg); out_integer(nkp); out_integer(nwp);
+ end;
+ end;
+
+@ The routines that follow need a few temporary variables of different types.
+
+@<Gl...@>=
+@!j:0..max_header_bytes; {index into |header_bytes|}
+@!p:pointer; {index into |memory|}
+@!q:width..italic; {runs through the list heads for dimensions}
+@!par_ptr:0..max_param_words; {runs through the parameters}
+
+@ The header block follows the subfile sizes. The necessary information all
+appears in |header_bytes|, except that the design size and the seven-bit-safe
+flag must still be set.
+
+@<Output the header block@>=
+if not check_sum_specified then @<Compute the check sum@>;
+header_bytes[design_size_loc]:=design_size div @'100000000;
+ {this works since |design_size>0|}
+header_bytes[design_size_loc+1]:=(design_size div @'200000) mod 256;
+header_bytes[design_size_loc+2]:=(design_size div 256) mod 256;
+header_bytes[design_size_loc+3]:=design_size mod 256;
+if not seven_unsafe then header_bytes[seven_flag_loc]:=128;
+for j:=0 to header_ptr-1 do out(header_bytes[j]);
+
+@ @<Compute the check sum@>=
+begin c0:=bc; c1:=ec; c2:=bc; c3:=ec;
+for c:=bc to ec do if char_wd[c]>0 then begin
+ temp_width:=memory[char_wd[c]];
+ if design_units<>unity then
+ temp_width:=round((temp_width/design_units)*1048576.0);
+ temp_width:=temp_width + (c+4)*@'20000000; {this should be positive}
+ c0:=(c0+c0+temp_width) mod 255;
+ c1:=(c1+c1+temp_width) mod 253;
+ c2:=(c2+c2+temp_width) mod 251;
+ c3:=(c3+c3+temp_width) mod 247;
+ end;
+header_bytes[check_sum_loc]:=c0;
+header_bytes[check_sum_loc+1]:=c1;
+header_bytes[check_sum_loc+2]:=c2;
+header_bytes[check_sum_loc+3]:=c3;
+end
+
+@ @<Global...@>=
+@!tab:integer;
+
+@
+@<Compute the character info size@>=
+if ofm_level=1 then begin
+ ncw:=0;
+ if nkcp>-1 then
+ npc:=nki+nkf+nkr+nkg+nkcp+1
+ else if nkcg>-1 then
+ npc:=nki+nkf+nkr+nkcg+1
+ else if nkcr>-1 then
+ npc:=nki+nkf+nkcr+1
+ else if nkcf>-1 then
+ npc:=nki+nkcf+1
+ else if nkci>-1 then
+ npc:=nkci+1
+ else
+ npc:=0;
+ needed_space:=(12+npc*2) div 4;
+ extra_bytes:=(needed_space*4) - (10+npc*2);
+ for c:=bc to ec do begin
+ if char_original[c]=c then begin
+ cprime:=c+1;
+ diff:=false;
+ while (not diff) and (cprime<=ec) do begin
+ if index[char_wd[c]]<>index[char_wd[cprime]] then diff:=true;
+ if index[char_ht[c]]<>index[char_ht[cprime]] then diff:=true;
+ if index[char_dp[c]]<>index[char_dp[cprime]] then diff:=true;
+ if index[char_ic[c]]<>index[char_ic[cprime]] then diff:=true;
+ if char_remainder[c]<>char_remainder[cprime] then diff:=true;
+ for tab:=0 to npc-1 do begin
+ if char_table[c,tab]<>char_table[cprime,tab] then diff:=true;
+ end;
+ if not diff then begin
+ char_original[cprime]:=c;
+ cprime:=cprime+1;
+ end;
+ end;
+ if cprime>(c+1) then begin
+ char_repeats[c]:=cprime-c-1;
+ end;
+ ncw:=ncw+needed_space;
+ end;
+ end;
+ end;
+
+@ The next block contains packed |char_info|.
+
+@<Output the character info@>=
+index[0]:=0;
+for c:=bc to ec do
+case ofm_level of
+ -1: begin
+ out(index[char_wd[c]]);
+ out(index[char_ht[c]]*16+index[char_dp[c]]);
+ out(index[char_ic[c]]*4+char_tag[c]);
+ out(char_remainder[c]);
+ end;
+ 0: begin
+ out(index[char_wd[c]] div 256); out(index[char_wd[c]] mod 256);
+ out(index[char_ht[c]]); out(index[char_dp[c]]);
+ out(index[char_ic[c]] div 64);out((index[char_ic[c]] mod 64)*4+char_tag[c]);
+ out(char_remainder[c] div 256); out(char_remainder[c] mod 256);
+ end;
+ 1: begin
+ if c=char_original[c] then begin
+ out(index[char_wd[c]] div 256); out(index[char_wd[c]] mod 256);
+ out(index[char_ht[c]]); out(index[char_dp[c]]);
+ out(index[char_ic[c]]);
+ tab:=char_tag[c];
+ if char_extended_tag[c] then begin
+ tab:=5;
+ end;
+ out(tab);
+ out(char_remainder[c] div 256); out(char_remainder[c] mod 256);
+ out_size(char_repeats[c]);
+ for tab:=0 to npc-1 do begin
+ out(char_table[c,tab] div 256); out(char_table[c,tab] mod 256);
+ end;
+ for tab:=1 to extra_bytes do begin
+ out(0);
+ end;
+ end;
+ end;
+ end;
+
+
+@ When a scaled quantity is output, we may need to divide it by |design_units|.
+The following subroutine takes care of this, using floating point arithmetic
+only if |design_units<>1.0|.
+
+@p procedure out_scaled(x:fix_word); {outputs a scaled |fix_word|}
+var @!n:byte; {the first byte after the sign}
+@!m:0..65535; {the two least significant bytes}
+begin if abs(x/design_units)>=16.0 then begin
+ print_ln('The relative dimension ',x/@'4000000:1:3,
+ ' is too large.');
+@.The relative dimension...@>
+ print(' (Must be less than 16*designsize');
+ if design_units<>unity then print(' =',design_units/@'200000:1:3,
+ ' designunits');
+ print_ln(')'); x:=0;
+ end;
+if design_units<>unity then x:=round((x/design_units)*1048576.0);
+if x<0 then begin
+ out(255); x:=x+@'100000000;
+ if x<=0 then x:=1;
+ end
+else begin out(0);
+ if x>=@'100000000 then x:=@'77777777;
+ end;
+n:=x div @'200000; m:=x mod @'200000;
+out(n); out(m div 256); out(m mod 256);
+end;
+
+@ We have output the packed indices for individual characters.
+The scaled widths, heights, depths, and italic corrections are next.
+
+@<Output the dimensions themselves@>=
+for q:=width to italic do begin
+ out(0); out(0); out(0); out(0); {output the zero word}
+ p:=link[q]; {head of list}
+ while p>0 do begin
+ out_scaled(memory[p]);
+ p:=link[p];
+ end;
+ end;
+
+@ One embarrassing problem remains: The ligature/kern program might be very
+long, but the starting addresses in |char_remainder| can be at most~255.
+Therefore we need to output some indirect address information; we want to
+compute |lk_offset| so that addition of |lk_offset| to all remainders makes
+all but |lk_offset| distinct remainders less than~256.
+
+For this we need a sorted table of all relevant remainders.
+
+@<Glob...@>=
+@!label_table:array[xchar_type] of record
+ @!rr: -1..xmax_label; {sorted label values}
+ @!cc: integer; {associated characters}
+ end;
+@!label_ptr:xchar_type; {index of highest entry in |label_table|}
+@!sort_ptr:xchar_type; {index into |label_table|}
+@!lk_offset:xchar_type; {smallest offset value that might work}
+@!t:0..xmax_label; {label value that is being redirected}
+@!extra_loc_needed:boolean; {do we need a special word for |bchar|?}
+
+@ @<Compute the ligature/kern program offset@>=
+@<Insert all labels into |label_table|@>;
+if bchar<xmax_char then begin
+ extra_loc_needed:=true; lk_offset:=1;
+ end
+else begin
+ extra_loc_needed:=false; lk_offset:=0;
+ end;
+@<Find the minimum |lk_offset| and adjust all remainders@>;
+if bchar_label<xmax_label then begin
+ if ofm_level=-1 then begin
+ lig_kern[nl-1].b2:=(bchar_label+lk_offset)div 256;
+ lig_kern[nl-1].b3:=(bchar_label+lk_offset)mod 256;
+ end
+ else begin
+ lig_kern[nl-1].b2:=(bchar_label+lk_offset)div 65536;
+ lig_kern[nl-1].b3:=(bchar_label+lk_offset)mod 65536;
+ end
+ end
+
+@ @<Insert all labels...@>=
+label_ptr:=0; label_table[0].rr:=-1; {sentinel}
+for c:=bc to ec do if char_tag[c]=lig_tag then begin
+ sort_ptr:=label_ptr; {there's a hole at position |sort_ptr+1|}
+ while label_table[sort_ptr].rr>char_remainder[c] do begin
+ label_table[sort_ptr+1]:=label_table[sort_ptr];
+ decr(sort_ptr); {move the hole}
+ end;
+ label_table[sort_ptr+1].cc:=c;
+ label_table[sort_ptr+1].rr:=char_remainder[c];
+ incr(label_ptr);
+ end
+
+@ @<Find the minimum |lk_offset| and adjust all remainders@>=
+begin sort_ptr:=label_ptr; {the largest unallocated label}
+if ofm_level=-1 then begin
+ if label_table[sort_ptr].rr+lk_offset > 255 then begin
+ lk_offset:=0; extra_loc_needed:=false; {location 0 can do double duty}
+ repeat char_remainder[label_table[sort_ptr].cc]:=lk_offset;
+ while label_table[sort_ptr-1].rr=label_table[sort_ptr].rr do begin
+ decr(sort_ptr); char_remainder[label_table[sort_ptr].cc]:=lk_offset;
+ end;
+ incr(lk_offset); decr(sort_ptr);
+ until lk_offset+label_table[sort_ptr].rr<256;
+ {N.B.: |lk_offset=256| satisfies this when |sort_ptr=0|}
+ end;
+ end
+else begin
+ if label_table[sort_ptr].rr+lk_offset > 65535 then begin
+ lk_offset:=0; extra_loc_needed:=false; {location 0 can do double duty}
+ repeat char_remainder[label_table[sort_ptr].cc]:=lk_offset;
+ while label_table[sort_ptr-1].rr=label_table[sort_ptr].rr do begin
+ decr(sort_ptr); char_remainder[label_table[sort_ptr].cc]:=lk_offset;
+ end;
+ incr(lk_offset); decr(sort_ptr);
+ until lk_offset+label_table[sort_ptr].rr<65536;
+ {N.B.: |lk_offset=65536| satisfies this when |sort_ptr=0|}
+ end;
+ end;
+if lk_offset>0 then while sort_ptr>0 do begin
+ char_remainder[label_table[sort_ptr].cc]:=
+ char_remainder[label_table[sort_ptr].cc]+lk_offset;
+ decr(sort_ptr);
+ end;
+end
+
+@ @<Output the ligature/kern program@>=
+if ofm_level=-1 then begin
+ if extra_loc_needed then begin {|lk_offset=1|}
+ out(255); out(bchar); out(0); out(0);
+ end
+ else for sort_ptr:=1 to lk_offset do begin {output the redirection specs}
+ t:=label_table[label_ptr].rr;
+ if bchar<256 then begin
+ out(255); out(bchar);
+ end
+ else begin
+ out(254); out(0);
+ end;
+ out_size(t+lk_offset);
+ repeat decr(label_ptr); until label_table[label_ptr].rr<t;
+ end;
+ if nl>0 then for lig_ptr:=0 to nl-1 do begin
+ out(lig_kern[lig_ptr].b0);
+ out(lig_kern[lig_ptr].b1);
+ out(lig_kern[lig_ptr].b2);
+ out(lig_kern[lig_ptr].b3);
+ end;
+ if nk>0 then for krn_ptr:=0 to nk-1 do out_scaled(kern[krn_ptr])
+ end
+else begin
+ if extra_loc_needed then {|lk_offset=1|} begin
+ out_size(255); out_size(bchar); out_size(0); out_size(0);
+ end
+ else
+ for sort_ptr:=1 to lk_offset do {output the redirection specs} begin
+ t:=label_table[label_ptr].rr;
+ if bchar<xmax_char then begin
+ out_size(255); out_size(bchar);
+ end
+ else begin
+ out_size(254); out_size(0);
+ end;
+ out_size((t+lk_offset) div 256);
+ out_size((t+lk_offset) mod 256);
+ repeat decr(label_ptr); until label_table[label_ptr].rr<t;
+ end;
+ if nl>0 then for lig_ptr:=0 to nl-1 do begin
+ out_size(lig_kern[lig_ptr].b0);
+ out_size(lig_kern[lig_ptr].b1);
+ out_size(lig_kern[lig_ptr].b2);
+ out_size(lig_kern[lig_ptr].b3);
+ end;
+ if nk>0 then for krn_ptr:=0 to nk-1 do out_scaled(kern[krn_ptr])
+ end
+
+@ @<Output the extensible character recipes@>=
+if ofm_level=-1 then begin
+ if ne>0 then for c:=0 to ne-1 do begin
+ out(exten[c].b0);
+ out(exten[c].b1);
+ out(exten[c].b2);
+ out(exten[c].b3);
+ end;
+ end
+else begin
+ if ne>0 then for c:=0 to ne-1 do begin
+ out_size(exten[c].b0);
+ out_size(exten[c].b1);
+ out_size(exten[c].b2);
+ out_size(exten[c].b3);
+ end;
+ end;
+
+@ For our grand finale, we wind everything up by outputting the parameters.
+
+@<Output the parameters@>=
+for par_ptr:=1 to np do begin
+ if par_ptr=1 then
+ @<Output the slant (|param[1]|) without scaling@>
+ else out_scaled(param[par_ptr]);
+ end
+
+@ @<Output the slant...@>=
+begin if param[1]<0 then begin
+ param[1]:=param[1]+@'10000000000;
+ out((param[1] div @'100000000)+256-64);
+ end
+else out(param[1] div @'100000000);
+out((param[1] div @'200000) mod 256);
+out((param[1] div 256) mod 256);
+out(param[1] mod 256);
+end
+
+@* The main program.
+The routines sketched out so far need to be packaged into separate procedures,
+on some systems, since some \PASCAL\ compilers place a strict limit on the
+size of a routine. The packaging is done here in an attempt to avoid some
+system-dependent changes.
+
+@p procedure param_enter;
+begin @<Enter the parameter names@>;
+end;
+@#
+procedure name_enter; {enter all names and their equivalents}
+begin @<Enter all of the names...@>;
+param_enter;
+end;
+@#
+procedure read_lig_kern;
+var @!krn_ptr:0..max_kerns; {an index into |kern|}
+@!c:integer; {runs through all character codes}
+begin @<Read ligature/kern list@>;
+end;
+@#
+procedure output_new_information_ofm;
+begin @<Output the new information for OFM files@>;
+end;
+@#
+procedure compute_new_header_ofm;
+begin @<Compute the new header information for OFM files@>;
+end;
+@#
+procedure finish_extended_font;
+begin @<Finish up the extended font stuff@>;
+end;
+@#
+procedure output_subfile_sizes;
+begin @<Output the subfile sizes@>;
+end;
+@#
+procedure compute_subfile_sizes;
+begin @<Compute the subfile sizes@>;
+end;
+@#
+procedure output_character_info;
+begin @<Output the character info@>;
+end;
+@#
+procedure read_font_rule_list;
+begin @<Read font rule list@>;
+end;
+@#
+procedure read_font_glue_list;
+begin @<Read font glue list@>;
+end;
+@#
+procedure read_font_penalty_list;
+begin @<Read font penalty list@>;
+end;
+@#
+procedure read_font_mvalue_list;
+begin @<Read font mvalue list@>;
+end;
+@#
+procedure read_font_fvalue_list;
+begin @<Read font fvalue list@>;
+end;
+@#
+procedure read_font_ivalue_list;
+begin @<Read font ivalue list@>;
+end;
+@#
+procedure read_repeated_character_info;
+begin @<Read repeated character info@>;
+end;
+@#
+procedure read_lig_kern_command;
+begin @<Read a ligature/kern command@>;
+end;
+@#
+procedure read_character_property;
+begin @<Read a character property@>;
+end;
+@#
+procedure read_char_info;
+begin @<Read character info list@>;
+end;
+@#
+procedure read_input;
+var @!c:integer; {header or parameter index}
+begin @<Read all the input@>;
+end;
+@#
+procedure corr_and_check;
+var @!c:integer; {runs through all character codes}
+@!hh:0..hash_size; {an index into |hash_list|}
+@!lig_ptr:0..max_lig_steps; {an index into |lig_kern|}
+@!g:byte; {a character generated by the current character |c|}
+begin @<Correct and check the information@>
+end;
+
+@ Here is where \.{PLtoTF} begins and ends.
+
+@p begin initialize;@/
+name_enter;@/
+read_input; print('.');@/
+corr_and_check;@/
+@<Do the font metric output@>;
+end.
+
+@ @<Global...@>=
+@!ofm_level:integer;
+
+@ @<Set init...@>=
+ofm_level:=-1; {Suppose that it is a TFM file}
+
+@ @<Read OFM level code@>=
+begin
+ofm_level:=get_integer;
+if (ofm_level<0) or (ofm_level>1) then begin
+ flush_error('OFMLEVEL must be 0 or 1 -- 1 assumed');
+ ofm_level:=1;
+ end;
+end
+
+@ @<Read font direction code@>=
+begin
+font_dir:=-1;
+repeat get_next;
+until cur_char<>" ";
+case cur_char of
+ "T": begin get_next;
+ if cur_char="L" then font_dir:=0
+ else if cur_char="R" then font_dir:=2;
+ end;
+ "B": begin get_next;
+ if cur_char="L" then font_dir:=4
+ else if cur_char="R" then font_dir:=6;
+ end;
+ "R": begin get_next;
+ if cur_char="T" then font_dir:=5
+ else if cur_char="B" then font_dir:=7;
+ end;
+ "L": begin get_next;
+ if cur_char="T" then font_dir:=1
+ else if cur_char="B" then font_dir:=3;
+ end;
+ end;
+while cur_char<>")" do get_next;
+if font_dir = -1 then begin
+ flush_error('FONTDIR must be valid direction, -- TR assumed');
+ font_dir:=0;
+ end;
+end
+
+@ @<Read natural font direction code@>=
+begin
+font_dir:=-1;
+repeat get_next;
+until cur_char<>" ";
+case cur_char of
+ "T": begin get_next;
+ if cur_char="L" then font_dir:=8
+ else if cur_char="R" then font_dir:=10;
+ end;
+ "B": begin get_next;
+ if cur_char="L" then font_dir:=12
+ else if cur_char="R" then font_dir:=14;
+ end;
+ "R": begin get_next;
+ if cur_char="T" then font_dir:=13
+ else if cur_char="B" then font_dir:=15;
+ end;
+ "L": begin get_next;
+ if cur_char="T" then font_dir:=9
+ else if cur_char="B" then font_dir:=11;
+ end;
+ end;
+while cur_char<>")" do get_next;
+if font_dir = -1 then begin
+ flush_error('NFONTDIR must be valid direction, -- TR assumed');
+ font_dir:=8;
+ end;
+end
+
+@
+Here are some general values for the various entries.
+They can all be changed.
+
+@d arrays_per_kind==20
+@d entries_per_array==200
+
+@ @<Constants...@>=
+@!rule_arrays=arrays_per_kind;
+@!rule_entries=entries_per_array;
+
+@ @<Types...@>=
+rule_array_type=0..rule_arrays;
+rule_entry_type=0..rule_entries;
+rule_node=
+record
+ rn_width: fix_word;
+ rn_height: fix_word;
+ rn_depth: fix_word;
+end;
+
+@ @<Global...@>=
+@!rules:array[rule_array_type,rule_entry_type] of rule_node;
+@!npr:array[rule_array_type] of integer;
+@!nkr:integer;
+@!nkcr:integer;
+@!nwr:integer;
+@!r_array:integer;
+@!r_number:integer;
+
+@ @<Set init...@>=
+for r_array := 0 to rule_arrays do begin
+ npr[r_array]:=0;
+ @<Null out the rule@>;
+ end;
+nkr:=-1;
+nkcr:=-1;
+
+@ @<Read font rule list@>=
+begin
+if tables_read then
+ flush_error('All parameter tables must appear before character info');
+r_array:=get_integer;
+if r_array>rule_arrays then
+ flush_error('This FONTRULE table index is too big for my present size')
+else if r_array<0 then
+ flush_error('This FONTRULE index is negative')
+else begin
+ if r_array>nkr then nkr:=r_array;
+ while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a rule@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+ finish_inner_property_list;
+ end;
+end
+
+@ @<Read a rule@>=
+begin
+get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if cur_code<>rule_code then
+ flush_error('This property name doesn''t belong in a RULE list')
+else begin
+ r_number:=get_integer;
+ if r_number>rule_entries then
+ flush_error('This RULE index is too big for my present table size')
+ else if r_number<0 then
+ flush_error('This RULE index is negative')
+ else begin
+ while npr[r_array]<r_number do begin
+ incr(npr[r_array]); @<Null out the rule@>;
+ end;
+ @<Read all of a rule's values@>;
+ finish_the_property;
+ end;
+ end;
+end
+
+@ @<Null out the rule@>=
+begin
+rules[r_array,npr[r_array]].rn_width:=0;
+rules[r_array,npr[r_array]].rn_depth:=0;
+rules[r_array,npr[r_array]].rn_height:=0;
+end
+
+@ @<Read all of a rule's values@>=
+begin
+while level=2 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a single rule value@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a single rule value@>=
+begin
+get_name;
+case cur_code of
+ rule_width_code:
+ rules[r_array,r_number].rn_width:=get_fix;
+ rule_height_code:
+ rules[r_array,r_number].rn_height:=get_fix;
+ rule_depth_code:
+ rules[r_array,r_number].rn_depth:=get_fix;
+ end;
+finish_the_property;
+end
+
+@ @<Header information for rules@>=
+begin
+nwr:=0;
+for r_array := 0 to nkr do begin
+ incr(npr[r_array]);
+ nwr := nwr + 3*npr[r_array];
+ end;
+incr(nkr);
+end
+
+@ @<Output the rules@>=
+begin
+for r_array:= 0 to nkr-1 do
+ for r_number:=0 to npr[r_array]-1 do begin
+ out_scaled(rules[r_array,r_number].rn_width);
+ out_scaled(rules[r_array,r_number].rn_height);
+ out_scaled(rules[r_array,r_number].rn_depth);
+ end;
+end
+
+@ @<Output the rule headers@>=
+begin
+for r_array:= 0 to nkr-1 do begin
+ out_integer(npr[r_array]);
+ end;
+end
+
+@ @<Constants...@>=
+@!glue_arrays=arrays_per_kind;
+@!glue_entries=entries_per_array;
+
+@
+@d t_normal==0
+@d t_aleaders==1
+@d t_cleaders==2
+@d t_xleaders==3
+
+@d o_unit==0
+@d o_fi==1
+@d o_fil==2
+@d o_fill==3
+@d o_filll==4
+
+@d g_space==0
+@d g_rule==1
+@d g_char==2
+
+@<Types...@>=
+glue_array_type=0..glue_arrays;
+glue_entry_type=0..glue_entries;
+glue_node=
+record
+ gn_width: fix_word;
+ gn_stretch: fix_word;
+ gn_shrink: fix_word;
+ gn_type: integer;
+ gn_arg_type: g_space..g_char;
+ gn_stretch_order: integer;
+ gn_shrink_order: integer;
+ gn_argument: integer;
+end;
+
+@ @<Global...@>=
+@!glues:array[glue_array_type,glue_entry_type] of glue_node;
+@!npg:array[glue_array_type] of integer;
+@!nkg:integer;
+@!nkcg:integer;
+@!nwg:integer;
+@!g_array:integer;
+@!g_byte:integer;
+@!g_number:integer;
+
+@ @<Set init...@>=
+for g_array := 0 to glue_arrays do
+begin
+ npg[g_array]:=0;
+ @<Null out the glue@>;
+end;
+nkg:=-1;
+nkcg:=-1;
+
+@ @<Read font glue list@>=
+begin
+if tables_read then
+ flush_error('All parameter tables must appear before character info');
+g_array:=get_integer;
+if g_array>glue_arrays then
+ flush_error('This FONTGLUE table index is too big for my present size')
+else if g_array<0 then
+ flush_error('This FONTGLUE index is negative')
+else begin
+ if g_array>nkg then nkg:=g_array;
+ while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a glue@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+ finish_inner_property_list;
+ end;
+end
+
+@ @<Read a glue@>=
+begin
+get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if cur_code<>glue_code then
+ flush_error('This property name doesn''t belong in a GLUE list')
+else begin
+ g_number:=get_integer;
+ if g_number>glue_entries then
+ flush_error('This GLUE index is too big for my present table size')
+ else if g_number<0 then
+ flush_error('This GLUE index is negative')
+ else begin
+ while npg[g_array]<g_number do begin
+ incr(npg[g_array]); @<Null out the glue@>;
+ end;
+ @<Read all of a glue's values@>;
+ finish_the_property;
+ end;
+ end;
+end
+
+@ @<Null out the glue@>=
+begin
+glues[g_array,npg[g_array]].gn_width:=0;
+glues[g_array,npg[g_array]].gn_stretch:=0;
+glues[g_array,npg[g_array]].gn_shrink:=0;
+glues[g_array,npg[g_array]].gn_type:=0;
+glues[g_array,npg[g_array]].gn_arg_type:=0;
+glues[g_array,npg[g_array]].gn_stretch_order:=0;
+glues[g_array,npg[g_array]].gn_shrink_order:=0;
+glues[g_array,npg[g_array]].gn_argument:=0;
+end
+
+@ @<Read all of a glue's values@>=
+begin
+while level=2 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a single glue value@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a single glue value@>=
+begin
+get_name;
+case cur_code of
+ glue_width_code:
+ glues[g_array,g_number].gn_width:=get_fix;
+ glue_stretch_code:
+ glues[g_array,g_number].gn_stretch:=get_fix;
+ glue_shrink_code:
+ glues[g_array,g_number].gn_shrink:=get_fix;
+ glue_type_code: begin
+ g_byte:=get_integer;
+ if (g_byte<0) or (g_byte>3) then begin
+ g_byte:=0;
+ end;
+ glues[g_array,g_number].gn_type:=g_byte;
+ end;
+ glue_stretch_order_code: begin
+ g_byte:=get_integer;
+ if (g_byte<0) or (g_byte>4) then begin
+ g_byte:=0;
+ end;
+ glues[g_array,g_number].gn_stretch_order:=g_byte;
+ end;
+ glue_shrink_order_code: begin
+ g_byte:=get_integer;
+ if (g_byte<0) or (g_byte>4) then begin
+ g_byte:=0;
+ end;
+ glues[g_array,g_number].gn_shrink_order:=g_byte;
+ end;
+ glue_char_code: begin
+ glues[g_array,g_number].gn_argument:=get_integer;
+ glues[g_array,g_number].gn_arg_type:=g_char;
+ end;
+ glue_rule_code: begin
+ glues[g_array,g_number].gn_argument:=get_integer;
+ glues[g_array,g_number].gn_arg_type:=g_rule;
+ end;
+ end;
+finish_the_property;
+end
+
+@ @<Header information for glues@>=
+begin
+nwg:=0;
+for g_array := 0 to nkg do begin
+ incr(npg[g_array]);
+ nwg := nwg + 4*npg[g_array];
+ end;
+incr(nkg);
+end
+
+@ @<Output the glues@>=
+begin
+for g_array:= 0 to nkg-1 do
+ for g_number:=0 to npg[g_array]-1 do begin
+ g_byte:=glues[g_array,g_number].gn_type*16+
+ glues[g_array,g_number].gn_arg_type;
+ out(g_byte);
+ g_byte:=glues[g_array,g_number].gn_stretch_order*16+
+ glues[g_array,g_number].gn_shrink_order;
+ out(g_byte);
+ g_byte:=glues[g_array,g_number].gn_argument div 256;
+ out(g_byte);
+ g_byte:=glues[g_array,g_number].gn_argument mod 256;
+ out(g_byte);
+ out_scaled(glues[g_array,g_number].gn_width);
+ out_scaled(glues[g_array,g_number].gn_stretch);
+ out_scaled(glues[g_array,g_number].gn_shrink);
+ end;
+end
+
+@ @<Output the glue headers@>=
+begin
+for g_array:= 0 to nkg-1 do begin
+ out_integer(npg[g_array]);
+ end;
+end
+
+@ @<Constants...@>=
+@!penalty_arrays=arrays_per_kind;
+@!penalty_entries=entries_per_array;
+
+@ @<Types...@>=
+penalty_array_type=0..penalty_arrays;
+penalty_entry_type=0..penalty_entries;
+penalty_node=
+record
+ pn_val: integer;
+end;
+
+@ @<Global...@>=
+@!penalties:array[penalty_array_type,penalty_entry_type] of penalty_node;
+@!npp:array[penalty_array_type] of integer;
+@!nkp:integer;
+@!nkcp:integer;
+@!nwp:integer;
+@!p_array:integer;
+@!p_number:integer;
+
+@ @<Set init...@>=
+for p_array := 0 to penalty_arrays do begin
+ npp[p_array]:=0;
+ @<Null out the penalty@>;
+ end;
+nkp:=-1;
+nkcp:=-1;
+
+@ @<Read font penalty list@>=
+begin
+if tables_read then
+ flush_error('All parameter tables must appear before character info');
+p_array:=get_integer;
+if p_array>penalty_arrays then
+ flush_error('This FONTPENALTY table index is too big for my present size')
+else if p_array<0 then
+ flush_error('This FONTPENALTY index is negative')
+else begin
+ if p_array>nkp then nkp:=p_array;
+ while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a penalty@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+ finish_inner_property_list;
+ end;
+end
+
+@ @<Read a penalty@>=
+begin
+get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if cur_code<>penalty_code then
+ flush_error('This property name doesn''t belong in a PENALTY list')
+else begin
+ p_number:=get_integer;
+ if p_number>penalty_entries then
+ flush_error('This PENALTY index is too big for my present table size')
+ else if p_number<0 then
+ flush_error('This PENALTY index is negative')
+ else begin
+ while npp[p_array]<p_number do begin
+ incr(npp[p_array]); @<Null out the penalty@>;
+ end;
+ @<Read all of a penalty's values@>;
+ finish_the_property;
+ end;
+ end;
+end
+
+@ @<Null out the penalty@>=
+begin
+penalties[p_array,npp[p_array]].pn_val:=0;
+end
+
+@ @<Read all of a penalty's values@>=
+begin
+while level=2 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a single penalty value@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a single penalty value@>=
+begin
+get_name;
+case cur_code of
+ penalty_val_code:
+ penalties[p_array,p_number].pn_val:=get_integer;
+ end;
+finish_the_property;
+end
+
+@ @<Header information for penalties@>=
+begin
+nwp:=0;
+for p_array := 0 to nkp do begin
+ incr(npp[p_array]);
+ nwp := nwp + npp[p_array];
+ end;
+incr(nkp);
+end
+
+@ @<Output the penalties@>=
+begin
+for p_array:= 0 to nkp-1 do
+ for p_number:=0 to npp[p_array]-1 do begin
+ out_integer(penalties[p_array,p_number].pn_val);
+ end;
+end
+
+@ @<Output the penalty headers@>=
+begin
+for p_array:= 0 to nkp-1 do begin
+ out_integer(npp[p_array]);
+ end;
+end
+
+@ @<Constants...@>=
+@!mvalue_arrays=arrays_per_kind;
+@!mvalue_entries=entries_per_array;
+
+@ @<Types...@>=
+mvalue_array_type=0..mvalue_arrays;
+mvalue_entry_type=0..mvalue_entries;
+mvalue_node=
+record
+ fn_val: fix_word;
+end;
+
+@ @<Global...@>=
+@!mvalues:array[mvalue_array_type,mvalue_entry_type] of mvalue_node;
+@!npm:array[mvalue_array_type] of integer;
+@!nkm:integer;
+@!nkcm:integer;
+@!nwm:integer;
+@!m_array:integer;
+@!m_number:integer;
+
+@ @<Set init...@>=
+for m_array := 0 to mvalue_arrays do begin
+ npm[m_array]:=0;
+ @<Null out the mvalue@>;
+ end;
+nkm:=-1;
+nkcm:=-1;
+
+@ @<Read font mvalue list@>=
+begin
+if tables_read then
+ flush_error('All parameter tables must appear before character info');
+m_array:=get_integer;
+if m_array>mvalue_arrays then
+ flush_error('This FONTMVALUE table index is too big for my present size')
+else if m_array<0 then
+ flush_error('This FONTMVALUE index is negative')
+else begin
+ if m_array>nkm then nkm:=m_array;
+ while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read an mvalue@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+ finish_inner_property_list;
+ end;
+end
+
+@ @<Read an mvalue@>=
+begin
+get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if cur_code<>mvalue_code then
+ flush_error('This property name doesn''t belong in an MVALUE list')
+else begin
+ m_number:=get_integer;
+ if m_number>mvalue_entries then
+ flush_error('This MVALUE index is too big for my present table size')
+ else if m_number<0 then
+ flush_error('This MVALUE index is negative')
+ else begin
+ while npm[m_array]<m_number do begin
+ incr(npm[m_array]); @<Null out the mvalue@>;
+ end;
+ @<Read all of an mvalue's values@>;
+ finish_the_property;
+ end;
+ end;
+end
+
+@ @<Null out the mvalue@>=
+begin
+mvalues[m_array,npm[m_array]].fn_val:=0;
+end
+
+@ @<Read all of an mvalue's values@>=
+begin
+while level=2 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a single mvalue value@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a single mvalue value@>=
+begin
+get_name;
+case cur_code of
+ mvalue_val_code:
+ mvalues[m_array,m_number].fn_val:=get_fix;
+ end;
+finish_the_property;
+end
+
+@ @<Header information for mvalues@>=
+begin
+nwm:=0;
+for m_array := 0 to nkm do begin
+ incr(npm[m_array]);
+ nwm := nwm + npm[m_array];
+ end;
+incr(nkm);
+end
+
+@ @<Output the mvalues@>=
+begin
+for m_array:= 0 to nkm-1 do
+ for m_number:=0 to npm[m_array]-1 do begin
+ out_scaled(mvalues[m_array,m_number].fn_val);
+ end;
+end
+
+@ @<Output the mvalue headers@>=
+begin
+for m_array:= 0 to nkm-1 do begin
+ out_integer(npm[m_array]);
+ end;
+end
+
+@ @<Constants...@>=
+@!fvalue_arrays=arrays_per_kind;
+@!fvalue_entries=entries_per_array;
+
+@ @<Types...@>=
+fvalue_array_type=0..fvalue_arrays;
+fvalue_entry_type=0..fvalue_entries;
+fvalue_node=
+record
+ fn_val: fix_word;
+end;
+
+@ @<Global...@>=
+@!fvalues:array[fvalue_array_type,fvalue_entry_type] of fvalue_node;
+@!npf:array[fvalue_array_type] of integer;
+@!nkf:integer;
+@!nkcf:integer;
+@!nwf:integer;
+@!f_array:integer;
+@!f_number:integer;
+
+@ @<Set init...@>=
+for f_array := 0 to fvalue_arrays do begin
+ npf[f_array]:=0;
+ @<Null out the fvalue@>;
+ end;
+nkf:=-1;
+nkcf:=-1;
+
+@ @<Read font fvalue list@>=
+begin
+if tables_read then
+ flush_error('All parameter tables must appear before character info');
+f_array:=get_integer;
+if f_array>fvalue_arrays then
+ flush_error('This FONTFVALUE table index is too big for my present size')
+else if f_array<0 then
+ flush_error('This FONTFVALUE index is negative')
+else begin
+ if f_array>nkf then nkf:=f_array;
+ while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read an fvalue@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+ finish_inner_property_list;
+ end;
+end
+
+@ @<Read an fvalue@>=
+begin
+get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if cur_code<>fvalue_code then
+ flush_error('This property name doesn''t belong in an FVALUE list')
+else begin
+ f_number:=get_integer;
+ if f_number>fvalue_entries then
+ flush_error('This FVALUE index is too big for my present table size')
+ else if f_number<0 then
+ flush_error('This FVALUE index is negative')
+ else begin
+ while npf[f_array]<f_number do begin
+ incr(npf[f_array]); @<Null out the fvalue@>;
+ end;
+ @<Read all of an fvalue's values@>;
+ finish_the_property;
+ end;
+ end;
+end
+
+@ @<Null out the fvalue@>=
+begin
+fvalues[f_array,npf[f_array]].fn_val:=0;
+end
+
+@ @<Read all of an fvalue's values@>=
+begin
+while level=2 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a single fvalue value@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a single fvalue value@>=
+begin
+get_name;
+case cur_code of
+ fvalue_val_code:
+ fvalues[f_array,f_number].fn_val:=get_fix;
+ end;
+finish_the_property;
+end
+
+@ @<Header information for fvalues@>=
+begin
+nwf:=0;
+for f_array := 0 to nkf do begin
+ incr(npf[f_array]);
+ nwf := nwf + npf[f_array];
+ end;
+incr(nkf);
+end
+
+@ @<Output the fvalues@>=
+begin
+for f_array:= 0 to nkf-1 do
+ for f_number:=0 to npf[f_array]-1 do begin
+ out_scaled(fvalues[f_array,f_number].fn_val);
+ end;
+end
+
+@ @<Output the fvalue headers@>=
+begin
+for f_array:= 0 to nkf-1 do begin
+ out_integer(npf[f_array]);
+ end;
+end
+
+@ @<Constants...@>=
+@!ivalue_arrays=arrays_per_kind;
+@!ivalue_entries=entries_per_array;
+
+@ @<Types...@>=
+ivalue_array_type=0..ivalue_arrays;
+ivalue_entry_type=0..ivalue_entries;
+ivalue_node=
+record
+ in_val: integer;
+end;
+
+@ @<Global...@>=
+@!ivalues:array[ivalue_array_type,ivalue_entry_type] of ivalue_node;
+@!npi:array[ivalue_array_type] of integer;
+@!font_i_array:boolean;
+@!nki:integer;
+@!nkci:integer;
+@!nwi:integer;
+@!i_array:integer;
+@!i_number:integer;
+
+@ @<Set init...@>=
+for i_array := 0 to ivalue_arrays do begin
+ npi[i_array]:=0;
+ @<Null out the ivalue@>;
+ end;
+nki:=-1;
+nkci:=-1;
+
+@ @<Read font ivalue list@>=
+begin
+if tables_read then
+ flush_error('All parameter tables must appear before character info');
+i_array:=get_integer;
+if i_array>ivalue_arrays then
+ flush_error('This FONTIVALUE table index is too big for my present size')
+else if i_array<0 then
+ flush_error('This FONTIVALUE index is negative')
+else begin
+ if i_array>nki then nki:=i_array;
+ while level=1 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read an ivalue@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+ finish_inner_property_list;
+ end;
+end
+
+@ @<Read an ivalue@>=
+begin
+get_name;
+if cur_code=comment_code then skip_to_end_of_item
+else if cur_code<>ivalue_code then
+ flush_error('This property name doesn''t belong in an IVALUE list')
+else begin
+ i_number:=get_integer;
+ if i_number>ivalue_entries then
+ flush_error('This IVALUE index is too big for my present table size')
+ else if i_number<0 then
+ flush_error('This IVALUE index is negative')
+ else begin
+ while npi[i_array]<i_number do begin
+ incr(npi[i_array]); @<Null out the ivalue@>;
+ end;
+ @<Read all of an ivalue's values@>;
+ finish_the_property;
+ end;
+ end;
+end
+
+@ @<Null out the ivalue@>=
+begin
+ivalues[i_array,npi[i_array]].in_val:=0;
+end
+
+@ @<Read all of an ivalue's values@>=
+begin
+while level=2 do begin
+ while cur_char=" " do get_next;
+ if cur_char="(" then @<Read a single ivalue value@>
+ else if cur_char=")" then skip_to_end_of_item
+ else junk_error;
+ end;
+finish_inner_property_list;
+end
+
+@ @<Read a single ivalue value@>=
+begin
+get_name;
+case cur_code of
+ ivalue_val_code:
+ ivalues[i_array,i_number].in_val:=get_integer;
+ end;
+finish_the_property;
+end
+
+@ @<Header information for ivalues@>=
+begin
+nwi:=0;
+for i_array := 0 to nki do begin
+ incr(npi[i_array]);
+ nwi := nwi + npi[i_array];
+ end;
+incr(nki);
+end
+
+@ @<Output the ivalues@>=
+begin
+for i_array:= 0 to nki-1 do
+ for i_number:=0 to npi[i_array]-1 do begin
+ out_integer(ivalues[i_array,i_number].in_val);
+ end;
+end
+
+@ @<Output the ivalue headers@>=
+begin
+for i_array:= 0 to nki-1 do begin
+ out_integer(npi[i_array]);
+ end;
+end
+
+@ @<Compute the new header information for OFM files@>=
+begin
+@<Header information for ivalues@>;
+@<Header information for fvalues@>;
+@<Header information for mvalues@>;
+@<Header information for rules@>;
+@<Header information for glues@>;
+@<Header information for penalties@>;
+end
+
+@ @<Output the new information for OFM files@>=
+begin
+@<Output the ivalue headers@>;
+@<Output the fvalue headers@>;
+@<Output the mvalue headers@>;
+@<Output the rule headers@>;
+@<Output the glue headers@>;
+@<Output the penalty headers@>;
+@<Output the ivalues@>;
+@<Output the fvalues@>;
+@<Output the rules@>;
+@<Output the glues@>;
+@<Output the penalties@>;
+end
+
+@* System-dependent changes.
+This section should be replaced, if necessary, by changes to the program
+that are necessary to make \.{PLtoTF} work at a particular installation.
+It is usually best to design your change file so that all changes to
+previous sections preserve the section numbering; then everybody's version
+will be consistent with the printed program. More extensive changes,
+which introduce new sections, can be inserted here; then only the index
+itself will get a new section number.
+@^system dependencies@>
+
+@* Index.
+Pointers to error messages appear here together with the section numbers
+where each ident\-i\-fier is used.