modernc.org/knuth@v0.0.4/vptovf/vptovf.go

// Code generated by '[/tmp/go-build2255657050/b001/exe/generate]', DO NOT EDIT.

// % This program by D. E. Knuth is not copyrighted and can be used freely.
// % Version 1 was implemented in December 1989.
// % Version 1.1 fixed some for-loop indices for stricter Pascal (April 1990).
// % Version 1.2 fixed `nonexistent char 0' bug, and a bit more (September 1990).
// % Version 1.3 has more robust `out_scaled' (March 1991).
// % Version 1.4 (March 1995) initialized lk_step_ended (Armin K\"ollner).
// % Version 1.5 (August 1998) corrected vf_fix(0) (Wayne Sullivan).
// % Version 1.6 (January 2014) corrected possible end-of-line glitch (Ken Nakano),
// %  and get_fix now treats -- as + (Peter Breitenlohner).
//
// % 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[VP\lowercase[to]VF]
// \def\contentspagenumber[201]
// \def\topofcontents[\null
//   \titlefalse % include headline on the contents page
//   \def\rheader[\mainfont\hfil \contentspagenumber]
//   \vfill
//   \centerline[\titlefont The [\ttitlefont VPtoVF] processor]
//   \vskip 15pt
//   \centerline[(Version 1.6, January 2014)]
//   \vfill]
// \def\botofcontents[\vfill
//   \centerline[\hsize 5in\baselineskip9pt
//     \vbox[\ninerm\noindent
//     The preparation of this program
//     was supported in part by the National Science
//     Foundation and by the System Development Foundation. `\TeX' is a
//     trademark of the American Mathematical Society.]]]
// \pageno=\contentspagenumber \advance\pageno by 1
//
//

// 1. Introduction

// tangle:pos vptovf.web:41:14:

// The \.[VPtoVF] utility program converts virtual-property-list (``\.[VPL]'')
// files into an equivalent pair of files called a virtual font (``\.[VF]'') file
// and a \TeX\ font metric (``\.[TFM]'') file. It also makes a thorough check
// of the given \.[VPL] file, so that the \.[VF] file should be acceptable to
// device drivers and the \.[TFM] file should be acceptable to \TeX.
//
// \indent\.[VPtoVF] is an extended version of the program \.[PLtoTF], which
// is part of the standard \TeX ware library.
// The idea of a virtual font was inspired by the work of David R. Fuchs
// \xref[Fuchs, David Raymond]
// who designed a similar set of conventions in 1984 while developing a
// device driver for ArborText, Inc. He wrote a somewhat similar program
// called \.[PLFONT].
//
// The |banner| string defined here should be changed whenever \.[VPtoVF]
// gets modified.

// 2.

// tangle:pos vptovf.web:59:75:

// 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 |vpl_file|, and the output is written on |vf_file| and |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.
// \xref[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.

package vptovf

import (
	"math"
	"unsafe"

	"modernc.org/knuth"
)

var (
	_ = math.MaxInt32
	_ unsafe.Pointer
)

type (
	char   = byte
	signal int
)

func strcopy(dst []char, src string) {
	for i := 0; i < len(dst) && i < len(src); i++ {
		dst[i] = src[i]
	}
}

func arraystr(a []char) string {
	b := make([]byte, len(a))
	for i, c := range a {
		b[i] = c
	}
	return string(b)
}

func abs(n int32) int32 {
	if n >= 0 {
		return n
	}

	return -n
}

func fabs(f float64) float64 {
	if f >= 0 {
		return f
	}

	return -f
}

func round(f float64) int32 {
	if f >= 0 {
		return int32(f + 0.5)
	}

	return int32(f - 0.5)
}

const (
	firstOrd             = 0    /* ordinal number of the smallest element of |char| */
	lastOrd              = 127  /* ordinal number of the largest element of |char| */
	invalidCode          = 0177 /* code deserving an error message */
	maxNameIndex         = 100  /* upper bound on the number of keywords */
	maxLetters           = 666  /* upper bound on the total length of all keywords */
	longestName          = 20   /* length of \.[DEFAULTRULETHICKNESS] */
	hashPrime            = 141  /* size of the hash table */
	commentCode          = 0
	checkSumCode         = 1
	designSizeCode       = 2
	designUnitsCode      = 3
	codingSchemeCode     = 4
	familyCode           = 5
	faceCode             = 6
	sevenBitSafeFlagCode = 7
	headerCode           = 8
	fontDimenCode        = 9
	ligTableCode         = 10
	boundaryCharCode     = 11
	virtualTitleCode     = 12
	mapFontCode          = 13
	characterCode        = 14
	fontNameCode         = 20
	fontAreaCode         = 21
	fontChecksumCode     = 22
	fontAtCode           = 23
	fontDsizeCode        = 24
	parameterCode        = 30
	charInfoCode         = 60
	width                = 1
	height               = 2
	depth                = 3
	italic               = 4
	charWdCode           = charInfoCode + width
	charHtCode           = charInfoCode + height
	charDpCode           = charInfoCode + depth
	charIcCode           = charInfoCode + italic
	nextLargerCode       = 65
	mapCode              = 66
	varCharCode          = 67
	selectFontCode       = 80
	setCharCode          = 81
	setRuleCode          = 82
	moveRightCode        = 83
	moveDownCode         = 85
	pushCode             = 87
	popCode              = 88
	specialCode          = 89
	specialHexCode       = 90
	labelCode            = 100
	stopCode             = 101
	skipCode             = 102
	krnCode              = 103
	ligCode              = 104
	checkSumLoc          = 0
	designSizeLoc        = 4
	codingSchemeLoc      = 8
	familyLoc            = codingSchemeLoc + 40
	sevenFlagLoc         = familyLoc + 20
	faceLoc              = sevenFlagLoc + 3
	memSize              = 1028 + 4 /* number of nonzero memory addresses */
	noTag                = 0        /* vanilla character */
	ligTag               = 1        /* character has a ligature/kerning program */
	listTag              = 2        /* character has a successor in a charlist */
	extTag               = 3        /* character is extensible */
	stopFlag             = 128      /* value indicating `\.[STOP]' in a lig/kern program */
	kernFlag             = 128      /* op code for a kern step */
	setChar0             = 0        /* \.[DVI] command to typeset character 0 and move right */
	set1                 = 128      /* typeset a character and move right */
	setRule              = 132      /* typeset a rule and move right */
	push                 = 141      /* save the current positions */
	pop                  = 142      /* restore previous positions */
	right1               = 143      /* move right */
	w0                   = 147      /* move right by |w| */
	w1                   = 148      /* move right and set |w| */
	x0                   = 152      /* move right by |x| */
	x1                   = 153      /* move right and set |x| */
	down1                = 157      /* move down */
	y0                   = 161      /* move down by |y| */
	y1                   = 162      /* move down and set |y| */
	z0                   = 166      /* move down by |z| */
	z1                   = 167      /* move down and set |z| */
	fntNum0              = 171      /* set current font to 0 */
	fnt1                 = 235      /* set current font */
	xxx1                 = 239      /* extension to \.[DVI] primitives */
	xxx4                 = 242      /* potentially long extension to \.[DVI] primitives */
	fntDef1              = 243      /* define the meaning of a font number */
	pre                  = 247      /* preamble */
	post                 = 248      /* postamble beginning */
	simple               = 0        /* $f(x,y)=z$ */
	leftZ                = 1        /* $f(x,y)=f(z,y)$ */
	rightZ               = 2        /* $f(x,y)=f(x,z)$ */
	bothZ                = 3        /* $f(x,y)=f(f(x,z),y)$ */
	pending              = 4        /* $f(x,y)$ is being evaluated */
	idByte               = 202      /* current version of \.[VF] format */

	// Constants in the outer block
	bufSize        = 60  // length of lines displayed in error messages
	maxHeaderBytes = 100 // four times the maximum number of words allowed in
	//   the \.[TFM] file header block, must be 1024 or less

	vfSize        = 10000 // maximum length of |vf| data, in bytes
	maxStack      = 100   // maximum depth of simulated \.[DVI] stack
	maxParamWords = 30    // the maximum number of \.[fontdimen] parameters allowed
	maxLigSteps   = 5000
	// maximum length of ligature program, must be at most $32767-257=32510$
	maxKerns = 500  // the maximum number of distinct kern values
	hashSize = 5003 // preferably a prime number, a bit larger than the number
// of character pairs in lig/kern steps
)

type (
	// Types in the outer block
	// byte =  /* 0..255 */  byte // unsigned eight-bit quantity
	asciiCode = /* 040..0177 */ byte // standard ASCII code numbers

	fourBytes = struct {
		b0 byte
		b1 byte
		b2 byte
		b3 byte
	}

	fixWord = int32 // a scaled real value with 20 bits of fraction

	headerIndex = /* 0..maxHeaderBytes */ byte
	indx        = /* 0..077777 */ uint16

	pointer = /* 0..memSize */ uint16 // an index into memory
)

type prg struct {
	stdin, stdout, stderr knuth.File
	// Globals in the outer block
	vplFile/* text */ knuth.File

	vfFile  knuth.File
	tfmFile knuth.File

	xord [256]asciiCode // conversion table

	line       int32 // the number of the current line
	goodIndent int32 // the number of lines since the last bad indentation
	indent     int32 // the number of spaces per open parenthesis, zero if unknown
	level      int32 // the current number of open parentheses

	leftLn, rightLn bool // are the left and right ends of the buffer
	//   at end-of-line marks?

	limit/* 0..bufSize */ byte // position of the last character present in the buffer
	loc/* 0..bufSize */ byte   // position of the last character read in the buffer
	buffer                     [60]char
	inputHasEnded              bool // there is no more input to read

	charsOnLine/* 0..8 */ byte // the number of characters printed on the current line

	curChar asciiCode // we have just read this

	start                              [100] /* 0..maxLetters */ uint16
	dictionary                         [667]asciiCode
	startPtr/* 0..maxNameIndex */ byte // the first available place in |start|
	dictPtr/* 0..maxLetters */ uint16  // the first available place in |dictionary|

	curName                             [20]asciiCode // a name to look up
	nameLength/* 0..longestName */ byte // its length
	namePtr/* 0..maxNameIndex */ byte   // its ordinal number in the dictionary

	nhash                            [141] /* 0..maxNameIndex */ byte
	curHash/* 0..hashPrime-1 */ byte // current position in the hash table

	equiv   [101]byte
	curCode byte // equivalent most recently found in |equiv|

	curBytes  fourBytes // a four-byte accumulator
	zeroBytes fourBytes // four bytes all zero

	fractionDigits [7]int32 // $2^[21]$ times $d_j$

	headerBytes                       [101]byte       // the header block
	headerPtr                         headerIndex     // the number of header bytes in use
	designSize                        fixWord         // the design size
	designUnits                       fixWord         // reciprocal of the scaling factor
	frozenDu                          bool            // have we used |design_units| irrevocably?
	sevenBitSafeFlag                  bool            // does the file claim to be seven-bit-safe?
	ligKern                           [5001]fourBytes // the ligature program
	nl/* 0..32767 */ uint16           // the number of ligature/kern instructions so far
	minNl/* 0..32767 */ uint16        // the final value of |nl| must be at least this
	kern                              [501]fixWord // the distinct kerning amounts
	nk/* 0..maxKerns */ uint16        // the number of entries of |kern|
	exten                             [256]fourBytes // extensible character specs
	ne/* 0..256 */ uint16             // the number of extensible characters
	param                             [30]fixWord // \.[FONTDIMEN] parameters
	np/* 0..maxParamWords */ byte     // the largest parameter set nonzero
	checkSumSpecified                 bool // did the user name the check sum?
	bchar/* 0..256 */ uint16          // the right boundary character, or 256 if unspecified
	vf                                [10001]byte // stored bytes for \.[VF] file
	vfPtr/* 0..vfSize */ uint16       // first unused location in |vf|
	vtitleStart/* 0..vfSize */ uint16 // starting location of \.[VTITLE] string
	vtitleLength                      byte // length of \.[VTITLE] string
	packetStart                       [256] /* 0..vfSize */ uint16
	// beginning location of character packet
	packetLength               [256]int32 // length of character packet
	fontPtr/* 0..256 */ uint16 // number of distinct local fonts seen
	curFont/* 0..256 */ uint16 // number of the current local font
	fnameStart                 [256] /* 0..vfSize */ uint16 // beginning of local font name
	fnameLength                [256]byte                    // length of local font name
	fareaStart                 [256] /* 0..vfSize */ uint16 // beginning of local font area
	fareaLength                [256]byte                    // length of local font area
	fontChecksum               [256]fourBytes               // local font checksum
	fontNumber                 [257]fourBytes               // local font id number
	fontAt                     [256]fixWord                 // local font ``at size''
	fontDsize                  [256]fixWord                 // local font design size

	memory        [1033]fixWord                  // character dimensions and kerns
	memPtr        pointer                        // largest |memory| word in use
	link          [1033]pointer                  // to make lists of |memory| items
	charWd        [256]pointer                   // pointers to the widths
	charHt        [256]pointer                   // pointers to the heights
	charDp        [256]pointer                   // pointers to the depths
	charIc        [256]pointer                   // pointers to italic corrections
	charTag       [256] /* noTag..extTag */ byte // character tags
	charRemainder [257] /* 0..65535 */ uint16    // pointers to ligature labels,
	//   next larger characters, or extensible characters

	nextD fixWord // the next larger interval that is worth trying

	index  [1033]byte
	excess byte // number of words to remove, if list is being shortened

	c byte    // the current character or byte being processed
	x fixWord // current dimension of interest
	k int32   // general-purpose index

	lkStepEnded bool
	// was the last \.[LIGTABLE] property \.[LIG] or \.[KRN]?
	krnPtr/* 0..maxKerns */ uint16 // an index into |kern|

	hstack                         [101] /* 0..2 */ byte // number of known horizontal movements
	vstack                         [101] /* 0..2 */ byte // number of known vertical movements
	wstack, xstack, ystack, zstack [101]fixWord
	stackPtr/* 0..maxStack */ byte

	sevenUnsafe bool // do seven-bit characters generate eight-bit ones?

	delta fixWord // size of the intervals needed for rounding

	ligPtr/* 0..maxLigSteps */ uint16       // an index into |lig_kern|
	hash                                    [5004] /* 0..66048 */ uint32 // $256x+y+1$ for $x\le257$ and $y\le255$
	class                                   [5004] /* simple..pending */ byte
	ligZ                                    [5004] /* 0..257 */ uint16
	hashPtr/* 0..hashSize */ uint16         // the number of nonzero entries in |hash|
	hashList                                [5004] /* 0..hashSize */ uint16 // list of those nonzero entries
	h, hh/* 0..hashSize */ uint16           // indices into the hash table
	tt                                      indx // temporary register
	xLigCycle, yLigCycle/* 0..256 */ uint16 // problematic ligature pair

	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/* 0..32767 */ uint16 // the number of words in the entire \.[TFM] file
	notFound                bool    // has a font character been found?
	tempWidth               fixWord // width being used to compute a check sum

	j/* 0..maxHeaderBytes */ byte     // index into |header_bytes|
	p                                 pointer // index into |memory|
	q/* width..italic */ byte         // runs through the list heads for dimensions
	parPtr/* 0..maxParamWords */ byte // runs through the parameters

	labelTable [257]struct {
		rr int16 // sorted label values
		cc byte  // associated characters
	}
	labelPtr/* 0..256 */ uint16 // index of highest entry in |label_table|
	sortPtr/* 0..256 */ uint16  // index into |label_table|
	lkOffset/* 0..256 */ uint16 // smallest offset value that might work
	t/* 0..077777 */ uint16     // label value that is being redirected
	extraLocNeeded              bool // do we need a special word for |bchar|?

	vcount int32 // number of bytes written to |vf_file|
}

func (prg *prg) initialize() { // this procedure gets things started properly
	var (
		// Local variables for initialization
		k int32 // all-purpose initialization index

		h/* 0..hashPrime-1 */ byte // runs through the hash table

		d headerIndex // an index into |header_bytes|

		c byte // runs through all character codes
	)
	prg.stdout.Writeln("This is VPtoVF, Version 1.6 (govptovf v0.0-prerelease)")

	// Set initial values
	prg.vplFile.Reset()

	prg.vfFile.Rewrite()
	prg.tfmFile.Rewrite()

	for ii := int32(firstOrd); ii <= lastOrd; ii++ {
		k = ii
		_ = k
		prg.xord[char(k)] = byte(invalidCode)
	}
	prg.xord[' '] = ' '
	prg.xord['!'] = '!'
	prg.xord['"'] = '"'
	prg.xord['#'] = '#'
	prg.xord['$'] = '$'
	prg.xord['%'] = '%'
	prg.xord['&'] = '&'
	prg.xord['\''] = '\''
	prg.xord['('] = '('
	prg.xord[')'] = ')'
	prg.xord['*'] = '*'
	prg.xord['+'] = '+'
	prg.xord[','] = ','
	prg.xord['-'] = '-'
	prg.xord['.'] = '.'
	prg.xord['/'] = '/'
	prg.xord['0'] = '0'
	prg.xord['1'] = '1'
	prg.xord['2'] = '2'
	prg.xord['3'] = '3'
	prg.xord['4'] = '4'
	prg.xord['5'] = '5'
	prg.xord['6'] = '6'
	prg.xord['7'] = '7'
	prg.xord['8'] = '8'
	prg.xord['9'] = '9'
	prg.xord[':'] = ':'
	prg.xord[';'] = ';'
	prg.xord['<'] = '<'
	prg.xord['='] = '='
	prg.xord['>'] = '>'
	prg.xord['?'] = '?'
	prg.xord['@'] = '@'
	prg.xord['A'] = 'A'
	prg.xord['B'] = 'B'
	prg.xord['C'] = 'C'
	prg.xord['D'] = 'D'
	prg.xord['E'] = 'E'
	prg.xord['F'] = 'F'
	prg.xord['G'] = 'G'
	prg.xord['H'] = 'H'
	prg.xord['I'] = 'I'
	prg.xord['J'] = 'J'
	prg.xord['K'] = 'K'
	prg.xord['L'] = 'L'
	prg.xord['M'] = 'M'
	prg.xord['N'] = 'N'
	prg.xord['O'] = 'O'
	prg.xord['P'] = 'P'
	prg.xord['Q'] = 'Q'
	prg.xord['R'] = 'R'
	prg.xord['S'] = 'S'
	prg.xord['T'] = 'T'
	prg.xord['U'] = 'U'
	prg.xord['V'] = 'V'
	prg.xord['W'] = 'W'
	prg.xord['X'] = 'X'
	prg.xord['Y'] = 'Y'
	prg.xord['Z'] = 'Z'
	prg.xord['['] = '['
	prg.xord['\\'] = '\\'
	prg.xord[']'] = ']'
	prg.xord['^'] = '^'
	prg.xord['_'] = '_'
	prg.xord['`'] = '`'
	prg.xord['a'] = 'a'
	prg.xord['b'] = 'b'
	prg.xord['c'] = 'c'
	prg.xord['d'] = 'd'
	prg.xord['e'] = 'e'
	prg.xord['f'] = 'f'
	prg.xord['g'] = 'g'
	prg.xord['h'] = 'h'
	prg.xord['i'] = 'i'
	prg.xord['j'] = 'j'
	prg.xord['k'] = 'k'
	prg.xord['l'] = 'l'
	prg.xord['m'] = 'm'
	prg.xord['n'] = 'n'
	prg.xord['o'] = 'o'
	prg.xord['p'] = 'p'
	prg.xord['q'] = 'q'
	prg.xord['r'] = 'r'
	prg.xord['s'] = 's'
	prg.xord['t'] = 't'
	prg.xord['u'] = 'u'
	prg.xord['v'] = 'v'
	prg.xord['w'] = 'w'
	prg.xord['x'] = 'x'
	prg.xord['y'] = 'y'
	prg.xord['z'] = 'z'
	prg.xord['{'] = '{'
	prg.xord['|'] = '|'
	prg.xord['}'] = '}'
	prg.xord['~'] = '~'

	prg.line = 0
	prg.goodIndent = 0
	prg.indent = 0
	prg.level = 0

	prg.limit = 0
	prg.loc = 0
	prg.leftLn = true
	prg.rightLn = true
	prg.inputHasEnded = false

	prg.charsOnLine = 0

	prg.startPtr = 1
	prg.start[1-1] = 0
	prg.dictPtr = 0

	for ii := int32(0); ii <= hashPrime-1; ii++ {
		h = byte(ii)
		_ = h
		prg.nhash[h] = 0
	}

	prg.zeroBytes.b0 = 0
	prg.zeroBytes.b1 = 0
	prg.zeroBytes.b2 = 0
	prg.zeroBytes.b3 = 0

	for ii := int32(0); ii <= 18*4-1; ii++ {
		d = headerIndex(ii)
		_ = d
		prg.headerBytes[d] = 0
	}
	prg.headerBytes[8] = 11
	prg.headerBytes[9] = 'U'
	prg.headerBytes[10] = 'N'
	prg.headerBytes[11] = 'S'
	prg.headerBytes[12] = 'P'
	prg.headerBytes[13] = 'E'
	prg.headerBytes[14] = 'C'
	prg.headerBytes[15] = 'I'
	prg.headerBytes[16] = 'F'
	prg.headerBytes[17] = 'I'
	prg.headerBytes[18] = 'E'
	prg.headerBytes[19] = 'D'
	// \xref[UNSPECIFIED]
	for ii := int32(familyLoc); ii <= familyLoc+11; ii++ {
		d = headerIndex(ii)
		_ = d
		prg.headerBytes[d] = prg.headerBytes[int32(d)-40]
	}
	prg.designSize = 10 * 04000000
	prg.designUnits = 04000000
	prg.frozenDu = false
	prg.sevenBitSafeFlag = false

	prg.headerPtr = byte(18 * 4)
	prg.nl = 0
	prg.minNl = 0
	prg.nk = 0
	prg.ne = 0
	prg.np = 0

	prg.checkSumSpecified = false
	prg.bchar = 256

	prg.vfPtr = 0
	prg.vtitleStart = 0
	prg.vtitleLength = 0
	prg.fontPtr = 0
	for ii := int32(0); ii <= 255; ii++ {
		k = ii
		_ = k
		prg.packetStart[k] = uint16(vfSize)
	}
	for ii := int32(0); ii <= 127; ii++ {
		k = ii
		_ = k
		prg.packetLength[k] = 1
	}
	for ii := int32(128); ii <= 255; ii++ {
		k = ii
		_ = k
		prg.packetLength[k] = 2
	}

	prg.charRemainder[256] = 077777
	for ii := int32(0); ii <= 255; ii++ {
		c = byte(ii)
		_ = c
		prg.charWd[c] = 0
		prg.charHt[c] = 0
		prg.charDp[c] = 0
		prg.charIc[c] = 0

		prg.charTag[c] = byte(noTag)
		prg.charRemainder[c] = 0
	}
	prg.memory[0] = 017777777777 // an ``infinite'' element at the end of the lists
	prg.memory[width] = 0
	prg.link[width] = 0 // width list is empty
	prg.memory[height] = 0
	prg.link[height] = 0 // height list is empty
	prg.memory[depth] = 0
	prg.link[depth] = 0 // depth list is empty
	prg.memory[italic] = 0
	prg.link[italic] = 0 // italic list is empty
	prg.memPtr = uint16(italic)

	prg.hashPtr = 0
	prg.yLigCycle = 256
	for ii := int32(0); ii <= hashSize; ii++ {
		k = ii
		_ = k
		prg.hash[k] = 0
	}

}

