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

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

// % This program by D. E. Knuth is not copyrighted and can be used freely.
// % Version 0 was released in December, 1981.
// % Version 1 was released in September, 1982, with version 0 of TeX.
// % Slight changes were made in October, 1982, for version 0.6 of TeX.
// % Version 1.2 introduced [:nnn] comments, added @= and @\ (December, 1982).
// % Version 1.4 added "history" (February, 1983).
// % Version 1.5 conformed to TeX version 0.96 and fixed @\ (March, 1983).
// % Version 1.7 introduced the new change file format (June, 1983).
// % Version 2.0 was released in July, 1983, with version 0.999 of TeX.
// % Version 2.5 was released in November, 1983, with version 1.0 of TeX.
// % Version 2.6 fixed a bug: force-line-break after a constant (August, 1984).
// % Version 2.7 fixed the definition of check_sum_prime (May, 1985).
// % Version 2.8 fixed a bug in change_buffer movement (August, 1985).
// % Version 2.9 allows nonnumeric macros before their def (December, 1988).
// % Version 3, for Sewell's book, fixed long-line bug in input_ln (March, 1989).
// % Version 4 was major change to allow 8-bit input (September, 1989).
// % Version 4.1 conforms to ANSI standard for-loop rules (September, 1990).
// % Version 4.2 fixes stat report if phase one dies (March, 1991).
// % Version 4.3 fixes @ bug in verbatim, catches extra ] (September, 1991).
// % Version 4.4 activates debug_help on errors as advertised (February, 1993).
// % Version 4.5 prevents modno-comments from being split across lines (Dec 2002).
// % Version 4.6 fixes archaic @z logic; is again big enough for TeX (Jan 2021).
//
// % 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]
// \def\pb[$\.|\ldots\.|$] % Pascal brackets (|...|)
// \def\v[\.[\char'174]] % vertical (|) in typewriter font
// \mathchardef\BA="3224 % double arrow
// \def\([] % kludge for alphabetizing certain module names
//
// \def\title[TANGLE]
// \def\contentspagenumber[125] % should be odd
// \def\topofcontents[\null\vfill
//   \titlefalse % include headline on the contents page
//   \def\rheader[\mainfont Appendix E\hfil \contentspagenumber]
//   \centerline[\titlefont The [\ttitlefont TANGLE] processor]
//   \vskip 15pt
//   \centerline[(Version 4.6)]
//   \vfill]
// \pageno=\contentspagenumber \advance\pageno by 1
//
//

// 1. Introduction

// tangle:pos tangle.web:45:17:

// This program converts a \.[WEB] file to a \PASCAL\ file. It was written
// by D. E. Knuth in September, 1981; a somewhat similar [\mc SAIL] program had
// been developed in March, 1979. Since this program describes itself, a
// bootstrapping process involving hand-translation had to be used to get started.
//
// For large \.[WEB] files one should have a large memory, since \.[TANGLE] keeps
// all the \PASCAL\ text in memory (in an abbreviated form). The program uses
// a few features of the local \PASCAL\ compiler that may need to be changed in
// other installations:
//
// \yskip\item[1)] Case statements have a default.
// \item[2)] Input-output routines may need to be adapted for use with a particular
// character set and/or for printing messages on the user's terminal.
//
// \yskip\noindent
// These features are also present in the \PASCAL\ version of \TeX, where they
// are used in a similar (but more complex) way. System-dependent portions
// of \.[TANGLE] can be identified by looking at the entries for `system
// dependencies' in the index below.
//  \xref[system dependencies]
//
// The ``banner line'' defined here should be changed whenever \.[TANGLE]
// is modified.

// 2.

// tangle:pos tangle.web:72:3:

// The program begins with a fairly normal header, made up of pieces that
// \xref[system dependencies]
// will mostly be filled in later. The \.[WEB] input comes from files |web_file|
// and |change_file|, the \PASCAL\ output goes to file |Pascal_file|,
// and the string pool output goes to file |pool|.
//
// If it is necessary to abort the job because of a fatal error, the program
// calls the `|jump_out|' procedure, which goes to the label |end_of_TANGLE|.
// \4
// Compiler directives
// $C-,A+,D-
// no range check, catch arithmetic overflow, no debug overhead
//  [$C+,D+]  [  ]
// but turn everything on when debugging

package tangle

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 (
	endOfTangle     = 9999           /* go here to wrap it up */
	exit            = 10             /* go here to leave a procedure */
	restart         = 20             /* go here to start a procedure again */
	reswitch        = 21             /* go here to start a case statement again */
	continue1       = 22             /* go here to resume a loop */
	done            = 30             /* go here to exit a loop */
	found           = 31             /* go here when you've found it */
	notFound        = 32             /* go here when you've found something else */
	spotless        = 0              /* |history| value for normal jobs */
	harmlessMessage = 1              /* |history| value when non-serious info was printed */
	errorMessage    = 2              /* |history| value when an error was noted */
	fatalMessage    = 3              /* |history| value when we had to stop prematurely */
	firstTextChar   = 0              /* ordinal number of the smallest element of |text_char| */
	lastTextChar    = 255            /* ordinal number of the largest element of |text_char| */
	andSign         = 04             /* equivalent to `\.[and]' */
	notSign         = 05             /* equivalent to `\.[not]' */
	setElementSign  = 06             /* equivalent to `\.[in]' */
	tabMark         = 011            /* ASCII code used as tab-skip */
	lineFeed        = 012            /* ASCII code thrown away at end of line */
	formFeed        = 014            /* ASCII code used at end of page */
	carriageReturn  = 015            /* ASCII code used at end of line */
	leftArrow       = 030            /* equivalent to `\.[:=]' */
	notEqual        = 032            /* equivalent to `\.[<>]' */
	lessOrEqual     = 034            /* equivalent to `\.[<=]' */
	greaterOrEqual  = 035            /* equivalent to `\.[>=]' */
	equivalenceSign = 036            /* equivalent to `\.[==]' */
	orSign          = 037            /* equivalent to `\.[or]' */
	ww              = 2              /* we multiply the byte capacity by approximately this amount */
	zz              = 3              /* we multiply the token capacity by approximately this amount */
	normal          = 0              /* ordinary identifiers have |normal| ilk */
	numeric         = 1              /* numeric macros and strings have |numeric| ilk */
	simple          = 2              /* simple macros have |simple| ilk */
	parametric      = 3              /* parametric macros have |parametric| ilk */
	less            = 0              /* the first name is lexicographically less than the second */
	equal           = 1              /* the first name is equal to the second */
	greater         = 2              /* the first name is lexicographically greater than the second */
	prefix          = 3              /* the first name is a proper prefix of the second */
	extension       = 4              /* the first name is a proper extension of the second */
	param           = 0              /* ASCII null code will not appear */
	verbatim        = 02             /* extended ASCII alpha should not appear */
	forceLine       = 03             /* extended ASCII beta should not appear */
	beginComment    = 011            /* ASCII tab mark will not appear */
	endComment      = 012            /* ASCII line feed will not appear */
	octal           = 014            /* ASCII form feed will not appear */
	hex             = 015            /* ASCII carriage return will not appear */
	doubleDot       = 040            /* ASCII space will not appear except in strings */
	checkSum        = 0175           /* will not be confused with right brace */
	join            = 0177           /* ASCII delete will not appear */
	number          = 0200           /* code returned by |get_output| when next output is numeric */
	moduleNumber    = 0201           /* code returned by |get_output| for module numbers */
	identifier      = 0202           /* code returned by |get_output| for identifiers */
	misc            = 0              /* state associated with special characters */
	numOrId         = 1              /* state associated with numbers and identifiers */
	sign            = 2              /* state associated with pending \.+ or \.- */
	signVal         = numOrId + 2    /* state associated with pending sign and value */
	signValSign     = sign + 2       /* |sign_val| followed by another pending sign */
	signValVal      = signVal + 2    /* |sign_val| followed by another pending value */
	unbreakable     = signValVal + 1 /* state associated with \.[@\&] */
	str             = 1              /* |send_out| code for a string */
	ident           = 2              /* |send_out| code for an identifier */
	frac            = 3              /* |send_out| code for a fraction */
	badCase         = 666            /* this is a label used below */
	getFraction     = 2              /* this label is used below */
	ignore          = 0              /* control code of no interest to \.[TANGLE] */
	controlText     = 0203           /* control code for `\.[@t]', `\.[@\^]', etc. */
	format          = 0204           /* control code for `\.[@f]' */
	definition      = 0205           /* control code for `\.[@d]' */
	beginPascal     = 0206           /* control code for `\.[@p]' */
	moduleName      = 0207           /* control code for `\.[@<]' */
	newModule       = 0210           /* control code for `\.[@\ ]' and `\.[@*]' */
	breakpoint      = 888            // place where a breakpoint is desirable
	// \xref[system dependencies]

	// Constants in the outer block
	bufSize  = 100   // maximum length of input line
	maxBytes = 45000 // |1/ww| times the number of bytes in identifiers,
	//   strings, and module names; must be less than 65536

	maxToks = 65000 // |1/zz| times the number of bytes in compressed \PASCAL\ code;
	//   must be less than 65536

	maxNames = 4000 // number of identifiers, strings, module names;
	//   must be less than 10240

	maxTexts    = 2000 // number of replacement texts, must be less than 10240
	hashSize    = 353  // should be prime
	longestName = 400  // module names shouldn't be longer than this
	lineLength  = 72   // lines of \PASCAL\ output have at most this many characters
	outBufSize  = 144  // length of output buffer, should be twice |line_length|
	stackSize   = 50   // number of simultaneous levels of macro expansion
	maxIdLength = 32   // long identifiers are chopped to this length, which must
	//   not exceed |line_length|

	unambigLength = 32 // identifiers must be unique if chopped to this length
)

type (
	// Types in the outer block
	asciiCode = /* 0..255 */ byte // eight-bit numbers, a subrange of the integers

	textFile = knuth.File

	eightBits   = /* 0..255 */ byte     // unsigned one-byte quantity
	sixteenBits = /* 0..65535 */ uint16 // unsigned two-byte quantity

	namePointer = /* 0..maxNames */ uint16 // identifies a name

	textPointer = /* 0..maxTexts */ uint16 // identifies a replacement text

	// \4
	outputState = struct {
		endField  sixteenBits // ending location of replacement text
		byteField sixteenBits // present location within replacement text
		nameField namePointer // |byte_start| index for text being output
		replField textPointer // |tok_start| index for text being output
		modField  uint16      // module number or zero if not a module
	}
)

type prg struct {
	stdin, stdout, stderr knuth.File
	/* Globals in the outer block  */ history/* spotless..fatalMessage */ byte // how bad was this run?

	xord [256]asciiCode
	// specifies conversion of input characters
	xchr [256]char
	// specifies conversion of output characters

	termOut textFile // the terminal as an output file

	webFile    textFile // primary input
	changeFile textFile // updates

	pascalFile textFile
	pool       textFile

	buffer [101]asciiCode

	phaseOne bool // |true| in Phase I, |false| in Phase II

	byteMem [2][45001]asciiCode
	// characters of names
	tokMem    [3][65001]eightBits // tokens
	byteStart [4001]sixteenBits   // directory into |byte_mem|
	tokStart  [2001]sixteenBits   // directory into |tok_mem|
	link      [4001]sixteenBits   // hash table or tree links
	ilk       [4001]sixteenBits   // type codes or tree links
	equiv     [4001]sixteenBits   // info corresponding to names
	textLink  [2001]sixteenBits   // relates replacement texts

	namePtr   namePointer // first unused position in |byte_start|
	stringPtr namePointer // next number to be given to a string of length |<>1|
	bytePtr   [2] /* 0..maxBytes */ uint16
	// first unused position in |byte_mem|
	poolCheckSum int32 // sort of a hash for the whole string pool

	// \hskip1em
	textPtr textPointer // first unused position in |tok_start|
	// \hskip1em
	tokPtr [3] /* 0..maxToks */ uint16
	// first unused position in a given segment of |tok_mem|
	// \hskip1em
	z/* 0..zz-1 */ byte // current segment of |tok_mem|
	//   max_tok_ptr:array[0..zz-1] of 0..max_toks;
	//   [largest values assumed by |tok_ptr|]
	// [  ]

	idFirst/* 0..bufSize */ byte     // where the current identifier begins in the buffer
	idLoc/* 0..bufSize */ byte       // just after the current identifier in the buffer
	doubleChars/* 0..bufSize */ byte // correction to length in case of strings

	hash, chopHash [354]sixteenBits // heads of hash lists
	choppedId      [33]asciiCode    // chopped identifier

	modText [401]asciiCode // name being sought for

	lastUnnamed textPointer // most recent replacement text of unnamed module

	curState outputState // |cur_end|, |cur_byte|, |cur_name|,
	//   |cur_repl|, |cur_mod|

	stack                           [50]outputState // info for non-current levels
	stackPtr/* 0..stackSize */ byte // first unused location in the output state stack

	zo/* 0..zz-1 */ byte // the segment of |tok_mem| from which output is coming

	braceLevel eightBits // current depth of $\.[@\[]\ldots\.[@\]]$ nesting

	curVal int32 // additional information corresponding to output token

	outBuf                           [145]asciiCode // assembled characters
	outPtr/* 0..outBufSize */ byte   // first available place in |out_buf|
	breakPtr/* 0..outBufSize */ byte // last breaking place in |out_buf|
	semiPtr/* 0..outBufSize */ byte  // last semicolon breaking place in |out_buf|

	outState                    eightBits // current status of partial output
	outVal, outApp              int32     // pending values
	outSign                     asciiCode // sign to use if appending |out_val>=0|
	lastSign/*  -1.. +1 */ int8 // sign to use if appending a zero

	outContrib [72]asciiCode // a contribution to |out_buf|

	ii1       int32 // general purpose |for| loop variable in the outer block
	line      int32 // the number of the current line in the current file
	otherLine int32 // the number of the current line in the input file that
	//   is not currently being read

	tempLine                   int32 // used when interchanging |line| with |other_line|
	limit/* 0..bufSize */ byte // the last character position occupied in the buffer
	loc/* 0..bufSize */ byte   // the next character position to be read from the buffer
	inputHasEnded              bool // if |true|, there is no more input
	changing                   bool // if |true|, the current line is from |change_file|

	changeBuffer                     [101]asciiCode
	changeLimit/* 0..bufSize */ byte // the last position occupied in |change_buffer|

	curModule   namePointer // name of module just scanned
	scanningHex bool        // are we scanning a hexadecimal constant?

	nextControl eightBits // control code waiting to be acted upon

	curReplText textPointer // replacement text formed by |scan_repl|

	moduleCount/* 0..027777 */ uint16 // the current module number

	//  trouble_shooting:boolean; [is |debug_help| wanted?]
	//  ddt:integer; [operation code for the |debug_help| routine]
	//  dd:integer; [operand in procedures performed by |debug_help|]
	//  debug_cycle:integer; [threshold for |debug_help| stopping]
	//  debug_skipped:integer; [we have skipped this many |debug_help| calls]
	//  term_in:text_file; [the user's terminal as an input file]
	// [  ]

	//   wo:0..ww-1; [segment of memory for which statistics are being printed]
	// [  ]

	// Error handling procedures
	//
	//	procedure debug_help; forward;  [  ]
}

func (prg *prg) error1() { // prints '\..' and location of error message
	var (
		j/* 0..outBufSize */ byte // index into |out_buf|
		k, l/* 0..bufSize */ byte // indices into |buffer|
	)
	if prg.phaseOne {
		if prg.changing {
			prg.stdout.Write(". (change file ")
		} else {
			prg.stdout.Write(". (")
		}
		prg.stdout.Writeln("l.", prg.line, knuth.WriteWidth(1), ")")
		if int32(prg.loc) >= int32(prg.limit) {
			l = prg.limit
		} else {
			l = prg.loc
		}
		for ii := int32(1); ii <= int32(l); ii++ {
			k = byte(ii)
			_ = k
			if int32(prg.buffer[int32(k)-1]) == tabMark {
				prg.stdout.Write(" ")
			} else {
				prg.stdout.Write(string(rune(prg.xchr[prg.buffer[int32(k)-1]])))
			}
		} // print the characters already read
		prg.stdout.Writeln()
		for ii := int32(1); ii <= int32(l); ii++ {
			k = byte(ii)
			_ = k
			prg.stdout.Write(" ")
		} // space out the next line
		for ii := int32(l) + 1; ii <= int32(prg.limit); ii++ {
			k = byte(ii)
			_ = k
			prg.stdout.Write(string(rune(prg.xchr[prg.buffer[int32(k)-1]])))
		} // print the part not yet read
		prg.stdout.Write(" ") // this space separates the message from future asterisks
	} else {
		// Print error location based on output buffer
		prg.stdout.Writeln(". (l.", prg.line, knuth.WriteWidth(1), ")")
		for ii := int32(1); ii <= int32(prg.outPtr); ii++ {
			j = byte(ii)
			_ = j
			prg.stdout.Write(string(rune(prg.xchr[prg.outBuf[int32(j)-1]])))
		} // print current partial line
		prg.stdout.Write("... ") // indicate that this information is partial
	}
	prg.history = byte(errorMessage)
	//  debug_skipped:=debug_cycle; debug_help; [  ]
}