// 4.

// tangle:pos vptovf.web:101:40:

// Here are some macros for common programming idioms.

// 7.

// tangle:pos vptovf.web:133:17:

// A \.[VPL] file is like a \.[PL] file with a few extra features, so we
// can begin to define it by reviewing the definition of \.[PL] files. The
// material in the next few sections is copied from the program \.[PLtoTF].
//
// 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.

// 8.

// tangle:pos vptovf.web:209:14:

// 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 example
// above, 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, \.[VPtoVF] will not notice
// the discrepancy; it simply uses the final value given. Once again, however, the
// \.[LIGTABLE] is an exception to this rule; \.[VPtoVF] 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.

// 9.

// tangle:pos vptovf.web:245:71:

// A \.[VPL] file also includes information about how to create each character,
// by typesetting characters from other fonts and/or by drawing lines, etc.
// Such information is the value of the `\.[MAP]' property, which can be
// illustrated as follows:
// $$\vbox[\halign[\.[#]\hfil\cr
// (MAPFONT D 0 (FONTNAME Times-Roman))\cr
// (MAPFONT D 1 (FONTNAME Symbol))\cr
// (MAPFONT D 2 (FONTNAME cmr10)(FONTAT D 20))\cr
// (CHARACTER O 0 (MAP (SELECTFONT D 1)(SETCHAR C G)))\cr
// (CHARACTER O 76 (MAP (SETCHAR O 277)))\cr
// (CHARACTER D 197 (MAP\cr
// \qquad(PUSH)(SETCHAR C A)(POP)\cr
// \qquad(MOVEUP R 0.937)(MOVERIGHT R 1.5)(SETCHAR O 312)))\cr
// (CHARACTER O 200 (MAP (MOVEDOWN R 2.1)(SETRULE R 1 R 8)))\cr
// (CHARACTER O 201 (MAP\cr
// \qquad (SPECIAL ps: /SaveGray currentgray def .5 setgray)\cr
// \qquad (SELECTFONT D 2)(SETCHAR C A)\cr
// \qquad (SPECIAL ps: SaveGray setgray)))\cr
// ]]$$
// (These specifications appear in addition to the conventional \.[PL]
// information. The \.[MAP] attribute can be mixed in with other attributes
// like \.[CHARWD] or it can be given separately.)
//
// In this example, the virtual font is composed of characters that can be
// fabricated from three actual fonts, `\.[Times-Roman]',
// `\.[Symbol]', and `\.[cmr10] \.[at] \.[20\\u]' (where \.[\\u]
// is the unit size in this \.[VPL] file). Character |@'0| is typeset as
// a `G' from the symbol font. Character |@'76| is typeset as character |@'277|
// from the ordinary Times font. (If no other font is selected, font
// number~0 is the default. If no \.[MAP] attribute is given, the default map
// is a character of the same number in the default font.)
//
// Character 197 (decimal) is more interesting: First an A is typeset (in the
// default font Times), and this is enclosed by \.[PUSH] and \.[POP] so that
// the original position is restored. Then the accent character |@'312| is
// typeset, after moving up .937 units and right 1.5 units.
//
// To typeset character |@'200| in this virtual font, we move down 2.1 units,
// then typeset a rule that is 1 unit high and 8 units wide.
//
// Finally, to typeset character |@'201|, we do something that requires a
// special ability to interpret PostScript commands; this example
// sets the PostScript ``color'' to 50\char`\%\ gray and typesets an `A'
// from \.[cmr10] \.[at] \.[20\\u] in that color.
//
// In general, the \.[MAP] attribute of a virtual character can be any sequence
// of typesetting commands that might appear in a page of a \.[DVI] file.
// A single character might map into an entire page.

// 10.

// tangle:pos vptovf.web:294:50:

// But instead of relying on a hypothetical example, let's consider a complete
// grammar for \.[VPL] files, beginning with the (unchanged) grammatical rules
// for \.[PL] files. At the outer level, the following property names
// are valid in any \.[PL] file:
//
// \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 \.[VPL] file,
// \.[VPtoVF] 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.)
// \.[VPtoVF] 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] (one-byte 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 a one-byte 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.

// 11.

// tangle:pos vptovf.web:374:39:

// 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 an unsigned decimal integer, which must be
// less than $2^[32]$, i.e., at most `\.[D 4294967295]'.
//
// \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.

// 12.

// tangle:pos vptovf.web:399:39:

// 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|.

// 13.

// tangle:pos vptovf.web:416:33:

// 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] (one-byte 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.

// 14.

// tangle:pos vptovf.web:447:76:

// 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] (one-byte 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 one-byte 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] (a one-byte 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 and $c$;
// otherwise go on to the next instruction.'' The value of $r$, which is in
// design units, 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] steps has been skipped over. The number of subsequent \.[LIG] and
// \.[KRN] instructions must therefore exceed this specified amount.

// 15.

// tangle:pos vptovf.web:490:66:

// In addition to all these possibilities, the property name \.[COMMENT] is
// allowed in any property list. Such comments are ignored.

// 16.

// tangle:pos vptovf.web:493:57:

// So that is what \.[PL] files hold. In a \.[VPL] file additional
// properties are recognized; two of these are valid on the outermost level:
//
// \yskip\hang\.[VTITLE] (string value, default is empty). The value will be
// reproduced at the beginning of the \.[VF] file (and printed on the terminal
// by \.[VFtoVP] when it examines that file).
//
// \yskip\hang\.[MAPFONT]. The value is a nonnegative integer followed by
// a property list. The integer represents an identifying number for fonts
// used in \.[MAP] attributes. The property list, which identifies the font and
// relative size, is defined below.
//
// \yskip\noindent
// And one additional ``virtual property'' is valid within a \.[CHARACTER]:
//
// \yskip\hang\.[MAP]. The value is a property list consisting of typesetting
// commands. Default is the single command \.[SETCHAR]~$c$, where $c$ is
// the current character number.

// 17.

// tangle:pos vptovf.web:512:30:

// The elements of a \.[MAPFONT] property list can be of the following types.
//
// \yskip\hang\.[FONTNAME] (string value, default is \.[NULL]).
// This is the font's identifying name.
//
// \yskip\hang\.[FONTAREA] (string value, default is empty). If the font appears
// in a nonstandard directory, according to local conventions, the directory
// name is given here. (This is system dependent, just as in \.[DVI] files.)
//
// \yskip\hang\.[FONTCHECKSUM] (four-byte value, default is zero). This value,
// which should be a nonnegative integer less than $2^[32]$, can be used to
// check that the font being referred to matches the intended font. If nonzero,
// it should equal the \.[CHECKSUM] parameter in that font.
//
// \yskip\hang\.[FONTAT] (numeric value, default is the \.[DESIGNUNITS] of the
// present virtual font). This value is relative to the design units of
// the present virtual font, hence it will be scaled when the virtual
// font is magnified or reduced.  It represents the value that will
// effectively replace the design size of the font being referred to,
// so that all characters will be scaled appropriately.
//
// \yskip\hang\.[FONTDSIZE] (numeric value, default is 10). This value is
// absolute, in units of printer's points. It should equal the \.[DESIGNSIZE]
// parameter in the font being referred to.
//
// \yskip\noindent
// If any of the
// string values contain parentheses, the parentheses must be balanced. Leading
// blanks are removed from the strings, but trailing blanks are not.

// 18.

// tangle:pos vptovf.web:542:66:

// Finally, the elements of a \.[MAP] property list are an ordered sequence
// of typesetting commands chosen from among the following:
//
// \yskip\hang\.[SELECTFONT] (four-byte integer value). The value must be the
// number of a previously defined \.[MAPFONT]. This font (or more precisely, the
// final font that is mapped to that code number, if two \.[MAPFONT] properties
// happen to specify the same code) will be used in subsequent \.[SETCHAR]
// instructions until overridden by another \.[SELECTFONT]. The first-specified
// \.[MAPFONT] is implicitly selected before the first \.[SELECTFONT] in every
// character's map.
//
// \yskip\hang\.[SETCHAR] (one-byte integer value). There must be a character of
// this number in the currently selected font. (\.[VPtoVF] doesn't check that
// the character is valid, but \.[VFtoVP] does.) That character is typeset at the
// current position, and the typesetter moves right by the \.[CHARWD] in
// that character's \.[TFM] file.
//
// \yskip\hang\.[SETRULE] (two real values). The first value specifies height,
// the second specifies width, in design units. If both height and width are
// positive, a rule is typeset at the current position. Then the typesetter
// moves right, by the specified width.
//
// \yskip\hang\.[MOVERIGHT], \.[MOVELEFT], \.[MOVEUP], \.[MOVEDOWN] (real
// value). The typesetter moves its current position
// by the number of design units specified.
//
// \yskip\hang\.[PUSH]. The current typesetter position is remembered, to
// be restored on a subsequent \.[POP].
//
// \yskip\hang\.[POP]. The current typesetter position is reset to where it
// was on the most recent unmatched \.[PUSH]. The \.[PUSH] and \.[POP]
// commands in any \.[MAP] must be properly nested like balanced parentheses.
//
// \yskip\hang\.[SPECIAL] (string value). The subsequent characters, starting
// with the first nonblank and ending just before the first `\.)' that has no
// matching `\.(', are interpreted according to local conventions with the
// same system-dependent meaning as a `special' (\\[xxx]) command
// in a \.[DVI] file.
//
// \yskip\hang\.[SPECIALHEX] (hexadecimal string value). The subsequent
// nonblank characters before the next `\.)' must consist entirely of
// hexadecimal digits, and they must contain an even number of such digits.
// Each pair of hex digits specifies a byte, and this string of bytes is
// treated just as the value of a \.[SPECIAL]. (This convention permits
// arbitrary byte strings to be represented in an ordinary text file.)

// 19.

// tangle:pos vptovf.web:588:68:

// Virtual font mapping is a recursive process, like macro expansion.
// Thus, a \.[MAPFONT] might
// specify another virtual font, whose characters are themselves mapped to
// other fonts. As an example of this possibility, consider the
// following curious file called \.[recurse.vpl], which defines a
// virtual font that is self-contained and self-referential:
// $$\vbox[\halign[\.[#]\cr
// (VTITLE Example of recursion)\cr
// (MAPFONT D 0 (FONTNAME recurse)(FONTAT D 2))\cr
// (CHARACTER C A (CHARWD D 1)(CHARHT D 1)(MAP (SETRULE D 1 D 1)))\cr
// (CHARACTER C B (CHARWD D 2)(CHARHT D 2)(MAP (SETCHAR C A)))\cr
// (CHARACTER C C (CHARWD D 4)(CHARHT D 4)(MAP (SETCHAR C B)))\cr
// ]]$$
// The design size is 10 points (the default), hence the character \.A
// in font \.[recurse] is a $10\times10$ point black square. Character \.B
// is typeset as character \.A in \.[recurse] [scaled] [2000], hence it
// is a $20\times20$ point black square. And character \.C is typeset as
// character \.[B] in \.[recurse] [scaled] [2000], hence its size is
// $40\times40$.
//
// Users are responsible for making sure that infinite recursion doesn't happen.

// 20.

// tangle:pos vptovf.web:610:78:

// So that is what \.[VPL] files hold. From these rules,
// you can guess (correctly) that \.[VPtoVF] operates in four main stages.
// First it assigns the default values to all properties; then it scans
// through the \.[VPL] file, changing property values as new ones are seen; then
// it checks the information and corrects any problems; and finally it outputs
// the \.[VF] and \.[TFM] files.

// 33.

// tangle:pos vptovf.web:742:18:

// 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.
func (prg *prg) showErrorContext() { // prints the current scanner location
	var (
		k /* 0..bufSize */ byte // an index into |buffer|
	)
	prg.stdout.Writeln(" (line ", prg.line, knuth.WriteWidth(1), ").")
	if !prg.leftLn {
		prg.stdout.Write("...")
	}
	for ii := int32(1); ii <= int32(prg.loc); ii++ {
		k = byte(ii)
		_ = k
		prg.stdout.Write(string(rune(prg.buffer[k-1])))
	} // print the characters already scanned
	prg.stdout.Writeln(" ")
	if !prg.leftLn {
		prg.stdout.Write("   ")
	}
	for ii := int32(1); ii <= int32(prg.loc); ii++ {
		k = byte(ii)
		_ = k
		prg.stdout.Write(" ")
	} // space out the second line
	for ii := int32(prg.loc) + 1; ii <= int32(prg.limit); ii++ {
		k = byte(ii)
		_ = k
		prg.stdout.Write(string(rune(prg.buffer[k-1])))
	} // print the characters yet unseen
	if prg.rightLn {
		prg.stdout.Writeln(" ")
	} else {
		prg.stdout.Writeln("...")
	}
	prg.charsOnLine = 0
}

// 34.

// tangle:pos vptovf.web:763:5:

// 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.)
// \xref[system dependencies]
func (prg *prg) fillBuffer() {
	prg.leftLn = prg.rightLn
	prg.limit = 0
	prg.loc = 0
	if prg.leftLn {
		if prg.line > 0 {
			prg.vplFile.Readln()
		}
		prg.line = prg.line + 1
	}
	if prg.vplFile.EOF() {
		prg.limit = 1
		prg.buffer[1-1] = ')'
		prg.rightLn = false
		prg.inputHasEnded = true
	} else {
		for int32(prg.limit) < bufSize-2 && !prg.vplFile.EOLN() {
			prg.limit = byte(int32(prg.limit) + 1)
			prg.vplFile.Read(&prg.buffer[prg.limit-1])
		}
		prg.buffer[int32(prg.limit)+1-1] = ' '
		prg.rightLn = prg.vplFile.EOLN()
		if prg.rightLn {
			prg.limit = byte(int32(prg.limit) + 1)
			prg.buffer[int32(prg.limit)+1-1] = ' '
		}
		if prg.leftLn {
			for int32(prg.loc) < int32(prg.limit) && int32(prg.buffer[int32(prg.loc)+1-1]) == ' ' {
				prg.loc = byte(int32(prg.loc) + 1)
			}
			if int32(prg.loc) < int32(prg.limit) {
				if prg.level == 0 {
					if int32(prg.loc) == 0 {
						prg.goodIndent = prg.goodIndent + 1
					} else {
						if prg.goodIndent >= 10 {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("Warning: Indented line occurred at level zero")
							prg.showErrorContext()
						}
						prg.goodIndent = 0
						prg.indent = 0
					}
				} else if prg.indent == 0 {
					if int32(prg.loc)%prg.level == 0 {
						prg.indent = int32(prg.loc) / prg.level
						prg.goodIndent = 1
					} else {
						prg.goodIndent = 0
					}
				} else if prg.indent*prg.level == int32(prg.loc) {
					prg.goodIndent = prg.goodIndent + 1
				} else {
					if prg.goodIndent >= 10 {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("Warning: Inconsistent indentation; ",
							// \xref[Warning: Inconsistent indentation...]
							"you are at parenthesis level ", prg.level, knuth.WriteWidth(1))
						prg.showErrorContext()
					}
					prg.goodIndent = 0
					prg.indent = 0
				}
			}
		}
	}
}

// 37.

// tangle:pos vptovf.web:831:48:

// 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.
func (prg *prg) getKeywordChar() {
	for int32(prg.loc) == int32(prg.limit) && !prg.rightLn {
		prg.fillBuffer()
	}
	if int32(prg.loc) == int32(prg.limit) {
		prg.curChar = ' '
	} else {
		prg.curChar = prg.xord[prg.buffer[int32(prg.loc)+1-1]]
		if int32(prg.curChar) >= 'a' {
			prg.curChar = byte(int32(prg.curChar) - 040)
		}
		if int32(prg.curChar) >= '0' && int32(prg.curChar) <= '9' {
			prg.loc = byte(int32(prg.loc) + 1)
		} else if int32(prg.curChar) >= 'A' && int32(prg.curChar) <= 'Z' {
			prg.loc = byte(int32(prg.loc) + 1)
		} else if int32(prg.curChar) == '/' {
			prg.loc = byte(int32(prg.loc) + 1)
		} else if int32(prg.curChar) == '>' {
			prg.loc = byte(int32(prg.loc) + 1)
		} else {
			prg.curChar = ' '
		}
	}
}

// 38.

// tangle:pos vptovf.web:851:5:

// 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.
func (prg *prg) getNext() {
	for int32(prg.loc) == int32(prg.limit) {
		prg.fillBuffer()
	}
	prg.loc = byte(int32(prg.loc) + 1)
	prg.curChar = prg.xord[prg.buffer[prg.loc-1]]
	if int32(prg.curChar) >= 'a' {
		if int32(prg.curChar) <= 'z' {
			prg.curChar = byte(int32(prg.curChar) - 040)
		} else {
			if int32(prg.curChar) == invalidCode {
				{
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("Illegal character in the file")
					prg.showErrorContext()
				}
				// \xref[Illegal character...]
				prg.curChar = '?'
			}
		}
	} else if int32(prg.curChar) <= ')' && int32(prg.curChar) >= '(' {
		prg.loc = byte(int32(prg.loc) - 1)
	}
}

// 39.

// tangle:pos vptovf.web:876:5:

// Here's a procedure that scans a hexadecimal digit or a right parenthesis.
func (prg *prg) getHex() (r byte) {
	var (
		a int32 // partial result
	)
	for {
		prg.getNext()
		if int32(prg.curChar) != ' ' {
			break
		}
	}
	a = int32(prg.curChar) - ')'
	if a > 0 {
		a = int32(prg.curChar) - '0'
		if int32(prg.curChar) > '9' {
			if int32(prg.curChar) < 'A' {
				a = -1
			} else {
				a = int32(prg.curChar) - 'A' + 10
			}
		}
	}
	if a < 0 || a > 15 {
		{
			if int32(prg.charsOnLine) > 0 {
				prg.stdout.Writeln(" ")
			}
			prg.stdout.Write("Illegal hexadecimal digit")
			prg.showErrorContext()
		}
		r = 0
		// \xref[Illegal hexadecimal digit]
	} else {
		r = byte(a)
	}
	return r
}

// 40.

// tangle:pos vptovf.web:895:5:

// 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.
func (prg *prg) skipToEndOfItem() {
	var (
		l int32 // initial value of |level|
	)
	l = prg.level
	for prg.level >= l {
		for int32(prg.loc) == int32(prg.limit) {
			prg.fillBuffer()
		}
		prg.loc = byte(int32(prg.loc) + 1)
		if int32(prg.buffer[prg.loc-1]) == ')' {
			prg.level = prg.level - 1
		} else if int32(prg.buffer[prg.loc-1]) == '(' {
			prg.level = prg.level + 1
		}
	}
	if prg.inputHasEnded {
		if int32(prg.charsOnLine) > 0 {
			prg.stdout.Writeln(" ")
		}
		prg.stdout.Write("File ended unexpectedly: No closing \")\"")
		prg.showErrorContext()
	}
	// \xref[File ended unexpectedly...]
	prg.curChar = ' ' // now the right parenthesis has been read and digested
}

// 41.

// tangle:pos vptovf.web:914:5:

// A similar procedure copies the bytes remaining in an item. The copied bytes
// go into an array |vf| that we'll declare later. Leading blanks are ignored.
func (prg *prg) copyToEndOfItem() {
	var (
		l             int32 // initial value of |level|
		nonblankFound bool  // have we seen a nonblank character yet?
	)
	l = prg.level
	nonblankFound = false
	for true {
		for int32(prg.loc) == int32(prg.limit) {
			prg.fillBuffer()
		}
		if int32(prg.buffer[int32(prg.loc)+1-1]) == ')' {
			if prg.level == l {
				goto _30
			} else {
				prg.level = prg.level - 1
			}
		}
		prg.loc = byte(int32(prg.loc) + 1)
		if int32(prg.buffer[prg.loc-1]) == '(' {
			prg.level = prg.level + 1
		}
		if int32(prg.buffer[prg.loc-1]) != ' ' {
			nonblankFound = true
		}
		if nonblankFound {
			if int32(prg.xord[prg.buffer[prg.loc-1]]) == invalidCode {
				{
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("Illegal character in the file")
					prg.showErrorContext()
				}
				// \xref[Illegal character...]
				{
					prg.vf[prg.vfPtr] = '?'
					if int32(prg.vfPtr) == vfSize {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("I'm out of memory---increase my vfsize!")
						prg.showErrorContext()
					} else {
						prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
					}
				}
			} else {
				prg.vf[prg.vfPtr] = prg.xord[prg.buffer[prg.loc-1]]
				if int32(prg.vfPtr) == vfSize {
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("I'm out of memory---increase my vfsize!")
					prg.showErrorContext()
				} else {
					prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
				}
			}
		}
	}
_30:
}

// 42.

// tangle:pos vptovf.web:946:8:

// 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).

// 43.

// tangle:pos vptovf.web:957:69:

// 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).
func (prg *prg) finishTheProperty() {
	for int32(prg.curChar) == ' ' {
		prg.getNext()
	}
	if int32(prg.curChar) != ')' {
		if int32(prg.charsOnLine) > 0 {
			prg.stdout.Writeln(" ")
		}
		prg.stdout.Write("Junk after property value will be ignored")
		prg.showErrorContext()
	}
	// \xref[Junk after property value...]
	prg.skipToEndOfItem()
}

// 50.

// tangle:pos vptovf.web:1014:41:

// 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.
func (prg *prg) lookup() { // finds |cur_name| in the dictionary
	var (
		k/* 0..longestName */ byte       // index into |cur_name|
		j/* 0..maxLetters */ uint16      // index into |dictionary|
		notFound                    bool // clumsy thing necessary to avoid |goto| statement
	)
	prg.curHash = prg.curName[1-1]
	for ii := int32(2); ii <= int32(prg.nameLength); ii++ {
		k = byte(ii)
		_ = k
		prg.curHash = byte((int32(prg.curHash) + int32(prg.curHash) + int32(prg.curName[k-1])) % hashPrime)
	}
	notFound = true
	for notFound {
		if int32(prg.curHash) == 0 {
			prg.curHash = byte(hashPrime - 1)
		} else {
			prg.curHash = byte(int32(prg.curHash) - 1)
		}
		if int32(prg.nhash[prg.curHash]) == 0 {
			notFound = false
		} else {
			j = prg.start[prg.nhash[prg.curHash]-1]
			if int32(prg.start[int32(prg.nhash[prg.curHash])+1-1]) == int32(j)+int32(prg.nameLength) {
				notFound = false
				for ii := int32(1); ii <= int32(prg.nameLength); ii++ {
					k = byte(ii)
					_ = k
					if int32(prg.dictionary[int32(j)+int32(k)-1]) != int32(prg.curName[k-1]) {
						notFound = true
					}
				}
			}
		}
	}
	prg.namePtr = prg.nhash[prg.curHash]
}

// 53.

// tangle:pos vptovf.web:1099:61:

// 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.
func (prg *prg) enterName(v byte) { // |cur_name| goes into the dictionary
	var (
		k /* 0..longestName */ byte
	)
	for ii := int32(1); ii <= int32(prg.nameLength); ii++ {
		k = byte(ii)
		_ = k
		prg.curName[k-1] = prg.curName[int32(k)+longestName-int32(prg.nameLength)-1]
	}
	// now the name has been shifted into the correct position
	prg.lookup() // this sets |cur_hash| to the proper insertion place
	prg.nhash[prg.curHash] = prg.startPtr
	prg.equiv[prg.startPtr] = v
	for ii := int32(1); ii <= int32(prg.nameLength); ii++ {
		k = byte(ii)
		_ = k
		prg.dictionary[prg.dictPtr] = prg.curName[k-1]
		prg.dictPtr = uint16(int32(prg.dictPtr) + 1)
	}
	prg.startPtr = byte(int32(prg.startPtr) + 1)
	prg.start[prg.startPtr-1] = prg.dictPtr
}

// 54.

// tangle:pos vptovf.web:1118:5:

// 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.

// 58.

// tangle:pos vptovf.web:1269:65:

// 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|.
func (prg *prg) getName() {
	prg.loc = byte(int32(prg.loc) + 1)
	prg.level = prg.level + 1 // pass the left parenthesis
	prg.curChar = ' '
	for int32(prg.curChar) == ' ' {
		prg.getNext()
	}
	if int32(prg.curChar) > ')' || int32(prg.curChar) < '(' {
		prg.loc = byte(int32(prg.loc) - 1)
	} // back up one character
	prg.nameLength = 0
	prg.getKeywordChar() // prepare to scan the name
	for int32(prg.curChar) != ' ' {
		if int32(prg.nameLength) == longestName {
			prg.curName[1-1] = 'X'
		} else {
			prg.nameLength = byte(int32(prg.nameLength) + 1)
		}
		prg.curName[prg.nameLength-1] = prg.curChar
		prg.getKeywordChar()
	}
	prg.lookup()
	if int32(prg.namePtr) == 0 {
		if int32(prg.charsOnLine) > 0 {
			prg.stdout.Writeln(" ")
		}
		prg.stdout.Write("Sorry, I don't know that property name")
		prg.showErrorContext()
	}
	// \xref[Sorry, I don't know...]
	prg.curCode = prg.equiv[prg.namePtr]
}

// 59. Scanning numeric data

// tangle:pos vptovf.web:1293:22:

// 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.

// 60.

// tangle:pos vptovf.web:1298:55:

// The first number scanner, which returns a one-byte value, surely has
// no problems of arithmetic overflow.
func (prg *prg) getByte() (r byte) { // scans a one-byte property value
	var (
		acc int32     // an accumulator
		t   asciiCode // the type of value to be scanned
	)
	for {
		prg.getNext()
		if int32(prg.curChar) != ' ' {
			break
		}
	} // skip the blanks before the type code
	t = prg.curChar
	acc = 0
	for {
		prg.getNext()
		if int32(prg.curChar) != ' ' {
			break
		}
	} // skip the blanks after the type code
	if int32(t) == 'C' {
		if int32(prg.curChar) >= 041 && int32(prg.curChar) <= 0176 && (int32(prg.curChar) < '(' || int32(prg.curChar) > ')') {
			acc = int32(prg.xord[prg.buffer[prg.loc-1]])
		} else {
			{
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Writeln(" ")
				}
				prg.stdout.Write("\"C\" value must be standard ASCII and not a paren")
				prg.showErrorContext()
			}
			for {
				prg.getNext()
				if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
					break
				}
			}
		}
	} else if int32(t) == 'D' {
		for int32(prg.curChar) >= '0' && int32(prg.curChar) <= '9' {
			acc = acc*10 + int32(prg.curChar) - '0'
			if acc > 255 {
				{
					{
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("This value shouldn't exceed 255")
						prg.showErrorContext()
					}
					for {
						prg.getNext()
						if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
							break
						}
					}
				}
				// \xref[This value shouldn't...]
				acc = 0
				prg.curChar = ' '
			} else {
				prg.getNext()
			}
		}
		{
			if int32(prg.curChar) > ')' || int32(prg.curChar) < '(' {
				prg.loc = byte(int32(prg.loc) - 1)
			}
		}
	} else if int32(t) == 'O' {
		for int32(prg.curChar) >= '0' && int32(prg.curChar) <= '7' {
			acc = acc*8 + int32(prg.curChar) - '0'
			if acc > 255 {
				{
					{
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("This value shouldn't exceed '377")
						prg.showErrorContext()
					}
					for {
						prg.getNext()
						if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
							break
						}
					}
				}
				// \xref[This value shouldn't...]
				acc = 0
				prg.curChar = ' '
			} else {
				prg.getNext()
			}
		}
		{
			if int32(prg.curChar) > ')' || int32(prg.curChar) < '(' {
				prg.loc = byte(int32(prg.loc) - 1)
			}
		}
	} else if int32(t) == 'H' {
		for int32(prg.curChar) >= '0' && int32(prg.curChar) <= '9' || int32(prg.curChar) >= 'A' && int32(prg.curChar) <= 'F' {
			if int32(prg.curChar) >= 'A' {
				prg.curChar = byte(int32(prg.curChar) + '0' + 10 - 'A')
			}
			acc = acc*16 + int32(prg.curChar) - '0'
			if acc > 255 {
				{
					{
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("This value shouldn't exceed \"FF")
						prg.showErrorContext()
					}
					for {
						prg.getNext()
						if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
							break
						}
					}
				}
				// \xref[This value shouldn't...]
				acc = 0
				prg.curChar = ' '
			} else {
				prg.getNext()
			}
		}
		{
			if int32(prg.curChar) > ')' || int32(prg.curChar) < '(' {
				prg.loc = byte(int32(prg.loc) - 1)
			}
		}
	} else if int32(t) == 'F' {
		if int32(prg.curChar) == 'B' {
			acc = 2
		} else if int32(prg.curChar) == 'L' {
			acc = 4
		} else if int32(prg.curChar) != 'M' {
			acc = 18
		}
		prg.getNext()
		if int32(prg.curChar) == 'I' {
			acc = acc + 1
		} else if int32(prg.curChar) != 'R' {
			acc = 18
		}
		prg.getNext()
		if int32(prg.curChar) == 'C' {
			acc = acc + 6
		} else if int32(prg.curChar) == 'E' {
			acc = acc + 12
		} else if int32(prg.curChar) != 'R' {
			acc = 18
		}
		if acc >= 18 {
			{
				{
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("Illegal face code, I changed it to MRR")
					prg.showErrorContext()
				}
				for {
					prg.getNext()
					if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
						break
					}
				}
			}
			// \xref[Illegal face code...]
			acc = 0
		}
	} else {
		{
			if int32(prg.charsOnLine) > 0 {
				prg.stdout.Writeln(" ")
			}
			prg.stdout.Write("You need \"C\" or \"D\" or \"O\" or \"H\" or \"F\" here")
			prg.showErrorContext()
		}
		for {
			prg.getNext()
			if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
				break
			}
		}
	}
	// \xref[You need "C" or "D" ...here]
	prg.curChar = ' '
	r = byte(acc)
	return r
}

// 69.

// tangle:pos vptovf.web:1406:72:

// 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.
func (prg *prg) getFourBytes() { // scans an unsigned constant and sets |four_bytes|
	var (
		c  int32 // local two-byte accumulator
		r1 int32 // radix
	)
	for {
		prg.getNext()
		if int32(prg.curChar) != ' ' {
			break
		}
	} // skip the blanks before the type code
	r1 = 0
	prg.curBytes = prg.zeroBytes // start with the accumulator zero
	if int32(prg.curChar) == 'H' {
		r1 = 16
	} else if int32(prg.curChar) == 'O' {
		r1 = 8
	} else if int32(prg.curChar) == 'D' {
		r1 = 10
	} else {
		{
			if int32(prg.charsOnLine) > 0 {
				prg.stdout.Writeln(" ")
			}
			prg.stdout.Write("Decimal (\"D\"), octal (\"O\"), or hex (\"H\") value needed here")
			prg.showErrorContext()
		}
		for {
			prg.getNext()
			if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
				break
			}
		}
	}
	// \xref[Decimal ("D"), octal ("O"), or hex...]
	if r1 > 0 {
		for {
			prg.getNext()
			if int32(prg.curChar) != ' ' {
				break
			}
		} // skip the blanks after the type code
		for int32(prg.curChar) >= '0' && int32(prg.curChar) <= '9' || int32(prg.curChar) >= 'A' && int32(prg.curChar) <= 'F' {

			// Multiply by |r|, add |cur_char-"0"|, and |get_next|
			if int32(prg.curChar) >= 'A' {
				prg.curChar = byte(int32(prg.curChar) + '0' + 10 - 'A')
			}
			if int32(prg.curChar) >= '0'+r1 {
				{
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("Illegal digit")
					prg.showErrorContext()
				}
				for {
					prg.getNext()
					if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
						break
					}
				}
			} else {
				c = int32(prg.curBytes.b3)*r1 + int32(prg.curChar) - '0'
				prg.curBytes.b3 = byte(c % 256)

				c = int32(prg.curBytes.b2)*r1 + c/256
				prg.curBytes.b2 = byte(c % 256)

				c = int32(prg.curBytes.b1)*r1 + c/256
				prg.curBytes.b1 = byte(c % 256)

				c = int32(prg.curBytes.b0)*r1 + c/256
				if c < 256 {
					prg.curBytes.b0 = byte(c)
				} else {
					prg.curBytes = prg.zeroBytes
					if r1 == 8 {
						{
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("Sorry, the maximum octal value is O 37777777777")
							prg.showErrorContext()
						}
						for {
							prg.getNext()
							if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
								break
							}
						}
					} else if r1 == 10 {
						{
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("Sorry, the maximum decimal value is D 4294967295")
							prg.showErrorContext()
						}
						for {
							prg.getNext()
							if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
								break
							}
						}
					} else {
						{
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("Sorry, the maximum hex value is H FFFFFFFF")
							prg.showErrorContext()
						}
						for {
							prg.getNext()
							if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
								break
							}
						}
					}
				}
				prg.getNext()
			}
		}
	}
}

// 72.

// tangle:pos vptovf.web:1461:67:

// When a real value is desired, we might as well treat `\.D' and `\.R'
// formats as if they were identical.
func (prg *prg) getFix() (r fixWord) { // scans a real property value
	var (
		negative         bool  // was there a minus sign?
		acc              int32 // an accumulator
		intPart          int32 // the integer part
		j/* 0..7 */ byte       // the number of decimal places stored
	)
	for {
		prg.getNext()
		if int32(prg.curChar) != ' ' {
			break
		}
	} // skip the blanks before the type code
	negative = false
	acc = 0 // start with the accumulators zero
	if int32(prg.curChar) != 'R' && int32(prg.curChar) != 'D' {
		{
			if int32(prg.charsOnLine) > 0 {
				prg.stdout.Writeln(" ")
			}
			prg.stdout.Write("An \"R\" or \"D\" value is needed here")
			prg.showErrorContext()
		}
		for {
			prg.getNext()
			if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
				break
			}
		}
	} else {
		for {
			prg.getNext()
			if int32(prg.curChar) == '-' {
				prg.curChar = ' '
				negative = !negative
			} else if int32(prg.curChar) == '+' {
				prg.curChar = ' '
			}
			if int32(prg.curChar) != ' ' {
				break
			}
		}
		for int32(prg.curChar) >= '0' && int32(prg.curChar) <= '9' {

			// Multiply by 10, add |cur_char-"0"|, and |get_next|
			acc = acc*10 + int32(prg.curChar) - '0'
			if acc >= 2048 {
				{
					{
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("Real constants must be less than 2048")
						prg.showErrorContext()
					}
					for {
						prg.getNext()
						if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
							break
						}
					}
				}
				// \xref[Real constants must be...]
				acc = 0
				prg.curChar = ' '
			} else {
				prg.getNext()
			}
		}
		intPart = acc
		acc = 0
		if int32(prg.curChar) == '.' {
			j = 0
			prg.getNext()
			for int32(prg.curChar) >= '0' && int32(prg.curChar) <= '9' {
				if int32(j) < 7 {
					j = byte(int32(j) + 1)
					prg.fractionDigits[j-1] = 010000000 * (int32(prg.curChar) - '0')
				}
				prg.getNext()
			}
			acc = 0
			for int32(j) > 0 {
				acc = prg.fractionDigits[j-1] + acc/10
				j = byte(int32(j) - 1)
			}
			acc = (acc + 10) / 20
		}
		if acc >= 04000000 && intPart == 2047 {
			{
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Writeln(" ")
				}
				prg.stdout.Write("Real constants must be less than 2048")
				prg.showErrorContext()
			}
			for {
				prg.getNext()
				if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
					break
				}
			}
		} else {
			acc = intPart*04000000 + acc
		}
	}
	if negative {
		r = -acc
	} else {
		r = acc
	}
	return r
}

// 85.

// tangle:pos vptovf.web:1680:17:

// 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 \.[VPL] file might foolishly give any number of
// different sizes to the same character.
func (prg *prg) sortIn(h pointer, d fixWord) (r pointer) { // inserts into list
	var (
		p pointer // the current node of interest
	)
	if d == 0 && int32(h) != width {
		r = 0
	} else {
		p = h
		for d >= prg.memory[prg.link[p]] {
			p = prg.link[p]
		}
		if d == prg.memory[p] && int32(p) != int32(h) {
			r = p
		} else if int32(prg.memPtr) == memSize {
			{
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Writeln(" ")
				}
				prg.stdout.Write("Memory overflow: more than 1028 widths, etc")
				prg.showErrorContext()
			}
			// \xref[Memory overflow...]
			prg.stdout.Writeln("Congratulations! It's hard to make this error.")
			r = p
		} else {
			prg.memPtr = uint16(int32(prg.memPtr) + 1)
			prg.memory[prg.memPtr] = d
			prg.link[prg.memPtr] = prg.link[p]
			prg.link[p] = prg.memPtr
			prg.memory[h] = prg.memory[h] + 1
			r = prg.memPtr
		}
	}
	return r
}

// 87.

// tangle:pos vptovf.web:1733:67:

// Once again we can make good use of the fact that |memory[0]| is ``infinite.''
func (prg *prg) minCover(h pointer, d fixWord) (r int32) {
	var (
		p pointer // the current node of interest
		l fixWord // the least element covered by the current interval
		m int32   // the current size of the cover being generated
	)
	m = 0
	p = prg.link[h]
	prg.nextD = prg.memory[0]
	for int32(p) != 0 {
		m = m + 1
		l = prg.memory[p]
		for prg.memory[prg.link[p]] <= l+d {
			p = prg.link[p]
		}
		p = prg.link[p]
		if prg.memory[p]-l < prg.nextD {
			prg.nextD = prg.memory[p] - l
		}
	}
	r = m
	return r
}

// 88.

// tangle:pos vptovf.web:1749:5:

// 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.
func (prg *prg) shorten(h pointer, m int32) (r fixWord) { // finds best way to round
	var (
		d fixWord // the current trial interval length
		k int32   // the size of a minimum cover
	)
	if prg.memory[h] > m {
		prg.excess = byte(prg.memory[h] - m)
		k = prg.minCover(h, fixWord(0))
		d = prg.nextD // now the answer is at least |d|
		for {
			d = d + d
			k = prg.minCover(h, d)
			if k <= m {
				break
			}
		} // first we ascend rapidly until finding the range
		d = d / 2
		k = prg.minCover(h, d) // now we run through the feasible steps
		for k > m {
			d = prg.nextD
			k = prg.minCover(h, d)
		}
		r = d
	} else {
		r = 0
	}
	return r
}

// 90.

// tangle:pos vptovf.web:1778:71:

// 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.
func (prg *prg) setIndices(h pointer, d fixWord) { // 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 fixWord // least value in the current interval
	)
	q = h
	p = prg.link[q]
	m = 0
	for int32(p) != 0 {
		m = byte(int32(m) + 1)
		l = prg.memory[p]
		prg.index[p] = m
		for prg.memory[prg.link[p]] <= l+d {
			p = prg.link[p]
			prg.index[p] = m
			prg.excess = byte(int32(prg.excess) - 1)
			if int32(prg.excess) == 0 {
				d = 0
			}
		}
		prg.link[q] = p
		prg.memory[p] = l + (prg.memory[p]-l)/2
		q = p
		p = prg.link[p]
	}
	prg.memory[h] = int32(m)
}

// 93.

// tangle:pos vptovf.web:1820:22:

// The |junk_error| routine just referred to is called when something
// appears in the forbidden area between properties of a property list.
func (prg *prg) junkError() {
	{
		if int32(prg.charsOnLine) > 0 {
			prg.stdout.Writeln(" ")
		}
		prg.stdout.Write("There's junk here that is not in parentheses")
		prg.showErrorContext()
	}
	// \xref[There's junk here...]
	for {
		prg.getNext()
		if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
			break
		}
	}
}

// 96.

// tangle:pos vptovf.web:1870:4:

// The |case| statement just given makes use of three 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.
func (prg *prg) readFourBytes(l headerIndex) {
	prg.getFourBytes()
	prg.headerBytes[l] = prg.curBytes.b0
	prg.headerBytes[int32(l)+1] = prg.curBytes.b1
	prg.headerBytes[int32(l)+2] = prg.curBytes.b2
	prg.headerBytes[int32(l)+3] = prg.curBytes.b3
}

// 97.

// tangle:pos vptovf.web:1882:5:

// 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).
func (prg *prg) readBcpl(l headerIndex, n byte) {
	var (
		k headerIndex
	)
	k = l
	for int32(prg.curChar) == ' ' {
		prg.getNext()
	}
	for int32(prg.curChar) != '(' && int32(prg.curChar) != ')' {
		if int32(k) < int32(l)+int32(n) {
			k = byte(int32(k) + 1)
		}
		if int32(k) < int32(l)+int32(n) {
			prg.headerBytes[k] = prg.curChar
		}
		prg.getNext()
	}
	if int32(k) == int32(l)+int32(n) {
		{
			if int32(prg.charsOnLine) > 0 {
				prg.stdout.Writeln(" ")
			}
			prg.stdout.Write("String is too long; its first ", int32(n)-1, knuth.WriteWidth(1),
				// \xref[String is too long...]
				" characters will be kept")
			prg.showErrorContext()
		}
		k = byte(int32(k) - 1)
	}
	prg.headerBytes[l] = byte(int32(k) - int32(l))
	for int32(k) < int32(l)+int32(n)-1 { // tidy up the remaining bytes by setting them to nulls
		k = byte(int32(k) + 1)
		prg.headerBytes[k] = 0
	}
}

// 111.

// tangle:pos vptovf.web:2091:4:

// 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.
func (prg *prg) checkTag(c byte) {
	switch prg.charTag[c] {
	case noTag:
	case ligTag:
		if int32(prg.charsOnLine) > 0 {
			prg.stdout.Writeln(" ")
		}
		prg.stdout.Write("This character already appeared in a LIGTABLE LABEL")
		prg.showErrorContext()
	// \xref[This character already...]
	case listTag:
		if int32(prg.charsOnLine) > 0 {
			prg.stdout.Writeln(" ")
		}
		prg.stdout.Write("This character already has a NEXTLARGER spec")
		prg.showErrorContext()
	case extTag:
		if int32(prg.charsOnLine) > 0 {
			prg.stdout.Writeln(" ")
		}
		prg.stdout.Write("This character already has a VARCHAR spec")
		prg.showErrorContext()
	}
}

// 122. Assembling the mappings

// tangle:pos vptovf.web:2251:24:

// Each \.[MAP] property is a sequence of \.[DVI] instructions, for which
// we need to know some of the opcodes.

// 124.

// tangle:pos vptovf.web:2285:26:

// The packet is built by straightforward assembly of \.[DVI] instructions.
// Declare the |vf_fix| procedure
func (prg *prg) vfFix(opcode byte, x fixWord) {
	var (
		negative         bool
		k/* 0..4 */ byte       // number of bytes to typeset
		t                int32 // threshold
	)
	prg.frozenDu = true
	if prg.designUnits != 04000000 {
		x = round(float64(x) / float64(prg.designUnits) * 1048576.0)
	}
	if x >= 0 {
		negative = false
	} else {
		negative = true
		x = -1 - x
	}
	if int32(opcode) == 0 {
		k = 4
		t = 0100000000
	} else {
		t = 127
		k = 1
		for x > t {
			t = 256*t + 255
			k = byte(int32(k) + 1)
		}
		{
			prg.vf[prg.vfPtr] = byte(int32(opcode) + int32(k) - 1)
			if int32(prg.vfPtr) == vfSize {
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Writeln(" ")
				}
				prg.stdout.Write("I'm out of memory---increase my vfsize!")
				prg.showErrorContext()
			} else {
				prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
			}
		}
		t = t/128 + 1
	}
	for {
		if negative {
			{
				prg.vf[prg.vfPtr] = byte(255 - x/t)
				if int32(prg.vfPtr) == vfSize {
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("I'm out of memory---increase my vfsize!")
					prg.showErrorContext()
				} else {
					prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
				}
			}
			negative = false
			x = x/t*t + t - 1 - x
		} else {
			prg.vf[prg.vfPtr] = byte(x / t % 256)
			if int32(prg.vfPtr) == vfSize {
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Writeln(" ")
				}
				prg.stdout.Write("I'm out of memory---increase my vfsize!")
				prg.showErrorContext()
			} else {
				prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
			}
		}
		k = byte(int32(k) - 1)
		t = t / 256
		if int32(k) == 0 {
			break
		}
	}
}

func (prg *prg) readPacket(c byte) {
	var (
		cc                                 byte    // character being typeset
		x                                  fixWord // movement
		h, v/* 0..2 */ byte                        // top of |hstack| and |vstack|
		specialStart/* 0..vfSize */ uint16         // location of |xxx1| command
		k/* 0..vfSize */ uint16                    // loop index
	)
	prg.packetStart[c] = prg.vfPtr
	prg.stackPtr = 0
	h = 0
	v = 0
	prg.curFont = 0
	for prg.level == 2 {
		for int32(prg.curChar) == ' ' {
			prg.getNext()
		}
		if int32(prg.curChar) == '(' {
			prg.getName()
			if int32(prg.curCode) == commentCode {
				prg.skipToEndOfItem()
			} else if int32(prg.curCode) < selectFontCode || int32(prg.curCode) > specialHexCode {
				{
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("This property name doesn't belong in a MAP list")
					prg.showErrorContext()
				}
				prg.skipToEndOfItem()
			} else {
				switch prg.curCode {
				case selectFontCode:
					// Assemble a font selection
					prg.getFourBytes()
					prg.fontNumber[prg.fontPtr] = prg.curBytes
					prg.curFont = 0
					for int32(prg.fontNumber[prg.curFont].b3) != int32(prg.fontNumber[prg.fontPtr].b3) || int32(prg.fontNumber[prg.curFont].b2) != int32(prg.fontNumber[prg.fontPtr].b2) || int32(prg.fontNumber[prg.curFont].b1) != int32(prg.fontNumber[prg.fontPtr].b1) || int32(prg.fontNumber[prg.curFont].b0) != int32(prg.fontNumber[prg.fontPtr].b0) {
						prg.curFont = uint16(int32(prg.curFont) + 1)
					}
					if int32(prg.curFont) == int32(prg.fontPtr) {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("Undefined MAPFONT cannot be selected")
						prg.showErrorContext()
					} else if int32(prg.curFont) < 64 {
						prg.vf[prg.vfPtr] = byte(fntNum0 + int32(prg.curFont))
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					} else {
						{
							prg.vf[prg.vfPtr] = byte(fnt1)
							if int32(prg.vfPtr) == vfSize {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("I'm out of memory---increase my vfsize!")
								prg.showErrorContext()
							} else {
								prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
							}
						}
						{
							prg.vf[prg.vfPtr] = byte(prg.curFont)
							if int32(prg.vfPtr) == vfSize {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("I'm out of memory---increase my vfsize!")
								prg.showErrorContext()
							} else {
								prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
							}
						}
					}

				case setCharCode:
					// Assemble a typesetting instruction
					if int32(prg.curFont) == int32(prg.fontPtr) {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("Character cannot be typeset in undefined font")
						prg.showErrorContext()
					} else {
						cc = prg.getByte()
						if int32(cc) >= 128 {
							prg.vf[prg.vfPtr] = byte(set1)
							if int32(prg.vfPtr) == vfSize {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("I'm out of memory---increase my vfsize!")
								prg.showErrorContext()
							} else {
								prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
							}
						}
						{
							prg.vf[prg.vfPtr] = cc
							if int32(prg.vfPtr) == vfSize {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("I'm out of memory---increase my vfsize!")
								prg.showErrorContext()
							} else {
								prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
							}
						}
					}

				case setRuleCode:
					// Assemble a rulesetting instruction
					{
						prg.vf[prg.vfPtr] = byte(setRule)
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					}
					prg.vfFix(byte(0), prg.getFix())
					prg.vfFix(byte(0), prg.getFix())

				case moveRightCode, moveRightCode + 1:
					// Assemble a horizontal movement
					if int32(prg.curCode) == moveRightCode {
						x = prg.getFix()
					} else {
						x = -prg.getFix()
					}
					if int32(h) == 0 {
						prg.wstack[prg.stackPtr] = x
						h = 1
						prg.vfFix(byte(w1), x)
					} else if x == prg.wstack[prg.stackPtr] {
						prg.vf[prg.vfPtr] = byte(w0)
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					} else if int32(h) == 1 {
						prg.xstack[prg.stackPtr] = x
						h = 2
						prg.vfFix(byte(x1), x)
					} else if x == prg.xstack[prg.stackPtr] {
						prg.vf[prg.vfPtr] = byte(x0)
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					} else {
						prg.vfFix(byte(right1), x)
					}

				case moveDownCode, moveDownCode + 1:
					// Assemble a vertical movement
					if int32(prg.curCode) == moveDownCode {
						x = prg.getFix()
					} else {
						x = -prg.getFix()
					}
					if int32(v) == 0 {
						prg.ystack[prg.stackPtr] = x
						v = 1
						prg.vfFix(byte(y1), x)
					} else if x == prg.ystack[prg.stackPtr] {
						prg.vf[prg.vfPtr] = byte(y0)
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					} else if int32(v) == 1 {
						prg.zstack[prg.stackPtr] = x
						v = 2
						prg.vfFix(byte(z1), x)
					} else if x == prg.zstack[prg.stackPtr] {
						prg.vf[prg.vfPtr] = byte(z0)
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					} else {
						prg.vfFix(byte(down1), x)
					}

				case pushCode:
					// Assemble a stack push
					if int32(prg.stackPtr) == maxStack {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("Don't push so much---stack is full!")
						prg.showErrorContext()
					} else {
						{
							prg.vf[prg.vfPtr] = byte(push)
							if int32(prg.vfPtr) == vfSize {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("I'm out of memory---increase my vfsize!")
								prg.showErrorContext()
							} else {
								prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
							}
						}
						prg.hstack[prg.stackPtr] = h
						prg.vstack[prg.stackPtr] = v
						prg.stackPtr = byte(int32(prg.stackPtr) + 1)
						h = 0
						v = 0
					}

				case popCode:
					// Assemble a stack pop
					if int32(prg.stackPtr) == 0 {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("Empty stack cannot be popped")
						prg.showErrorContext()
					} else {
						{
							prg.vf[prg.vfPtr] = byte(pop)
							if int32(prg.vfPtr) == vfSize {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("I'm out of memory---increase my vfsize!")
								prg.showErrorContext()
							} else {
								prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
							}
						}
						prg.stackPtr = byte(int32(prg.stackPtr) - 1)
						h = prg.hstack[prg.stackPtr]
						v = prg.vstack[prg.stackPtr]
					}

				case specialCode, specialHexCode:
					// Assemble a special command
					{
						prg.vf[prg.vfPtr] = byte(xxx1)
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					}
					{
						prg.vf[prg.vfPtr] = 0
						if int32(prg.vfPtr) == vfSize {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I'm out of memory---increase my vfsize!")
							prg.showErrorContext()
						} else {
							prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
						}
					} // dummy length
					specialStart = prg.vfPtr
					if int32(prg.curCode) == specialCode {
						prg.copyToEndOfItem()
					} else {
						for {
							x = int32(prg.getHex())
							if int32(prg.curChar) > ')' {
								prg.vf[prg.vfPtr] = byte(x*16 + int32(prg.getHex()))
								if int32(prg.vfPtr) == vfSize {
									if int32(prg.charsOnLine) > 0 {
										prg.stdout.Writeln(" ")
									}
									prg.stdout.Write("I'm out of memory---increase my vfsize!")
									prg.showErrorContext()
								} else {
									prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
								}
							}
							if int32(prg.curChar) <= ')' {
								break
							}
						}
					}
					if int32(prg.vfPtr)-int32(specialStart) > 255 {
						if int32(prg.vfPtr)+3 > vfSize {
							{
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("Special command being clipped---no room left!")
								prg.showErrorContext()
							}
							// \xref[Special command being clipped...]
							prg.vfPtr = uint16(int32(specialStart) + 255)
							prg.vf[int32(specialStart)-1] = 255
						} else {
							for ii := int32(prg.vfPtr); ii >= int32(specialStart); ii-- {
								k = uint16(ii)
								_ = k
								prg.vf[int32(k)+3] = prg.vf[k]
							}
							x = int32(prg.vfPtr) - int32(specialStart)
							prg.vfPtr = uint16(int32(prg.vfPtr) + 3)
							prg.vf[int32(specialStart)-2] = byte(xxx4)
							prg.vf[int32(specialStart)-1] = byte(x / 0100000000)
							prg.vf[specialStart] = byte(x / 0200000 % 256)
							prg.vf[int32(specialStart)+1] = byte(x / 0400 % 256)
							prg.vf[int32(specialStart)+2] = byte(x % 256)
						}
					} else {
						prg.vf[int32(specialStart)-1] = byte(int32(prg.vfPtr) - int32(specialStart))
					}

				}

				prg.finishTheProperty()
			}
		} else if int32(prg.curChar) == ')' {
			prg.skipToEndOfItem()
		} else {
			prg.junkError()
		}
	}
	for int32(prg.stackPtr) > 0 {
		{
			if int32(prg.charsOnLine) > 0 {
				prg.stdout.Writeln(" ")
			}
			prg.stdout.Write("Missing POP supplied")
			prg.showErrorContext()
		}
		// \xref[Missing POP supplied]
		{
			prg.vf[prg.vfPtr] = byte(pop)
			if int32(prg.vfPtr) == vfSize {
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Writeln(" ")
				}
				prg.stdout.Write("I'm out of memory---increase my vfsize!")
				prg.showErrorContext()
			} else {
				prg.vfPtr = uint16(int32(prg.vfPtr) + 1)
			}
		}
		prg.stackPtr = byte(int32(prg.stackPtr) - 1)
	}
	prg.packetLength[c] = int32(prg.vfPtr) - int32(prg.packetStart[c])
	{
		prg.loc = byte(int32(prg.loc) - 1)
		prg.level = prg.level + 1
		prg.curChar = ')'
	}
}

// 136.

// tangle:pos vptovf.web:2449:6:

// The input routine is now complete except for the following code,
// which prints a progress report as the file is being read.
func (prg *prg) printOctal(c byte) {
	prg.stdout.Write("'", int32(c)/64, knuth.WriteWidth(1), int32(c)/8%8, knuth.WriteWidth(1), int32(c)%8, knuth.WriteWidth(1))
}

// 146.

// tangle:pos vptovf.web:2579:4:

// 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.

// 150.

// tangle:pos vptovf.web:2630:4:

// 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.
func (prg *prg) hashInput(p, c indx) (r bool) { // go here for a quick exit
	var (
		cc/* simple..bothZ */ byte       // class of data being entered
		zz/* 0..255 */ byte              // function value or ligature character being entered
		y/* 0..255 */ byte               // the character after the cursor
		key                        int32 // value to be stored in |hash|
		t                          int32 // temporary register for swapping
	)
	if int32(prg.hashPtr) == hashSize {
		r = false
		goto _30
	}

	// Compute the command parameters |y|, |cc|, and |zz|
	y = prg.ligKern[p].b1
	t = int32(prg.ligKern[p].b2)
	cc = byte(simple)
	zz = prg.ligKern[p].b3
	if t >= kernFlag {
		zz = y
	} else {
		switch t {
		case 0, 6: // \.[LIG],\.[/LIG>]
		case 5, 11:
			zz = y // \.[LIG/>], \.[/LIG/>>]
		case 1, 7:
			cc = byte(leftZ) // \.[LIG/], \.[/LIG/>]
		case 2:
			cc = byte(rightZ) // \.[/LIG]
		case 3:
			cc = byte(bothZ) // \.[/LIG/]
		} // there are no other cases
	}
	key = 256*int32(c) + int32(y) + 1
	prg.h = uint16(1009 * key % hashSize)
	for int32(prg.hash[prg.h]) > 0 {
		if int32(prg.hash[prg.h]) <= key {
			if int32(prg.hash[prg.h]) == key {
				r = false
				goto _30 // unused ligature command
			}
			t = int32(prg.hash[prg.h])
			prg.hash[prg.h] = uint32(key)
			key = t // do ordered-hash-table insertion
			t = int32(prg.class[prg.h])
			prg.class[prg.h] = cc
			cc = byte(t) // namely, do a swap
			t = int32(prg.ligZ[prg.h])
			prg.ligZ[prg.h] = uint16(zz)
			zz = byte(t)
		}
		if int32(prg.h) > 0 {
			prg.h = uint16(int32(prg.h) - 1)
		} else {
			prg.h = uint16(hashSize)
		}
	}
	prg.hash[prg.h] = uint32(key)
	prg.class[prg.h] = cc
	prg.ligZ[prg.h] = uint16(zz)
	prg.hashPtr = uint16(int32(prg.hashPtr) + 1)
	prg.hashList[prg.hashPtr] = prg.h
	r = true
_30:
	;
	return r
} // \2
// compute $f$ for arguments known to be in |hash[h]|
func (prg *prg) eval(x, y indx) (r indx) { // compute $f(x,y)$ with hashtable lookup
	var (
		key int32 // value sought in hash table
	)
	key = 256*int32(x) + int32(y) + 1
	prg.h = uint16(1009 * key % hashSize)
	for int32(prg.hash[prg.h]) > key {
		if int32(prg.h) > 0 {
			prg.h = uint16(int32(prg.h) - 1)
		} else {
			prg.h = uint16(hashSize)
		}
	}
	if int32(prg.hash[prg.h]) < key {
		r = y
	} else {
		r = prg.f(prg.h, x, y)
	}
	return r
}