func (prg *prg) jumpOut() {
	panic(signal(endOfTangle))
}

func (prg *prg) initialize() {
	var (
		// Local variables for initialization
		i/* 0..255 */ byte

		wi/* 0..ww-1 */ byte // to initialize the |byte_mem| indices

		zi/* 0..zz-1 */ byte // to initialize the |tok_mem| indices

		h/* 0..hashSize */ uint16 // index into hash-head arrays
	)
	prg.history = byte(spotless)

	prg.xchr[040] = ' '
	prg.xchr[041] = '!'
	prg.xchr[042] = '"'
	prg.xchr[043] = '#'
	prg.xchr[044] = '$'
	prg.xchr[045] = '%'
	prg.xchr[046] = '&'
	prg.xchr[047] = '\''

	prg.xchr[050] = '('
	prg.xchr[051] = ')'
	prg.xchr[052] = '*'
	prg.xchr[053] = '+'
	prg.xchr[054] = ','
	prg.xchr[055] = '-'
	prg.xchr[056] = '.'
	prg.xchr[057] = '/'

	prg.xchr[060] = '0'
	prg.xchr[061] = '1'
	prg.xchr[062] = '2'
	prg.xchr[063] = '3'
	prg.xchr[064] = '4'
	prg.xchr[065] = '5'
	prg.xchr[066] = '6'
	prg.xchr[067] = '7'

	prg.xchr[070] = '8'
	prg.xchr[071] = '9'
	prg.xchr[072] = ':'
	prg.xchr[073] = ';'
	prg.xchr[074] = '<'
	prg.xchr[075] = '='
	prg.xchr[076] = '>'
	prg.xchr[077] = '?'

	prg.xchr[0100] = '@'
	prg.xchr[0101] = 'A'
	prg.xchr[0102] = 'B'
	prg.xchr[0103] = 'C'
	prg.xchr[0104] = 'D'
	prg.xchr[0105] = 'E'
	prg.xchr[0106] = 'F'
	prg.xchr[0107] = 'G'

	prg.xchr[0110] = 'H'
	prg.xchr[0111] = 'I'
	prg.xchr[0112] = 'J'
	prg.xchr[0113] = 'K'
	prg.xchr[0114] = 'L'
	prg.xchr[0115] = 'M'
	prg.xchr[0116] = 'N'
	prg.xchr[0117] = 'O'

	prg.xchr[0120] = 'P'
	prg.xchr[0121] = 'Q'
	prg.xchr[0122] = 'R'
	prg.xchr[0123] = 'S'
	prg.xchr[0124] = 'T'
	prg.xchr[0125] = 'U'
	prg.xchr[0126] = 'V'
	prg.xchr[0127] = 'W'

	prg.xchr[0130] = 'X'
	prg.xchr[0131] = 'Y'
	prg.xchr[0132] = 'Z'
	prg.xchr[0133] = '['
	prg.xchr[0134] = '\\'
	prg.xchr[0135] = ']'
	prg.xchr[0136] = '^'
	prg.xchr[0137] = '_'

	prg.xchr[0140] = '`'
	prg.xchr[0141] = 'a'
	prg.xchr[0142] = 'b'
	prg.xchr[0143] = 'c'
	prg.xchr[0144] = 'd'
	prg.xchr[0145] = 'e'
	prg.xchr[0146] = 'f'
	prg.xchr[0147] = 'g'

	prg.xchr[0150] = 'h'
	prg.xchr[0151] = 'i'
	prg.xchr[0152] = 'j'
	prg.xchr[0153] = 'k'
	prg.xchr[0154] = 'l'
	prg.xchr[0155] = 'm'
	prg.xchr[0156] = 'n'
	prg.xchr[0157] = 'o'

	prg.xchr[0160] = 'p'
	prg.xchr[0161] = 'q'
	prg.xchr[0162] = 'r'
	prg.xchr[0163] = 's'
	prg.xchr[0164] = 't'
	prg.xchr[0165] = 'u'
	prg.xchr[0166] = 'v'
	prg.xchr[0167] = 'w'

	prg.xchr[0170] = 'x'
	prg.xchr[0171] = 'y'
	prg.xchr[0172] = 'z'
	prg.xchr[0173] = '{'
	prg.xchr[0174] = '|'
	prg.xchr[0175] = '}'
	prg.xchr[0176] = '~'

	prg.xchr[0] = ' '
	prg.xchr[0177] = ' ' // these ASCII codes are not used

	for ii := int32(1); ii <= 037; ii++ {
		i = byte(ii)
		_ = i
		prg.xchr[i] = ' '
	}
	for ii := int32(0200); ii <= 0377; ii++ {
		i = byte(ii)
		_ = i
		prg.xchr[i] = ' '
	}

	for ii := int32(firstTextChar); ii <= lastTextChar; ii++ {
		i = byte(ii)
		_ = i
		prg.xord[i] = ' '
	}
	for ii := int32(1); ii <= 0377; ii++ {
		i = byte(ii)
		_ = i
		prg.xord[prg.xchr[i]] = i
	}
	prg.xord[' '] = ' '

	prg.pascalFile.Rewrite()
	prg.pool.Rewrite()

	for ii := int32(0); ii <= ww-1; ii++ {
		wi = byte(ii)
		_ = wi
		prg.byteStart[wi] = 0
		prg.bytePtr[wi] = 0
	}
	prg.byteStart[ww] = 0 // this makes name 0 of length zero
	prg.namePtr = 1
	prg.stringPtr = 256
	prg.poolCheckSum = 271828

	for ii := int32(0); ii <= zz-1; ii++ {
		zi = byte(ii)
		_ = zi
		prg.tokStart[zi] = 0
		prg.tokPtr[zi] = 0
	}
	prg.tokStart[zz] = 0 // this makes replacement text 0 of length zero
	prg.textPtr = 1
	prg.z = byte(1 % zz)

	prg.ilk[0] = 0   // the binary search tree starts out with nothing in it
	prg.equiv[0] = 0 // the undefined module has no replacement text

	for ii := int32(0); ii <= hashSize-1; ii++ {
		h = uint16(ii)
		_ = h
		prg.hash[h] = 0
		prg.chopHash[h] = 0
	}

	prg.lastUnnamed = 0
	prg.textLink[0] = 0

	prg.scanningHex = false

	prg.modText[0] = ' '

	//  trouble_shooting:=true; debug_cycle:=1; debug_skipped:=0;
	//
	// trouble_shooting:=false; debug_cycle:=99999; [use these when it almost works]
	// reset(term_in,'TTY:','/I'); [open |term_in| as the terminal, don't do a |get|]
	// [  ]

}

// 3.

// tangle:pos tangle.web:95:3:

// Some of this code is optional for use when debugging only;
// such material is enclosed between the delimiters |debug| and $|gubed|$.
// Other parts, delimited by |stat| and $|tats|$, are optionally included if
// statistics about \.[TANGLE]'s memory usage are desired.

// 5.

// tangle:pos tangle.web:124:3:

// Labels are given symbolic names by the following definitions. We insert
// the label `|exit|:' just before the `\ignorespaces|end|\unskip' of a
// procedure in which we have used the `|return|' statement defined below;
// the label `|restart|' is occasionally used at the very beginning of a
// procedure; and the label `|reswitch|' is occasionally used just prior to
// a \&[case] statement in which some cases change the conditions and we wish to
// branch to the newly applicable case.
// Loops that are set up with the \&[loop] construction defined below are
// commonly exited by going to `|done|' or to `|found|' or to `|not_found|',
// and they are sometimes repeated by going to `|continue|'.

// 6.

// tangle:pos tangle.web:143:3:

// Here are some macros for common programming idioms.

// 7.

// tangle:pos tangle.web:153:3:

// We assume that |case| statements may include a default case that applies
// if no matching label is found. Thus, we shall use constructions like
// \xref[system dependencies]
// $$\vbox[\halign[#\hfil\cr
// |case x of|\cr
// 1: $\langle\,$code for $x=1\,\rangle$;\cr
// 3: $\langle\,$code for $x=3\,\rangle$;\cr
// |othercases| $\langle\,$code for |x<>1| and |x<>3|$\,\rangle$\cr
// |endcases|\cr]]$$
// since most \PASCAL\ compilers have plugged this hole in the language by
// incorporating some sort of default mechanism. For example, the compiler
// used to develop \.[WEB] and \TeX\ allows `|others|:' as a default label,
// and other \PASCAL s allow syntaxes like `\ignorespaces|else|\unskip' or
// `\&[otherwise]' or `\\[otherwise]:', etc. The definitions of |othercases|
// and |endcases| should be changed to agree with local conventions. (Of
// course, if no default mechanism is available, the |case| statements of
// this program must be extended by listing all remaining cases. The author
// would have taken the trouble to modify \.[TANGLE] so that such extensions
// were done automatically, if he had not wanted to encourage \PASCAL\
// compiler writers to make this important change in \PASCAL, where it belongs.)

// 15.

// tangle:pos tangle.web:432:3:

// Some of the ASCII codes below @'40 have been given symbolic names in
// \.[WEAVE] and \.[TANGLE] because they are used with a special meaning.

// 19. Input and output

// tangle:pos tangle.web:494:21:

// The input conventions of this program are intended to be very much like those
// of \TeX\ (except, of course, that they are much simpler, because much less
// needs to be done). Furthermore they are identical to those of \.[WEAVE].
// Therefore people who need to make modifications to all three systems
// should be able to do so without too many headaches.
//
// We use the standard \PASCAL\ input/output procedures in several places that
// \TeX\ cannot, since \.[TANGLE] does not have to deal with files that are named
// dynamically by the user, and since there is no input from the terminal.

// 22.

// tangle:pos tangle.ch:77:3:

// The |update_terminal| procedure is called when we want
// to make sure that everything we have output to the terminal so far has
// actually left the computer's internal buffers and been sent.
// \xref[system dependencies]

// 24.

// tangle:pos tangle.web:541:3:

// The following code opens the input files.  Since these files were listed
// in the program header, we assume that the \PASCAL\ runtime system has
// already checked that suitable file names have been given; therefore no
// additional error checking needs to be done.
// \xref[system dependencies]
func (prg *prg) openInput() {
	prg.webFile.Reset()
	prg.changeFile.Reset()
}

// 28.

// tangle:pos tangle.web:571:3:

// The |input_ln| procedure brings the next line of input from the specified
// file into the |buffer| array and returns the value |true|, unless the file has
// already been entirely read, in which case it returns |false|. The conventions
// of \TeX\ are followed; i.e., |ASCII_code| numbers representing the next line
// of the file are input into |buffer[0]|, |buffer[1]|, \dots,
// |buffer[limit-1]|; trailing blanks are ignored;
// and the global variable |limit| is set to the length of the
// \xref[system dependencies]
// line. The value of |limit| must be strictly less than |buf_size|.
//
// We assume that none of the |ASCII_code| values
// of |buffer[j]| for |0<=j<limit| is equal to 0, @'177, |line_feed|, |form_feed|,
// or |carriage_return|.
func (prg *prg) inputLn(f textFile) (r bool) {
	// inputs a line or returns |false|
	var (
		finalLimit /* 0..bufSize */ byte // |limit| without trailing blanks
	)
	prg.limit = 0
	finalLimit = 0
	if f.EOF() {
		r = false
	} else {
		for !f.EOLN() {
			prg.buffer[prg.limit] = prg.xord[*f.ByteP()]
			f.Get()
			prg.limit = byte(int32(prg.limit) + 1)
			if int32(prg.buffer[int32(prg.limit)-1]) != ' ' {
				finalLimit = prg.limit
			}
			if int32(prg.limit) == bufSize {
				for !f.EOLN() {
					f.Get()
				}
				prg.limit = byte(int32(prg.limit) - 1) // keep |buffer[buf_size]| empty
				if int32(finalLimit) > int32(prg.limit) {
					finalLimit = prg.limit
				}
				{
					prg.stdout.Writeln()
					prg.stdout.Write("! Input line too long")
				}
				prg.loc = 0
				prg.error1()
				// \xref[Input line too long]
			}
		}
		f.Readln()
		prg.limit = finalLimit
		r = true
	}
	return r
}

// 35.

// tangle:pos tangle.web:699:3:

// Sometimes the program's behavior is far different from what it should be,
// and \.[TANGLE] prints an error message that is really for the \.[TANGLE]
// maintenance person, not the user. In such cases the program says
// |confusion('indication of where we are')|.

// 36.

// tangle:pos tangle.web:707:3:

// An overflow stop occurs if \.[TANGLE]'s tables aren't large enough.

// 47.

// tangle:pos tangle.web:851:3:

// Four types of identifiers are distinguished by their |ilk|:
//
// \yskip\hang |normal| identifiers will appear in the \PASCAL\ program as
// ordinary identifiers since they have not been defined to be macros; the
// corresponding value in the |equiv| array
// for such identifiers is a link in a secondary hash table that
// is used to check whether any two of them agree in their first |unambig_length|
// characters after underline symbols are removed and lowercase letters are
// changed to uppercase.
//
// \yskip\hang |numeric| identifiers have been defined to be numeric macros;
// their |equiv| value contains the corresponding numeric value plus $2^[15]$.
// Strings are treated as numeric macros.
//
// \yskip\hang |simple| identifiers have been defined to be simple macros;
// their |equiv| value points to the corresponding replacement text.
//
// \yskip\hang |parametric| identifiers have been defined to be parametric macros;
// like simple identifiers, their |equiv| value points to the replacement text.

// 49.

// tangle:pos tangle.web:893:3:

// Here is a little procedure that prints the text of a given name.
func (prg *prg) printId(p namePointer) { // print identifier or module name
	var (
		k/* 0..maxBytes */ uint16 // index into |byte_mem|
		w/* 0..ww-1 */ byte       // segment of |byte_mem|
	)
	if int32(p) >= int32(prg.namePtr) {
		prg.stdout.Write("IMPOSSIBLE")
	} else {
		w = byte(int32(p) % ww)
		for ii := int32(prg.byteStart[p]); ii <= int32(prg.byteStart[int32(p)+ww])-1; ii++ {
			k = uint16(ii)
			_ = k
			prg.stdout.Write(string(rune(prg.xchr[prg.byteMem[w][k]])))
		}
	}
}

// 53.

// tangle:pos tangle.web:957:3:

// Here now is the main procedure for finding identifiers (and strings).
// The parameter |t| is set to |normal| except when the identifier is
// a macro name that is just being defined; in the latter case, |t| will be
// |numeric|, |simple|, or |parametric|.
func (prg *prg) idLookup(t eightBits) (r namePointer) {
	var (
		c                            eightBits   // byte being chopped
		i/* 0..bufSize */ byte                   // index into |buffer|
		h/* 0..hashSize */ uint16                // hash code
		k/* 0..maxBytes */ uint16                // index into |byte_mem|
		w/* 0..ww-1 */ byte                      // segment of |byte_mem|
		l/* 0..bufSize */ byte                   // length of the given identifier
		p, q                         namePointer // where the identifier is being sought
		s/* 0..unambigLength */ byte             // index into |chopped_id|
	)
	l = byte(int32(prg.idLoc) - int32(prg.idFirst)) // compute the length

	// Compute the hash code |h|
	h = uint16(prg.buffer[prg.idFirst])
	i = byte(int32(prg.idFirst) + 1)
	for int32(i) < int32(prg.idLoc) {
		h = uint16((int32(h) + int32(h) + int32(prg.buffer[i])) % hashSize)
		i = byte(int32(i) + 1)
	}

	// Compute the name location |p|
	p = prg.hash[h]
	for int32(p) != 0 {
		if int32(prg.byteStart[int32(p)+ww])-int32(prg.byteStart[p]) == int32(l) {
			i = prg.idFirst
			k = prg.byteStart[p]
			w = byte(int32(p) % ww)
			for int32(i) < int32(prg.idLoc) && int32(prg.buffer[i]) == int32(prg.byteMem[w][k]) {
				i = byte(int32(i) + 1)
				k = uint16(int32(k) + 1)
			}
			if int32(i) == int32(prg.idLoc) {
				goto found
			} // all characters agree
		}
		p = prg.link[p]
	}
	p = prg.namePtr // the current identifier is new
	prg.link[p] = prg.hash[h]
	prg.hash[h] = p // insert |p| at beginning of hash list
	// insert |p| at beginning of hash list
found:
	;
	if int32(p) == int32(prg.namePtr) || int32(t) != normal {
		if int32(p) != int32(prg.namePtr) && int32(t) != normal && int32(prg.ilk[p]) == normal || int32(p) == int32(prg.namePtr) && int32(t) == normal && int32(prg.buffer[prg.idFirst]) != '"' {
			i = prg.idFirst
			s = 0
			h = 0
			for int32(i) < int32(prg.idLoc) && int32(s) < unambigLength {
				if int32(prg.buffer[i]) != '_' {
					if int32(prg.buffer[i]) >= 'a' {
						prg.choppedId[s] = byte(int32(prg.buffer[i]) - 040)
					} else {
						prg.choppedId[s] = prg.buffer[i]
					}
					h = uint16((int32(h) + int32(h) + int32(prg.choppedId[s])) % hashSize)
					s = byte(int32(s) + 1)
				}
				i = byte(int32(i) + 1)
			}
			prg.choppedId[s] = 0
		}
		if int32(p) != int32(prg.namePtr) {
			if int32(prg.ilk[p]) == normal {
				if int32(t) == numeric {
					prg.stdout.Writeln()
					prg.stdout.Write("! This identifier has already appeared")
					prg.error1()
				}
				// \xref[This identifier has already...]

				// Remove |p| from secondary hash table
				q = prg.chopHash[h]
				if int32(q) == int32(p) {
					prg.chopHash[h] = prg.equiv[p]
				} else {
					for int32(prg.equiv[q]) != int32(p) {
						q = prg.equiv[q]
					}
					prg.equiv[q] = prg.equiv[p]
				}
			} else {
				prg.stdout.Writeln()
				prg.stdout.Write("! This identifier was defined before")
				prg.error1()
			}
			// \xref[This identifier was defined...]
			prg.ilk[p] = uint16(t)
		} else {
			// Enter a new identifier into the table at position |p|
			if int32(t) == normal && int32(prg.buffer[prg.idFirst]) != '"' {
				q = prg.chopHash[h]
				for int32(q) != 0 {
					{
						k = prg.byteStart[q]
						s = 0
						w = byte(int32(q) % ww)
						for int32(k) < int32(prg.byteStart[int32(q)+ww]) && int32(s) < unambigLength {
							c = prg.byteMem[w][k]
							if int32(c) != '_' {
								if int32(c) >= 'a' {
									c = byte(int32(c) - 040)
								} // merge lowercase with uppercase
								if int32(prg.choppedId[s]) != int32(c) {
									goto notFound
								}
								s = byte(int32(s) + 1)
							}
							k = uint16(int32(k) + 1)
						}
						if int32(k) == int32(prg.byteStart[int32(q)+ww]) && int32(prg.choppedId[s]) != 0 {
							goto notFound
						}
						{
							prg.stdout.Writeln()
							prg.stdout.Write("! Identifier conflict with ")
						}
						// \xref[Identifier conflict...]
						for ii := int32(prg.byteStart[q]); ii <= int32(prg.byteStart[int32(q)+ww])-1; ii++ {
							k = uint16(ii)
							_ = k
							prg.stdout.Write(string(rune(prg.xchr[prg.byteMem[w][k]])))
						}
						prg.error1()
						q = 0 // only one conflict will be printed, since |equiv[0]=0|
						// only one conflict will be printed, since |equiv[0]=0|
					notFound:
					}
					q = prg.equiv[q]
				}
				prg.equiv[p] = prg.chopHash[h]
				prg.chopHash[h] = p // put |p| at front of secondary list
			}
			w = byte(int32(prg.namePtr) % ww)
			k = prg.bytePtr[w]
			if int32(k)+int32(l) > maxBytes {
				prg.stderr.Writeln("! Sorry, ", "byte memory", " capacity exceeded")
				prg.error1()
				prg.history = byte(fatalMessage)
				prg.jumpOut()
			}
			if int32(prg.namePtr) > maxNames-ww {
				prg.stderr.Writeln("! Sorry, ", "name", " capacity exceeded")
				prg.error1()
				prg.history = byte(fatalMessage)
				prg.jumpOut()
			}
			i = prg.idFirst // get ready to move the identifier into |byte_mem|
			for int32(i) < int32(prg.idLoc) {
				prg.byteMem[w][k] = prg.buffer[i]
				k = uint16(int32(k) + 1)
				i = byte(int32(i) + 1)
			}
			prg.bytePtr[w] = k
			prg.byteStart[int32(prg.namePtr)+ww] = k
			prg.namePtr = uint16(int32(prg.namePtr) + 1)
			if int32(prg.buffer[prg.idFirst]) != '"' {
				prg.ilk[p] = uint16(t)
			} else {
				// Define and output a new string of the pool
				prg.ilk[p] = uint16(numeric) // strings are like numeric macros
				if int32(l)-int32(prg.doubleChars) == 2 {
					prg.equiv[p] = uint16(int32(prg.buffer[int32(prg.idFirst)+1]) + 0100000)
				} else {
					prg.equiv[p] = uint16(int32(prg.stringPtr) + 0100000)
					l = byte(int32(l) - int32(prg.doubleChars) - 1)
					if int32(l) > 99 {
						prg.stdout.Writeln()
						prg.stdout.Write("! Preprocessed string is too long")
						prg.error1()
					}
					// \xref[Preprocessed string is too long]
					prg.stringPtr = uint16(int32(prg.stringPtr) + 1)
					prg.pool.Write(string(rune(prg.xchr['0'+int32(l)/10])), string(rune(prg.xchr['0'+int32(l)%10]))) // output the length
					prg.poolCheckSum = prg.poolCheckSum + prg.poolCheckSum + int32(l)
					for prg.poolCheckSum > 03777777667 {
						prg.poolCheckSum = prg.poolCheckSum - 03777777667
					}
					i = byte(int32(prg.idFirst) + 1)
					for int32(i) < int32(prg.idLoc) {
						prg.pool.Write(string(rune(prg.xchr[prg.buffer[i]]))) // output characters of string
						prg.poolCheckSum = prg.poolCheckSum + prg.poolCheckSum + int32(prg.buffer[i])
						for prg.poolCheckSum > 03777777667 {
							prg.poolCheckSum = prg.poolCheckSum - 03777777667
						}
						if int32(prg.buffer[i]) == '"' || int32(prg.buffer[i]) == '@' {
							i = byte(int32(i) + 2)
						} else {
							i = byte(int32(i) + 1)
						}
					}
					prg.pool.Writeln()
				}
			}
		}
	}
	r = p
	return r
}

// 66.

// tangle:pos tangle.web:1158:3:

// According to the rules of \.[WEB], no module name
// should be a proper prefix of another, so a ``clean'' comparison should
// occur between any two names. The result of |mod_lookup| is 0 if this
// prefix condition is violated. An error message is printed when such violations
// are detected during phase two of \.[WEAVE].
func (prg *prg) modLookup(l sixteenBits) (r namePointer) {
	var (
		c/* less..extension */ byte              // comparison between two names
		j/* 0..longestName */ uint16             // index into |mod_text|
		k/* 0..maxBytes */ uint16                // index into |byte_mem|
		w/* 0..ww-1 */ byte                      // segment of |byte_mem|
		p                            namePointer // current node of the search tree
		q                            namePointer // father of node |p|
	)
	c = byte(greater)
	q = 0
	p = prg.ilk[0] // |rlink[0]| is the root of the tree
	for int32(p) != 0 {
		{
			k = prg.byteStart[p]
			w = byte(int32(p) % ww)
			c = byte(equal)
			j = 1
			for int32(k) < int32(prg.byteStart[int32(p)+ww]) && int32(j) <= int32(l) && int32(prg.modText[j]) == int32(prg.byteMem[w][k]) {
				k = uint16(int32(k) + 1)
				j = uint16(int32(j) + 1)
			}
			if int32(k) == int32(prg.byteStart[int32(p)+ww]) {
				if int32(j) > int32(l) {
					c = byte(equal)
				} else {
					c = byte(extension)
				}
			} else if int32(j) > int32(l) {
				c = byte(prefix)
			} else if int32(prg.modText[j]) < int32(prg.byteMem[w][k]) {
				c = byte(less)
			} else {
				c = byte(greater)
			}
		}
		q = p
		if int32(c) == less {
			p = prg.link[q]
		} else if int32(c) == greater {
			p = prg.ilk[q]
		} else {
			goto found
		}
	}

	// Enter a new module name into the tree
	w = byte(int32(prg.namePtr) % ww)
	k = prg.bytePtr[w]
	if int32(k)+int32(l) > maxBytes {
		prg.stderr.Writeln("! Sorry, ", "byte memory", " capacity exceeded")
		prg.error1()
		prg.history = byte(fatalMessage)
		prg.jumpOut()
	}
	if int32(prg.namePtr) > maxNames-ww {
		prg.stderr.Writeln("! Sorry, ", "name", " capacity exceeded")
		prg.error1()
		prg.history = byte(fatalMessage)
		prg.jumpOut()
	}
	p = prg.namePtr
	if int32(c) == less {
		prg.link[q] = p
	} else {
		prg.ilk[q] = p
	}
	prg.link[p] = 0
	prg.ilk[p] = 0
	c = byte(equal)
	prg.equiv[p] = 0
	for ii := int32(1); ii <= int32(l); ii++ {
		j = uint16(ii)
		_ = j
		prg.byteMem[w][int32(k)+int32(j)-1] = prg.modText[j]
	}
	prg.bytePtr[w] = uint16(int32(k) + int32(l))
	prg.byteStart[int32(prg.namePtr)+ww] = uint16(int32(k) + int32(l))
	prg.namePtr = uint16(int32(prg.namePtr) + 1)

found:
	if int32(c) != equal {
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Incompatible section names")
			prg.error1()
		}
		p = 0
		// \xref[Incompatible module names]
	}
	r = p
	return r
}

// 69.

// tangle:pos tangle.web:1218:3:

// The |prefix_lookup| procedure is supposed to find exactly one module
// name that has |mod_text[1..l]| as a prefix. Actually the algorithm silently
// accepts also the situation that some module name is a prefix of
// |mod_text[1..l]|, because the user who painstakingly typed in more than
// necessary probably doesn't want to be told about the wasted effort.
func (prg *prg) prefixLookup(l sixteenBits) (r namePointer) { // finds name extension
	var (
		c/* less..extension */ byte               // comparison between two names
		count/* 0..maxNames */ uint16             // the number of hits
		j/* 0..longestName */ uint16              // index into |mod_text|
		k/* 0..maxBytes */ uint16                 // index into |byte_mem|
		w/* 0..ww-1 */ byte                       // segment of |byte_mem|
		p                             namePointer // current node of the search tree
		q                             namePointer // another place to resume the search after one branch is done
		r1                            namePointer // extension found
	)
	q = 0
	p = prg.ilk[0]
	count = 0
	r1 = 0 // begin search at root of tree
	for int32(p) != 0 {
		{
			k = prg.byteStart[p]
			w = byte(int32(p) % ww)
			c = byte(equal)
			j = 1
			for int32(k) < int32(prg.byteStart[int32(p)+ww]) && int32(j) <= int32(l) && int32(prg.modText[j]) == int32(prg.byteMem[w][k]) {
				k = uint16(int32(k) + 1)
				j = uint16(int32(j) + 1)
			}
			if int32(k) == int32(prg.byteStart[int32(p)+ww]) {
				if int32(j) > int32(l) {
					c = byte(equal)
				} else {
					c = byte(extension)
				}
			} else if int32(j) > int32(l) {
				c = byte(prefix)
			} else if int32(prg.modText[j]) < int32(prg.byteMem[w][k]) {
				c = byte(less)
			} else {
				c = byte(greater)
			}
		}
		if int32(c) == less {
			p = prg.link[p]
		} else if int32(c) == greater {
			p = prg.ilk[p]
		} else {
			r1 = p
			count = uint16(int32(count) + 1)
			q = prg.ilk[p]
			p = prg.link[p]
		}
		if int32(p) == 0 {
			p = q
			q = 0
		}
	}
	if int32(count) != 1 {
		if int32(count) == 0 {
			prg.stdout.Writeln()
			prg.stdout.Write("! Name does not match")
			prg.error1()
		} else {
			prg.stdout.Writeln()
			prg.stdout.Write("! Ambiguous prefix")
			prg.error1()
		}
	}
	// \xref[Ambiguous prefix]
	r = r1 // the result will be 0 if there was no match
	return r
}

// 72.

// tangle:pos tangle.web:1277:3:

// If the first byte of a token is less than @'200, the token occupies a
// single byte. Otherwise we make a sixteen-bit token by combining two consecutive
// bytes |a| and |b|. If |@'200<=a<@'250|, then $(a-@'200)\times2^8+b$ points
// to an identifier; if |@'250<=a<@'320|, then
// $(a-@'250)\times2^8+b$ points to a module name; otherwise, i.e., if
// |@'320<=a<@'400|, then $(a-@'320)\times2^8+b$ is the number of the module
// in which the current replacement text appears.
//
// Codes less than @'200 are 7-bit ASCII codes that represent themselves.
// In particular, a single-character identifier like `|x|' will be a one-byte
// token, while all longer identifiers will occupy two bytes.
//
// Some of the 7-bit ASCII codes will not be present, however, so we can
// use them for special purposes. The following symbolic names are used:
//
// \yskip\hang |param| denotes insertion of a parameter. This occurs only in
// the replacement texts of parametric macros, outside of single-quoted strings
// in those texts.
//
// \hang |begin_comment| denotes \.[@\[], which will become either
// \.[\[] or \.[[].
//
// \hang |end_comment| denotes \.[@\]], which will become either
// \.[\]] or \.[]].
//
// \hang |octal| denotes the \.[@\'] that precedes an octal constant.
//
// \hang |hex| denotes the \.[@"] that precedes a hexadecimal constant.
//
// \hang |check_sum| denotes the \.[@\char'44] that denotes the string pool
// check sum.
//
// \hang |join| denotes the concatenation of adjacent items with no
// space or line breaks allowed between them (the \.[@\&] operation of \.[WEB]).
//
// \hang |double_dot| denotes `\.[..]' in \PASCAL.
//
// \hang |verbatim| denotes the \.[@=] that begins a verbatim \PASCAL\ string.
// The \.[@>] at the end of such a string is also denoted by |verbatim|.
//
// \hang |force_line| denotes the \.[@\\] that forces a new line in the
// \PASCAL\ output.
// \xref[ASCII code]

// 73.

// tangle:pos tangle.web:1332:3:

// The following procedure is used to enter a two-byte value into
// |tok_mem| when a replacement text is being generated.
func (prg *prg) storeTwoBytes(x sixteenBits) {
	if int32(prg.tokPtr[prg.z])+2 > maxToks {
		prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
		prg.error1()
		prg.history = byte(fatalMessage)
		prg.jumpOut()
	}
	prg.tokMem[prg.z][prg.tokPtr[prg.z]] = byte(int32(x) / 0400)          // this could be done by a shift command
	prg.tokMem[prg.z][int32(prg.tokPtr[prg.z])+1] = byte(int32(x) % 0400) // this could be done by a logical and
	prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 2)
}

// 74.

// tangle:pos tangle.web:1343:3:

// When \.[TANGLE] is being operated in debug mode, it has a procedure to display
// a replacement text in symbolic form. This procedure has not been spruced up to
// generate a real great format, but at least the results are not as bad as
// a memory dump.
//  procedure print_repl( p:text_pointer);
// var k:0..max_toks; [index into |tok_mem|]
//  a: sixteen_bits; [current byte(s)]
//  zp: 0..zz-1; [segment of |tok_mem| being accessed]
// begin if p>=text_ptr then write('BAD')
// else  begin k:=tok_start[p]; zp:=p mod zz;
//   while k<tok_start[p+zz] do
//     begin a:=tok_mem[zp,k];
//     if a>=[0200=]128 then
// [ Display two-byte token starting with |a| ]
// begin   k:= k+1 ;
// if a<[0250=]168 then [identifier or string]
//   begin a:=(a-[0200=]128)*[0400=]256+tok_mem[zp,k]; print_id(a);
//   if byte_mem[a mod ww,byte_start[a]]=[""""=]34 then write('"')
//   else write(' ') ;
//   end
// else if a<[0320=]208 then [module name]
//   begin write('@<') ; print_id((a-[0250=]168)*[0400=]256+tok_mem[zp,k]);
//   write('@>') ;
//   end
// else  begin a:=(a-[0320=]208)*[0400=]256+tok_mem[zp,k]; [module number]
//   write('@', xchr[["["=] 123], a: 1,'@', xchr[["]"=] 125]) ; [can't use right brace
//     between \&[debug] and \&[gubed]]
//   end;
// end
//
//     else
// [ Display one-byte token |a| ]
// case a of
// begin_comment: write('@', xchr[["["=] 123]) ;
// end_comment: write('@', xchr[["]"=] 125]) ; [can't use right brace
//     between \&[debug] and \&[gubed]]
// octal: write('@''') ;
// hex: write('@"') ;
// check_sum: write(' 271828 ') ;
// param: write('#') ;
// ["@"=]64: write('@@') ;
// verbatim: write('@=') ;
// force_line: write('@\') ;
//  else  write( xchr[ a])
//  end
//
// ;
//       k:= k+1 ;
//     end;
//   end;
// end;
// [  ]

// 77. Stacks for output

// tangle:pos tangle.web:1396:22:

// Let's make sure that our data structures contain enough information to
// produce the entire \PASCAL\ program as desired, by working next on the
// algorithms that actually do produce that program.

// 81.

// tangle:pos tangle.web:1453:3:

// Parameters must also be stacked. They are placed in
// |tok_mem| just above the other replacement texts, and dummy parameter
// `names' are placed in |byte_start| just after the other names.
// The variables |text_ptr| and |tok_ptr[z]| essentially serve as parameter
// stack pointers during the output phase, so there is no need for a separate
// data structure to handle this problem.

// 84.

// tangle:pos tangle.web:1479:3:

// When the replacement text for name |p| is to be inserted into the output,
// the following subroutine is called to save the old level of output and get
// the new one going.
func (prg *prg) pushLevel(p namePointer) {
	if int32(prg.stackPtr) == stackSize {
		prg.stderr.Writeln("! Sorry, ", "stack", " capacity exceeded")
		prg.error1()
		prg.history = byte(fatalMessage)
		prg.jumpOut()
	} else {
		prg.stack[prg.stackPtr-1] = prg.curState // save |cur_end|, |cur_byte|, etc.
		prg.stackPtr = byte(int32(prg.stackPtr) + 1)
		prg.curState.nameField = p
		prg.curState.replField = prg.equiv[p]
		prg.zo = byte(int32(prg.curState.replField) % zz)
		prg.curState.byteField = prg.tokStart[prg.curState.replField]
		prg.curState.endField = prg.tokStart[int32(prg.curState.replField)+zz]
		prg.curState.modField = 0
	}
}

// 85.

// tangle:pos tangle.web:1493:3:

// When we come to the end of a replacement text, the |pop_level| subroutine
// does the right thing: It either moves to the continuation of this replacement
// text or returns the state to the most recently stacked level. Part of this
// subroutine, which updates the parameter stack, will be given later when we
// study the parameter stack in more detail.
func (prg *prg) popLevel() {
	if int32(prg.textLink[prg.curState.replField]) == 0 {
		if int32(prg.ilk[prg.curState.nameField]) == parametric {
			prg.namePtr = uint16(int32(prg.namePtr) - 1)
			prg.textPtr = uint16(int32(prg.textPtr) - 1)
			prg.z = byte(int32(prg.textPtr) % zz)
			//	if tok_ptr[z]>max_tok_ptr[z] then max_tok_ptr[z]:=tok_ptr[z];
			//
			// [  ]
			// the maximum value of |tok_ptr| occurs just before parameter popping
			prg.tokPtr[prg.z] = prg.tokStart[prg.textPtr]
			//    byte_ptr[ name_ptr  mod  ww]:= byte_ptr[ name_ptr  mod  ww]-1 ; [  ]
		}
	} else if int32(prg.textLink[prg.curState.replField]) < maxTexts {
		prg.curState.replField = prg.textLink[prg.curState.replField] // we will stay on the same level
		prg.zo = byte(int32(prg.curState.replField) % zz)
		prg.curState.byteField = prg.tokStart[prg.curState.replField]
		prg.curState.endField = prg.tokStart[int32(prg.curState.replField)+zz]

		goto exit
	}
	prg.stackPtr = byte(int32(prg.stackPtr) - 1) // we will go down to the previous level
	if int32(prg.stackPtr) > 0 {
		prg.curState = prg.stack[prg.stackPtr-1]
		prg.zo = byte(int32(prg.curState.replField) % zz)
	}

exit:
}

// 87.

// tangle:pos tangle.web:1536:3:

// If |get_output| finds that no more output remains, it returns the value zero.
func (prg *prg) getOutput() (r sixteenBits) {
	var (
		a                         sixteenBits // value of current byte
		b                         eightBits   // byte being copied
		bal                       sixteenBits // excess of \.( versus \.) while copying a parameter
		k/* 0..maxBytes */ uint16             // index into |byte_mem|
		w/* 0..ww-1 */ byte                   // segment of |byte_mem|
	)
restart:
	if int32(prg.stackPtr) == 0 {
		a = 0
		goto found
	}
	if int32(prg.curState.byteField) == int32(prg.curState.endField) {
		prg.curVal = -int32(prg.curState.modField)
		prg.popLevel()
		if prg.curVal == 0 {
			goto restart
		}
		a = uint16(moduleNumber)
		goto found
	}
	a = uint16(prg.tokMem[prg.zo][prg.curState.byteField])
	prg.curState.byteField = uint16(int32(prg.curState.byteField) + 1)
	if int32(a) < 0200 {
		if int32(a) == param {
			prg.pushLevel(namePointer(int32(prg.namePtr) - 1))
			goto restart
		} else {
			goto found
		}
	}
	a = uint16((int32(a)-0200)*0400 + int32(prg.tokMem[prg.zo][prg.curState.byteField]))
	prg.curState.byteField = uint16(int32(prg.curState.byteField) + 1)
	if int32(a) < 024000 {
		switch prg.ilk[a] {
		case normal:
			prg.curVal = int32(a)
			a = uint16(identifier)

		case numeric:
			prg.curVal = int32(prg.equiv[a]) - 0100000
			a = uint16(number)

		case simple:
			prg.pushLevel(a)
			goto restart

		case parametric:
			for int32(prg.curState.byteField) == int32(prg.curState.endField) && int32(prg.stackPtr) > 0 {
				prg.popLevel()
			}
			if int32(prg.stackPtr) == 0 || int32(prg.tokMem[prg.zo][prg.curState.byteField]) != '(' {
				{
					prg.stdout.Writeln()
					prg.stdout.Write("! No parameter given for ")
				}
				prg.printId(a)
				prg.error1()
				// \xref[No parameter given for macro]

				// \xref[No parameter given for macro]
				goto restart
			}

			// Copy the parameter into |tok_mem|
			bal = 1
			prg.curState.byteField = uint16(int32(prg.curState.byteField) + 1) // skip the opening `\.('
			for true {
				b = prg.tokMem[prg.zo][prg.curState.byteField]
				prg.curState.byteField = uint16(int32(prg.curState.byteField) + 1)
				if int32(b) == param {
					prg.storeTwoBytes(sixteenBits(int32(prg.namePtr) + 077777))
				} else {
					if int32(b) >= 0200 {
						{
							if int32(prg.tokPtr[prg.z]) == maxToks {
								prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
								prg.error1()
								prg.history = byte(fatalMessage)
								prg.jumpOut()
							}
							prg.tokMem[prg.z][prg.tokPtr[prg.z]] = b
							prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
						}
						b = prg.tokMem[prg.zo][prg.curState.byteField]
						prg.curState.byteField = uint16(int32(prg.curState.byteField) + 1)
					} else {
						switch b {
						case '(':
							bal = uint16(int32(bal) + 1)
						// ")"=
						case ')':
							bal = uint16(int32(bal) - 1)
							if int32(bal) == 0 {
								goto done
							}

						// "'"=
						case '\'':
							for {
								{
									if int32(prg.tokPtr[prg.z]) == maxToks {
										prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
										prg.error1()
										prg.history = byte(fatalMessage)
										prg.jumpOut()
									}
									prg.tokMem[prg.z][prg.tokPtr[prg.z]] = b
									prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
								}
								b = prg.tokMem[prg.zo][prg.curState.byteField]
								prg.curState.byteField = uint16(int32(prg.curState.byteField) + 1)
								if int32(b) == '\'' {
									break
								}
							}
							// copy string, don't change |bal|
						default:
						}
					}
					{
						if int32(prg.tokPtr[prg.z]) == maxToks {
							prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
							prg.error1()
							prg.history = byte(fatalMessage)
							prg.jumpOut()
						}
						prg.tokMem[prg.z][prg.tokPtr[prg.z]] = b
						prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
					}
				}
			}

		done:
			;
			prg.equiv[prg.namePtr] = prg.textPtr
			prg.ilk[prg.namePtr] = uint16(simple)
			w = byte(int32(prg.namePtr) % ww)
			k = prg.bytePtr[w]
			//	if k=max_bytes then begin writeln( stderr,'! Sorry, ','byte memory',' capacity exceeded') ; error; history:=fatal_message ; jump_out; end  [ \xref[Sorry, x capacity exceeded] ] ;
			//
			// byte_mem[w,k]:=["#"=]35;   k:= k+1 ; byte_ptr[w]:=k;
			// [  ]
			// this code has set the parameter identifier for debugging printouts
			if int32(prg.namePtr) > maxNames-ww {
				prg.stderr.Writeln("! Sorry, ", "name", " capacity exceeded")
				prg.error1()
				prg.history = byte(fatalMessage)
				prg.jumpOut()
			}
			prg.byteStart[int32(prg.namePtr)+ww] = k
			prg.namePtr = uint16(int32(prg.namePtr) + 1)
			if int32(prg.textPtr) > maxTexts-zz {
				prg.stderr.Writeln("! Sorry, ", "text", " capacity exceeded")
				prg.error1()
				prg.history = byte(fatalMessage)
				prg.jumpOut()
			}
			prg.textLink[prg.textPtr] = 0
			prg.tokStart[int32(prg.textPtr)+zz] = prg.tokPtr[prg.z]
			prg.textPtr = uint16(int32(prg.textPtr) + 1)
			prg.z = byte(int32(prg.textPtr) % zz)
			prg.pushLevel(a)
			goto restart

		default:
			prg.stderr.Writeln("! This can't happen (", "output", ")")
			prg.error1()
			prg.history = byte(fatalMessage)
			prg.jumpOut() // \xref[This can't happen]
		}

		goto found
	}
	if int32(a) < 050000 {
		a = uint16(int32(a) - 024000)
		if int32(prg.equiv[a]) != 0 {
			prg.pushLevel(a)
		} else if int32(a) != 0 {
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Not present: <")
			}
			prg.printId(a)
			prg.stdout.Write(">")
			prg.error1()
			// \xref[Not present: <section name>]
		}

		goto restart
	}
	prg.curVal = int32(a) - 050000
	a = uint16(moduleNumber)
	prg.curState.modField = uint16(prg.curVal)

found:
	r = a
	return r
}

// 97.

// tangle:pos tangle.web:1800:3:

// Here is a routine that is invoked when |out_ptr>line_length|
// or when it is time to flush out the final line. The |flush_buffer| procedure
// often writes out the line up to the current |break_ptr| position, then moves the
// remaining information to the front of |out_buf|. However, it prefers to
// write only up to |semi_ptr|, if the residual line won't be too long.
func (prg *prg) flushBuffer() { // writes one line to output file
	var (
		k/* 0..outBufSize */ byte // index into |out_buf|
		b/* 0..outBufSize */ byte // value of |break_ptr| upon entry
	)
	b = prg.breakPtr
	if int32(prg.semiPtr) != 0 && int32(prg.outPtr)-int32(prg.semiPtr) <= lineLength {
		prg.breakPtr = prg.semiPtr
	}
	for ii := int32(1); ii <= int32(prg.breakPtr); ii++ {
		k = byte(ii)
		_ = k
		prg.pascalFile.Write(string(rune(prg.xchr[prg.outBuf[int32(k)-1]])))
	}
	prg.pascalFile.Writeln()
	prg.line = prg.line + 1
	if prg.line%100 == 0 {
		prg.stdout.Write(".")
		if prg.line%500 == 0 {
			prg.stdout.Write(prg.line, knuth.WriteWidth(1))
		}
		// progress report
	}
	if int32(prg.breakPtr) < int32(prg.outPtr) {
		if int32(prg.outBuf[prg.breakPtr]) == ' ' {
			prg.breakPtr = byte(int32(prg.breakPtr) + 1) // drop space at break
			if int32(prg.breakPtr) > int32(b) {
				b = prg.breakPtr
			}
		}
		for ii := int32(prg.breakPtr); ii <= int32(prg.outPtr)-1; ii++ {
			k = byte(ii)
			_ = k
			prg.outBuf[int32(k)-int32(prg.breakPtr)] = prg.outBuf[k]
		}
	}
	prg.outPtr = byte(int32(prg.outPtr) - int32(prg.breakPtr))
	prg.breakPtr = byte(int32(b) - int32(prg.breakPtr))
	prg.semiPtr = 0
	if int32(prg.outPtr) > lineLength {
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Long line must be truncated")
			prg.error1()
		}
		prg.outPtr = byte(lineLength)
		// \xref[Long line must be truncated]
	}
}

// 99.

// tangle:pos tangle.web:1840:3:

// Another simple and useful routine appends the decimal equivalent of
// a nonnegative integer to the output buffer.
func (prg *prg) appVal(v int32) { // puts |v| into buffer, assumes |v>=0|
	var (
		k /* 0..outBufSize */ byte // index into |out_buf|
	)
	k = byte(outBufSize) // first we put the digits at the very end of |out_buf|
	for {
		prg.outBuf[k] = byte(v % 10)
		v = v / 10
		k = byte(int32(k) - 1)
		if v == 0 {
			break
		}
	}
	for {
		k = byte(int32(k) + 1)
		{
			prg.outBuf[prg.outPtr] = byte(int32(prg.outBuf[k]) + '0')
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		}
		if int32(k) == outBufSize {
			break
		}
	} // then we append them, most significant first
}

// 101.

// tangle:pos tangle.web:1878:3:

// A slightly subtle point in the following code is that the user may ask
// for a |join| operation (i.e., \.[@\&]) following whatever is being sent
// out.  We will see later that |join| is implemented in part by calling
// |send_out(frac,0)|.
func (prg *prg) sendOut(t eightBits, v sixteenBits) {
	var (
		k /* 0..lineLength */ byte // index into |out_contrib|
	)
	// Get the buffer ready for appending the new information
restart:
	switch prg.outState {
	case numOrId:
		if int32(t) != frac {
			prg.breakPtr = prg.outPtr
			if int32(t) == ident {
				prg.outBuf[prg.outPtr] = ' '
				prg.outPtr = byte(int32(prg.outPtr) + 1)
			}
		}
	case sign:
		{
			prg.outBuf[prg.outPtr] = byte(',' - prg.outApp)
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		}
		if int32(prg.outPtr) > lineLength {
			prg.flushBuffer()
		}
		prg.breakPtr = prg.outPtr

	case signVal, signValSign:
		if prg.outVal < 0 || prg.outVal == 0 && int32(prg.lastSign) < 0 {
			prg.outBuf[prg.outPtr] = '-'
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		} else if int32(prg.outSign) > 0 {
			prg.outBuf[prg.outPtr] = prg.outSign
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		}
		prg.appVal(abs(prg.outVal))
		if int32(prg.outPtr) > lineLength {
			prg.flushBuffer()
		}

		prg.outState = byte(int32(prg.outState) - 2)
		goto restart

	case signValVal:
		// Reduce |sign_val_val| to |sign_val| and |goto restart|
		if int32(t) == frac || (int32(t) == ident && int32(v) == 3 && (int32(prg.outContrib[1-1]) == 'D' && int32(prg.outContrib[2-1]) == 'I' && int32(prg.outContrib[3-1]) == 'V' || int32(prg.outContrib[1-1]) == 'M' && int32(prg.outContrib[2-1]) == 'O' && int32(prg.outContrib[3-1]) == 'D') || int32(t) == misc && (int32(v) == '*' || int32(v) == '/')) {
			if prg.outVal < 0 || prg.outVal == 0 && int32(prg.lastSign) < 0 {
				prg.outBuf[prg.outPtr] = '-'
				prg.outPtr = byte(int32(prg.outPtr) + 1)
			} else if int32(prg.outSign) > 0 {
				prg.outBuf[prg.outPtr] = prg.outSign
				prg.outPtr = byte(int32(prg.outPtr) + 1)
			}
			prg.appVal(abs(prg.outVal))
			if int32(prg.outPtr) > lineLength {
				prg.flushBuffer()
			}

			prg.outSign = '+'
			prg.outVal = prg.outApp
		} else {
			prg.outVal = prg.outVal + prg.outApp
		}
		prg.outState = byte(signVal)
		goto restart

	case misc:
		if int32(t) != frac {
			prg.breakPtr = prg.outPtr
		}

	default: // this is for |unbreakable| state
	}
	if int32(t) != misc {
		for ii := int32(1); ii <= int32(v); ii++ {
			k = byte(ii)
			_ = k
			prg.outBuf[prg.outPtr] = prg.outContrib[k-1]
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		}
	} else {
		prg.outBuf[prg.outPtr] = byte(v)
		prg.outPtr = byte(int32(prg.outPtr) + 1)
	}
	if int32(prg.outPtr) > lineLength {
		prg.flushBuffer()
	}
	if int32(t) == misc && (int32(v) == ';' || int32(v) == '}') {
		prg.semiPtr = prg.outPtr
		prg.breakPtr = prg.outPtr
	}
	if int32(t) >= ident {
		prg.outState = byte(numOrId)
	} else {
		prg.outState = byte(misc)
	}
}

// 106.

// tangle:pos tangle.web:1942:3:

// The following routine is called with $v=\pm1$ when a plus or minus sign is
// appended to the output. It extends \PASCAL\ to allow repeated signs
// (e.g., `\.[--]' is equivalent to `\.+'), rather than to give an error message.
// The signs following `\.E' in real constants are treated as part of a fraction,
// so they are not seen by this routine.
func (prg *prg) sendSign(v int32) {
	switch prg.outState {
	case sign, signValSign:
		prg.outApp = prg.outApp * v
	case signVal:
		prg.outApp = v
		prg.outState = byte(signValSign)

	case signValVal:
		prg.outVal = prg.outVal + prg.outApp
		prg.outApp = v
		prg.outState = byte(signValSign)

	default:
		prg.breakPtr = prg.outPtr
		prg.outApp = v
		prg.outState = byte(sign)

	}

	prg.lastSign = int8(prg.outApp)
}

// 107.

// tangle:pos tangle.web:1962:3:

// When a (signed) integer value is to be output, we call |send_val|.
func (prg *prg) sendVal(v int32) {
	switch prg.outState {
	case numOrId:
		if int32(prg.outPtr) == int32(prg.breakPtr)+3 || int32(prg.outPtr) == int32(prg.breakPtr)+4 && int32(prg.outBuf[prg.breakPtr]) == ' ' {
			if int32(prg.outBuf[int32(prg.outPtr)-3]) == 'D' && int32(prg.outBuf[int32(prg.outPtr)-2]) == 'I' && int32(prg.outBuf[int32(prg.outPtr)-1]) == 'V' || int32(prg.outBuf[int32(prg.outPtr)-3]) == 'M' && int32(prg.outBuf[int32(prg.outPtr)-2]) == 'O' && int32(prg.outBuf[int32(prg.outPtr)-1]) == 'D' {
				goto badCase
			}
		}
		prg.outSign = ' '
		prg.outState = byte(signVal)
		prg.outVal = v
		prg.breakPtr = prg.outPtr
		prg.lastSign = int8(+1)

	case misc:
		if int32(prg.outPtr) == int32(prg.breakPtr)+1 && (int32(prg.outBuf[prg.breakPtr]) == '*' || int32(prg.outBuf[prg.breakPtr]) == '/') {
			goto badCase
		}
		prg.outSign = 0
		prg.outState = byte(signVal)
		prg.outVal = v
		prg.breakPtr = prg.outPtr
		prg.lastSign = int8(+1)

	// \4
	// Handle cases of |send_val| when |out_state| contains a sign
	case sign:
		prg.outSign = '+'
		prg.outState = byte(signVal)
		prg.outVal = prg.outApp * v

	case signVal:
		prg.outState = byte(signValVal)
		prg.outApp = v
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Two numbers occurred without a sign between them")
			prg.error1()
		}

	case signValSign:
		prg.outState = byte(signValVal)
		prg.outApp = prg.outApp * v

	case signValVal:
		prg.outVal = prg.outVal + prg.outApp
		prg.outApp = v
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Two numbers occurred without a sign between them")
			prg.error1()
		}
	// \xref[Two numbers occurred...]

	default:
		goto badCase
	}

	goto exit

badCase:
	if v >= 0 {
		if int32(prg.outState) == numOrId {
			prg.breakPtr = prg.outPtr
			{
				prg.outBuf[prg.outPtr] = ' '
				prg.outPtr = byte(int32(prg.outPtr) + 1)
			}
		}
		prg.appVal(v)
		if int32(prg.outPtr) > lineLength {
			prg.flushBuffer()
		}
		prg.outState = byte(numOrId)
	} else {
		{
			prg.outBuf[prg.outPtr] = '('
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		}
		{
			prg.outBuf[prg.outPtr] = '-'
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		}
		prg.appVal(-v)
		{
			prg.outBuf[prg.outPtr] = ')'
			prg.outPtr = byte(int32(prg.outPtr) + 1)
		}
		if int32(prg.outPtr) > lineLength {
			prg.flushBuffer()
		}
		prg.outState = byte(misc)
	}

exit:
}

// 113.

// tangle:pos tangle.web:2040:3:

// A many-way switch is used to send the output:
func (prg *prg) sendTheOutput() {
	var (
		curChar                   eightBits // the latest character received
		k/* 0..lineLength */ byte           // index into |out_contrib|
		j/* 0..maxBytes */ uint16           // index into |byte_mem|
		w/* 0..ww-1 */ byte                 // segment of |byte_mem|
		n                         int32     // number being scanned
	)
	for int32(prg.stackPtr) > 0 {
		curChar = byte(prg.getOutput())

	reswitch:
		switch curChar {
		case 0: // this case might arise if output ends unexpectedly
		// \4
		// Cases related to identifiers
		// "A"=
		case 'A', 'Z' - 24, 'Z' - 23, 'Z' - 22,
			'Z' - 21, 'Z' - 20, 'Z' - 19, 'Z' - 18,
			'Z' - 17, 'Z' - 16, 'Z' - 15, 'Z' - 14,
			'Z' - 13, 'Z' - 12, 'Z' - 11, 'Z' - 10,
			'Z' - 9, 'Z' - 8, 'Z' - 7, 'Z' - 6,
			'Z' - 5, 'Z' - 4, 'Z' - 3, 'Z' - 2,
			'Z' - 1, 'Z':
			prg.outContrib[1-1] = curChar
			prg.sendOut(eightBits(ident), sixteenBits(1))

		// "a"=
		case 'a', 'z' - 24, 'z' - 23, 'z' - 22,
			'z' - 21, 'z' - 20, 'z' - 19, 'z' - 18,
			'z' - 17, 'z' - 16, 'z' - 15, 'z' - 14,
			'z' - 13, 'z' - 12, 'z' - 11, 'z' - 10,
			'z' - 9, 'z' - 8, 'z' - 7, 'z' - 6,
			'z' - 5, 'z' - 4, 'z' - 3, 'z' - 2,
			'z' - 1, 'z':
			prg.outContrib[1-1] = byte(int32(curChar) - 040)
			prg.sendOut(eightBits(ident), sixteenBits(1))

		case identifier:
			k = 0
			j = prg.byteStart[prg.curVal]
			w = byte(prg.curVal % ww)
			for int32(k) < maxIdLength && int32(j) < int32(prg.byteStart[prg.curVal+ww]) {
				k = byte(int32(k) + 1)
				prg.outContrib[k-1] = prg.byteMem[w][j]
				j = uint16(int32(j) + 1)
				if int32(prg.outContrib[k-1]) >= 'a' {
					prg.outContrib[k-1] = byte(int32(prg.outContrib[k-1]) - 040)
				} else if int32(prg.outContrib[k-1]) == '_' {
					k = byte(int32(k) - 1)
				}
			}
			prg.sendOut(eightBits(ident), sixteenBits(k))

		// \4
		// Cases related to constants, possibly leading to |get_fraction| or |reswitch|
		// "0"=
		case '0', '1', '2', '3',
			'4', '5', '6', '7',
			'8', '9':
			n = 0
			for {
				curChar = byte(int32(curChar) - '0')
				if n >= 01463146314 {
					prg.stdout.Writeln()
					prg.stdout.Write("! Constant too big")
					prg.error1()
				} else {
					n = 10*n + int32(curChar)
				}
				curChar = byte(prg.getOutput())
				if int32(curChar) > '9' || int32(curChar) < '0' {
					break
				}
			}
			prg.sendVal(n)
			k = 0
			if int32(curChar) == 'e' {
				curChar = 'E'
			}
			// \xref[uppercase]
			if int32(curChar) == 'E' {
				goto getFraction
			} else {
				goto reswitch
			}

		case checkSum:
			prg.sendVal(prg.poolCheckSum)
		case octal:
			n = 0
			curChar = '0'
			for {
				curChar = byte(int32(curChar) - '0')
				if n >= 02000000000 {
					prg.stdout.Writeln()
					prg.stdout.Write("! Constant too big")
					prg.error1()
				} else {
					n = 8*n + int32(curChar)
				}
				curChar = byte(prg.getOutput())
				if int32(curChar) > '7' || int32(curChar) < '0' {
					break
				}
			}
			prg.sendVal(n)
			goto reswitch

		case hex:
			n = 0
			curChar = '0'
			for {
				if int32(curChar) >= 'A' {
					curChar = byte(int32(curChar) + 10 - 'A')
				} else {
					curChar = byte(int32(curChar) - '0')
				}
				if n >= 01000000000 {
					prg.stdout.Writeln()
					prg.stdout.Write("! Constant too big")
					prg.error1()
				} else {
					n = 16*n + int32(curChar)
				}
				curChar = byte(prg.getOutput())
				if int32(curChar) > 'F' || int32(curChar) < '0' || int32(curChar) > '9' && int32(curChar) < 'A' {
					break
				}
			}
			prg.sendVal(n)
			goto reswitch

		case number:
			prg.sendVal(prg.curVal)
		// "."=
		case '.':
			k = 1
			prg.outContrib[1-1] = '.'
			curChar = byte(prg.getOutput())
			if int32(curChar) == '.' {
				prg.outContrib[2-1] = '.'
				prg.sendOut(eightBits(str), sixteenBits(2))
			} else if int32(curChar) >= '0' && int32(curChar) <= '9' {
				goto getFraction
			} else {
				prg.sendOut(eightBits(misc), sixteenBits('.'))
				goto reswitch
			}

		// "+"=
		case '+', '-':
			prg.sendSign(',' - int32(curChar))
		// \4
		// Cases like \.[<>] and \.[:=]
		case andSign:
			prg.outContrib[1-1] = 'A'
			prg.outContrib[2-1] = 'N'
			prg.outContrib[3-1] = 'D'
			// \xref[uppercase]
			prg.sendOut(eightBits(ident), sixteenBits(3))

		case notSign:
			prg.outContrib[1-1] = 'N'
			prg.outContrib[2-1] = 'O'
			prg.outContrib[3-1] = 'T'
			prg.sendOut(eightBits(ident), sixteenBits(3))

		case setElementSign:
			prg.outContrib[1-1] = 'I'
			prg.outContrib[2-1] = 'N'
			prg.sendOut(eightBits(ident), sixteenBits(2))

		case orSign:
			prg.outContrib[1-1] = 'O'
			prg.outContrib[2-1] = 'R'
			prg.sendOut(eightBits(ident), sixteenBits(2))

		case leftArrow:
			prg.outContrib[1-1] = ':'
			prg.outContrib[2-1] = '='
			prg.sendOut(eightBits(str), sixteenBits(2))

		case notEqual:
			prg.outContrib[1-1] = '<'
			prg.outContrib[2-1] = '>'
			prg.sendOut(eightBits(str), sixteenBits(2))

		case lessOrEqual:
			prg.outContrib[1-1] = '<'
			prg.outContrib[2-1] = '='
			prg.sendOut(eightBits(str), sixteenBits(2))

		case greaterOrEqual:
			prg.outContrib[1-1] = '>'
			prg.outContrib[2-1] = '='
			prg.sendOut(eightBits(str), sixteenBits(2))

		case equivalenceSign:
			prg.outContrib[1-1] = '='
			prg.outContrib[2-1] = '='
			prg.sendOut(eightBits(str), sixteenBits(2))

		case doubleDot:
			prg.outContrib[1-1] = '.'
			prg.outContrib[2-1] = '.'
			prg.sendOut(eightBits(str), sixteenBits(2))

		// "'"=
		case '\'':
			// Send a string, |goto reswitch|
			k = 1
			prg.outContrib[1-1] = '\''
			for {
				if int32(k) < lineLength {
					k = byte(int32(k) + 1)
				}
				prg.outContrib[k-1] = byte(prg.getOutput())
				if int32(prg.outContrib[k-1]) == '\'' || int32(prg.stackPtr) == 0 {
					break
				}
			}
			if int32(k) == lineLength {
				prg.stdout.Writeln()
				prg.stdout.Write("! String too long")
				prg.error1()
			}
			// \xref[String too long]
			prg.sendOut(eightBits(str), sixteenBits(k))
			curChar = byte(prg.getOutput())
			if int32(curChar) == '\'' {
				prg.outState = byte(unbreakable)
			}

			goto reswitch

		// Other printable characters
		// "!"=
		case '!', '"', '#', '$',
			'%', '&', '(', ')',
			'*', ',', '/', ':',
			';', '<', '=', '>',
			'?', '@', '[', '\\',
			']', '^', '_', '`',
			'{', '|':
			prg.sendOut(eightBits(misc), sixteenBits(curChar))
		// \4
		// Cases involving \.[@\[] and \.[@\]]
		case beginComment:
			if int32(prg.braceLevel) == 0 {
				prg.sendOut(eightBits(misc), sixteenBits('{'))
			} else {
				prg.sendOut(eightBits(misc), sixteenBits('['))
			}
			prg.braceLevel = byte(int32(prg.braceLevel) + 1)

		case endComment:
			if int32(prg.braceLevel) > 0 {
				prg.braceLevel = byte(int32(prg.braceLevel) - 1)
				if int32(prg.braceLevel) == 0 {
					prg.sendOut(eightBits(misc), sixteenBits('}'))
				} else {
					prg.sendOut(eightBits(misc), sixteenBits(']'))
				}
			} else {
				prg.stdout.Writeln()
				prg.stdout.Write("! Extra @}")
				prg.error1()
			}
		// \xref[Extra \AT!\]]
		case moduleNumber:
			k = 2
			if int32(prg.braceLevel) == 0 {
				prg.outContrib[1-1] = '{'
			} else {
				prg.outContrib[1-1] = '['
			}
			if prg.curVal < 0 {
				prg.outContrib[k-1] = ':'
				prg.curVal = -prg.curVal
				k = byte(int32(k) + 1)
			}
			n = 10
			for prg.curVal >= n {
				n = 10 * n
			}
			for {
				n = n / 10
				prg.outContrib[k-1] = byte('0' + prg.curVal/n)
				prg.curVal = prg.curVal % n
				k = byte(int32(k) + 1)
				if n == 1 {
					break
				}
			}
			if int32(prg.outContrib[2-1]) != ':' {
				prg.outContrib[k-1] = ':'
				k = byte(int32(k) + 1)
			}
			if int32(prg.braceLevel) == 0 {
				prg.outContrib[k-1] = '}'
			} else {
				prg.outContrib[k-1] = ']'
			}
			prg.sendOut(eightBits(str), sixteenBits(k))

		case join:
			prg.sendOut(eightBits(frac), sixteenBits(0))
			prg.outState = byte(unbreakable)

		case verbatim:
			// Send verbatim string
			k = 0
			for {
				if int32(k) < lineLength {
					k = byte(int32(k) + 1)
				}
				prg.outContrib[k-1] = byte(prg.getOutput())
				if int32(prg.outContrib[k-1]) == verbatim || int32(prg.stackPtr) == 0 {
					break
				}
			}
			if int32(k) == lineLength {
				prg.stdout.Writeln()
				prg.stdout.Write("! Verbatim string too long")
				prg.error1()
			}
			// \xref[Verbatim string too long]
			prg.sendOut(eightBits(str), sixteenBits(int32(k)-1))

		case forceLine:
			// Force a line break
			prg.sendOut(eightBits(str), sixteenBits(0)) // normalize the buffer
			for int32(prg.outPtr) > 0 {
				if int32(prg.outPtr) <= lineLength {
					prg.breakPtr = prg.outPtr
				}
				prg.flushBuffer()
			}
			prg.outState = byte(misc)

		default:
			prg.stdout.Writeln()
			prg.stdout.Write("! Can't output ASCII code ", curChar, knuth.WriteWidth(1))
			prg.error1()
			// \xref[Can't output ASCII code n]
		}

		goto continue1

	getFraction:
		for {
			if int32(k) < lineLength {
				k = byte(int32(k) + 1)
			}
			prg.outContrib[k-1] = curChar
			curChar = byte(prg.getOutput())
			if int32(prg.outContrib[k-1]) == 'E' && (int32(curChar) == '+' || int32(curChar) == '-') {
				if int32(k) < lineLength {
					k = byte(int32(k) + 1)
				}
				prg.outContrib[k-1] = curChar
				curChar = byte(prg.getOutput())
			} else if int32(curChar) == 'e' {
				curChar = 'E'
			}
			if int32(curChar) != 'E' && (int32(curChar) < '0' || int32(curChar) > '9') {
				break
			}
		}
		if int32(k) == lineLength {
			prg.stdout.Writeln()
			prg.stdout.Write("! Fraction too long")
			prg.error1()
		}
		// \xref[Fraction too long]
		prg.sendOut(eightBits(frac), sixteenBits(k))
		goto reswitch

	continue1:
	}
}