// 152.

// tangle:pos vptovf.web:2675:6:

// (More good stuff from \.[TFtoPL].)
func (prg *prg) f(h, x, y indx) (r indx) {
	switch prg.class[h] {
	case simple:
	case leftZ:
		prg.class[h] = byte(pending)
		prg.ligZ[h] = prg.eval(prg.ligZ[h], y)
		prg.class[h] = byte(simple)

	case rightZ:
		prg.class[h] = byte(pending)
		prg.ligZ[h] = prg.eval(x, prg.ligZ[h])
		prg.class[h] = byte(simple)

	case bothZ:
		prg.class[h] = byte(pending)
		prg.ligZ[h] = prg.eval(prg.eval(x, prg.ligZ[h]), y)
		prg.class[h] = byte(simple)

	case pending:
		prg.xLigCycle = x
		prg.yLigCycle = y
		prg.ligZ[h] = 257
		prg.class[h] = byte(simple)
		// the value 257 will break all cycles, since it's not in |hash|
	} // there are no other cases
	r = prg.ligZ[h]
	return r
}

// 156. The TFM output phase

// tangle:pos vptovf.web:2771:21:

// Now that we know how to get all of the font data correctly stored in
// \.[VPtoVF]'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:

// 165.

// tangle:pos vptovf.web:2885:6:

// 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|.
func (prg *prg) outScaled(x fixWord) { // outputs a scaled |fix_word|
	var (
		n                      byte // the first byte after the sign
		m/* 0..65535 */ uint16      // the two least significant bytes
	)
	if fabs(float64(x)/float64(prg.designUnits)) >= 16.0 {
		prg.stdout.Writeln("The relative dimension ", float64(x)/float64(04000000), knuth.WriteWidth(1), knuth.WriteWidth(3),
			" is too large.")
		// \xref[The relative dimension...]
		prg.stdout.Write("  (Must be less than 16*designsize")
		if prg.designUnits != 04000000 {
			prg.stdout.Write(" =", float64(prg.designUnits)/float64(0200000), knuth.WriteWidth(1), knuth.WriteWidth(3),
				" designunits")
		}
		prg.stdout.Writeln(")")
		x = 0
	}
	if prg.designUnits != 04000000 {
		x = round(float64(x) / float64(prg.designUnits) * 1048576.0)
	}
	if x < 0 {
		prg.tfmFile.Write(255)
		x = x + 0100000000
		if x <= 0 {
			x = 1
		}
	} else {
		prg.tfmFile.Write(0)
		if x >= 0100000000 {
			x = 077777777
		}
	}
	n = byte(x / 0200000)
	m = uint16(x % 0200000)
	prg.tfmFile.Write(n)
	prg.tfmFile.Write(int32(m) / 256)
	prg.tfmFile.Write(int32(m) % 256)
}

// 176.

// tangle:pos vptovf.web:3049:57:

// We need a routine to output integers as four bytes. Negative values
// will never be less than $-2^[24]$.
func (prg *prg) voutInt(x int32) {
	if x >= 0 {
		prg.vfFile.Write(x / 0100000000)
	} else {
		prg.vfFile.Write(255)
		x = x + 0100000000
	}
	prg.vfFile.Write(x / 0200000 % 256)
	prg.vfFile.Write(x / 0400 % 256)
	prg.vfFile.Write(x % 256)
}

// 180. The main program

// tangle:pos vptovf.web:3109:17:

// 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.
func (prg *prg) paramEnter() {
	prg.nameLength = 5
	prg.curName[16-1] = 'S'
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'A'
	prg.curName[19-1] = 'N'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(parameterCode + 1))

	prg.nameLength = 5
	prg.curName[16-1] = 'S'
	prg.curName[17-1] = 'P'
	prg.curName[18-1] = 'A'
	prg.curName[19-1] = 'C'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(parameterCode + 2))

	prg.nameLength = 7
	prg.curName[14-1] = 'S'
	prg.curName[15-1] = 'T'
	prg.curName[16-1] = 'R'
	prg.curName[17-1] = 'E'
	prg.curName[18-1] = 'T'
	prg.curName[19-1] = 'C'
	prg.curName[20-1] = 'H'
	prg.enterName(byte(parameterCode + 3))

	prg.nameLength = 6
	prg.curName[15-1] = 'S'
	prg.curName[16-1] = 'H'
	prg.curName[17-1] = 'R'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'N'
	prg.curName[20-1] = 'K'
	prg.enterName(byte(parameterCode + 4))

	prg.nameLength = 7
	prg.curName[14-1] = 'X'
	prg.curName[15-1] = 'H'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'G'
	prg.curName[19-1] = 'H'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(parameterCode + 5))

	prg.nameLength = 4
	prg.curName[17-1] = 'Q'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'D'
	prg.enterName(byte(parameterCode + 6))

	prg.nameLength = 10
	prg.curName[11-1] = 'E'
	prg.curName[12-1] = 'X'
	prg.curName[13-1] = 'T'
	prg.curName[14-1] = 'R'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'S'
	prg.curName[17-1] = 'P'
	prg.curName[18-1] = 'A'
	prg.curName[19-1] = 'C'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(parameterCode + 7))

	prg.nameLength = 4
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = '1'
	prg.enterName(byte(parameterCode + 8))

	prg.nameLength = 4
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = '2'
	prg.enterName(byte(parameterCode + 9))

	prg.nameLength = 4
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = '3'
	prg.enterName(byte(parameterCode + 10))

	prg.nameLength = 6
	prg.curName[15-1] = 'D'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'O'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = '1'
	prg.enterName(byte(parameterCode + 11))

	prg.nameLength = 6
	prg.curName[15-1] = 'D'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'O'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = '2'
	prg.enterName(byte(parameterCode + 12))

	prg.nameLength = 4
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'P'
	prg.curName[20-1] = '1'
	prg.enterName(byte(parameterCode + 13))

	prg.nameLength = 4
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'P'
	prg.curName[20-1] = '2'
	prg.enterName(byte(parameterCode + 14))

	prg.nameLength = 4
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'P'
	prg.curName[20-1] = '3'
	prg.enterName(byte(parameterCode + 15))

	prg.nameLength = 4
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'B'
	prg.curName[20-1] = '1'
	prg.enterName(byte(parameterCode + 16))

	prg.nameLength = 4
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'B'
	prg.curName[20-1] = '2'
	prg.enterName(byte(parameterCode + 17))

	prg.nameLength = 7
	prg.curName[14-1] = 'S'
	prg.curName[15-1] = 'U'
	prg.curName[16-1] = 'P'
	prg.curName[17-1] = 'D'
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'O'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(parameterCode + 18))

	prg.nameLength = 7
	prg.curName[14-1] = 'S'
	prg.curName[15-1] = 'U'
	prg.curName[16-1] = 'B'
	prg.curName[17-1] = 'D'
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'O'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(parameterCode + 19))

	prg.nameLength = 6
	prg.curName[15-1] = 'D'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = '1'
	prg.enterName(byte(parameterCode + 20))

	prg.nameLength = 6
	prg.curName[15-1] = 'D'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = '2'
	prg.enterName(byte(parameterCode + 21))

	prg.nameLength = 10
	prg.curName[11-1] = 'A'
	prg.curName[12-1] = 'X'
	prg.curName[13-1] = 'I'
	prg.curName[14-1] = 'S'
	prg.curName[15-1] = 'H'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'G'
	prg.curName[19-1] = 'H'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(parameterCode + 22))

	prg.nameLength = 20
	prg.curName[1-1] = 'D'
	prg.curName[2-1] = 'E'
	prg.curName[3-1] = 'F'
	prg.curName[4-1] = 'A'
	prg.curName[5-1] = 'U'
	prg.curName[6-1] = 'L'
	prg.curName[7-1] = 'T'
	prg.curName[8-1] = 'R'
	prg.curName[9-1] = 'U'
	prg.curName[10-1] = 'L'
	prg.curName[11-1] = 'E'
	prg.curName[12-1] = 'T'
	prg.curName[13-1] = 'H'
	prg.curName[14-1] = 'I'
	prg.curName[15-1] = 'C'
	prg.curName[16-1] = 'K'
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'E'
	prg.curName[19-1] = 'S'
	prg.curName[20-1] = 'S'
	prg.enterName(byte(parameterCode + 8))

	prg.nameLength = 13
	prg.curName[8-1] = 'B'
	prg.curName[9-1] = 'I'
	prg.curName[10-1] = 'G'
	prg.curName[11-1] = 'O'
	prg.curName[12-1] = 'P'
	prg.curName[13-1] = 'S'
	prg.curName[14-1] = 'P'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'N'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '1'
	prg.enterName(byte(parameterCode + 9))

	prg.nameLength = 13
	prg.curName[8-1] = 'B'
	prg.curName[9-1] = 'I'
	prg.curName[10-1] = 'G'
	prg.curName[11-1] = 'O'
	prg.curName[12-1] = 'P'
	prg.curName[13-1] = 'S'
	prg.curName[14-1] = 'P'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'N'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '2'
	prg.enterName(byte(parameterCode + 10))

	prg.nameLength = 13
	prg.curName[8-1] = 'B'
	prg.curName[9-1] = 'I'
	prg.curName[10-1] = 'G'
	prg.curName[11-1] = 'O'
	prg.curName[12-1] = 'P'
	prg.curName[13-1] = 'S'
	prg.curName[14-1] = 'P'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'N'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '3'
	prg.enterName(byte(parameterCode + 11))

	prg.nameLength = 13
	prg.curName[8-1] = 'B'
	prg.curName[9-1] = 'I'
	prg.curName[10-1] = 'G'
	prg.curName[11-1] = 'O'
	prg.curName[12-1] = 'P'
	prg.curName[13-1] = 'S'
	prg.curName[14-1] = 'P'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'N'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '4'
	prg.enterName(byte(parameterCode + 12))

	prg.nameLength = 13
	prg.curName[8-1] = 'B'
	prg.curName[9-1] = 'I'
	prg.curName[10-1] = 'G'
	prg.curName[11-1] = 'O'
	prg.curName[12-1] = 'P'
	prg.curName[13-1] = 'S'
	prg.curName[14-1] = 'P'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'N'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '5'
	prg.enterName(byte(parameterCode + 13))

}

func (prg *prg) vplEnter() {
	prg.nameLength = 6
	prg.curName[15-1] = 'V'
	prg.curName[16-1] = 'T'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'T'
	prg.curName[19-1] = 'L'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(virtualTitleCode))

	prg.nameLength = 7
	prg.curName[14-1] = 'M'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'P'
	prg.curName[17-1] = 'F'
	prg.curName[18-1] = 'O'
	prg.curName[19-1] = 'N'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(mapFontCode))

	prg.nameLength = 3
	prg.curName[18-1] = 'M'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(mapCode))

	prg.nameLength = 8
	prg.curName[13-1] = 'F'
	prg.curName[14-1] = 'O'
	prg.curName[15-1] = 'N'
	prg.curName[16-1] = 'T'
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'A'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(fontNameCode))

	prg.nameLength = 8
	prg.curName[13-1] = 'F'
	prg.curName[14-1] = 'O'
	prg.curName[15-1] = 'N'
	prg.curName[16-1] = 'T'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'A'
	prg.enterName(byte(fontAreaCode))

	prg.nameLength = 12
	prg.curName[9-1] = 'F'
	prg.curName[10-1] = 'O'
	prg.curName[11-1] = 'N'
	prg.curName[12-1] = 'T'
	prg.curName[13-1] = 'C'
	prg.curName[14-1] = 'H'
	prg.curName[15-1] = 'E'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'K'
	prg.curName[18-1] = 'S'
	prg.curName[19-1] = 'U'
	prg.curName[20-1] = 'M'
	prg.enterName(byte(fontChecksumCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'F'
	prg.curName[16-1] = 'O'
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'T'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(fontAtCode))

	prg.nameLength = 9
	prg.curName[12-1] = 'F'
	prg.curName[13-1] = 'O'
	prg.curName[14-1] = 'N'
	prg.curName[15-1] = 'T'
	prg.curName[16-1] = 'D'
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'Z'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(fontDsizeCode))

	prg.nameLength = 10
	prg.curName[11-1] = 'S'
	prg.curName[12-1] = 'E'
	prg.curName[13-1] = 'L'
	prg.curName[14-1] = 'E'
	prg.curName[15-1] = 'C'
	prg.curName[16-1] = 'T'
	prg.curName[17-1] = 'F'
	prg.curName[18-1] = 'O'
	prg.curName[19-1] = 'N'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(selectFontCode))

	prg.nameLength = 7
	prg.curName[14-1] = 'S'
	prg.curName[15-1] = 'E'
	prg.curName[16-1] = 'T'
	prg.curName[17-1] = 'C'
	prg.curName[18-1] = 'H'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'R'
	prg.enterName(byte(setCharCode))

	prg.nameLength = 7
	prg.curName[14-1] = 'S'
	prg.curName[15-1] = 'E'
	prg.curName[16-1] = 'T'
	prg.curName[17-1] = 'R'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'L'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(setRuleCode))

	prg.nameLength = 9
	prg.curName[12-1] = 'M'
	prg.curName[13-1] = 'O'
	prg.curName[14-1] = 'V'
	prg.curName[15-1] = 'E'
	prg.curName[16-1] = 'R'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'G'
	prg.curName[19-1] = 'H'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(moveRightCode))

	prg.nameLength = 8
	prg.curName[13-1] = 'M'
	prg.curName[14-1] = 'O'
	prg.curName[15-1] = 'V'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'E'
	prg.curName[19-1] = 'F'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(moveRightCode + 1))

	prg.nameLength = 8
	prg.curName[13-1] = 'M'
	prg.curName[14-1] = 'O'
	prg.curName[15-1] = 'V'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'D'
	prg.curName[18-1] = 'O'
	prg.curName[19-1] = 'W'
	prg.curName[20-1] = 'N'
	prg.enterName(byte(moveDownCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'M'
	prg.curName[16-1] = 'O'
	prg.curName[17-1] = 'V'
	prg.curName[18-1] = 'E'
	prg.curName[19-1] = 'U'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(moveDownCode + 1))

	prg.nameLength = 4
	prg.curName[17-1] = 'P'
	prg.curName[18-1] = 'U'
	prg.curName[19-1] = 'S'
	prg.curName[20-1] = 'H'
	prg.enterName(byte(pushCode))

	prg.nameLength = 3
	prg.curName[18-1] = 'P'
	prg.curName[19-1] = 'O'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(popCode))

	prg.nameLength = 7
	prg.curName[14-1] = 'S'
	prg.curName[15-1] = 'P'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'C'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'L'
	prg.enterName(byte(specialCode))

	prg.nameLength = 10
	prg.curName[11-1] = 'S'
	prg.curName[12-1] = 'P'
	prg.curName[13-1] = 'E'
	prg.curName[14-1] = 'C'
	prg.curName[15-1] = 'I'
	prg.curName[16-1] = 'A'
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'H'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'X'
	prg.enterName(byte(specialHexCode))

}

func (prg *prg) nameEnter() {
	prg.equiv[0] = byte(commentCode) // this is used after unknown keywords
	prg.nameLength = 8
	prg.curName[13-1] = 'C'
	prg.curName[14-1] = 'H'
	prg.curName[15-1] = 'E'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'K'
	prg.curName[18-1] = 'S'
	prg.curName[19-1] = 'U'
	prg.curName[20-1] = 'M'
	prg.enterName(byte(checkSumCode))

	prg.nameLength = 10
	prg.curName[11-1] = 'D'
	prg.curName[12-1] = 'E'
	prg.curName[13-1] = 'S'
	prg.curName[14-1] = 'I'
	prg.curName[15-1] = 'G'
	prg.curName[16-1] = 'N'
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'Z'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(designSizeCode))

	prg.nameLength = 11
	prg.curName[10-1] = 'D'
	prg.curName[11-1] = 'E'
	prg.curName[12-1] = 'S'
	prg.curName[13-1] = 'I'
	prg.curName[14-1] = 'G'
	prg.curName[15-1] = 'N'
	prg.curName[16-1] = 'U'
	prg.curName[17-1] = 'N'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'T'
	prg.curName[20-1] = 'S'
	prg.enterName(byte(designUnitsCode))

	prg.nameLength = 12
	prg.curName[9-1] = 'C'
	prg.curName[10-1] = 'O'
	prg.curName[11-1] = 'D'
	prg.curName[12-1] = 'I'
	prg.curName[13-1] = 'N'
	prg.curName[14-1] = 'G'
	prg.curName[15-1] = 'S'
	prg.curName[16-1] = 'C'
	prg.curName[17-1] = 'H'
	prg.curName[18-1] = 'E'
	prg.curName[19-1] = 'M'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(codingSchemeCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'F'
	prg.curName[16-1] = 'A'
	prg.curName[17-1] = 'M'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'L'
	prg.curName[20-1] = 'Y'
	prg.enterName(byte(familyCode))

	prg.nameLength = 4
	prg.curName[17-1] = 'F'
	prg.curName[18-1] = 'A'
	prg.curName[19-1] = 'C'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(faceCode))

	prg.nameLength = 16
	prg.curName[5-1] = 'S'
	prg.curName[6-1] = 'E'
	prg.curName[7-1] = 'V'
	prg.curName[8-1] = 'E'
	prg.curName[9-1] = 'N'
	prg.curName[10-1] = 'B'
	prg.curName[11-1] = 'I'
	prg.curName[12-1] = 'T'
	prg.curName[13-1] = 'S'
	prg.curName[14-1] = 'A'
	prg.curName[15-1] = 'F'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'F'
	prg.curName[18-1] = 'L'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'G'
	prg.enterName(byte(sevenBitSafeFlagCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'H'
	prg.curName[16-1] = 'E'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'D'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'R'
	prg.enterName(byte(headerCode))

	prg.nameLength = 9
	prg.curName[12-1] = 'F'
	prg.curName[13-1] = 'O'
	prg.curName[14-1] = 'N'
	prg.curName[15-1] = 'T'
	prg.curName[16-1] = 'D'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'M'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'N'
	prg.enterName(byte(fontDimenCode))

	prg.nameLength = 8
	prg.curName[13-1] = 'L'
	prg.curName[14-1] = 'I'
	prg.curName[15-1] = 'G'
	prg.curName[16-1] = 'T'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'B'
	prg.curName[19-1] = 'L'
	prg.curName[20-1] = 'E'
	prg.enterName(byte(ligTableCode))

	prg.nameLength = 12
	prg.curName[9-1] = 'B'
	prg.curName[10-1] = 'O'
	prg.curName[11-1] = 'U'
	prg.curName[12-1] = 'N'
	prg.curName[13-1] = 'D'
	prg.curName[14-1] = 'A'
	prg.curName[15-1] = 'R'
	prg.curName[16-1] = 'Y'
	prg.curName[17-1] = 'C'
	prg.curName[18-1] = 'H'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'R'
	prg.enterName(byte(boundaryCharCode))

	prg.nameLength = 9
	prg.curName[12-1] = 'C'
	prg.curName[13-1] = 'H'
	prg.curName[14-1] = 'A'
	prg.curName[15-1] = 'R'
	prg.curName[16-1] = 'A'
	prg.curName[17-1] = 'C'
	prg.curName[18-1] = 'T'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'R'
	prg.enterName(byte(characterCode))

	prg.nameLength = 9
	prg.curName[12-1] = 'P'
	prg.curName[13-1] = 'A'
	prg.curName[14-1] = 'R'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'M'
	prg.curName[17-1] = 'E'
	prg.curName[18-1] = 'T'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'R'
	prg.enterName(byte(parameterCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'C'
	prg.curName[16-1] = 'H'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'W'
	prg.curName[20-1] = 'D'
	prg.enterName(byte(charWdCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'C'
	prg.curName[16-1] = 'H'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'H'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(charHtCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'C'
	prg.curName[16-1] = 'H'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'D'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(charDpCode))

	prg.nameLength = 6
	prg.curName[15-1] = 'C'
	prg.curName[16-1] = 'H'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'I'
	prg.curName[20-1] = 'C'
	prg.enterName(byte(charIcCode))

	prg.nameLength = 10
	prg.curName[11-1] = 'N'
	prg.curName[12-1] = 'E'
	prg.curName[13-1] = 'X'
	prg.curName[14-1] = 'T'
	prg.curName[15-1] = 'L'
	prg.curName[16-1] = 'A'
	prg.curName[17-1] = 'R'
	prg.curName[18-1] = 'G'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'R'
	prg.enterName(byte(nextLargerCode))

	prg.nameLength = 7
	prg.curName[14-1] = 'V'
	prg.curName[15-1] = 'A'
	prg.curName[16-1] = 'R'
	prg.curName[17-1] = 'C'
	prg.curName[18-1] = 'H'
	prg.curName[19-1] = 'A'
	prg.curName[20-1] = 'R'
	prg.enterName(byte(varCharCode))

	prg.nameLength = 3
	prg.curName[18-1] = 'T'
	prg.curName[19-1] = 'O'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(varCharCode + 1))

	prg.nameLength = 3
	prg.curName[18-1] = 'M'
	prg.curName[19-1] = 'I'
	prg.curName[20-1] = 'D'
	prg.enterName(byte(varCharCode + 2))

	prg.nameLength = 3
	prg.curName[18-1] = 'B'
	prg.curName[19-1] = 'O'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(varCharCode + 3))

	prg.nameLength = 3
	prg.curName[18-1] = 'R'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(varCharCode + 4))

	prg.nameLength = 3
	prg.curName[18-1] = 'E'
	prg.curName[19-1] = 'X'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(varCharCode + 4)) // compatibility with older \.[PL] format
	prg.nameLength = 7
	prg.curName[14-1] = 'C'
	prg.curName[15-1] = 'O'
	prg.curName[16-1] = 'M'
	prg.curName[17-1] = 'M'
	prg.curName[18-1] = 'E'
	prg.curName[19-1] = 'N'
	prg.curName[20-1] = 'T'
	prg.enterName(byte(commentCode))

	prg.nameLength = 5
	prg.curName[16-1] = 'L'
	prg.curName[17-1] = 'A'
	prg.curName[18-1] = 'B'
	prg.curName[19-1] = 'E'
	prg.curName[20-1] = 'L'
	prg.enterName(byte(labelCode))

	prg.nameLength = 4
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'T'
	prg.curName[19-1] = 'O'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(stopCode))

	prg.nameLength = 4
	prg.curName[17-1] = 'S'
	prg.curName[18-1] = 'K'
	prg.curName[19-1] = 'I'
	prg.curName[20-1] = 'P'
	prg.enterName(byte(skipCode))

	prg.nameLength = 3
	prg.curName[18-1] = 'K'
	prg.curName[19-1] = 'R'
	prg.curName[20-1] = 'N'
	prg.enterName(byte(krnCode))

	prg.nameLength = 3
	prg.curName[18-1] = 'L'
	prg.curName[19-1] = 'I'
	prg.curName[20-1] = 'G'
	prg.enterName(byte(ligCode))

	prg.nameLength = 4
	prg.curName[17-1] = '/'
	prg.curName[18-1] = 'L'
	prg.curName[19-1] = 'I'
	prg.curName[20-1] = 'G'
	prg.enterName(byte(ligCode + 2))

	prg.nameLength = 5
	prg.curName[16-1] = '/'
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '>'
	prg.enterName(byte(ligCode + 6))

	prg.nameLength = 4
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '/'
	prg.enterName(byte(ligCode + 1))

	prg.nameLength = 5
	prg.curName[16-1] = 'L'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'G'
	prg.curName[19-1] = '/'
	prg.curName[20-1] = '>'
	prg.enterName(byte(ligCode + 5))

	prg.nameLength = 5
	prg.curName[16-1] = '/'
	prg.curName[17-1] = 'L'
	prg.curName[18-1] = 'I'
	prg.curName[19-1] = 'G'
	prg.curName[20-1] = '/'
	prg.enterName(byte(ligCode + 3))

	prg.nameLength = 6
	prg.curName[15-1] = '/'
	prg.curName[16-1] = 'L'
	prg.curName[17-1] = 'I'
	prg.curName[18-1] = 'G'
	prg.curName[19-1] = '/'
	prg.curName[20-1] = '>'
	prg.enterName(byte(ligCode + 7))

	prg.nameLength = 7
	prg.curName[14-1] = '/'
	prg.curName[15-1] = 'L'
	prg.curName[16-1] = 'I'
	prg.curName[17-1] = 'G'
	prg.curName[18-1] = '/'
	prg.curName[19-1] = '>'
	prg.curName[20-1] = '>'
	prg.enterName(byte(ligCode + 11))

	prg.vplEnter()
	prg.paramEnter()
}

func (prg *prg) readLigKern() {
	var (
		krnPtr/* 0..maxKerns */ uint16      // an index into |kern|
		c                              byte // runs through all character codes
	)
	{
		prg.lkStepEnded = false
		for prg.level == 1 {
			for int32(prg.curChar) == ' ' {
				prg.getNext()
			}
			if int32(prg.curChar) == '(' {
				prg.getName()
				if int32(prg.curCode) == commentCode {
					prg.skipToEndOfItem()
				} else if int32(prg.curCode) < labelCode {
					{
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("This property name doesn't belong in a LIGTABLE list")
						prg.showErrorContext()
					}
					prg.skipToEndOfItem()
				} else {
					switch prg.curCode {
					case labelCode:
						// Read a label step
						for int32(prg.curChar) == ' ' {
							prg.getNext()
						}
						if int32(prg.curChar) == 'B' {
							prg.charRemainder[256] = prg.nl
							for {
								prg.getNext()
								if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
									break
								}
							} // \.[LABEL BOUNDARYCHAR]
						} else {
							{
								if int32(prg.curChar) > ')' || int32(prg.curChar) < '(' {
									prg.loc = byte(int32(prg.loc) - 1)
								}
							}
							c = prg.getByte()
							prg.checkTag(c)
							prg.charTag[c] = byte(ligTag)
							prg.charRemainder[c] = prg.nl
						}
						if int32(prg.minNl) <= int32(prg.nl) {
							prg.minNl = uint16(int32(prg.nl) + 1)
						}
						prg.lkStepEnded = false

					case stopCode:
						// Read a stop step
						if !prg.lkStepEnded {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("STOP must follow LIG or KRN")
							prg.showErrorContext()
						} else {
							prg.ligKern[int32(prg.nl)-1].b0 = byte(stopFlag)
							prg.lkStepEnded = false
						}

					case skipCode:
						// Read a skip step
						if !prg.lkStepEnded {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("SKIP must follow LIG or KRN")
							prg.showErrorContext()
						} else {
							c = prg.getByte()
							if int32(c) >= 128 {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("Maximum SKIP amount is 127")
								prg.showErrorContext()
							} else if int32(prg.nl)+int32(c) >= maxLigSteps {
								if int32(prg.charsOnLine) > 0 {
									prg.stdout.Writeln(" ")
								}
								prg.stdout.Write("Sorry, LIGTABLE too long for me to handle")
								prg.showErrorContext()
							} else {
								prg.ligKern[int32(prg.nl)-1].b0 = c
								if int32(prg.minNl) <= int32(prg.nl)+int32(c) {
									prg.minNl = uint16(int32(prg.nl) + int32(c) + 1)
								}
							}
							prg.lkStepEnded = false
						}

					case krnCode:
						// Read a kerning step
						prg.ligKern[prg.nl].b0 = 0
						prg.ligKern[prg.nl].b1 = prg.getByte()
						prg.kern[prg.nk] = prg.getFix()
						krnPtr = 0
						for prg.kern[krnPtr] != prg.kern[prg.nk] {
							krnPtr = uint16(int32(krnPtr) + 1)
						}
						if int32(krnPtr) == int32(prg.nk) {
							if int32(prg.nk) < maxKerns {
								prg.nk = uint16(int32(prg.nk) + 1)
							} else {
								{
									if int32(prg.charsOnLine) > 0 {
										prg.stdout.Writeln(" ")
									}
									prg.stdout.Write("Sorry, too many different kerns for me to handle")
									prg.showErrorContext()
								}
								// \xref[Sorry, too many different kerns...]
								krnPtr = uint16(int32(krnPtr) - 1)
							}
						}
						prg.ligKern[prg.nl].b2 = byte(kernFlag + int32(krnPtr)/256)
						prg.ligKern[prg.nl].b3 = byte(int32(krnPtr) % 256)
						if int32(prg.nl) >= maxLigSteps-1 {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("Sorry, LIGTABLE too long for me to handle")
							prg.showErrorContext()
						} else {
							prg.nl = uint16(int32(prg.nl) + 1)
						}
						prg.lkStepEnded = true

					case ligCode, ligCode + 1, ligCode + 2, ligCode + 3,
						ligCode + 5, ligCode + 6, ligCode + 7, ligCode + 11:
						// Read a ligature step
						prg.ligKern[prg.nl].b0 = 0
						prg.ligKern[prg.nl].b2 = byte(int32(prg.curCode) - ligCode)
						prg.ligKern[prg.nl].b1 = prg.getByte()
						prg.ligKern[prg.nl].b3 = prg.getByte()
						if int32(prg.nl) >= maxLigSteps-1 {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("Sorry, LIGTABLE too long for me to handle")
							prg.showErrorContext()
						} else {
							prg.nl = uint16(int32(prg.nl) + 1)
						}
						prg.lkStepEnded = true

					} // there are no other cases |>=label_code|
					prg.finishTheProperty()
				}
			} else if int32(prg.curChar) == ')' {
				prg.skipToEndOfItem()
			} else {
				prg.junkError()
			}
		}
		{
			prg.loc = byte(int32(prg.loc) - 1)
			prg.level = prg.level + 1
			prg.curChar = ')'
		}
	}
}

func (prg *prg) readCharInfo() {
	var (
		c byte // the char
	)
	{
		c = prg.getByte() // read the character code that is being specified

		// Print |c| in octal notation
		{
			if int32(prg.charsOnLine) == 8 {
				prg.stdout.Writeln(" ")
				prg.charsOnLine = 1
			} else {
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Write(" ")
				}
				prg.charsOnLine = byte(int32(prg.charsOnLine) + 1)
			}
			prg.printOctal(c) // progress report
		}
		for prg.level == 1 {
			for int32(prg.curChar) == ' ' {
				prg.getNext()
			}
			if int32(prg.curChar) == '(' {
				prg.getName()
				if int32(prg.curCode) == commentCode {
					prg.skipToEndOfItem()
				} else if int32(prg.curCode) < charWdCode || int32(prg.curCode) > varCharCode {
					{
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("This property name doesn't belong in a CHARACTER list")
						prg.showErrorContext()
					}
					prg.skipToEndOfItem()
				} else {
					switch prg.curCode {
					case charWdCode:
						prg.charWd[c] = prg.sortIn(pointer(width), prg.getFix())
					case charHtCode:
						prg.charHt[c] = prg.sortIn(pointer(height), prg.getFix())
					case charDpCode:
						prg.charDp[c] = prg.sortIn(pointer(depth), prg.getFix())
					case charIcCode:
						prg.charIc[c] = prg.sortIn(pointer(italic), prg.getFix())
					case nextLargerCode:
						prg.checkTag(c)
						prg.charTag[c] = byte(listTag)
						prg.charRemainder[c] = uint16(prg.getByte())

					case mapCode:
						prg.readPacket(c)
					case varCharCode:
						// Read an extensible recipe for |c|
						if int32(prg.ne) == 256 {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("At most 256 VARCHAR specs are allowed")
							prg.showErrorContext()
						} else {
							prg.checkTag(c)
							prg.charTag[c] = byte(extTag)
							prg.charRemainder[c] = prg.ne

							prg.exten[prg.ne] = prg.zeroBytes
							for prg.level == 2 {
								for int32(prg.curChar) == ' ' {
									prg.getNext()
								}
								if int32(prg.curChar) == '(' {
									prg.getName()
									if int32(prg.curCode) == commentCode {
										prg.skipToEndOfItem()
									} else if int32(prg.curCode) < varCharCode+1 || int32(prg.curCode) > varCharCode+4 {
										{
											if int32(prg.charsOnLine) > 0 {
												prg.stdout.Writeln(" ")
											}
											prg.stdout.Write("This property name doesn't belong in a VARCHAR list")
											prg.showErrorContext()
										}
										prg.skipToEndOfItem()
									} else {
										switch int32(prg.curCode) - (varCharCode + 1) {
										case 0:
											prg.exten[prg.ne].b0 = prg.getByte()
										case 1:
											prg.exten[prg.ne].b1 = prg.getByte()
										case 2:
											prg.exten[prg.ne].b2 = prg.getByte()
										case 3:
											prg.exten[prg.ne].b3 = prg.getByte()
										}

										prg.finishTheProperty()
									}
								} else if int32(prg.curChar) == ')' {
									prg.skipToEndOfItem()
								} else {
									prg.junkError()
								}
							}
							prg.ne = uint16(int32(prg.ne) + 1)
							{
								prg.loc = byte(int32(prg.loc) - 1)
								prg.level = prg.level + 1
								prg.curChar = ')'
							}
						}

					}

					prg.finishTheProperty()
				}
			} else if int32(prg.curChar) == ')' {
				prg.skipToEndOfItem()
			} else {
				prg.junkError()
			}
		}
		if int32(prg.charWd[c]) == 0 {
			prg.charWd[c] = prg.sortIn(pointer(width), fixWord(0))
		} // legitimatize |c|
		{
			prg.loc = byte(int32(prg.loc) - 1)
			prg.level = prg.level + 1
			prg.curChar = ')'
		}
	}
}