// 123. Introduction to the input phase

// tangle:pos tangle.web:2291:36:

// We have now seen that \.[TANGLE] will be able to output the full
// \PASCAL\ program, if we can only get that program into the byte memory in
// the proper format. The input process is something like the output process
// in reverse, since we compress the text as we read it in and we expand it
// as we write it out.
//
// There are three main input routines. The most interesting is the one that gets
// the next token of a \PASCAL\ text; the other two are used to scan rapidly past
// \TeX\ text in the \.[WEB] source code. One of the latter routines will jump to
// the next token that starts with `\.[@]', and the other skips to the end
// of a \PASCAL\ comment.

// 125.

// tangle:pos tangle.web:2319:3:

// As we change |changing| from |true| to |false| and back again, we must
// remember to swap the values of |line| and |other_line| so that the |err_print|
// routine will be sure to report the correct line number.

// 127.

// tangle:pos tangle.web:2337:3:

// Here's a simple function that checks if the two buffers are different.
func (prg *prg) linesDontMatch() (r bool) {
	var (
		k /* 0..bufSize */ byte // index into the buffers
	)
	r = true
	if int32(prg.changeLimit) != int32(prg.limit) {
		goto exit
	}
	if int32(prg.limit) > 0 {
		for ii := int32(0); ii <= int32(prg.limit)-1; ii++ {
			k = byte(ii)
			_ = k
			if int32(prg.changeBuffer[k]) != int32(prg.buffer[k]) {
				goto exit
			}
		}
	}
	r = false

exit:
	;
	return r
}

// 128.

// tangle:pos tangle.web:2349:3:

// Procedure |prime_the_change_buffer| sets |change_buffer| in preparation
// for the next matching operation. Since blank lines in the change file are
// not used for matching, we have |(change_limit=0)and not changing| if and
// only if the change file is exhausted. This procedure is called only
// when |changing| is true; hence error messages will be reported correctly.
func (prg *prg) primeTheChangeBuffer() {
	var (
		k /* 0..bufSize */ byte // index into the buffers
	)
	prg.changeLimit = 0 // this value will be used if the change file ends

	// Skip over comment lines in the change file; |return| if end of file
	for true {
		prg.line = prg.line + 1
		if !prg.inputLn(prg.changeFile) {
			goto exit
		}
		if int32(prg.limit) < 2 {
			goto continue1
		}
		if int32(prg.buffer[0]) != '@' {
			goto continue1
		}
		if int32(prg.buffer[1]) >= 'X' && int32(prg.buffer[1]) <= 'Z' {
			prg.buffer[1] = byte(int32(prg.buffer[1]) + 'z' - 'Z')
		} // lowercasify
		if int32(prg.buffer[1]) == 'x' {
			goto done
		}
		if int32(prg.buffer[1]) == 'y' || int32(prg.buffer[1]) == 'z' {
			prg.loc = 2
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Where is the matching @x?")
				prg.error1()
			}
			// \xref[Where is the match...]
		}

	continue1:
	}

done:
	;

	// Skip to the next nonblank line; |return| if end of file
	for {
		prg.line = prg.line + 1
		if !prg.inputLn(prg.changeFile) {
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Change file ended after @x")
				prg.error1()
			}
			// \xref[Change file ended...]

			// \xref[Change file ended...]
			goto exit
		}
		if int32(prg.limit) > 0 {
			break
		}
	}

	// Move |buffer| and |limit| to |change_buffer| and |change_limit|
	{
		prg.changeLimit = prg.limit
		if int32(prg.limit) > 0 {
			for ii := int32(0); ii <= int32(prg.limit)-1; ii++ {
				k = byte(ii)
				_ = k
				prg.changeBuffer[k] = prg.buffer[k]
			}
		}
	}

exit:
}

// 132.

// tangle:pos tangle.web:2400:3:

// The following procedure is used to see if the next change entry should
// go into effect; it is called only when |changing| is false.
// The idea is to test whether or not the current
// contents of |buffer| matches the current contents of |change_buffer|.
// If not, there's nothing more to do; but if so, a change is called for:
// All of the text down to the \.[@y] is supposed to match. An error
// message is issued if any discrepancy is found. Then the procedure
// prepares to read the next line from |change_file|.
func (prg *prg) checkChange() {
	var (
		n                      int32 // the number of discrepancies found
		k/* 0..bufSize */ byte       // index into the buffers
	)
	if prg.linesDontMatch() {
		goto exit
	}
	n = 0
	for true {
		prg.changing = !prg.changing
		prg.tempLine = prg.otherLine
		prg.otherLine = prg.line
		prg.line = prg.tempLine // now it's |true|
		prg.line = prg.line + 1
		if !prg.inputLn(prg.changeFile) {
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Change file ended before @y")
				prg.error1()
			}
			// \xref[Change file ended...]
			prg.changeLimit = 0
			prg.changing = !prg.changing
			prg.tempLine = prg.otherLine
			prg.otherLine = prg.line
			prg.line = prg.tempLine // |false| again
			// |false| again
			goto exit
		}

		// If the current line starts with \.[@y], report any discrepancies and |return|
		if int32(prg.limit) > 1 {
			if int32(prg.buffer[0]) == '@' {
				if int32(prg.buffer[1]) >= 'X' && int32(prg.buffer[1]) <= 'Z' {
					prg.buffer[1] = byte(int32(prg.buffer[1]) + 'z' - 'Z')
				} // lowercasify
				if int32(prg.buffer[1]) == 'x' || int32(prg.buffer[1]) == 'z' {
					prg.loc = 2
					{
						prg.stdout.Writeln()
						prg.stdout.Write("! Where is the matching @y?")
						prg.error1()
					}
					// \xref[Where is the match...]
				} else if int32(prg.buffer[1]) == 'y' {
					if n > 0 {
						prg.loc = 2
						{
							prg.stdout.Writeln()
							prg.stdout.Write("! Hmm... ", n, knuth.WriteWidth(1),
								" of the preceding lines failed to match")
							prg.error1()
						}
						// \xref[Hmm... n of the preceding...]
					}

					goto exit
				}
			}
		}

		// Move |buffer| and |limit|...
		{
			prg.changeLimit = prg.limit
			if int32(prg.limit) > 0 {
				for ii := int32(0); ii <= int32(prg.limit)-1; ii++ {
					k = byte(ii)
					_ = k
					prg.changeBuffer[k] = prg.buffer[k]
				}
			}
		}
		prg.changing = !prg.changing
		prg.tempLine = prg.otherLine
		prg.otherLine = prg.line
		prg.line = prg.tempLine // now it's |false|
		prg.line = prg.line + 1
		if !prg.inputLn(prg.webFile) {
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! WEB file ended during a change")
				prg.error1()
			}
			// \xref[WEB file ended...]
			prg.inputHasEnded = true
			goto exit
		}
		if prg.linesDontMatch() {
			n = n + 1
		}
	}

exit:
}

// 135.

// tangle:pos tangle.web:2460:3:

// The |get_line| procedure is called when |loc>limit|; it puts the next
// line of merged input into the buffer and updates the other variables
// appropriately. A space is placed at the right end of the line.
func (prg *prg) getLine() {
restart:
	if prg.changing {
		prg.line = prg.line + 1
		if !prg.inputLn(prg.changeFile) {
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Change file ended without @z")
				prg.error1()
			}
			// \xref[Change file ended...]
			prg.buffer[0] = '@'
			prg.buffer[1] = 'z'
			prg.limit = 2
		}
		if int32(prg.limit) > 1 {
			if int32(prg.buffer[0]) == '@' {
				if int32(prg.buffer[1]) >= 'X' && int32(prg.buffer[1]) <= 'Z' {
					prg.buffer[1] = byte(int32(prg.buffer[1]) + 'z' - 'Z')
				} // lowercasify
				if int32(prg.buffer[1]) == 'x' || int32(prg.buffer[1]) == 'y' {
					prg.loc = 2
					{
						prg.stdout.Writeln()
						prg.stdout.Write("! Where is the matching @z?")
						prg.error1()
					}
					// \xref[Where is the match...]
				} else if int32(prg.buffer[1]) == 'z' {
					prg.primeTheChangeBuffer()
					prg.changing = !prg.changing
					prg.tempLine = prg.otherLine
					prg.otherLine = prg.line
					prg.line = prg.tempLine
				}
			}
		}
	}
	if !prg.changing {
		{
			prg.line = prg.line + 1
			if !prg.inputLn(prg.webFile) {
				prg.inputHasEnded = true
			} else if int32(prg.changeLimit) > 0 {
				prg.checkChange()
			}
		}
		if prg.changing {
			goto restart
		}
	}
	prg.loc = 0
	prg.buffer[prg.limit] = ' '
}

// 139.

// tangle:pos tangle.web:2513:3:

// Important milestones are reached during the input phase when certain
// control codes are sensed.
//
// Control codes in \.[WEB] begin with `\.[@]', and the next character
// identifies the code. Some of these are of interest only to \.[WEAVE],
// so \.[TANGLE] ignores them; the others are converted by \.[TANGLE] into
// internal code numbers by the |control_code| function below. The ordering
// of these internal code numbers has been chosen to simplify the program logic;
// larger numbers are given to the control codes that denote more significant
// milestones.
func (prg *prg) controlCode(c asciiCode) (r eightBits) {
	switch c {
	case '@':
		r = '@' // `quoted' at sign
	// "'"=
	case '\'':
		r = byte(octal) // precedes octal constant
	// """"=
	case '"':
		r = byte(hex) // precedes hexadecimal constant
	// "$"=
	case '$':
		r = byte(checkSum) // string pool check sum
	// " "=
	case ' ', tabMark:
		r = byte(newModule) // beginning of a new module
	// "*"=
	case '*':
		prg.stdout.Write("*", int32(prg.moduleCount)+1, knuth.WriteWidth(1))
		// print a progress report
		r = byte(newModule) // beginning of a new module

	// "D"=
	case 'D', 'd':
		r = byte(definition) // macro definition
	// "F"=
	case 'F', 'f':
		r = byte(format) // format definition
	// "["=
	case '{':
		r = byte(beginComment) // begin-comment delimiter
	// "]"=
	case '}':
		r = byte(endComment) // end-comment delimiter
	// "P"=
	case 'P', 'p':
		r = byte(beginPascal) // \PASCAL\ text in unnamed module
	// "T"=
	case 'T', 't', '^', '.',
		':':
		r = byte(controlText) // control text to be ignored
	// "&"=
	case '&':
		r = byte(join) // concatenate two tokens
	// "<"=
	case '<':
		r = byte(moduleName) // beginning of a module name
	// "="=
	case '=':
		r = byte(verbatim) // beginning of \PASCAL\ verbatim mode
	// "\"=
	case '\\':
		r = byte(forceLine)
		// force a new line in \PASCAL\ output
	default:
		r = byte(ignore) // ignore all other cases
	}
	return r
}

// 140.

// tangle:pos tangle.web:2557:3:

// The |skip_ahead| procedure reads through the input at fairly high speed
// until finding the next non-ignorable control code, which it returns.
func (prg *prg) skipAhead() (r eightBits) {
	var (
		c eightBits // control code found
	)
	for true {
		if int32(prg.loc) > int32(prg.limit) {
			prg.getLine()
			if prg.inputHasEnded {
				c = byte(newModule)
				goto done
			}
		}
		prg.buffer[int32(prg.limit)+1] = '@'
		for int32(prg.buffer[prg.loc]) != '@' {
			prg.loc = byte(int32(prg.loc) + 1)
		}
		if int32(prg.loc) <= int32(prg.limit) {
			prg.loc = byte(int32(prg.loc) + 2)
			c = prg.controlCode(prg.buffer[int32(prg.loc)-1])
			if int32(c) != ignore || int32(prg.buffer[int32(prg.loc)-1]) == '>' {
				goto done
			}
		}
	}

done:
	r = c
	return r
}

// 141.

// tangle:pos tangle.web:2579:3:

// The |skip_comment| procedure reads through the input at somewhat high speed
// until finding the first unmatched right brace or until coming to the end
// of the file. It ignores characters following `\.\\' characters, since all
// braces that aren't nested are supposed to be hidden in that way. For
// example, consider the process of skipping the first comment below,
// where the string containing the right brace has been typed as \.[\`\\.\\\]\']
// in the \.[WEB] file.
func (prg *prg) skipComment() {
	var (
		bal eightBits // excess of left braces
		c   asciiCode // current character
	)
	bal = 0
	for true {
		if int32(prg.loc) > int32(prg.limit) {
			prg.getLine()
			if prg.inputHasEnded {
				{
					prg.stdout.Writeln()
					prg.stdout.Write("! Input ended in mid-comment")
					prg.error1()
				}
				// \xref[Input ended in mid-comment]

				// \xref[Input ended in mid-comment]
				goto exit
			}
		}
		c = prg.buffer[prg.loc]
		prg.loc = byte(int32(prg.loc) + 1)

		// Do special things when |c="@", "\", "[", "]"|; |return| at end
		if int32(c) == '@' {
			c = prg.buffer[prg.loc]
			if int32(c) != ' ' && int32(c) != tabMark && int32(c) != '*' {
				prg.loc = byte(int32(prg.loc) + 1)
			} else {
				{
					prg.stdout.Writeln()
					prg.stdout.Write("! Section ended in mid-comment")
					prg.error1()
				}
				// \xref[Section ended in mid-comment]
				prg.loc = byte(int32(prg.loc) - 1)
				goto exit
			}
		} else if int32(c) == '\\' && int32(prg.buffer[prg.loc]) != '@' {
			prg.loc = byte(int32(prg.loc) + 1)
		} else if int32(c) == '{' {
			bal = byte(int32(bal) + 1)
		} else if int32(c) == '}' {
			if int32(bal) == 0 {
				goto exit
			}
			bal = byte(int32(bal) - 1)
		}
	}

exit:
}

// 145.

// tangle:pos tangle.web:2648:3:

// At the top level, |get_next| is a multi-way switch based on the next
// character in the input buffer. A |new_module| code is inserted at the
// very end of the input file.
func (prg *prg) getNext() (r eightBits) {
	var (
		c                               eightBits // the current character
		d                               eightBits // the next character
		j, k/* 0..longestName */ uint16           // indices into |mod_text|
	)
restart:
	if int32(prg.loc) > int32(prg.limit) {
		prg.getLine()
		if prg.inputHasEnded {
			c = byte(newModule)
			goto found
		}
	}
	c = prg.buffer[prg.loc]
	prg.loc = byte(int32(prg.loc) + 1)
	if prg.scanningHex {
		if int32(c) >= '0' && int32(c) <= '9' || int32(c) >= 'A' && int32(c) <= 'F' {
			goto found
		} else {
			prg.scanningHex = false
		}
	}
	switch c {
	case 'A', 'Z' - 24, 'Z' - 23, 'Z' - 22,
		'Z' - 21, 'Z' - 20, 'Z' - 19, 'Z' - 18,
		'Z' - 17, 'Z' - 16, 'Z' - 15, 'Z' - 14,
		'Z' - 13, 'Z' - 12, 'Z' - 11, 'Z' - 10,
		'Z' - 9, 'Z' - 8, 'Z' - 7, 'Z' - 6,
		'Z' - 5, 'Z' - 4, 'Z' - 3, 'Z' - 2,
		'Z' - 1, 'Z', 'a', 'z' - 24,
		'z' - 23, 'z' - 22, 'z' - 21, 'z' - 20,
		'z' - 19, 'z' - 18, 'z' - 17, 'z' - 16,
		'z' - 15, 'z' - 14, 'z' - 13, 'z' - 12,
		'z' - 11, 'z' - 10, 'z' - 9, 'z' - 8,
		'z' - 7, 'z' - 6, 'z' - 5, 'z' - 4,
		'z' - 3, 'z' - 2, 'z' - 1, 'z':
		// Get an identifier
		if (int32(c) == 'e' || int32(c) == 'E') && int32(prg.loc) > 1 {
			if int32(prg.buffer[int32(prg.loc)-2]) <= '9' && int32(prg.buffer[int32(prg.loc)-2]) >= '0' {
				c = 0
			}
		}
		if int32(c) != 0 {
			prg.loc = byte(int32(prg.loc) - 1)
			prg.idFirst = prg.loc
			for {
				prg.loc = byte(int32(prg.loc) + 1)
				d = prg.buffer[prg.loc]
				if (int32(d) < '0' || int32(d) > '9' && int32(d) < 'A' || int32(d) > 'Z' && int32(d) < 'a' || int32(d) > 'z') && int32(d) != '_' {
					break
				}
			}
			if int32(prg.loc) > int32(prg.idFirst)+1 {
				c = byte(identifier)
				prg.idLoc = prg.loc
			}
		} else {
			c = 'E'
		} // exponent of a real constant

	// """"=
	case '"':
		// Get a preprocessed string
		prg.doubleChars = 0
		prg.idFirst = byte(int32(prg.loc) - 1)
		for {
			d = prg.buffer[prg.loc]
			prg.loc = byte(int32(prg.loc) + 1)
			if int32(d) == '"' || int32(d) == '@' {
				if int32(prg.buffer[prg.loc]) == int32(d) {
					prg.loc = byte(int32(prg.loc) + 1)
					d = 0
					prg.doubleChars = byte(int32(prg.doubleChars) + 1)
				} else {
					if int32(d) == '@' {
						prg.stdout.Writeln()
						prg.stdout.Write("! Double @ sign missing")
						prg.error1()
					}
				}
			} else if int32(prg.loc) > int32(prg.limit) {
				{
					prg.stdout.Writeln()
					prg.stdout.Write("! String constant didn't end")
					prg.error1()
				}
				d = '"'
				// \xref[String constant didn't end]
			}
			if int32(d) == '"' {
				break
			}
		}
		prg.idLoc = byte(int32(prg.loc) - 1)
		c = byte(identifier)

	// "@"=
	case '@':
		// Get control code and possible module name
		c = prg.controlCode(prg.buffer[prg.loc])
		prg.loc = byte(int32(prg.loc) + 1)
		if int32(c) == ignore {
			goto restart
		} else if int32(c) == hex {
			prg.scanningHex = true
		} else if int32(c) == moduleName {
			k = 0
			for true {
				if int32(prg.loc) > int32(prg.limit) {
					prg.getLine()
					if prg.inputHasEnded {
						{
							prg.stdout.Writeln()
							prg.stdout.Write("! Input ended in section name")
							prg.error1()
						}
						// \xref[Input ended in section name]

						// \xref[Input ended in section name]
						goto done
					}
				}
				d = prg.buffer[prg.loc]

				// If end of name, |goto done|
				if int32(d) == '@' {
					d = prg.buffer[int32(prg.loc)+1]
					if int32(d) == '>' {
						prg.loc = byte(int32(prg.loc) + 2)
						goto done
					}
					if int32(d) == ' ' || int32(d) == tabMark || int32(d) == '*' {
						{
							prg.stdout.Writeln()
							prg.stdout.Write("! Section name didn't end")
							prg.error1()
						}
						goto done
						// \xref[Section name didn't end]
					}
					k = uint16(int32(k) + 1)
					prg.modText[k] = '@'
					prg.loc = byte(int32(prg.loc) + 1) // now |d=buffer[loc]| again
				}
				prg.loc = byte(int32(prg.loc) + 1)
				if int32(k) < longestName-1 {
					k = uint16(int32(k) + 1)
				}
				if int32(d) == ' ' || int32(d) == tabMark {
					d = ' '
					if int32(prg.modText[int32(k)-1]) == ' ' {
						k = uint16(int32(k) - 1)
					}
				}
				prg.modText[k] = d
			}

		done:
			if int32(k) >= longestName-2 {
				{
					prg.stdout.Writeln()
					prg.stdout.Write("! Section name too long: ")
				}
				// \xref[Section name too long]
				for ii := int32(1); ii <= 25; ii++ {
					j = uint16(ii)
					_ = j
					prg.stdout.Write(string(rune(prg.xchr[prg.modText[j]])))
				}
				prg.stdout.Write("...") /*   */
				if int32(prg.history) == spotless {
					prg.history = byte(harmlessMessage)
				}
			}
			if int32(prg.modText[k]) == ' ' && int32(k) > 0 {
				k = uint16(int32(k) - 1)
			}

			if int32(k) > 3 {
				if int32(prg.modText[k]) == '.' && int32(prg.modText[int32(k)-1]) == '.' && int32(prg.modText[int32(k)-2]) == '.' {
					prg.curModule = prg.prefixLookup(sixteenBits(int32(k) - 3))
				} else {
					prg.curModule = prg.modLookup(k)
				}
			} else {
				prg.curModule = prg.modLookup(k)
			}
		} else if int32(c) == controlText {
			for {
				c = prg.skipAhead()
				if int32(c) != '@' {
					break
				}
			}
			if int32(prg.buffer[int32(prg.loc)-1]) != '>' {
				prg.stdout.Writeln()
				prg.stdout.Write("! Improper @ within control text")
				prg.error1()
			}
			// \xref[Improper \AT! within control text]

			// \xref[Improper \AT! within control text]
			goto restart
		}

	// \4
	// Compress two-symbol combinations like `\.[:=]'
	// "."=
	case '.':
		if int32(prg.buffer[prg.loc]) == '.' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(doubleDot)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		} else if int32(prg.buffer[prg.loc]) == ')' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = ']'
				prg.loc = byte(int32(prg.loc) + 1)
			}
		}
	// ":"=
	case ':':
		if int32(prg.buffer[prg.loc]) == '=' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(leftArrow)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		}
	// "="=
	case '=':
		if int32(prg.buffer[prg.loc]) == '=' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(equivalenceSign)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		}
	// ">"=
	case '>':
		if int32(prg.buffer[prg.loc]) == '=' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(greaterOrEqual)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		}
	// "<"=
	case '<':
		if int32(prg.buffer[prg.loc]) == '=' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(lessOrEqual)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		} else if int32(prg.buffer[prg.loc]) == '>' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(notEqual)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		}
	// "("=
	case '(':
		if int32(prg.buffer[prg.loc]) == '*' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(beginComment)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		} else if int32(prg.buffer[prg.loc]) == '.' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = '['
				prg.loc = byte(int32(prg.loc) + 1)
			}
		}
	// "*"=
	case '*':
		if int32(prg.buffer[prg.loc]) == ')' {
			if int32(prg.loc) <= int32(prg.limit) {
				c = byte(endComment)
				prg.loc = byte(int32(prg.loc) + 1)
			}
		}

	// " "=
	case ' ', tabMark:
		goto restart // ignore spaces and tabs
	// "["=
	case '{':
		prg.skipComment()
		goto restart

	// "]"=
	case '}':
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Extra }")
			prg.error1()
		}
		goto restart
	// \xref[Extra \]]

	default:
		if int32(c) >= 128 {
			goto restart
		} else {
		}
	}

found:
	r = c
	return r
}

// 157.

// tangle:pos tangle.web:2846:3:

// The evaluation of a numeric expression makes use of two variables called the
// |accumulator| and the |next_sign|. At the beginning, |accumulator| is zero and
// |next_sign| is $+1$. When a \.+ or \.- is scanned, |next_sign| is multiplied
// by the value of that sign. When a numeric value is scanned, it is multiplied by
// |next_sign| and added to the |accumulator|, then |next_sign| is reset to $+1$.
func (prg *prg) scanNumeric(p namePointer) {
	var (
		accumulator                 int32       // accumulates sums
		nextSign/*  -1.. +1 */ int8             // sign to attach to next value
		q                           namePointer // points to identifiers being evaluated
		val                         int32       // constants being evaluated
	)
	accumulator = 0
	nextSign = int8(+1)
	for true {
		prg.nextControl = prg.getNext()

	reswitch:
		switch prg.nextControl {
		case '0', '1', '2', '3',
			'4', '5', '6', '7',
			'8', '9':
			val = 0
			for {
				val = 10*val + int32(prg.nextControl) - '0'
				prg.nextControl = prg.getNext()
				if int32(prg.nextControl) > '9' || int32(prg.nextControl) < '0' {
					break
				}
			}
			{
				accumulator = accumulator + int32(nextSign)*val
				nextSign = int8(+1)
			}
			goto reswitch

		case octal:
			val = 0
			prg.nextControl = '0'
			for {
				val = 8*val + int32(prg.nextControl) - '0'
				prg.nextControl = prg.getNext()
				if int32(prg.nextControl) > '7' || int32(prg.nextControl) < '0' {
					break
				}
			}
			{
				accumulator = accumulator + int32(nextSign)*val
				nextSign = int8(+1)
			}
			goto reswitch

		case hex:
			val = 0
			prg.nextControl = '0'
			for {
				if int32(prg.nextControl) >= 'A' {
					prg.nextControl = byte(int32(prg.nextControl) + '0' + 10 - 'A')
				}
				val = 16*val + int32(prg.nextControl) - '0'
				prg.nextControl = prg.getNext()
				if int32(prg.nextControl) > 'F' || int32(prg.nextControl) < '0' || int32(prg.nextControl) > '9' && int32(prg.nextControl) < 'A' {
					break
				}
			}
			{
				accumulator = accumulator + int32(nextSign)*val
				nextSign = int8(+1)
			}
			goto reswitch

		case identifier:
			q = prg.idLookup(eightBits(normal))
			if int32(prg.ilk[q]) != numeric {
				prg.nextControl = '*'
				goto reswitch // leads to error
			}
			{
				accumulator = accumulator + int32(nextSign)*(int32(prg.equiv[q])-0100000)
				nextSign = int8(+1)
			}

		// "+"=
		case '+':
		// "-"=
		case '-':
			nextSign = -nextSign
		case format, definition, moduleName, beginPascal,
			newModule:
			goto done
		// ";"=
		case ';':
			prg.stdout.Writeln()
			prg.stdout.Write("! Omit semicolon in numeric definition")
			prg.error1()

		// \xref[Omit semicolon in numeric def...]
		default:
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Improper numeric definition will be flushed")
				prg.error1()
			}
			// \xref[Improper numeric definition...]
			for {
				prg.nextControl = prg.skipAhead()
				if int32(prg.nextControl) >= format {
					break
				}
			}
			if int32(prg.nextControl) == moduleName {
				prg.loc = byte(int32(prg.loc) - 2)
				prg.nextControl = prg.getNext()
			}
			accumulator = 0
			goto done

		}
	}

done:
	;
	if abs(accumulator) >= 0100000 {
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Value too big: ", accumulator, knuth.WriteWidth(1))
			prg.error1()
		}
		accumulator = 0
		// \xref[Value too big]
	}
	prg.equiv[p] = uint16(accumulator + 0100000) // name |p| now is defined to equal |accumulator|
}

// 163. Scanning a macro definition

// tangle:pos tangle.web:2930:32:

// The rules for generating the replacement texts corresponding to simple
// macros, parametric macros, and \PASCAL\ texts of a module are almost
// identical, so a single procedure is used for all three cases. The
// differences are that
//
// \yskip\item[a)] The sign |#| denotes a parameter only when it appears
// outside of strings in a parametric macro; otherwise it stands for the
// ASCII character |#|. (This is not used in standard \PASCAL, but some
// \PASCAL s allow, for example, `\.[/\#]' after a certain kind of file name.)
//
// \item[b)]Module names are not allowed in simple macros or parametric macros;
// in fact, the appearance of a module name terminates such macros and denotes
// the name of the current module.
//
// \item[c)]The symbols \.[@d] and \.[@f] and \.[@p] are not allowed after
// module names, while they terminate macro definitions.