func (prg *prg) readInput() {
	var (
		c byte // header or parameter index
	)
	prg.curChar = ' '
	for {
		for int32(prg.curChar) == ' ' {
			prg.getNext()
		}
		if int32(prg.curChar) == '(' {
			prg.getName()
			if int32(prg.curCode) == commentCode {
				prg.skipToEndOfItem()
			} else if int32(prg.curCode) > characterCode {
				{
					if int32(prg.charsOnLine) > 0 {
						prg.stdout.Writeln(" ")
					}
					prg.stdout.Write("This property name doesn't belong on the outer level")
					prg.showErrorContext()
				}
				prg.skipToEndOfItem()
			} else {
				switch prg.curCode {
				case checkSumCode:
					prg.checkSumSpecified = true
					prg.readFourBytes(headerIndex(checkSumLoc))

				case designSizeCode:
					// Read the design size
					prg.nextD = prg.getFix()
					if prg.nextD < 04000000 {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("The design size must be at least 1")
						prg.showErrorContext()
					} else {
						prg.designSize = prg.nextD
					}

				case designUnitsCode:
					// Read the design units
					prg.nextD = prg.getFix()
					if prg.nextD <= 0 {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("The number of units per design size must be positive")
						prg.showErrorContext()
					} else if prg.frozenDu {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("Sorry, it's too late to change the design units")
						prg.showErrorContext()
					} else {
						prg.designUnits = prg.nextD
					}

				case codingSchemeCode:
					prg.readBcpl(headerIndex(codingSchemeLoc), byte(40))
				case familyCode:
					prg.readBcpl(headerIndex(familyLoc), byte(20))
				case faceCode:
					prg.headerBytes[faceLoc] = prg.getByte()
				case sevenBitSafeFlagCode:
					// Read the seven-bit-safe flag
					for int32(prg.curChar) == ' ' {
						prg.getNext()
					}
					if int32(prg.curChar) == 'T' {
						prg.sevenBitSafeFlag = true
					} else if int32(prg.curChar) == 'F' {
						prg.sevenBitSafeFlag = false
					} else {
						if int32(prg.charsOnLine) > 0 {
							prg.stdout.Writeln(" ")
						}
						prg.stdout.Write("The flag value should be \"TRUE\" or \"FALSE\"")
						prg.showErrorContext()
					}
					// \xref[The flag value should be...]
					for {
						prg.getNext()
						if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
							break
						}
					}

				case headerCode:
					// Read an indexed header word
					c = prg.getByte()
					if int32(c) < 18 {
						{
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("HEADER indices should be 18 or more")
							prg.showErrorContext()
						}
						for {
							prg.getNext()
							if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
								break
							}
						}
					} else if 4*int32(c)+4 > maxHeaderBytes {
						{
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("This HEADER index is too big for my present table size")
							prg.showErrorContext()
						}
						for {
							prg.getNext()
							if int32(prg.curChar) == '(' || int32(prg.curChar) == ')' {
								break
							}
						}
					} else {
						for int32(prg.headerPtr) < 4*int32(c)+4 {
							prg.headerBytes[prg.headerPtr] = 0
							prg.headerPtr = byte(int32(prg.headerPtr) + 1)
						}
						prg.readFourBytes(headerIndex(4 * int32(c)))
					}

				case fontDimenCode:
					// Read font parameter list
					for prg.level == 1 {
						for int32(prg.curChar) == ' ' {
							prg.getNext()
						}
						if int32(prg.curChar) == '(' {
							prg.getName()
							if int32(prg.curCode) == commentCode {
								prg.skipToEndOfItem()
							} else if int32(prg.curCode) < parameterCode || int32(prg.curCode) >= charWdCode {
								{
									if int32(prg.charsOnLine) > 0 {
										prg.stdout.Writeln(" ")
									}
									prg.stdout.Write("This property name doesn't belong in a FONTDIMEN list")
									prg.showErrorContext()
								}
								prg.skipToEndOfItem()
							} else {
								if int32(prg.curCode) == parameterCode {
									c = prg.getByte()
								} else {
									c = byte(int32(prg.curCode) - parameterCode)
								}
								if int32(c) == 0 {
									{
										if int32(prg.charsOnLine) > 0 {
											prg.stdout.Writeln(" ")
										}
										prg.stdout.Write("PARAMETER index must not be zero")
										prg.showErrorContext()
									}
									prg.skipToEndOfItem()
								} else if int32(c) > maxParamWords {
									{
										if int32(prg.charsOnLine) > 0 {
											prg.stdout.Writeln(" ")
										}
										prg.stdout.Write("This PARAMETER index is too big for my present table size")
										prg.showErrorContext()
									}
									prg.skipToEndOfItem()
								} else {
									for int32(prg.np) < int32(c) {
										prg.np = byte(int32(prg.np) + 1)
										prg.param[prg.np-1] = 0
									}
									prg.param[c-1] = prg.getFix()
									prg.finishTheProperty()
								}
							}
						} else if int32(prg.curChar) == ')' {
							prg.skipToEndOfItem()
						} else {
							prg.junkError()
						}
					}
					{
						prg.loc = byte(int32(prg.loc) - 1)
						prg.level = prg.level + 1
						prg.curChar = ')'
					}

				case ligTableCode:
					prg.readLigKern()
				case boundaryCharCode:
					prg.bchar = uint16(prg.getByte())
				case virtualTitleCode:
					prg.vtitleStart = prg.vfPtr
					prg.copyToEndOfItem()
					if int32(prg.vfPtr) > int32(prg.vtitleStart)+255 {
						{
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("VTITLE clipped to 255 characters")
							prg.showErrorContext()
						}
						prg.vtitleLength = 255
						// \xref[VTITLE clipped...]
					} else {
						prg.vtitleLength = byte(int32(prg.vfPtr) - int32(prg.vtitleStart))
					}

				case mapFontCode:
					// Read a local font list
					prg.getFourBytes()
					prg.fontNumber[prg.fontPtr] = prg.curBytes
					prg.curFont = 0
					for int32(prg.fontNumber[prg.curFont].b3) != int32(prg.fontNumber[prg.fontPtr].b3) || int32(prg.fontNumber[prg.curFont].b2) != int32(prg.fontNumber[prg.fontPtr].b2) || int32(prg.fontNumber[prg.curFont].b1) != int32(prg.fontNumber[prg.fontPtr].b1) || int32(prg.fontNumber[prg.curFont].b0) != int32(prg.fontNumber[prg.fontPtr].b0) {
						prg.curFont = uint16(int32(prg.curFont) + 1)
					}
					if int32(prg.curFont) == int32(prg.fontPtr) {
						if int32(prg.fontPtr) < 256 {
							prg.fontPtr = uint16(int32(prg.fontPtr) + 1)
							prg.fnameStart[prg.curFont] = uint16(vfSize)
							prg.fnameLength[prg.curFont] = 4 // \.[NULL]
							prg.fareaStart[prg.curFont] = uint16(vfSize)
							prg.fareaLength[prg.curFont] = 0
							prg.fontChecksum[prg.curFont] = prg.zeroBytes
							prg.fontAt[prg.curFont] = 04000000     // denotes design size of this virtual font
							prg.fontDsize[prg.curFont] = 050000000 // the |fix_word| for 10
						} else {
							if int32(prg.charsOnLine) > 0 {
								prg.stdout.Writeln(" ")
							}
							prg.stdout.Write("I can handle only 256 different mapfonts")
							prg.showErrorContext()
						}
					}
					// \xref[I can handle only 256...]
					if int32(prg.curFont) == int32(prg.fontPtr) {
						prg.skipToEndOfItem()
					} else {
						for prg.level == 1 {
							for int32(prg.curChar) == ' ' {
								prg.getNext()
							}
							if int32(prg.curChar) == '(' {
								prg.getName()
								if int32(prg.curCode) == commentCode {
									prg.skipToEndOfItem()
								} else if int32(prg.curCode) < fontNameCode || int32(prg.curCode) > fontDsizeCode {
									{
										if int32(prg.charsOnLine) > 0 {
											prg.stdout.Writeln(" ")
										}
										prg.stdout.Write("This property name doesn't belong in a MAPFONT list")
										prg.showErrorContext()
									}
									prg.skipToEndOfItem()
								} else {
									switch prg.curCode {
									case fontNameCode:
										// Read a local font name
										prg.fnameStart[prg.curFont] = prg.vfPtr
										prg.copyToEndOfItem()
										if int32(prg.vfPtr) > int32(prg.fnameStart[prg.curFont])+255 {
											{
												if int32(prg.charsOnLine) > 0 {
													prg.stdout.Writeln(" ")
												}
												prg.stdout.Write("FONTNAME clipped to 255 characters")
												prg.showErrorContext()
											}
											// \xref[FONTNAME clipped...]
											prg.fnameLength[prg.curFont] = 255
										} else {
											prg.fnameLength[prg.curFont] = byte(int32(prg.vfPtr) - int32(prg.fnameStart[prg.curFont]))
										}

									case fontAreaCode:
										// Read a local font area
										prg.fareaStart[prg.curFont] = prg.vfPtr
										prg.copyToEndOfItem()
										if int32(prg.vfPtr) > int32(prg.fareaStart[prg.curFont])+255 {
											{
												if int32(prg.charsOnLine) > 0 {
													prg.stdout.Writeln(" ")
												}
												prg.stdout.Write("FONTAREA clipped to 255 characters")
												prg.showErrorContext()
											}
											// \xref[FONTAREA clipped...]
											prg.fareaLength[prg.curFont] = 255
										} else {
											prg.fareaLength[prg.curFont] = byte(int32(prg.vfPtr) - int32(prg.fareaStart[prg.curFont]))
										}

									case fontChecksumCode:
										prg.getFourBytes()
										prg.fontChecksum[prg.curFont] = prg.curBytes

									case fontAtCode:
										prg.frozenDu = true
										if prg.designUnits == 04000000 {
											prg.fontAt[prg.curFont] = prg.getFix()
										} else {
											prg.fontAt[prg.curFont] = round(float64(prg.getFix()) / float64(prg.designUnits) * 1048576.0)
										}

									case fontDsizeCode:
										prg.fontDsize[prg.curFont] = prg.getFix()
									} // there are no other cases
									prg.finishTheProperty()
								}
							} else if int32(prg.curChar) == ')' {
								prg.skipToEndOfItem()
							} else {
								prg.junkError()
							}
						}
					}
					{
						prg.loc = byte(int32(prg.loc) - 1)
						prg.level = prg.level + 1
						prg.curChar = ')'
					}

				case characterCode:
					prg.readCharInfo()
				}
				prg.finishTheProperty()
			}
		} else if int32(prg.curChar) == ')' && !prg.inputHasEnded {
			{
				if int32(prg.charsOnLine) > 0 {
					prg.stdout.Writeln(" ")
				}
				prg.stdout.Write("Extra right parenthesis")
				prg.showErrorContext()
			}
			prg.loc = byte(int32(prg.loc) + 1)
			prg.curChar = ' '
		} else if !prg.inputHasEnded {
			prg.junkError()
		}
		if prg.inputHasEnded {
			break
		}
	}
}

func (prg *prg) corrAndCheck() {
	var (
		c/* 0..256 */ uint16                   // runs through all character codes
		hh/* 0..hashSize */ uint16             // an index into |hash_list|
		ligPtr/* 0..maxLigSteps */ uint16      // an index into |lig_kern|
		g                                 byte // a character generated by the current character |c|
	)
	if int32(prg.nl) > 0 {
		if int32(prg.charRemainder[256]) < 077777 {
			prg.ligKern[prg.nl].b0 = 255
			prg.ligKern[prg.nl].b1 = 0
			prg.ligKern[prg.nl].b2 = 0
			prg.ligKern[prg.nl].b3 = 0
			prg.nl = uint16(int32(prg.nl) + 1)
		} // |bchar_label| will be stored later
		for int32(prg.minNl) > int32(prg.nl) {
			prg.ligKern[prg.nl].b0 = 255
			prg.ligKern[prg.nl].b1 = 0
			prg.ligKern[prg.nl].b2 = 0
			prg.ligKern[prg.nl].b3 = 0
			prg.nl = uint16(int32(prg.nl) + 1)
		}
		if int32(prg.ligKern[int32(prg.nl)-1].b0) == 0 {
			prg.ligKern[int32(prg.nl)-1].b0 = byte(stopFlag)
		}
	}
	prg.sevenUnsafe = false
	for ii := int32(0); ii <= 255; ii++ {
		c = uint16(ii)
		_ = c
		if int32(prg.charWd[c]) != 0 {
			switch prg.charTag[c] {
			case noTag:
			case ligTag:
				// Check ligature program of |c|
				ligPtr = prg.charRemainder[c]
				for {
					if prg.hashInput(ligPtr, c) {
						if int32(prg.ligKern[ligPtr].b2) < kernFlag {
							if int32(prg.ligKern[ligPtr].b1) != int32(prg.bchar) {
								g = prg.ligKern[ligPtr].b1
								if int32(prg.charWd[g]) == 0 {
									prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
									prg.stdout.Write("LIG character examined by", " ")
									prg.printOctal(byte(c))
									prg.stdout.Writeln(" had no CHARACTER spec.")
								}
							}
							// \xref[LIG character examined...]
							{
								g = prg.ligKern[ligPtr].b3
								if int32(prg.charWd[g]) == 0 {
									prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
									prg.stdout.Write("LIG character generated by", " ")
									prg.printOctal(byte(c))
									prg.stdout.Writeln(" had no CHARACTER spec.")
								}
							}
							// \xref[LIG character generated...]
							if int32(prg.ligKern[ligPtr].b3) >= 128 {
								if int32(c) < 128 || int32(c) == 256 {
									if int32(prg.ligKern[ligPtr].b1) < 128 || int32(prg.ligKern[ligPtr].b1) == int32(prg.bchar) {
										prg.sevenUnsafe = true
									}
								}
							}
						} else if int32(prg.ligKern[ligPtr].b1) != int32(prg.bchar) {
							g = prg.ligKern[ligPtr].b1
							if int32(prg.charWd[g]) == 0 {
								prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
								prg.stdout.Write("KRN character examined by", " ")
								prg.printOctal(byte(c))
								prg.stdout.Writeln(" had no CHARACTER spec.")
							}
						}
						// \xref[KRN character examined...]
					}
					if int32(prg.ligKern[ligPtr].b0) >= stopFlag {
						ligPtr = prg.nl
					} else {
						ligPtr = uint16(int32(ligPtr) + 1 + int32(prg.ligKern[ligPtr].b0))
					}
					if int32(ligPtr) >= int32(prg.nl) {
						break
					}
				}

			case listTag:
				g = byte(prg.charRemainder[c])
				if int32(g) >= 128 && int32(c) < 128 {
					prg.sevenUnsafe = true
				}
				if int32(prg.charWd[g]) == 0 {
					prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
					prg.stdout.Write("The character NEXTLARGER than", " ")
					prg.printOctal(byte(c))
					prg.stdout.Writeln(" had no CHARACTER spec.")
				}
			// \xref[The character NEXTLARGER...]
			case extTag:
				// Check the pieces of |exten[c]|
				if int32(prg.exten[prg.charRemainder[c]].b0) > 0 {
					g = prg.exten[prg.charRemainder[c]].b0
					if int32(g) >= 128 && int32(c) < 128 {
						prg.sevenUnsafe = true
					}
					if int32(prg.charWd[g]) == 0 {
						prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
						prg.stdout.Write("TOP piece of character", " ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln(" had no CHARACTER spec.")
					}
				}
				// \xref[TOP piece of character...]
				if int32(prg.exten[prg.charRemainder[c]].b1) > 0 {
					g = prg.exten[prg.charRemainder[c]].b1
					if int32(g) >= 128 && int32(c) < 128 {
						prg.sevenUnsafe = true
					}
					if int32(prg.charWd[g]) == 0 {
						prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
						prg.stdout.Write("MID piece of character", " ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln(" had no CHARACTER spec.")
					}
				}
				// \xref[MID piece of character...]
				if int32(prg.exten[prg.charRemainder[c]].b2) > 0 {
					g = prg.exten[prg.charRemainder[c]].b2
					if int32(g) >= 128 && int32(c) < 128 {
						prg.sevenUnsafe = true
					}
					if int32(prg.charWd[g]) == 0 {
						prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
						prg.stdout.Write("BOT piece of character", " ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln(" had no CHARACTER spec.")
					}
				}
				// \xref[BOT piece of character...]
				{
					g = prg.exten[prg.charRemainder[c]].b3
					if int32(g) >= 128 && int32(c) < 128 {
						prg.sevenUnsafe = true
					}
					if int32(prg.charWd[g]) == 0 {
						prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
						prg.stdout.Write("REP piece of character", " ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln(" had no CHARACTER spec.")
					}
				}
				// \xref[REP piece of character...]

			}
		}
	}
	if int32(prg.charRemainder[256]) < 077777 {
		c = 256
		// Check ligature program of |c|
		{
			ligPtr = prg.charRemainder[c]
			for {
				if prg.hashInput(ligPtr, c) {
					if int32(prg.ligKern[ligPtr].b2) < kernFlag {
						if int32(prg.ligKern[ligPtr].b1) != int32(prg.bchar) {
							g = prg.ligKern[ligPtr].b1
							if int32(prg.charWd[g]) == 0 {
								prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
								prg.stdout.Write("LIG character examined by", " ")
								prg.printOctal(byte(c))
								prg.stdout.Writeln(" had no CHARACTER spec.")
							}
						}
						// \xref[LIG character examined...]
						{
							g = prg.ligKern[ligPtr].b3
							if int32(prg.charWd[g]) == 0 {
								prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
								prg.stdout.Write("LIG character generated by", " ")
								prg.printOctal(byte(c))
								prg.stdout.Writeln(" had no CHARACTER spec.")
							}
						}
						// \xref[LIG character generated...]
						if int32(prg.ligKern[ligPtr].b3) >= 128 {
							if int32(c) < 128 || int32(c) == 256 {
								if int32(prg.ligKern[ligPtr].b1) < 128 || int32(prg.ligKern[ligPtr].b1) == int32(prg.bchar) {
									prg.sevenUnsafe = true
								}
							}
						}
					} else if int32(prg.ligKern[ligPtr].b1) != int32(prg.bchar) {
						g = prg.ligKern[ligPtr].b1
						if int32(prg.charWd[g]) == 0 {
							prg.charWd[g] = prg.sortIn(pointer(width), fixWord(0))
							prg.stdout.Write("KRN character examined by", " ")
							prg.printOctal(byte(c))
							prg.stdout.Writeln(" had no CHARACTER spec.")
						}
					}
					// \xref[KRN character examined...]
				}
				if int32(prg.ligKern[ligPtr].b0) >= stopFlag {
					ligPtr = prg.nl
				} else {
					ligPtr = uint16(int32(ligPtr) + 1 + int32(prg.ligKern[ligPtr].b0))
				}
				if int32(ligPtr) >= int32(prg.nl) {
					break
				}
			}
		}
	}
	if prg.sevenBitSafeFlag && prg.sevenUnsafe {
		prg.stdout.Writeln("The font is not really seven-bit-safe!")
	}
	// \xref[The font is not...safe]

	// Check for infinite ligature loops
	if int32(prg.hashPtr) < hashSize {
		for ii := int32(1); ii <= int32(prg.hashPtr); ii++ {
			hh = uint16(ii)
			_ = hh
			prg.tt = prg.hashList[hh]
			if int32(prg.class[prg.tt]) > simple {
				prg.tt = prg.f(prg.tt, indx((int32(prg.hash[prg.tt])-1)/256), indx((int32(prg.hash[prg.tt])-1)%256))
			}
		}
	}
	if int32(prg.hashPtr) == hashSize || int32(prg.yLigCycle) < 256 {
		if int32(prg.hashPtr) < hashSize {
			prg.stdout.Write("Infinite ligature loop starting with ")
			// \xref[Infinite ligature loop...]
			if int32(prg.xLigCycle) == 256 {
				prg.stdout.Write("boundary")
			} else {
				prg.printOctal(byte(prg.xLigCycle))
			}
			prg.stdout.Write(" and ")
			prg.printOctal(byte(prg.yLigCycle))
			prg.stdout.Writeln("!")
		} else {
			prg.stdout.Writeln("Sorry, I haven't room for so many ligature/kern pairs!")
		}
		// \xref[Sorry, I haven't room...]
		prg.stdout.Writeln("All ligatures will be cleared.")
		for ii := int32(0); ii <= 255; ii++ {
			c = uint16(ii)
			_ = c
			if int32(prg.charTag[c]) == ligTag {
				prg.charTag[c] = byte(noTag)
				prg.charRemainder[c] = 0
			}
		}
		prg.nl = 0
		prg.bchar = 256
		prg.charRemainder[256] = 077777
	}

	// Doublecheck the lig/kern commands and the extensible recipes
	if int32(prg.nl) > 0 {
		for ii := int32(0); ii <= int32(prg.nl)-1; ii++ {
			ligPtr = uint16(ii)
			_ = ligPtr
			if int32(prg.ligKern[ligPtr].b2) < kernFlag {
				if int32(prg.ligKern[ligPtr].b0) < 255 {
					{
						c = uint16(prg.ligKern[ligPtr].b1)
						if int32(prg.charWd[c]) == 0 {
							if int32(c) != int32(prg.bchar) {
								prg.ligKern[ligPtr].b1 = 0 // \1
								if int32(prg.charWd[0]) == 0 {
									prg.charWd[0] = prg.sortIn(pointer(width), fixWord(0))
								}
								prg.stdout.Write("Unused ", "LIG step", " refers to nonexistent character ")
								prg.printOctal(byte(c))
								prg.stdout.Writeln("!")
							}
						}
					}
					{
						c = uint16(prg.ligKern[ligPtr].b3)
						if int32(prg.charWd[c]) == 0 {
							if int32(c) != int32(prg.bchar) {
								prg.ligKern[ligPtr].b3 = 0 // \1
								if int32(prg.charWd[0]) == 0 {
									prg.charWd[0] = prg.sortIn(pointer(width), fixWord(0))
								}
								prg.stdout.Write("Unused ", "LIG step", " refers to nonexistent character ")
								prg.printOctal(byte(c))
								prg.stdout.Writeln("!")
							}
						}
					}
				}
			} else {
				c = uint16(prg.ligKern[ligPtr].b1)
				if int32(prg.charWd[c]) == 0 {
					if int32(c) != int32(prg.bchar) {
						prg.ligKern[ligPtr].b1 = 0 // \1
						if int32(prg.charWd[0]) == 0 {
							prg.charWd[0] = prg.sortIn(pointer(width), fixWord(0))
						}
						prg.stdout.Write("Unused ", "KRN step", " refers to nonexistent character ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln("!")
					}
				}
			}
		}
	}
	// \xref[Unused LIG step...]
	// \xref[Unused KRN step...]
	if int32(prg.ne) > 0 {
		for ii := int32(0); ii <= int32(prg.ne)-1; ii++ {
			g = byte(ii)
			_ = g
			{
				c = uint16(prg.exten[g].b0)
				if int32(c) > 0 {
					if int32(prg.charWd[c]) == 0 {
						prg.exten[g].b0 = 0 // \1
						if int32(prg.charWd[0]) == 0 {
							prg.charWd[0] = prg.sortIn(pointer(width), fixWord(0))
						}
						prg.stdout.Write("Unused ", "VARCHAR TOP", " refers to nonexistent character ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln("!")
					}
				}
			}
			{
				c = uint16(prg.exten[g].b1)
				if int32(c) > 0 {
					if int32(prg.charWd[c]) == 0 {
						prg.exten[g].b1 = 0 // \1
						if int32(prg.charWd[0]) == 0 {
							prg.charWd[0] = prg.sortIn(pointer(width), fixWord(0))
						}
						prg.stdout.Write("Unused ", "VARCHAR MID", " refers to nonexistent character ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln("!")
					}
				}
			}
			{
				c = uint16(prg.exten[g].b2)
				if int32(c) > 0 {
					if int32(prg.charWd[c]) == 0 {
						prg.exten[g].b2 = 0 // \1
						if int32(prg.charWd[0]) == 0 {
							prg.charWd[0] = prg.sortIn(pointer(width), fixWord(0))
						}
						prg.stdout.Write("Unused ", "VARCHAR BOT", " refers to nonexistent character ")
						prg.printOctal(byte(c))
						prg.stdout.Writeln("!")
					}
				}
			}
			{
				c = uint16(prg.exten[g].b3)
				if int32(prg.charWd[c]) == 0 {
					prg.exten[g].b3 = 0 // \1
					if int32(prg.charWd[0]) == 0 {
						prg.charWd[0] = prg.sortIn(pointer(width), fixWord(0))
					}
					prg.stdout.Write("Unused ", "VARCHAR REP", " refers to nonexistent character ")
					prg.printOctal(byte(c))
					prg.stdout.Writeln("!")
				}
			}
			// \xref[Unused VARCHAR...]
		}
	}
	for ii := int32(0); ii <= 255; ii++ {
		c = uint16(ii)
		_ = c

		// Make sure that |c| is not the largest element of a charlist cycle
		if int32(prg.charTag[c]) == listTag {
			g = byte(prg.charRemainder[c])
			for int32(g) < int32(c) && int32(prg.charTag[g]) == listTag {
				g = byte(prg.charRemainder[g])
			}
			if int32(g) == int32(c) {
				prg.charTag[c] = byte(noTag)
				prg.stdout.Write("A cycle of NEXTLARGER characters has been broken at ")
				// \xref[A cycle of NEXTLARGER...]
				prg.printOctal(byte(c))
				prg.stdout.Writeln(".")
			}
		}
	}

	// Put the width, height, depth, and italic lists into final form
	prg.delta = prg.shorten(pointer(width), 255)
	prg.setIndices(pointer(width), prg.delta)
	if prg.delta > 0 {
		prg.stdout.Writeln("I had to round some " /* \xref[I had to round...]  */, "width", "s by ", float64((prg.delta+1)/2)/float64(04000000), knuth.WriteWidth(1), knuth.WriteWidth(7), " units.")
	}

	prg.delta = prg.shorten(pointer(height), 15)
	prg.setIndices(pointer(height), prg.delta)
	if prg.delta > 0 {
		prg.stdout.Writeln("I had to round some " /* \xref[I had to round...]  */, "height", "s by ", float64((prg.delta+1)/2)/float64(04000000), knuth.WriteWidth(1), knuth.WriteWidth(7), " units.")
	}

	prg.delta = prg.shorten(pointer(depth), 15)
	prg.setIndices(pointer(depth), prg.delta)
	if prg.delta > 0 {
		prg.stdout.Writeln("I had to round some " /* \xref[I had to round...]  */, "depth", "s by ", float64((prg.delta+1)/2)/float64(04000000), knuth.WriteWidth(1), knuth.WriteWidth(7), " units.")
	}

	prg.delta = prg.shorten(pointer(italic), 63)
	prg.setIndices(pointer(italic), prg.delta)
	if prg.delta > 0 {
		prg.stdout.Writeln("I had to round some " /* \xref[I had to round...]  */, "italic correction", "s by ", float64((prg.delta+1)/2)/float64(04000000), knuth.WriteWidth(1), knuth.WriteWidth(7), " units.")
	}

}

func (prg *prg) vfOutput() {
	var (
		c                          byte  // runs through all character codes
		curFont/* 0..256 */ uint16       // runs through all local fonts
		k                          int32 // loop index
	)
	prg.vfFile.Write(pre)
	prg.vfFile.Write(idByte)
	prg.vfFile.Write(prg.vtitleLength)
	for ii := int32(0); ii <= int32(prg.vtitleLength)-1; ii++ {
		k = ii
		_ = k
		prg.vfFile.Write(prg.vf[int32(prg.vtitleStart)+k])
	}
	for ii := int32(checkSumLoc); ii <= designSizeLoc+3; ii++ {
		k = ii
		_ = k
		prg.vfFile.Write(prg.headerBytes[k])
	}
	prg.vcount = int32(prg.vtitleLength) + 11
	for ii := int32(0); ii <= int32(prg.fontPtr)-1; ii++ {
		curFont = uint16(ii)
		_ = curFont
		// Output a local font definition
		prg.vfFile.Write(fntDef1)
		prg.vfFile.Write(curFont)

		prg.vfFile.Write(prg.fontChecksum[curFont].b0)
		prg.vfFile.Write(prg.fontChecksum[curFont].b1)
		prg.vfFile.Write(prg.fontChecksum[curFont].b2)
		prg.vfFile.Write(prg.fontChecksum[curFont].b3)
		prg.voutInt(prg.fontAt[curFont])
		prg.voutInt(prg.fontDsize[curFont])
		prg.vfFile.Write(prg.fareaLength[curFont])
		prg.vfFile.Write(prg.fnameLength[curFont])
		for ii := int32(0); ii <= int32(prg.fareaLength[curFont])-1; ii++ {
			k = ii
			_ = k
			prg.vfFile.Write(prg.vf[int32(prg.fareaStart[curFont])+k])
		}
		if int32(prg.fnameStart[curFont]) == vfSize {
			prg.vfFile.Write('N')
			prg.vfFile.Write('U')
			prg.vfFile.Write('L')
			prg.vfFile.Write('L')
		} else {
			for ii := int32(0); ii <= int32(prg.fnameLength[curFont])-1; ii++ {
				k = ii
				_ = k
				prg.vfFile.Write(prg.vf[int32(prg.fnameStart[curFont])+k])
			}
		}
		prg.vcount = prg.vcount + 12 + int32(prg.fareaLength[curFont]) + int32(prg.fnameLength[curFont])
	}
	for ii := int32(prg.bc); ii <= int32(prg.ec); ii++ {
		c = byte(ii)
		_ = c
		if int32(prg.charWd[c]) > 0 {
			prg.x = prg.memory[prg.charWd[c]]
			if prg.designUnits != 04000000 {
				prg.x = round(float64(prg.x) / float64(prg.designUnits) * 1048576.0)
			}
			if prg.packetLength[c] > 241 || prg.x < 0 || prg.x >= 0100000000 {
				prg.vfFile.Write(242)
				prg.voutInt(prg.packetLength[c])
				prg.voutInt(int32(c))
				prg.voutInt(prg.x)
				prg.vcount = prg.vcount + 13 + prg.packetLength[c]
			} else {
				prg.vfFile.Write(prg.packetLength[c])
				prg.vfFile.Write(c)
				prg.vfFile.Write(prg.x / 0200000)
				prg.vfFile.Write(prg.x / 0400 % 256)
				prg.vfFile.Write(prg.x % 256)
				prg.vcount = prg.vcount + 5 + prg.packetLength[c]
			}
			if int32(prg.packetStart[c]) == vfSize {
				if int32(c) >= 128 {
					prg.vfFile.Write(set1)
				}
				prg.vfFile.Write(c)
			} else {
				for ii := int32(0); ii <= prg.packetLength[c]-1; ii++ {
					k = ii
					_ = k
					prg.vfFile.Write(prg.vf[int32(prg.packetStart[c])+k])
				}
			}
		}
	}
	for {
		prg.vfFile.Write(post)
		prg.vcount = prg.vcount + 1
		if prg.vcount%4 == 0 {
			break
		}
	}
}

// 181.

// tangle:pos vptovf.web:3157:5:

// Here is where \.[VPtoVF] begins and ends.
func (prg *prg) main() {
	defer func() {
		if prg.stderr != nil {
			prg.stderr.Close()
		}
		if prg.stdin != nil {
			prg.stdin.Close()
		}
		if prg.stdout != nil {
			prg.stdout.Close()
		}
		if prg.tfmFile != nil {
			prg.tfmFile.Close()
		}
		if prg.vfFile != nil {
			prg.vfFile.Close()
		}
		if prg.vplFile != nil {
			prg.vplFile.Close()
		}
	}()

	prg.initialize()

	prg.nameEnter()

	prg.readInput()
	prg.stdout.Writeln(".")

	prg.corrAndCheck()

	// Do the \.[TFM] output

	// Compute the twelve subfile sizes
	prg.lh = byte(int32(prg.headerPtr) / 4)

	prg.notFound = true
	prg.bc = 0
	for prg.notFound {
		if int32(prg.charWd[prg.bc]) > 0 || int32(prg.bc) == 255 {
			prg.notFound = false
		} else {
			prg.bc = byte(int32(prg.bc) + 1)
		}
	}
	prg.notFound = true
	prg.ec = 255
	for prg.notFound {
		if int32(prg.charWd[prg.ec]) > 0 || int32(prg.ec) == 0 {
			prg.notFound = false
		} else {
			prg.ec = byte(int32(prg.ec) - 1)
		}
	}
	if int32(prg.bc) > int32(prg.ec) {
		prg.bc = 1
	}
	prg.memory[width] = prg.memory[width] + 1
	prg.memory[height] = prg.memory[height] + 1
	prg.memory[depth] = prg.memory[depth] + 1
	prg.memory[italic] = prg.memory[italic] + 1

	// Compute the ligature/kern program offset

	// Insert all labels into |label_table|
	prg.labelPtr = 0
	prg.labelTable[0].rr = int16(-1) // sentinel
	for ii := int32(prg.bc); ii <= int32(prg.ec); ii++ {
		prg.c = byte(ii)
		_ = prg.c
		if int32(prg.charTag[prg.c]) == ligTag {
			prg.sortPtr = prg.labelPtr // there's a hole at position |sort_ptr+1|
			for int32(prg.labelTable[prg.sortPtr].rr) > int32(prg.charRemainder[prg.c]) {
				prg.labelTable[int32(prg.sortPtr)+1] = prg.labelTable[prg.sortPtr]
				prg.sortPtr = uint16(int32(prg.sortPtr) - 1) // move the hole
			}
			prg.labelTable[int32(prg.sortPtr)+1].cc = prg.c
			prg.labelTable[int32(prg.sortPtr)+1].rr = int16(prg.charRemainder[prg.c])
			prg.labelPtr = uint16(int32(prg.labelPtr) + 1)
		}
	}
	if int32(prg.bchar) < 256 {
		prg.extraLocNeeded = true
		prg.lkOffset = 1
	} else {
		prg.extraLocNeeded = false
		prg.lkOffset = 0
	}

	// Find the minimum |lk_offset| and adjust all remainders
	{
		prg.sortPtr = prg.labelPtr // the largest unallocated label
		if int32(prg.labelTable[prg.sortPtr].rr)+int32(prg.lkOffset) > 255 {
			prg.lkOffset = 0
			prg.extraLocNeeded = false // location 0 can do double duty
			for {
				prg.charRemainder[prg.labelTable[prg.sortPtr].cc] = prg.lkOffset
				for int32(prg.labelTable[int32(prg.sortPtr)-1].rr) == int32(prg.labelTable[prg.sortPtr].rr) {
					prg.sortPtr = uint16(int32(prg.sortPtr) - 1)
					prg.charRemainder[prg.labelTable[prg.sortPtr].cc] = prg.lkOffset
				}
				prg.lkOffset = uint16(int32(prg.lkOffset) + 1)
				prg.sortPtr = uint16(int32(prg.sortPtr) - 1)
				if int32(prg.lkOffset)+int32(prg.labelTable[prg.sortPtr].rr) < 256 {
					break
				}
			}
			// N.B.: |lk_offset=256| satisfies this when |sort_ptr=0|
		}
		if int32(prg.lkOffset) > 0 {
			for int32(prg.sortPtr) > 0 {
				prg.charRemainder[prg.labelTable[prg.sortPtr].cc] = uint16(int32(prg.charRemainder[prg.labelTable[prg.sortPtr].cc]) + int32(prg.lkOffset))
				prg.sortPtr = uint16(int32(prg.sortPtr) - 1)
			}
		}
	}
	if int32(prg.charRemainder[256]) < 077777 {
		prg.ligKern[int32(prg.nl)-1].b2 = byte((int32(prg.charRemainder[256]) + int32(prg.lkOffset)) / 256)
		prg.ligKern[int32(prg.nl)-1].b3 = byte((int32(prg.charRemainder[256]) + int32(prg.lkOffset)) % 256)
	}
	prg.lf = uint16(6 + int32(prg.lh) + (int32(prg.ec) - int32(prg.bc) + 1) + prg.memory[width] + prg.memory[height] + prg.memory[depth] + prg.memory[italic] + int32(prg.nl) + int32(prg.lkOffset) + int32(prg.nk) + int32(prg.ne) + int32(prg.np))

	// Output the twelve subfile sizes
	prg.tfmFile.Write(int32(prg.lf) / 256)
	prg.tfmFile.Write(int32(prg.lf) % 256)
	prg.tfmFile.Write(int32(prg.lh) / 256)
	prg.tfmFile.Write(int32(prg.lh) % 256)
	prg.tfmFile.Write(int32(prg.bc) / 256)
	prg.tfmFile.Write(int32(prg.bc) % 256)
	prg.tfmFile.Write(int32(prg.ec) / 256)
	prg.tfmFile.Write(int32(prg.ec) % 256)
	prg.tfmFile.Write(prg.memory[width] / 256)
	prg.tfmFile.Write(prg.memory[width] % 256)
	prg.tfmFile.Write(prg.memory[height] / 256)
	prg.tfmFile.Write(prg.memory[height] % 256)
	prg.tfmFile.Write(prg.memory[depth] / 256)
	prg.tfmFile.Write(prg.memory[depth] % 256)
	prg.tfmFile.Write(prg.memory[italic] / 256)
	prg.tfmFile.Write(prg.memory[italic] % 256)
	prg.tfmFile.Write((int32(prg.nl) + int32(prg.lkOffset)) / 256)
	prg.tfmFile.Write((int32(prg.nl) + int32(prg.lkOffset)) % 256)
	prg.tfmFile.Write(int32(prg.nk) / 256)
	prg.tfmFile.Write(int32(prg.nk) % 256)
	prg.tfmFile.Write(int32(prg.ne) / 256)
	prg.tfmFile.Write(int32(prg.ne) % 256)
	prg.tfmFile.Write(int32(prg.np) / 256)
	prg.tfmFile.Write(int32(prg.np) % 256)

	// Output the header block
	if !prg.checkSumSpecified {
		prg.curBytes.b0 = prg.bc
		prg.curBytes.b1 = prg.ec
		prg.curBytes.b2 = prg.bc
		prg.curBytes.b3 = prg.ec
		for ii := int32(prg.bc); ii <= int32(prg.ec); ii++ {
			prg.c = byte(ii)
			_ = prg.c
			if int32(prg.charWd[prg.c]) > 0 {
				prg.tempWidth = prg.memory[prg.charWd[prg.c]]
				if prg.designUnits != 04000000 {
					prg.tempWidth = round(float64(prg.tempWidth) / float64(prg.designUnits) * 1048576.0)
				}
				prg.tempWidth = prg.tempWidth + (int32(prg.c)+4)*020000000 // this should be positive
				prg.curBytes.b0 = byte((int32(prg.curBytes.b0) + int32(prg.curBytes.b0) + prg.tempWidth) % 255)
				prg.curBytes.b1 = byte((int32(prg.curBytes.b1) + int32(prg.curBytes.b1) + prg.tempWidth) % 253)
				prg.curBytes.b2 = byte((int32(prg.curBytes.b2) + int32(prg.curBytes.b2) + prg.tempWidth) % 251)
				prg.curBytes.b3 = byte((int32(prg.curBytes.b3) + int32(prg.curBytes.b3) + prg.tempWidth) % 247)
			}
		}
		prg.headerBytes[checkSumLoc] = prg.curBytes.b0
		prg.headerBytes[checkSumLoc+1] = prg.curBytes.b1
		prg.headerBytes[checkSumLoc+2] = prg.curBytes.b2
		prg.headerBytes[checkSumLoc+3] = prg.curBytes.b3
	}
	prg.headerBytes[designSizeLoc] = byte(prg.designSize / 0100000000)
	// this works since |design_size>0|
	prg.headerBytes[designSizeLoc+1] = byte(prg.designSize / 0200000 % 256)
	prg.headerBytes[designSizeLoc+2] = byte(prg.designSize / 256 % 256)
	prg.headerBytes[designSizeLoc+3] = byte(prg.designSize % 256)
	if !prg.sevenUnsafe {
		prg.headerBytes[sevenFlagLoc] = 128
	}
	for ii := int32(0); ii <= int32(prg.headerPtr)-1; ii++ {
		prg.j = byte(ii)
		_ = prg.j
		prg.tfmFile.Write(prg.headerBytes[prg.j])
	}

	// Output the character info
	prg.index[0] = 0
	for ii := int32(prg.bc); ii <= int32(prg.ec); ii++ {
		prg.c = byte(ii)
		_ = prg.c
		prg.tfmFile.Write(prg.index[prg.charWd[prg.c]])
		prg.tfmFile.Write(int32(prg.index[prg.charHt[prg.c]])*16 + int32(prg.index[prg.charDp[prg.c]]))
		prg.tfmFile.Write(int32(prg.index[prg.charIc[prg.c]])*4 + int32(prg.charTag[prg.c]))
		prg.tfmFile.Write(prg.charRemainder[prg.c])
	}

	// Output the dimensions themselves
	for ii := int32(width); ii <= italic; ii++ {
		prg.q = byte(ii)
		_ = prg.q
		prg.tfmFile.Write(0)
		prg.tfmFile.Write(0)
		prg.tfmFile.Write(0)
		prg.tfmFile.Write(0)    // output the zero word
		prg.p = prg.link[prg.q] // head of list
		for int32(prg.p) > 0 {
			prg.outScaled(prg.memory[prg.p])
			prg.p = prg.link[prg.p]
		}
	}

	// Output the ligature/kern program
	if prg.extraLocNeeded {
		prg.tfmFile.Write(255)
		prg.tfmFile.Write(prg.bchar)
		prg.tfmFile.Write(0)
		prg.tfmFile.Write(0)
	} else {
		for ii := int32(1); ii <= int32(prg.lkOffset); ii++ {
			prg.sortPtr = uint16(ii)
			_ = prg.sortPtr // output the redirection specs
			prg.t = uint16(prg.labelTable[prg.labelPtr].rr)
			if int32(prg.bchar) < 256 {
				prg.tfmFile.Write(255)
				prg.tfmFile.Write(prg.bchar)
			} else {
				prg.tfmFile.Write(254)
				prg.tfmFile.Write(0)
			}
			prg.tfmFile.Write((int32(prg.t) + int32(prg.lkOffset)) / 256)
			prg.tfmFile.Write((int32(prg.t) + int32(prg.lkOffset)) % 256)
			for {
				prg.labelPtr = uint16(int32(prg.labelPtr) - 1)
				if int32(prg.labelTable[prg.labelPtr].rr) < int32(prg.t) {
					break
				}
			}
		}
	}
	if int32(prg.nl) > 0 {
		for ii := int32(0); ii <= int32(prg.nl)-1; ii++ {
			prg.ligPtr = uint16(ii)
			_ = prg.ligPtr
			prg.tfmFile.Write(prg.ligKern[prg.ligPtr].b0)
			prg.tfmFile.Write(prg.ligKern[prg.ligPtr].b1)
			prg.tfmFile.Write(prg.ligKern[prg.ligPtr].b2)
			prg.tfmFile.Write(prg.ligKern[prg.ligPtr].b3)
		}
	}
	if int32(prg.nk) > 0 {
		for ii := int32(0); ii <= int32(prg.nk)-1; ii++ {
			prg.krnPtr = uint16(ii)
			_ = prg.krnPtr
			prg.outScaled(prg.kern[prg.krnPtr])
		}
	}

	// Output the extensible character recipes
	if int32(prg.ne) > 0 {
		for ii := int32(0); ii <= int32(prg.ne)-1; ii++ {
			prg.c = byte(ii)
			_ = prg.c
			prg.tfmFile.Write(prg.exten[prg.c].b0)
			prg.tfmFile.Write(prg.exten[prg.c].b1)
			prg.tfmFile.Write(prg.exten[prg.c].b2)
			prg.tfmFile.Write(prg.exten[prg.c].b3)
		}
	}

	// Output the parameters
	for ii := int32(1); ii <= int32(prg.np); ii++ {
		prg.parPtr = byte(ii)
		_ = prg.parPtr
		if int32(prg.parPtr) == 1 {
			if prg.param[1-1] < 0 {
				prg.param[1-1] = prg.param[1-1] + 010000000000
				prg.tfmFile.Write(prg.param[1-1]/0100000000 + 256 - 64)
			} else {
				prg.tfmFile.Write(prg.param[1-1] / 0100000000)
			}
			prg.tfmFile.Write(prg.param[1-1] / 0200000 % 256)
			prg.tfmFile.Write(prg.param[1-1] / 256 % 256)
			prg.tfmFile.Write(prg.param[1-1] % 256)
		} else {
			prg.outScaled(prg.param[prg.parPtr-1])
		}
	}
	prg.vfOutput()
}

// 182. System-dependent changes

// tangle:pos vptovf.web:3169:25:

// This section should be replaced, if necessary, by changes to the program
// that are necessary to make \.[VPtoVF] 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.
// \xref[system dependencies]

// 183. Index

// tangle:pos vptovf.web:3179:6:

// Pointers to error messages appear here together with the section numbers
// where each ident\-i\-fier is used.