// 165.
func (prg *prg) scanRepl(t eightBits) {
	var (
		a   sixteenBits // the current token
		b   asciiCode   // a character from the buffer
		bal eightBits   // left parentheses minus right parentheses
	)
	bal = 0
	for true {
	continue1:
		a = uint16(prg.getNext())
		switch a {
		case '(':
			bal = byte(int32(bal) + 1)
		// ")"=
		case ')':
			if int32(bal) == 0 {
				prg.stdout.Writeln()
				prg.stdout.Write("! Extra )")
				prg.error1()
			} else {
				bal = byte(int32(bal) - 1)
			}
		// "'"=
		case '\'':
			// Copy a string from the buffer to |tok_mem|
			b = '\''
			for true {
				{
					if int32(prg.tokPtr[prg.z]) == maxToks {
						prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
						prg.error1()
						prg.history = byte(fatalMessage)
						prg.jumpOut()
					}
					prg.tokMem[prg.z][prg.tokPtr[prg.z]] = b
					prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
				}
				if int32(b) == '@' {
					if int32(prg.buffer[prg.loc]) == '@' {
						prg.loc = byte(int32(prg.loc) + 1)
					} else {
						prg.stdout.Writeln()
						prg.stdout.Write("! You should double @ signs in strings")
						prg.error1()
					}
				}
				// \xref[You should double \AT! signs]
				if int32(prg.loc) == int32(prg.limit) {
					{
						prg.stdout.Writeln()
						prg.stdout.Write("! String didn't end")
						prg.error1()
					}
					// \xref[String didn't end]
					prg.buffer[prg.loc] = '\''
					prg.buffer[int32(prg.loc)+1] = 0
				}
				b = prg.buffer[prg.loc]
				prg.loc = byte(int32(prg.loc) + 1)
				if int32(b) == '\'' {
					if int32(prg.buffer[prg.loc]) != '\'' {
						goto found
					} else {
						prg.loc = byte(int32(prg.loc) + 1)
						{
							if int32(prg.tokPtr[prg.z]) == maxToks {
								prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
								prg.error1()
								prg.history = byte(fatalMessage)
								prg.jumpOut()
							}
							prg.tokMem[prg.z][prg.tokPtr[prg.z]] = '\''
							prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
						}
					}
				}
			}

		found:
			; // now |a| holds the final |"'"| that will be stored

		// "#"=
		case '#':
			if int32(t) == parametric {
				a = uint16(param)
			}
		// \4
		// In cases that |a| is a non-ASCII token (|identifier|, |module_name|, etc.), either process it and change |a| to a byte that should be stored, or |goto continue| if |a| should be ignored, or |goto done| if |a| signals the end of this replacement text
		case identifier:
			a = prg.idLookup(eightBits(normal))
			{
				if int32(prg.tokPtr[prg.z]) == maxToks {
					prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
					prg.error1()
					prg.history = byte(fatalMessage)
					prg.jumpOut()
				}
				prg.tokMem[prg.z][prg.tokPtr[prg.z]] = byte(int32(a)/0400 + 0200)
				prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
			}
			a = uint16(int32(a) % 0400)

		case moduleName:
			if int32(t) != moduleName {
				goto done
			} else {
				{
					if int32(prg.tokPtr[prg.z]) == maxToks {
						prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
						prg.error1()
						prg.history = byte(fatalMessage)
						prg.jumpOut()
					}
					prg.tokMem[prg.z][prg.tokPtr[prg.z]] = byte(int32(prg.curModule)/0400 + 0250)
					prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
				}
				a = uint16(int32(prg.curModule) % 0400)
			}
		case verbatim:
			// Copy verbatim string from the buffer to |tok_mem|
			{
				if int32(prg.tokPtr[prg.z]) == maxToks {
					prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
					prg.error1()
					prg.history = byte(fatalMessage)
					prg.jumpOut()
				}
				prg.tokMem[prg.z][prg.tokPtr[prg.z]] = byte(verbatim)
				prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
			}
			prg.buffer[int32(prg.limit)+1] = '@'

		reswitch:
			if int32(prg.buffer[prg.loc]) == '@' {
				if int32(prg.loc) < int32(prg.limit) {
					if int32(prg.buffer[int32(prg.loc)+1]) == '@' {
						{
							if int32(prg.tokPtr[prg.z]) == maxToks {
								prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
								prg.error1()
								prg.history = byte(fatalMessage)
								prg.jumpOut()
							}
							prg.tokMem[prg.z][prg.tokPtr[prg.z]] = '@'
							prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
						}
						prg.loc = byte(int32(prg.loc) + 2)

						goto reswitch
					}
				}
			} else {
				{
					if int32(prg.tokPtr[prg.z]) == maxToks {
						prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
						prg.error1()
						prg.history = byte(fatalMessage)
						prg.jumpOut()
					}
					prg.tokMem[prg.z][prg.tokPtr[prg.z]] = prg.buffer[prg.loc]
					prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
				}
				prg.loc = byte(int32(prg.loc) + 1)

				goto reswitch
			}
			if int32(prg.loc) >= int32(prg.limit) {
				prg.stdout.Writeln()
				prg.stdout.Write("! Verbatim string didn't end")
				prg.error1()
			} else if int32(prg.buffer[int32(prg.loc)+1]) != '>' {
				prg.stdout.Writeln()
				prg.stdout.Write("! You should double @ signs in verbatim strings")
				prg.error1()
			}
			// \xref[You should double \AT! signs]
			prg.loc = byte(int32(prg.loc) + 2)
			// another |verbatim| byte will be stored, since |a=verbatim|

		case definition, format, beginPascal:
			if int32(t) != moduleName {
				goto done
			} else {
				{
					prg.stdout.Writeln()
					prg.stdout.Write("! @", string(rune(prg.xchr[prg.buffer[int32(prg.loc)-1]])),
						// \xref[\AT!p is ignored in Pascal text]
						// \xref[\AT!d is ignored in Pascal text]
						// \xref[\AT!f is ignored in Pascal text]
						" is ignored in Pascal text")
					prg.error1()
				}
				goto continue1
			}
		case newModule:
			goto done

		default:
		}

		{
			if int32(prg.tokPtr[prg.z]) == maxToks {
				prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
				prg.error1()
				prg.history = byte(fatalMessage)
				prg.jumpOut()
			}
			prg.tokMem[prg.z][prg.tokPtr[prg.z]] = byte(a)
			prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
		} // store |a| in |tok_mem|
	}

done:
	prg.nextControl = byte(a)

	// Make sure the parentheses balance
	if int32(bal) > 0 {
		if int32(bal) == 1 {
			prg.stdout.Writeln()
			prg.stdout.Write("! Missing )")
			prg.error1()
		} else {
			prg.stdout.Writeln()
			prg.stdout.Write("! Missing ", bal, knuth.WriteWidth(1), " )'s")
			prg.error1()
		}
		// \xref[Missing n )]
		for int32(bal) > 0 {
			{
				if int32(prg.tokPtr[prg.z]) == maxToks {
					prg.stderr.Writeln("! Sorry, ", "token", " capacity exceeded")
					prg.error1()
					prg.history = byte(fatalMessage)
					prg.jumpOut()
				}
				prg.tokMem[prg.z][prg.tokPtr[prg.z]] = ')'
				prg.tokPtr[prg.z] = uint16(int32(prg.tokPtr[prg.z]) + 1)
			}
			bal = byte(int32(bal) - 1)
		}
	}
	if int32(prg.textPtr) > maxTexts-zz {
		prg.stderr.Writeln("! Sorry, ", "text", " capacity exceeded")
		prg.error1()
		prg.history = byte(fatalMessage)
		prg.jumpOut()
	}
	prg.curReplText = prg.textPtr
	prg.tokStart[int32(prg.textPtr)+zz] = prg.tokPtr[prg.z]
	prg.textPtr = uint16(int32(prg.textPtr) + 1)
	if int32(prg.z) == zz-1 {
		prg.z = 0
	} else {
		prg.z = byte(int32(prg.z) + 1)
	}
}

// 170.

// tangle:pos tangle.web:3057:3:

// The following procedure is used to define a simple or parametric macro,
// just after the `\.[==]' of its definition has been scanned.
func (prg *prg) defineMacro(t eightBits) {
	var (
		p namePointer // the identifier being defined
	)
	p = prg.idLookup(t)
	prg.scanRepl(t)

	prg.equiv[p] = prg.curReplText
	prg.textLink[prg.curReplText] = 0
}

// 172.

// tangle:pos tangle.web:3075:3:

// The top level of |scan_module| is trivial.
func (prg *prg) scanModule() {
	var (
		p namePointer // module name for the current module
	)
	prg.moduleCount = uint16(int32(prg.moduleCount) + 1)

	// Scan the \(definition part of the current module
	prg.nextControl = 0
	for true {
	continue1:
		for int32(prg.nextControl) <= format {
			prg.nextControl = prg.skipAhead()
			if int32(prg.nextControl) == moduleName {
				prg.loc = byte(int32(prg.loc) - 2)
				prg.nextControl = prg.getNext()
			}
		}
		if int32(prg.nextControl) != definition {
			goto done
		}
		prg.nextControl = prg.getNext() // get identifier name
		if int32(prg.nextControl) != identifier {
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Definition flushed, must start with ",
					// \xref[Definition flushed...]
					"identifier of length > 1")
				prg.error1()
			}
			goto continue1
		}
		prg.nextControl = prg.getNext() // get token after the identifier
		if int32(prg.nextControl) == '=' {
			prg.scanNumeric(prg.idLookup(eightBits(numeric)))
			goto continue1
		} else if int32(prg.nextControl) == equivalenceSign {
			prg.defineMacro(eightBits(simple))
			goto continue1
		} else if int32(prg.nextControl) == '(' {
			prg.nextControl = prg.getNext()
			if int32(prg.nextControl) == '#' {
				prg.nextControl = prg.getNext()
				if int32(prg.nextControl) == ')' {
					prg.nextControl = prg.getNext()
					if int32(prg.nextControl) == '=' {
						{
							prg.stdout.Writeln()
							prg.stdout.Write("! Use == for macros")
							prg.error1()
						}
						// \xref[Use == for macros]
						prg.nextControl = byte(equivalenceSign)
					}
					if int32(prg.nextControl) == equivalenceSign {
						prg.defineMacro(eightBits(parametric))
						goto continue1
					}
				}
			}
		}

		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Definition flushed since it starts badly")
			prg.error1()
		}
		// \xref[Definition flushed...]
	}

done:
	;

	// Scan the \PASCAL\ part of the current module
	switch prg.nextControl {
	case beginPascal:
		p = 0
	case moduleName:
		p = prg.curModule

		// Check that |=| or |==| follows this module name, otherwise |return|
		for {
			prg.nextControl = prg.getNext()
			if int32(prg.nextControl) != '+' {
				break
			}
		} // allow optional `\.[+=]'
		if int32(prg.nextControl) != '=' && int32(prg.nextControl) != equivalenceSign {
			{
				prg.stdout.Writeln()
				prg.stdout.Write("! Pascal text flushed, = sign is missing")
				prg.error1()
			}
			// \xref[Pascal text flushed...]
			for {
				prg.nextControl = prg.skipAhead()
				if int32(prg.nextControl) == newModule {
					break
				}
			}

			goto exit
		}

	default:
		goto exit
	}

	// Insert the module number into |tok_mem|
	prg.storeTwoBytes(sixteenBits(0150000 + int32(prg.moduleCount))) // |@'150000=@'320*@'400|

	prg.scanRepl(eightBits(moduleName)) // now |cur_repl_text| points to the replacement text

	// Update the data structure so that the replacement text is accessible
	if int32(p) == 0 {
		prg.textLink[prg.lastUnnamed] = prg.curReplText
		prg.lastUnnamed = prg.curReplText
	} else if int32(prg.equiv[p]) == 0 {
		prg.equiv[p] = prg.curReplText
	} else {
		p = prg.equiv[p]
		for int32(prg.textLink[p]) < maxTexts {
			p = prg.textLink[p]
		} // find end of list
		prg.textLink[p] = prg.curReplText
	}
	prg.textLink[prg.curReplText] = uint16(maxTexts)
	// mark this replacement text as a nonmacro

exit:
}

// 181.
//  procedure debug_help; [routine to display various things]
// label breakpoint,exit;
// var k:integer; [index into various arrays]
// begin   debug_skipped:= debug_skipped+1 ;
// if debug_skipped<debug_cycle then  goto exit ;
// debug_skipped:=0;
//  while true do    begin  begin writeln()  ; write('#') ; end ;  ; [prompt]
//   read(term_in,ddt); [read a debug-command code]
//   if ddt<0 then  goto exit
//   else if ddt=0 then
//     begin goto breakpoint;
//  [go to every label at least once]
//     breakpoint: ddt:=0;
//
//     end
//   else  begin read(term_in,dd);
//     case ddt of
//     1: print_id(dd);
//     2: print_repl(dd);
//     3: for k:=1 to dd do write( xchr[ buffer[ k]]) ;
//     4: for k:=1 to dd do write( xchr[ mod_text[ k]]) ;
//     5: for k:=1 to out_ptr do write( xchr[ out_buf[ k]]) ;
//     6: for k:=1 to dd do write( xchr[ out_contrib[ k]]) ;
//      else  write('?')
//      end ;
//     end;
//   end;
// exit:end;
// [  ]

// 182. The main program

// tangle:pos tangle.web:3240:21:

// We have defined plenty of procedures, and it is time to put the last
// pieces of the puzzle in place. Here is where \.[TANGLE] starts, and where
// it ends.
// \xref[system dependencies]
func (prg *prg) main() {
	defer func() {
		if prg.changeFile != nil {
			prg.changeFile.Close()
		}
		if prg.pascalFile != nil {
			prg.pascalFile.Close()
		}
		if prg.pool != nil {
			prg.pool.Close()
		}
		if prg.stderr != nil {
			prg.stderr.Close()
		}
		if prg.stdin != nil {
			prg.stdin.Close()
		}
		if prg.stdout != nil {
			prg.stdout.Close()
		}
		if prg.termOut != nil {
			prg.termOut.Close()
		}
		if prg.webFile != nil {
			prg.webFile.Close()
		}
	}()

	prg.initialize()

	// Initialize the input system
	prg.openInput()
	prg.line = 0
	prg.otherLine = 0

	prg.changing = true
	prg.primeTheChangeBuffer()
	prg.changing = !prg.changing
	prg.tempLine = prg.otherLine
	prg.otherLine = prg.line
	prg.line = prg.tempLine

	prg.limit = 0
	prg.loc = 1
	prg.buffer[0] = ' '
	prg.inputHasEnded = false

	prg.stdout.Writeln("This is TANGLE, Version 4.6 (gotangle v0.0-prereleaase)") // print a ``banner line''

	// Phase I: Read all the user's text and compress it into |tok_mem|
	prg.phaseOne = true
	prg.moduleCount = 0
	for {
		prg.nextControl = prg.skipAhead()
		if int32(prg.nextControl) == newModule {
			break
		}
	}
	for !prg.inputHasEnded {
		prg.scanModule()
	}

	// Check that all changes have been read
	if int32(prg.changeLimit) != 0 {
		for ii := int32(0); ii <= int32(prg.changeLimit)-1; ii++ {
			prg.ii1 = ii
			_ = prg.ii1
			prg.buffer[prg.ii1] = prg.changeBuffer[prg.ii1]
		}
		prg.limit = prg.changeLimit
		prg.changing = true
		prg.line = prg.otherLine
		prg.loc = prg.changeLimit
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! Change file entry did not match")
			prg.error1()
		}
		// \xref[Change file entry did not match]
	}
	prg.phaseOne = false

	//  for ii:=0 to zz-1 do max_tok_ptr[ii]:=tok_ptr[ii]; [  ]

	// Phase II:...
	if int32(prg.textLink[0]) == 0 {
		{
			prg.stdout.Writeln()
			prg.stdout.Write("! No output was specified.")
		} /*   */
		if int32(prg.history) == spotless {
			prg.history = byte(harmlessMessage)
		}
		// \xref[No output was specified]
	} else {
		{
			prg.stdout.Writeln()
			prg.stdout.Write("Writing the output file")
		}

		// Initialize the output stacks
		prg.stackPtr = 1
		prg.braceLevel = 0
		prg.curState.nameField = 0
		prg.curState.replField = prg.textLink[0]
		prg.zo = byte(int32(prg.curState.replField) % zz)
		prg.curState.byteField = prg.tokStart[prg.curState.replField]
		prg.curState.endField = prg.tokStart[int32(prg.curState.replField)+zz]
		prg.curState.modField = 0

		// Initialize the output buffer
		prg.outState = byte(misc)
		prg.outPtr = 0
		prg.breakPtr = 0
		prg.semiPtr = 0
		prg.outBuf[0] = 0
		prg.line = 1

		prg.sendTheOutput()

		// Empty the last line...
		prg.breakPtr = prg.outPtr
		prg.semiPtr = 0
		prg.flushBuffer()
		if int32(prg.braceLevel) != 0 {
			prg.stdout.Writeln()
			prg.stdout.Write("! Program ended at brace level ", prg.braceLevel, knuth.WriteWidth(1))
			prg.error1()
		}
		// \xref[Program ended at brace level n]

		{
			prg.stdout.Writeln()
			prg.stdout.Write("Done.")
		}
	}
	if int32(prg.stringPtr) > 256 {
		{
			prg.stdout.Writeln()
			prg.stdout.Write(int32(prg.stringPtr)-256, knuth.WriteWidth(1), " strings written to string pool file.")
		}
		prg.pool.Write("*")
		for ii := int32(1); ii <= 9; ii++ {
			prg.ii1 = ii
			_ = prg.ii1
			prg.outBuf[prg.ii1] = byte(prg.poolCheckSum % 10)
			prg.poolCheckSum = prg.poolCheckSum / 10
		}
		for ii := int32(9); ii >= 1; ii-- {
			prg.ii1 = ii
			_ = prg.ii1
			prg.pool.Write(string(rune(prg.xchr['0'+int32(prg.outBuf[prg.ii1])])))
		}
		prg.pool.Writeln()
	}
	//
	// [ Print statistics about memory usage ]
	//  begin writeln()  ; write('Memory usage statistics:') ; end ;
	//  begin writeln()  ; write(  name_ptr:  1, ' names, ',   text_ptr:  1, ' replacement texts;') ; end ;
	//  begin writeln()  ; write(  byte_ptr[  0]:  1) ; end ;
	// for wo:=1 to ww-1 do write('+', byte_ptr[ wo]: 1) ;
	// if phase_one then
	//   for ii:=0 to zz-1 do max_tok_ptr[ii]:=tok_ptr[ii];
	// write(' bytes, ',  max_tok_ptr[ 0]: 1) ;
	// for ii:=1 to zz-1 do write('+', max_tok_ptr[ ii]: 1) ;
	// write(' tokens.') ;
	//
	// ; [  ]

	// \4\4
	// here files should be closed if the operating system requires it

	// Print the job |history|
	switch prg.history {
	case spotless:
		prg.stdout.Writeln()
		prg.stdout.Write("(No errors were found.)")
	case harmlessMessage:
		prg.stdout.Writeln()
		prg.stdout.Write("(Did you see the warning message above?)")
	case errorMessage:
		prg.stdout.Writeln()
		prg.stdout.Write("(Pardon me, but I think I spotted something wrong.)")
	case fatalMessage:
		prg.stdout.Writeln()
		prg.stdout.Write("(That was a fatal error, my friend.)")
	}
	prg.stdout.Writeln()
}

// 188. System-dependent changes

// tangle:pos tangle.web:3307:29:

// This module should be replaced, if necessary, by changes to the program
// that are necessary to make \.[TANGLE] work at a particular installation.
// It is usually best to design your change file so that all changes to
// previous modules preserve the module numbering; then everybody's version
// will be consistent with the printed program. More extensive changes,
// which introduce new modules, can be inserted here; then only the index
// itself will get a new module number.
// \xref[system dependencies]

// 189. Index

// tangle:pos tangle.web:3317:10:

// Here is a cross-reference table for the \.[TANGLE] processor.
// All modules in which an identifier is
// used are listed with that identifier, except that reserved words are
// indexed only when they appear in format definitions, and the appearances
// of identifiers in module names are not indexed. Underlined entries
// correspond to where the identifier was declared. Error messages and
// a few other things like ``ASCII code'' are indexed here too.