Skip to content

Instantly share code, notes, and snippets.

@texdraft
Created August 13, 2019 19:21
Show Gist options
  • Save texdraft/c72fd78491439abd7d9d323fec3ec043 to your computer and use it in GitHub Desktop.
Save texdraft/c72fd78491439abd7d9d323fec3ec043 to your computer and use it in GitHub Desktop.
diff oldtex.web tex.web
This file has been truncated, but you can view the full file.
2,4c2,3
< \def\glob{13} % this should be the section number of "<Globals...>"
< \def\gglob{20, 26} % this should be the next two sections of "<Globals...>"
< This is \TeX, a document compiler intended to produce high-quality typesetting.
---
> This is \TeX, a document compiler intended to produce typesetting of high
> quality.
9c8
< will be obtainable on a great variety of different computers.
---
> will be obtainable on a great variety of computers.
34c33
< the \TeX\ user's manual.
---
> {\sl The \TeX book}.
35a35
> @:TeXbook}{\sl The \TeX book@>
38c38
< of@@1977, when Michael@@F. Plass and Frank@@M. Liang designed and coded
---
> of~1977, when Michael~F. Plass and Frank~M. Liang designed and coded
43c43
< based on some specifications that the author had made in April of that year.
---
> based on some specifications that the author had made in May of that year.
54c54,55
< somewhat like the present ``web'' were developed by Luis Trabb@@Pardo and
---
> somewhat like the present ``web'' were developed by Luis Trabb~Pardo and
> @^Trabb Pardo, Luis Isidoro@>
56c57
< created by Ignacio@@A. Zabala in 1979 and 1980. The \TeX82 program, which
---
> created by Ignacio~A. Zabala in 1979 and 1980. The \TeX82 program, which
67c68,76
< has been substantially improved.
---
> has been substantially improved. After the appearance of ``Version 0'' in
> September 1982, this program benefited greatly from the comments of
> many other people, notably David~R. Fuchs and Howard~W. Trickey.
> A final revision in September 1989 extended the input character set to
> eight-bit codes and introduced the ability to hyphenate words from
> different languages, based on some ideas of Michael~J. Ferguson.
> @^Fuchs, David Raymond@>
> @^Trickey, Howard Wellington@>
> @^Ferguson, Michael John@>
69c78
< No doubt there still is plenty of room for enhancements, but the author
---
> No doubt there still is plenty of room for improvement, but the author
71c80
< and reliabil\-ity are to be its main virtues.
---
> and reliability are to be its main virtues.
79a89
> @^system dependencies@>
81c91,99
< @d banner=='This is TeX, Version -0.25' {printed when \TeX\ starts}
---
> If this program is changed, the resulting system should not be called
> `\TeX'; the official name `\TeX' by itself is reserved
> for software systems that are fully compatible with each other.
> A special test suite called the ``\.{TRIP} test'' is available for
> helping to determine whether a particular implementation deserves to be
> known as `\TeX' [cf.~Stanford Computer Science report CS1027,
> November 1984].
>
> @d banner=='This is TeX, Version 3.14159265' {printed when \TeX\ starts}
84d101
< \def\ph{{\mc PASCAL-H}}
87c104
< available to the author in 1982. The methods used here to work with
---
> available to the author in 1982. Constructions that apply to
89,90c106,107
< reader to see how to make an appropriate interface for other systems
< if necessary. (\ph\ is Charles Hedrick's mod\-ifi\-ca\-tion of a compiler
---
> reader see how to make an appropriate interface for other systems
> if necessary. (\ph\ is Charles Hedrick's modification of a compiler
98,99c115,120
< \PASCAL\ itself, so that most of the code can be mechanically translated
< into other high-level languages.)
---
> \PASCAL\ itself, so that most of the code can be translated mechanically
> into other high-level languages. For example, the `\&{with}' and `\\{new}'
> features are not used, nor are pointer types, set types, or enumerated
> scalar types; there are no `\&{var}' parameters, except in the case of files;
> there are no tag fields on variant records; there are no assignments
> |real:=integer|; no procedures are declared local to other procedures.)
110a132,136
> Incidentally, \PASCAL's standard |round| function can be problematical,
> because it disagrees with the IEEE floating-point standard.
> Many implementors have
> therefore chosen to substitute their own home-grown rounding procedure.
>
114,115c140,141
< For example, the portion of the program called `\X\glob:Globals in the outer
< block\X' here will be replaced by a sequence of variable declarations
---
> For example, the portion of the program called `\X\glob:Global
> variables\X' below will be replaced by a sequence of variable declarations
120c146
< sections \gglob, $\ldots$,'' also make it possible to look at the set of
---
> sections \gglob, \dots,'' also make it possible to look at the set of
126a153
> @:PASCAL H}{\ph@>
138c165
< var@?@<Globals in the outer block@>@/
---
> var @<Global variables@>@/
141,143c168,170
< var@?@<Local variables for initialization@>@/
< begin @<Initialize whatever \TeX\ might access@>@;
< end;@#
---
> var @<Local variables for initialization@>@/
> begin @<Initialize whatever \TeX\ might access@>@;
> end;@#
150c177
< comment `@!|start_here|'. If you want to skip down to the
---
> comment `|start_here|'. If you want to skip down to the
167c194
< {key control points}
---
> {key control points}
173,177c200,207
< delimited by the codewords `$|debug|\ldotsm|gubed|$', with apologies
< to people who wish to preserve the purity of English. Similarly, there
< is some conditional code delimited by `$|stat|\ldotsm|tats|$'
< that is intended only for use when statistics
< are to be kept about \TeX's memory usage.
---
> delimited by the codewords `$|debug|\ldots|gubed|$', with apologies
> to people who wish to preserve the purity of English.
>
> Similarly, there is some conditional code delimited by
> `$|stat|\ldots|tats|$' that is intended for use when statistics are to be
> kept about \TeX's memory usage. The |stat| $\ldots$ |tats| code also
> implements diagnostic information for \.{\\tracingparagraphs} and
> \.{\\tracingpages}.
180,181c210,211
< @d debug==@{ {change this to `$\\{debug}\eqv\null$' when debugging}
< @d gubed==@} {change this to `$\\{gubed}\eqv\null$' when debugging}
---
> @d debug==@{ {change this to `$\\{debug}\equiv\null$' when debugging}
> @d gubed==@t@>@} {change this to `$\\{gubed}\equiv\null$' when debugging}
185,188c215,218
< @d stat==@{ {change this to `$\\{stat}\eqv\null$' when gathering
< usage statistics}
< @d tats==@} {change this to `$\\{tats}\eqv\null$' when gathering
< usage statistics}
---
> @d stat==@{ {change this to `$\\{stat}\equiv\null$' when gathering
> usage statistics}
> @d tats==@t@>@} {change this to `$\\{tats}\equiv\null$' when gathering
> usage statistics}
193c223
< version called \.{INITEX}, which does the extra calculations need to
---
> version called \.{INITEX}, which does the extra calculations needed to
195c225
< initialize \TeX's internal tables; and (2)@@there is a shorter and faster
---
> initialize \TeX's internal tables; and (2)~there is a shorter and faster
198c228
< the codewords `$|init|\ldotsm|tini|$'.
---
> the codewords `$|init|\ldots|tini|$'.
200,201c230,231
< @d init== {change this to `$\\{init}\eqv\.{@@\{}$' in the production version}
< @d tini== {change this to `$\\{tini}\eqv\.{@@\}}$' in the production version}
---
> @d init== {change this to `$\\{init}\equiv\.{@@\{}$' in the production version}
> @d tini== {change this to `$\\{tini}\equiv\.{@@\}}$' in the production version}
207c237
< init @<Initialize table entries (done by \.{INITEX} only)@>@;@+tini
---
> @!init @<Initialize table entries (done by \.{INITEX} only)@>@;@+tini
210d239
< @^system dependencies@>
217c246,248
< @^Overflow in arithmetic@>
---
> @:PASCAL H}{\ph@>
> @^system dependencies@>
> @^overflow in arithmetic@>
221c252
< debug @{@&$C+,D+@}@+ gubed {but turn everything on when debugging}
---
> @!debug @{@&$C+,D+@}@+ gubed {but turn everything on when debugging}
223c254
< @ This \TeX\ implementation conforms to the rules of the {\sl PASCAL User
---
> @ This \TeX\ implementation conforms to the rules of the {\sl Pascal User
234c265
< $$\vbox{\halign{\!#\hfil\cr
---
> $$\vbox{\halign{\ignorespaces#\hfil\cr
238c269
< |othercases| $\langle\,$code for |x≠1| and |x≠3|$\,\rangle$\cr
---
> |othercases| $\langle\,$code for |x<>1| and |x<>3|$\,\rangle$\cr
243,248c274,279
< syntaxes like `\!|else|\unskip' or `\\{otherwise}' or `\\{otherwise}:',
< etc. The definitions of |othercases| and |endcases| should be changed to
< agree with local conventions. Note that no semicolon appears before
< |endcases| in this program, so the definition of |endcases| should include
< a semicolon if the compiler wants one. (Of course, if no default mechanism
< is available, the |case| statements of \TeX\ will have to be laboriously
---
> syntaxes like `\&{else}' or `\&{otherwise}' or `\\{otherwise}:', etc. The
> definitions of |othercases| and |endcases| should be changed to agree with
> local conventions. Note that no semicolon appears before |endcases| in
> this program, so the definition of |endcases| should include a semicolon
> if the compiler wants one. (Of course, if no default mechanism is
> available, the |case| statements of \TeX\ will have to be laboriously
250c281,282
< \PASCAL s have in fact done this, successfully but not happily!)
---
> \PASCAL s have, in fact, done this, successfully but not happily!)
> @:PASCAL H}{\ph@>
264,265c296,301
< @!mem_max=30000; {greatest index in \TeX's internal |mem| array,
< must be strictly less than |max_halfword|}
---
> @!mem_max=30000; {greatest index in \TeX's internal |mem| array;
> must be strictly less than |max_halfword|;
> must be equal to |mem_top| in \.{INITEX}, otherwise |>=mem_top|}
> @!mem_min=0; {smallest index in \TeX's internal |mem| array;
> must be |min_halfword| or more;
> must be equal to |mem_bot| in \.{INITEX}, otherwise |<=mem_bot|}
267,272c303,309
< current lines of open files; must not exceed |max_halfword|}
< @!error_line=64; {width of context lines on terminal error messages}
< @!half_error_line=32; {width of first lines of contexts in terminal
< error messages, should be between 30 and |error_line-15|}
< @!max_print_line=72; {width of longest text lines output, should be at least 60}
< @!stack_size=80; {maximum number of simultaneous input sources}
---
> current lines of open files and in control sequences between
> \.{\\csname} and \.{\\endcsname}; must not exceed |max_halfword|}
> @!error_line=72; {width of context lines on terminal error messages}
> @!half_error_line=42; {width of first lines of contexts in terminal
> error messages; should be between 30 and |error_line-15|}
> @!max_print_line=79; {width of longest text lines output; should be at least 60}
> @!stack_size=200; {maximum number of simultaneous input sources}
274,278c311,315
< can be going on simultaneously}
< @!font_max=75; {maximum internal font number, must not exceed |max_quarterword|}
< @!bad_font_code=300; {user font codes must be less than this}
< @!font_mem_size=15000; {number of words of |font_info| for all fonts}
< @!param_size=30; {maximum number of simultaneous macro parameters}
---
> can be going on simultaneously}
> @!font_max=75; {maximum internal font number; must not exceed |max_quarterword|
> and must be at most |font_base+256|}
> @!font_mem_size=20000; {number of words of |font_info| for all fonts}
> @!param_size=60; {maximum number of simultaneous macro parameters}
282,292c319,330
< available for the user's control sequences and font names,
< after \TeX's own error messages are stored}
< @!pool_size=30000; {maximum number of characters in strings, including all
< error messages and help texts, and the names of all fonts and
< control sequences; must be at least 22000 more than |string_vacancies|}
< @!align_size=4; {maximum number of simultaneous alignments}
< @!save_size=300; {space for saving values outside of current group, must be
< at most |max_halfword|}
< @!trie_size=7000; {space for hyphenation patterns, should be larger for
< \.{INITEX} than it is in production versions of \TeX}
< @!dvi_buf_size=800; {size of the output buffer, must be a multiple of 8}
---
> available for the user's control sequences and font names,
> after \TeX's own error messages are stored}
> @!pool_size=32000; {maximum number of characters in strings, including all
> error messages and help texts, and the names of all fonts and
> control sequences; must exceed |string_vacancies| by the total
> length of \TeX's own strings, which is currently about 23000}
> @!save_size=600; {space for saving values outside of current group; must be
> at most |max_halfword|}
> @!trie_size=8000; {space for hyphenation patterns; should be larger for
> \.{INITEX} than it is in production versions of \TeX}
> @!trie_op_size=500; {space for ``opcodes'' in the hyphenation patterns}
> @!dvi_buf_size=800; {size of the output buffer; must be a multiple of 8}
294,296c332,334
< @!pool_name='<TeX.sources>TEX.POOL ';
< {string of length |file_name_size|, tells where string pool appears}
< @^system dependencies@>
---
> @!pool_name='TeXformats:TEX.POOL ';
> {string of length |file_name_size|; tells where the string pool appears}
> @.TeXformats@>
309,314c347,353
< @d mem_base=0 {smallest index in the |mem| array, must not be less
< than |min_halfword|}
< @d hi_mem_base=12000 {smallest index in the single-word area of |mem|,
< must be substantially larger than |mem_base| and smaller than |mem_max|}
< @d font_base=0 {smallest internal font number, must not be less
< than |min_quarterword|}
---
> @d mem_bot=0 {smallest index in the |mem| array dumped by \.{INITEX};
> must not be less than |mem_min|}
> @d mem_top==30000 {largest index in the |mem| array dumped by \.{INITEX};
> must be substantially larger than |mem_bot|
> and not greater than |mem_max|}
> @d font_base=0 {smallest internal font number; must not be less
> than |min_quarterword|}
316,317c355,356
< about |(mem_max-hi_mem_base)/6|, but 2100 is already quite generous}
< @d hash_prime=1777 {a prime number equal to about 85\%\ of |hash_size|}
---
> about |(mem_max-mem_min)/10|}
> @d hash_prime=1777 {a prime number equal to about 85\pct! of |hash_size|}
330,331c369,370
< @ Later on we will say `\!|if mem_max≥max_halfword then bad←10|', or
< something similar. (We can't do that until |max_halfword| has been defined.)
---
> @ Later on we will say `\ignorespaces|if mem_max>=max_halfword then bad:=14|',
> or something similar. (We can't do that until |max_halfword| has been defined.)
334,339c373,380
< bad←0;
< if (half_error_line<30)∨(half_error_line>error_line-15) then bad←1;
< if max_print_line<60 then bad←2;
< if dvi_buf_size mod 8≠0 then bad←3;
< if (hi_mem_base<mem_base+100)∨(hi_mem_base+100>mem_max) then bad←4;
< if hash_prime>hash_size then bad←5;
---
> bad:=0;
> if (half_error_line<30)or(half_error_line>error_line-15) then bad:=1;
> if max_print_line<60 then bad:=2;
> if dvi_buf_size mod 8<>0 then bad:=3;
> if mem_bot+1100>mem_top then bad:=4;
> if hash_prime>hash_size then bad:=5;
> if max_in_open>=128 then bad:=6;
> if mem_top<256+11 then bad:=7; {we will want |null_list>255|}
342,354c383,394
< occasional |goto| statements will be meaningful. We insert
< the label `|exit|:' just before the `\!|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|'.
< If two or more parts of a subroutine start differently but end up the same,
< the shared code may be gathered together at `|common_ending|'.
<
---
> occasional |goto| statements will be meaningful. 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|'. If two or more parts of a subroutine start differently but
> end up the same, the shared code may be gathered together at
> `|common_ending|'.
378,379c418,420
< @d incr(#) == #←#+1 {increase a variable by unity}
< @d decr(#) == #←#-1 {decrease a variable by unity}
---
> @d incr(#) == #:=#+1 {increase a variable by unity}
> @d decr(#) == #:=#-1 {decrease a variable by unity}
> @d negate(#) == #:=-# {change the sign of a variable}
381c422,423
< @f loop == xclause {\.{WEB}'s |xclause| acts like `\!|while true do|\unskip'}
---
> @f loop == xclause
> {\.{WEB}'s |xclause| acts like `\ignorespaces|while true do|\unskip'}
384a427,428
> @d empty=0 {symbolic name for a null constant}
>
386,388c430,432
< In order to make \TeX\ readily portable between a wide variety of
< computers, all of its input text is converted to an internal seven-bit
< code that is essentially standard ascii, the ``American Standard Code for
---
> In order to make \TeX\ readily portable to a wide variety of
> computers, all of its input text is converted to an internal eight-bit
> code that includes standard ASCII, the ``American Standard Code for
390c434
< character is read in. Conversely, characters are converted from ascii to
---
> character is read in. Conversely, characters are converted from ASCII to
392c436
< text file.
---
> text file.
396c440
< character `\.A' has ascii code $65=@'101$, and when \TeX\ typesets
---
> character `\.A' has ASCII code $65=@'101$, and when \TeX\ typesets
400c444
< \TeX's device-independent files is responsible for converting from ascii to
---
> \TeX's device-independent files is responsible for converting from ASCII to
402c446
< @^ascii code@>
---
> @^ASCII code@>
404c448
< \TeX's internal code is relevant also with respect to constants
---
> \TeX's internal code also defines the value of constants
406c450
< \.{\\chcode}, \.{\\mathcode}, \.{\\uccode}, \.{\\lccode}, and \.{\\delcode}
---
> \.{\\catcode}, \.{\\mathcode}, \.{\\uccode}, \.{\\lccode}, and \.{\\delcode}
409,410c453,454
< @ Characters of text that have been converted to \TeX's internal form
< are said to be of type |ascii_code|, which is a subrange of the integers.
---
> @ Characters of text that have been converted to \TeX's internal form
> are said to be of type |ASCII_code|, which is a subrange of the integers.
413c457
< @!ascii_code=0..127; {seven-bit numbers}
---
> @!ASCII_code=0..255; {eight-bit numbers}
416,418c460,462
< character sets were common, so it did not make provision for lower case
< letters. Nowadays, of course, we need to deal with both upper and lower case
< alphabets in a convenient way, especially in a program for typesetting;
---
> character sets were common, so it did not make provision for lowercase
> letters. Nowadays, of course, we need to deal with both capital and small
> letters in a convenient way, especially in a program for typesetting;
423c467
< with ascii codes @'40 through @'176; all of these characters are now
---
> with ASCII codes @'40 through @'176; all of these characters are now
435c479
< from |ascii_code| when they are input and output. We shall also assume
---
> from |ASCII_code| when they are input and output. We shall also assume
437c481
< |chr(last_text_char)|, in\-clu\-sive. The following definitions should be
---
> |chr(last_text_char)|, inclusive. The following definitions should be
443c487
< @d last_text_char=127 {ordinal number of the largest element of |text_char|}
---
> @d last_text_char=255 {ordinal number of the largest element of |text_char|}
446c490
< i:0..last_text_char;
---
> @!i:integer;
448c492
< @ The \TeX\ processor converts between ascii code and
---
> @ The \TeX\ processor converts between ASCII code and
452,462c496,509
< @<Globals...@>=
< @!xord: array [text_char] of ascii_code;
< {specifies conversion of input characters}
< @!xchr: array [ascii_code] of text_char;
< {specifies conversion of output characters}
<
< @ Since we are assuming that our \PASCAL\ system is able to read and write the
< visible characters of standard ascii (although not necessarily using the
< ascii codes to represent them), the following assignment statements initialize
< most of the |xchr| array properly, without needing any system-dependent
< changes.
---
> @<Glob...@>=
> @!xord: array [text_char] of ASCII_code;
> {specifies conversion of input characters}
> @!xchr: array [ASCII_code] of text_char;
> {specifies conversion of output characters}
>
> @ Since we are assuming that our \PASCAL\ system is able to read and
> write the visible characters of standard ASCII (although not
> necessarily using the ASCII codes to represent them), the following
> assignment statements initialize the standard part of the |xchr| array
> properly, without needing any system-dependent changes. On the other
> hand, it is possible to implement \TeX\ with less complete character
> sets, and in such cases it will be necessary to change something here.
> @^system dependencies@>
465,561c512,606
< xchr[@'40]←' ';
< xchr[@'41]←'!';
< xchr[@'42]←'"';
< xchr[@'43]←'#';
< xchr[@'44]←'$';
< xchr[@'45]←'%';
< xchr[@'46]←'&';
< xchr[@'47]←'''';@/
< xchr[@'50]←'(';
< xchr[@'51]←')';
< xchr[@'52]←'*';
< xchr[@'53]←'+';
< xchr[@'54]←',';
< xchr[@'55]←'-';
< xchr[@'56]←'.';
< xchr[@'57]←'/';@/
< xchr[@'60]←'0';
< xchr[@'61]←'1';
< xchr[@'62]←'2';
< xchr[@'63]←'3';
< xchr[@'64]←'4';
< xchr[@'65]←'5';
< xchr[@'66]←'6';
< xchr[@'67]←'7';@/
< xchr[@'70]←'8';
< xchr[@'71]←'9';
< xchr[@'72]←':';
< xchr[@'73]←';';
< xchr[@'74]←'<';
< xchr[@'75]←'=';
< xchr[@'76]←'>';
< xchr[@'77]←'?';@/
< xchr[@'100]←'@@';
< xchr[@'101]←'A';
< xchr[@'102]←'B';
< xchr[@'103]←'C';
< xchr[@'104]←'D';
< xchr[@'105]←'E';
< xchr[@'106]←'F';
< xchr[@'107]←'G';@/
< xchr[@'110]←'H';
< xchr[@'111]←'I';
< xchr[@'112]←'J';
< xchr[@'113]←'K';
< xchr[@'114]←'L';
< xchr[@'115]←'M';
< xchr[@'116]←'N';
< xchr[@'117]←'O';@/
< xchr[@'120]←'P';
< xchr[@'121]←'Q';
< xchr[@'122]←'R';
< xchr[@'123]←'S';
< xchr[@'124]←'T';
< xchr[@'125]←'U';
< xchr[@'126]←'V';
< xchr[@'127]←'W';@/
< xchr[@'130]←'X';
< xchr[@'131]←'Y';
< xchr[@'132]←'Z';
< xchr[@'133]←'[';
< xchr[@'134]←'\';
< xchr[@'135]←']';
< xchr[@'136]←'^';
< xchr[@'137]←'_';@/
< xchr[@'140]←'`';
< xchr[@'141]←'a';
< xchr[@'142]←'b';
< xchr[@'143]←'c';
< xchr[@'144]←'d';
< xchr[@'145]←'e';
< xchr[@'146]←'f';
< xchr[@'147]←'g';@/
< xchr[@'150]←'h';
< xchr[@'151]←'i';
< xchr[@'152]←'j';
< xchr[@'153]←'k';
< xchr[@'154]←'l';
< xchr[@'155]←'m';
< xchr[@'156]←'n';
< xchr[@'157]←'o';@/
< xchr[@'160]←'p';
< xchr[@'161]←'q';
< xchr[@'162]←'r';
< xchr[@'163]←'s';
< xchr[@'164]←'t';
< xchr[@'165]←'u';
< xchr[@'166]←'v';
< xchr[@'167]←'w';@/
< xchr[@'170]←'x';
< xchr[@'171]←'y';
< xchr[@'172]←'z';
< xchr[@'173]←'{';
< xchr[@'174]←'|';
< xchr[@'175]←'}';
< xchr[@'176]←'~';@/
< xchr[0]←' '; xchr[@'177]←' ';
< {ascii codes 0 and |@'177| do not appear in text}
---
> xchr[@'40]:=' ';
> xchr[@'41]:='!';
> xchr[@'42]:='"';
> xchr[@'43]:='#';
> xchr[@'44]:='$';
> xchr[@'45]:='%';
> xchr[@'46]:='&';
> xchr[@'47]:='''';@/
> xchr[@'50]:='(';
> xchr[@'51]:=')';
> xchr[@'52]:='*';
> xchr[@'53]:='+';
> xchr[@'54]:=',';
> xchr[@'55]:='-';
> xchr[@'56]:='.';
> xchr[@'57]:='/';@/
> xchr[@'60]:='0';
> xchr[@'61]:='1';
> xchr[@'62]:='2';
> xchr[@'63]:='3';
> xchr[@'64]:='4';
> xchr[@'65]:='5';
> xchr[@'66]:='6';
> xchr[@'67]:='7';@/
> xchr[@'70]:='8';
> xchr[@'71]:='9';
> xchr[@'72]:=':';
> xchr[@'73]:=';';
> xchr[@'74]:='<';
> xchr[@'75]:='=';
> xchr[@'76]:='>';
> xchr[@'77]:='?';@/
> xchr[@'100]:='@@';
> xchr[@'101]:='A';
> xchr[@'102]:='B';
> xchr[@'103]:='C';
> xchr[@'104]:='D';
> xchr[@'105]:='E';
> xchr[@'106]:='F';
> xchr[@'107]:='G';@/
> xchr[@'110]:='H';
> xchr[@'111]:='I';
> xchr[@'112]:='J';
> xchr[@'113]:='K';
> xchr[@'114]:='L';
> xchr[@'115]:='M';
> xchr[@'116]:='N';
> xchr[@'117]:='O';@/
> xchr[@'120]:='P';
> xchr[@'121]:='Q';
> xchr[@'122]:='R';
> xchr[@'123]:='S';
> xchr[@'124]:='T';
> xchr[@'125]:='U';
> xchr[@'126]:='V';
> xchr[@'127]:='W';@/
> xchr[@'130]:='X';
> xchr[@'131]:='Y';
> xchr[@'132]:='Z';
> xchr[@'133]:='[';
> xchr[@'134]:='\';
> xchr[@'135]:=']';
> xchr[@'136]:='^';
> xchr[@'137]:='_';@/
> xchr[@'140]:='`';
> xchr[@'141]:='a';
> xchr[@'142]:='b';
> xchr[@'143]:='c';
> xchr[@'144]:='d';
> xchr[@'145]:='e';
> xchr[@'146]:='f';
> xchr[@'147]:='g';@/
> xchr[@'150]:='h';
> xchr[@'151]:='i';
> xchr[@'152]:='j';
> xchr[@'153]:='k';
> xchr[@'154]:='l';
> xchr[@'155]:='m';
> xchr[@'156]:='n';
> xchr[@'157]:='o';@/
> xchr[@'160]:='p';
> xchr[@'161]:='q';
> xchr[@'162]:='r';
> xchr[@'163]:='s';
> xchr[@'164]:='t';
> xchr[@'165]:='u';
> xchr[@'166]:='v';
> xchr[@'167]:='w';@/
> xchr[@'170]:='x';
> xchr[@'171]:='y';
> xchr[@'172]:='z';
> xchr[@'173]:='{';
> xchr[@'174]:='|';
> xchr[@'175]:='}';
> xchr[@'176]:='~';@/
563c608
< @ Some of the ascii codes without visible characters have been given symbolic
---
> @ Some of the ASCII codes without visible characters have been given symbolic
566,568c611,613
< @d null_code=@'0 {ascii code that might disappear}
< @d carriage_return=@'15 {ascii code used at end of line}
< @d invalid_code=@'177 {ascii code that should not appear}
---
> @d null_code=@'0 {ASCII code that might disappear}
> @d carriage_return=@'15 {ASCII code used at end of line}
> @d invalid_code=@'177 {ASCII code that many systems prohibit in text files}
570c615
< @ The ascii code is ``standard'' only to a certain extent, since many
---
> @ The ASCII code is ``standard'' only to a certain extent, since many
572c617
< to more than 94 printing characters. Appendix@@C of the \TeX\ manual
---
> to more than 94 printing characters. Appendix~C of {\sl The \TeX book\/}
574a620
> @:TeXbook}{\sl The \TeX book@>
577c623
< on a garden-variety \PASCAL\ for which only standard ascii
---
> on a garden-variety \PASCAL\ for which only standard ASCII
579c625
< what codes are specified in |xchr[1..@'37]|, but the safest policy is to
---
> what codes are specified in |xchr[0..@'37]|, but the safest policy is to
584,588c630
< like `\.\NE' instead of `\.{\\ne}'. At MIT, for example, it would be more
< appropriate to substitute the code
< $$\hbox{|for i←1 to @'37 do xchr[i]←chr(i);|}$$
< \TeX's character set is essentially the same as MIT's, even with respect to
< characters less than@@@'40. People with extended character sets can
---
> like `\.^^Z' instead of `\.{\\ne}'. People with extended character sets can
590,596c632,638
< characters the users of \TeX\ are allowed to have in their input files,
< provided that unsuitable characters do not correspond to the special
< codes like |carriage_return| that are listed above. It is best
< to make the codes correspond to the intended interpretations as shown
< in Appendix@@C whenever possible; but this is not necessary. For example,
< in countries with an alphabet of more than 26 letters, it is usually best
< to map the additional letters into codes less than@@@'40.
---
> characters the users of \TeX\ are allowed to have in their input files.
> It is best to make the codes correspond to the intended interpretations as
> shown in Appendix~C whenever possible; but this is not necessary. For
> example, in countries with an alphabet of more than 26 letters, it is
> usually best to map the additional letters into codes less than~@'40.
> To get the most ``permissive'' character set, change |' '| on the
> right of these assignment statements to |chr(i)|.
601c643,644
< for i←1 to @'37 do xchr[i]←' ';
---
> for i:=0 to @'37 do xchr[i]:=' ';
> for i:=@'177 to @'377 do xchr[i]:=' ';
606c649
< |j| or more; hence, standard ascii code numbers will be used instead of
---
> |j| or more; hence, standard ASCII code numbers will be used instead of
610,611c653,656
< for i←first_text_char to last_text_char do xord[chr(i)]←invalid_code;
< for i←1 to @'176 do xord[xchr[i]]←i;
---
> for i:=first_text_char to last_text_char do xord[chr(i)]:=invalid_code;
> for i:=@'200 to @'377 do xord[xchr[i]]:=i;
> for i:=0 to @'176 do xord[xchr[i]]:=i;
>
616c661
< that input and output are not a part of ``real'' programming. Well, it is true
---
> that input and output are not part of ``real'' programming. Well, it is true
621,622c666,667
< two choices: whether to attack I/O now and get it over with, or to postpone
< it until near the end. Neither prospect is very attractive, so let's
---
> two choices, either to attack I/O now and get it over with, or to postpone
> I/O until near the end. Neither prospect is very attractive, so let's
625,627c670,672
< The basic operations we need to do are (1)@@inputting and outputting of
< text, to or from a file or the user's terminal; (2)@@inputting and
< outputting of eight-bit bytes, to or from a file; (3)@@instructing the
---
> The basic operations we need to do are (1)~inputting and outputting of
> text, to or from a file or the user's terminal; (2)~inputting and
> outputting of eight-bit bytes, to or from a file; (3)~instructing the
629c674
< output from a specified file; (4)@@testing whether the end of an input
---
> output from a specified file; (4)~testing whether the end of an input
632c677
< Note that \TeX\ needs to deal with only two kinds of files.
---
> \TeX\ needs to deal with two kinds of files.
641,644c686,689
< \TeX\ actually makes use also of a third kind of file, called a |word_file|,
< when dumping and reloading format information for its own initialization.
< We shall define a word file later; but it will be possible for us to
< do a few simple things with them in this section before they are defined.
---
> The program actually makes use also of a third kind of file, called a
> |word_file|, when dumping and reloading base information for its own
> initialization. We shall define a word file later; but it will be possible
> for us to specify simple operations on word files before they are defined.
664,667c709,712
< @!name_of_file:packed array[1..file_name_size] of char;
< {on some systems this may be a \&{record} variable}
< @!name_length:0..file_name_size; {this many characters are actually
< relevant in |name_of_file| (the rest are blank)}
---
> @!name_of_file:packed array[1..file_name_size] of char;@;@/
> {on some systems this may be a \&{record} variable}
> @!name_length:0..file_name_size;@/{this many characters are actually
> relevant in |name_of_file| (the rest are blank)}
669,670c714,715
< @ The \ph\ compiler with which the present version of \TeX\ was pre\-pared has
< extended the rules of \PASCAL\ in a very convenient way. To open file@@|f|,
---
> @ The \ph\ compiler with which the present version of \TeX\ was prepared has
> extended the rules of \PASCAL\ in a very convenient way. To open file~|f|,
672,677c717,722
< $$\vbox{\halign{#\hfil\qquadⓧ#\hfil\cr
< |reset(f,@t\\{name}@>,'/O')|ⓧfor input;\cr
< |rewrite(f,@t\\{name}@>,'/O')|ⓧfor output.\cr}}$$
< The `\\{name}' parameter, which is of type `\!|packed
< array[@t\<\\{any}>@>] of text_char|', stands for the name of
< the external file that is being opened for input or output.
---
> $$\vbox{\halign{#\hfil\qquad&#\hfil\cr
> |reset(f,@t\\{name}@>,'/O')|&for input;\cr
> |rewrite(f,@t\\{name}@>,'/O')|&for output.\cr}}$$
> The `\\{name}' parameter, which is of type `{\bf packed array
> $[\langle\\{any}\rangle]$ of \\{char}}', stands for the name of
> the external file that is being opened for input or output.
683,685c728,730
< (e.g., it might already be in use), we will have |eof(f)=true| after an
< unsuccessful |reset|, and |eof(f)=false| after an unsuccessful |rewrite|.
< This allows \TeX\ to undertake appropriate corrective action.
---
> (e.g., someone may already be trying to write the same file), we will have
> |@!erstat(f)<>0| after an unsuccessful |reset| or |rewrite|. This allows
> \TeX\ to undertake appropriate corrective action.
686a732
> @^system dependencies@>
688,690c734,735
< We can now implement the file-opening procedures in the following simple way,
< where the functions return |false| if no file identified by |name_of_file|
< could be opened:
---
> \TeX's file-opening procedures return |false| if no file identified by
> |name_of_file| could be opened.
691a737,738
> @d reset_OK(#)==erstat(#)=0
> @d rewrite_OK(#)==erstat(#)=0
694,695c741,742
< {open a text file for input}
< begin reset(f,name_of_file,'/O'); a_open_in←not eof(f);
---
> {open a text file for input}
> begin reset(f,name_of_file,'/O'); a_open_in:=reset_OK(f);
699,700c746,747
< {open a text file for output}
< begin rewrite(f,name_of_file,'/O'); a_open_out←eof(f);
---
> {open a text file for output}
> begin rewrite(f,name_of_file,'/O'); a_open_out:=rewrite_OK(f);
704,705c751,752
< {open a binary file for input}
< begin reset(f,name_of_file,'/O'); b_open_in←not eof(f);
---
> {open a binary file for input}
> begin reset(f,name_of_file,'/O'); b_open_in:=reset_OK(f);
709,710c756,757
< {open a binary file for output}
< begin rewrite(f,name_of_file,'/O'); b_open_out←eof(f);
---
> {open a binary file for output}
> begin rewrite(f,name_of_file,'/O'); b_open_out:=rewrite_OK(f);
714,715c761,762
< {open a word file for input}
< begin reset(f,name_of_file,'/O'); w_open_in←not eof(f);
---
> {open a word file for input}
> begin reset(f,name_of_file,'/O'); w_open_in:=reset_OK(f);
719,720c766,767
< {open a word file for output}
< begin rewrite(f,name_of_file,'/O'); w_open_out←eof(f);
---
> {open a word file for output}
> begin rewrite(f,name_of_file,'/O'); w_open_out:=rewrite_OK(f);
723a771
> @:PASCAL H}{\ph@>
729a778,780
> These procedures should not generate error messages if a file is
> being closed before it has been successfully opened.
>
744c795
< binary@@I/O. Text output is also easy to do with standard \PASCAL\ routines.
---
> binary~I/O. Text output is also easy to do with standard \PASCAL\ routines.
746,747c797,798
< of the necessary translation to |ascii_code| values, and because
< \TeX's conventions should be efficient and they should
---
> of the necessary translation to |ASCII_code| values.
> \TeX's conventions should be efficient, and they should
753c804
< now, it suffices for us to know that |buffer| is an array of |ascii_code|
---
> now, it suffices for us to know that |buffer| is an array of |ASCII_code|
758c809
< @!buffer:array[0..buf_size] of ascii_code; {lines of characters being read}
---
> @!buffer:array[0..buf_size] of ASCII_code; {lines of characters being read}
764,769c815,822
< field into available positions of the buffer array and returns the value |true|,
< unless the file has already been entirely read, in which case it returns
< |false| (and does nothing else). The |ascii_code| numbers that represent
< the next line of the file are input into |buffer[first]|, |buffer[first+1]|,
< $\ldotss$, |buffer[last-1]|; and the global variable |last| is set equal
< to |first| plus the length of the line.
---
> file into available positions of the buffer array and returns the value
> |true|, unless the file has already been entirely read, in which case it
> returns |false| and sets |last:=first|. In general, the |ASCII_code|
> numbers that represent the next line of the file are input into
> |buffer[first]|, |buffer[first+1]|, \dots, |buffer[last-1]|; and the
> global variable |last| is set equal to |first| plus the length of the
> line. Trailing blanks are removed from the line; thus, either |last=first|
> (in which case the line was entirely blank) or |buffer[last-1]<>" "|.
772c825
< would make |last≥buf_size|; this is done so that other parts of \TeX\
---
> would make |last>=buf_size|; this is done so that other parts of \TeX\
775,776c828,829
< |first<buf_size| will always hold, so there is always room for an ``empty''
< line.
---
> |first<buf_size| will always hold, so that there is always room for an
> ``empty'' line.
782,786c835,844
< This procedure does a |get| before looking at the first character of the
< line, and it does not do a |get| when it reaches the end of the line.
< Therefore it can be used to acquire input from the user's terminal as well
< as from ordinary text files. Other parts of \TeX\ take care of inputting
< the first line of a file, so that the first character is not lost.
---
> If the |bypass_eoln| parameter is |true|, |input_ln| will do a |get|
> before looking at the first character of the line; this skips over
> an |eoln| that was in |f^|. The procedure does not do a |get| when it
> reaches the end of the line; therefore it can be used to acquire input
> from the user's terminal as well as from ordinary text files.
>
> Standard \PASCAL\ says that a file should have |eoln| immediately
> before |eof|, but \TeX\ needs only a weaker restriction: If |eof|
> occurs in the middle of a line, the system function |eoln| should return
> a |true| result (even though |f^| will be undefined).
796,810c854,872
< @p function input_ln(var f:alpha_file):boolean; {inputs the next line
< or returns |false|}
< begin get(f); {input the first character of the line into |f^|}
< if eof(f) then input_ln←false
< else begin last←first; {cf.\ Matthew 19:30}
< while not eoln(f) do
< begin if last≥max_buf_stack then
< begin max_buf_stack←last+1;
< if max_buf_stack=buf_size then
< overflow("buffer size",buf_size);
< end;
< buffer[last]←xord[f^]; get(f); incr(last);
< end;
< input_ln←true;
< end;
---
> @p function input_ln(var f:alpha_file;@!bypass_eoln:boolean):boolean;
> {inputs the next line or returns |false|}
> var last_nonblank:0..buf_size; {|last| with trailing blanks removed}
> begin if bypass_eoln then if not eof(f) then get(f);
> {input the first character of the line into |f^|}
> last:=first; {cf.\ Matthew 19\thinspace:\thinspace30}
> if eof(f) then input_ln:=false
> else begin last_nonblank:=first;
> while not eoln(f) do
> begin if last>=max_buf_stack then
> begin max_buf_stack:=last+1;
> if max_buf_stack=buf_size then
> @<Report overflow of the input buffer, and abort@>;
> end;
> buffer[last]:=xord[f^]; get(f); incr(last);
> if buffer[last-1]<>" " then last_nonblank:=last;
> end;
> last:=last_nonblank; input_ln:=true;
> end;
823c885,887
< @ Here is how to open the terminal files in \ph:
---
> @ Here is how to open the terminal files
> in \ph. The `\.{/I}' switch suppresses the first |get|.
> @:PASCAL H}{\ph@>
826c890
< @d t_open_in==reset(term_in,'TTY:','/O') {open the terminal for text input}
---
> @d t_open_in==reset(term_in,'TTY:','/O/I') {open the terminal for text input}
830c894,895
< happens on the user's terminal, and two procedures are used for this
---
> happens on the user's terminal, and three system-dependent
> procedures are used for this
834c899
< The other, |clear_terminal|, is called when we wish to cancel any
---
> The second, |clear_terminal|, is called when we wish to cancel any
836,837c901,905
< issue an unexpected error message). The following macros show how these
< two operations can be specified in \ph:
---
> issue an unexpected error message). The third, |wake_up_terminal|,
> is supposed to revive the terminal if the user has disabled it by
> some instruction to the operating system. The following macros show how
> these operations can be specified in \ph:
> @:PASCAL H}{\ph@>
841a910
> @d wake_up_terminal == do_nothing {cancel the user's cancellation of output}
844,845c913,914
< the user's terminal. This line is special because it is read before we
< have opened the error transcript file; there is sort of a ``chicken and
---
> the user's terminal. This line is different because it is read before we
> have opened the transcript file; there is sort of a ``chicken and
848c917
< the transcript file will be named `\.{paper.err}'; but if no \.{\\input}
---
> the transcript file will be named `\.{paper.log}'; but if no \.{\\input}
850c919
< file will acquire its default name `\.{texput.err}'. (The transcript file
---
> file will acquire its default name `\.{texput.log}'. (The transcript file
852a922
> @.texput@>
862,863c932,951
< @ Different systems have different ways to get started, but regardless of
< what conventions are adopted the routine that initializes the terminal
---
> The first line is special also because it may be read before \TeX\ has
> input a format file. In such cases, normal error messages cannot yet
> be given. The following code uses concepts that will be explained later.
> (If the \PASCAL\ compiler does not support non-local |@!goto|\unskip, the
> @^system dependencies@>
> statement `|goto final_end|' should be replaced by something that
> quietly terminates the program.)
>
> @<Report overflow of the input buffer, and abort@>=
> if format_ident=0 then
> begin write_ln(term_out,'Buffer size exceeded!'); goto final_end;
> @.Buffer size exceeded@>
> end
> else begin cur_input.loc_field:=first; cur_input.limit_field:=last-1;
> overflow("buffer size",buf_size);
> @:TeX capacity exceeded buffer size}{\quad buffer size@>
> end
>
> @ Different systems have different ways to get started. But regardless of
> what conventions are adopted, the routine that initializes the terminal
867,868c955,956
< terminal. (The file |term_out| will already be open for output to the
< terminal.)
---
> terminal. (The file |term_out| will already be open for output to the
> terminal.)
871,873c959,961
< considered the first line of terminal input. Otherwise the
< user should be prompted with `\.{**}', and the first line of input
< should be whatever is typed in response.
---
> considered the first line of terminal input. Otherwise the
> user should be prompted with `\.{**}', and the first line of input
> should be whatever is typed in response.
876,877c964,965
< command line, should appear in locations 0 to |last-1| of the
< |buffer| array.
---
> command line, should appear in locations |first| to |last-1| of the
> |buffer| array.
880,881c968,969
< character that \TeX\ reads next is in |buffer[loc]|. This
< character should not be blank, and we should have |loc<last|.
---
> character to be read next by \TeX\ is in |buffer[loc]|. This
> character should not be blank, and we should have |loc<last|.
884,886c972,974
< before a non-blank line comes in. The prompt is `\.\#' instead of the
< later `\.*' because the meaning is slightly different: `\\input' need
< not be typed immediately after `\.\#'.)
---
> before a non-blank line comes in. The prompt is `\.{**}' instead of the
> later `\.*' because the meaning is slightly different: `\.{\\input}' need
> not be typed immediately after~`\.{**}'.)
891c979
< with\-out retrieving a possible command line.
---
> without retrieving a possible command line.
899,913c987,1002
< loop@+begin write(term_out,'**'); update_terminal;
< if not input_ln(term_in) then {this shouldn't happen}
< begin write_ln(term_out);
< write(term_out,'! End of file on the terminal... why?');
< @.End of file on the terminal...@>
< init_terminal←false; return;
< end;
< loc←first;
< while (loc<last)∧(buffer[loc]=" ") do incr(loc);
< if loc<last then
< begin init_terminal←true;
< return; {return unless the line was all blank}
< end;
< write_ln(term_out,'Please type the name of your input file.');
< end;
---
> loop@+begin wake_up_terminal; write(term_out,'**'); update_terminal;
> @.**@>
> if not input_ln(term_in,true) then {this shouldn't happen}
> begin write_ln(term_out);
> write(term_out,'! End of file on the terminal... why?');
> @.End of file on the terminal@>
> init_terminal:=false; return;
> end;
> loc:=first;
> while (loc<last)and(buffer[loc]=" ") do incr(loc);
> if loc<last then
> begin init_terminal:=true;
> return; {return unless the line was all blank}
> end;
> write_ln(term_out,'Please type the name of your input file.');
> end;
914a1004
>
917c1007
< of seven-bit characters. Since \PASCAL\ does not have a well-developed string
---
> of eight-bit characters. Since \PASCAL\ does not have a well-developed string
922c1012
< The array |str_pool| contains all of the (seven-bit) ascii codes in all
---
> The array |str_pool| contains all of the (eight-bit) ASCII codes in all
925,926c1015,1016
< string number |s| comprises the characters |str_pool[j]| for
< |str_start[s]≤j<str_start[s+1]|. Additional integer variables
---
> string number |s| comprises the characters |str_pool[j]| for
> |str_start[s]<=j<str_start[s+1]|. Additional integer variables
932,933c1022,1023
< String numbers 0 to 127 are reserved for strings that correspond to single
< ascii characters. This is in accordance with the conventions of \.{WEB},
---
> String numbers 0 to 255 are reserved for strings that correspond to single
> ASCII characters. This is in accordance with the conventions of \.{WEB},
935c1025
< which converts single-character strings into the ascii code number of the
---
> which converts single-character strings into the ASCII code number of the
939,941c1029,1031
< ascii code for a period, while \.{WEB} will convert a string like \.{"hello"}
< into some integer greater than@@127. String number 46 will presumably be the
< single character `\..'; but some ascii codes have no standard visible
---
> ASCII code for a period, while \.{WEB} will convert a string like \.{"hello"}
> into some integer greater than~255. String number 46 will presumably be the
> single character `\..'; but some ASCII codes have no standard visible
943,944c1033,1044
< ascii character, so the first 128 strings are used to specify exactly what
< should be printed for each of the 128 possibilities.
---
> ASCII character, so the first 256 strings are used to specify exactly what
> should be printed for each of the 256 possibilities.
>
> Elements of the |str_pool| array must be ASCII codes that can actually
> be printed; i.e., they must have an |xchr| equivalent in the local
> character set. (This restriction applies only to preloaded strings,
> not to those generated dynamically by the user.)
>
> Some \PASCAL\ compilers won't pack integers into a single byte unless the
> integers lie in the range |-128..127|. To accommodate such systems
> we access the string pool only via macros that can easily be redefined.
> @^system dependencies@>
946,948c1046,1047
< Elements of the |str_pool| array must be ascii codes that can actually be
< printed; i.e., they must have an |xchr| equivalent in the local
< character set.
---
> @d si(#) == # {convert from |ASCII_code| to |packed_ASCII_code|}
> @d so(#) == # {convert from |packed_ASCII_code| to |ASCII_code|}
952a1052
> @!packed_ASCII_code = 0..255; {elements of |str_pool| array}
954,955c1054,1055
< @ @<Globals...@>=
< @!str_pool:packed array[pool_pointer] of ascii_code; {the characters}
---
> @ @<Glob...@>=
> @!str_pool:packed array[pool_pointer] of packed_ASCII_code; {the characters}
958c1058,1060
< @!str_ptr : str_number; {start of the current string being created}
---
> @!str_ptr : str_number; {number of the current string being created}
> @!init_pool_ptr : pool_pointer; {the starting value of |pool_ptr|}
> @!init_str_ptr : str_number; {the starting value of |str_ptr|}
961c1063
< macros instead of using \PASCAL\ procedures, because many of the
---
> macros instead of \PASCAL\ procedures, because many of the
968c1070
< in string number \#}
---
> in string number \#}
975c1077
< The macro called |append_char|, defined here, does not check to see if the
---
> The |append_char| macro, defined here, does not check to see if the
984,985c1086,1087
< @d append_char(#) == {put |ascii_code| \#\ at the end of |str_pool|}
< begin str_pool[pool_ptr]←#; incr(pool_ptr);
---
> @d append_char(#) == {put |ASCII_code| \# at the end of |str_pool|}
> begin str_pool[pool_ptr]:=si(#); incr(pool_ptr);
988,990c1090,1094
< @d str_room(#) == begin if pool_ptr+# > pool_size then
< overflow("pool size",pool_size);
< end
---
> @d str_room(#) == {make sure that the pool hasn't overflowed}
> begin if pool_ptr+# > pool_size then
> overflow("pool size",pool_size-init_pool_ptr);
> @:TeX capacity exceeded pool size}{\quad pool size@>
> end
999,1001c1103,1106
< overflow("number of strings",max_strings);
< incr(str_ptr); str_start[str_ptr]←pool_ptr;
< make_string←str_ptr-1;
---
> overflow("number of strings",max_strings-init_str_ptr);
> @:TeX capacity exceeded number of strings}{\quad number of strings@>
> incr(str_ptr); str_start[str_ptr]:=pool_ptr;
> make_string:=str_ptr-1;
1006,1007c1111,1112
< @d flush_string==begin decr(str_ptr); pool_ptr←str_start[str_ptr];
< end
---
> @d flush_string==begin decr(str_ptr); pool_ptr:=str_start[str_ptr];
> end
1011a1117,1118
> Empirical tests indicate that |str_eq_buf| is used in such a way that
> it tends to return |true| about 80 percent of the time.
1014c1121
< {test equality of strings}
---
> {test equality of strings}
1018c1125
< begin j←str_start[s]; result←false;
---
> begin j:=str_start[s];
1020,1024c1127,1133
< begin if str_pool[j]≠buffer[k] then goto not_found;
< incr(j); incr(k);
< end;
< result←true;
< not_found: str_eq_buf←result;
---
> begin if so(str_pool[j])<>buffer[k] then
> begin result:=false; goto not_found;
> end;
> incr(j); incr(k);
> end;
> result:=true;
> not_found: str_eq_buf:=result;
1031c1140
< {test equality of strings}
---
> {test equality of strings}
1035,1037c1144,1146
< begin result←false;
< if length(s)≠length(t) then goto not_found;
< j←str_start[s]; k←str_start[t];
---
> begin result:=false;
> if length(s)<>length(t) then goto not_found;
> j:=str_start[s]; k:=str_start[t];
1039,1043c1148,1152
< begin if str_pool[j]≠str_pool[k] then goto not_found;
< incr(j); incr(k);
< end;
< result←true;
< not_found: str_eq_str←result;
---
> begin if str_pool[j]<>str_pool[k] then goto not_found;
> incr(j); incr(k);
> end;
> result:=true;
> not_found: str_eq_str:=result;
1052,1053c1161,1162
< @p init function init_strings:boolean; {initializes the string pool, but
< returns |false| if something goes wrong}
---
> @p @!init function get_strings_started:boolean; {initializes the string pool,
> but returns |false| if something goes wrong}
1055c1164
< var k,@!l:0..127; {small indices or counters}
---
> var k,@!l:0..255; {small indices or counters}
1059,1061c1168,1170
< @!c:boolean; {check sum has checked}
< begin pool_ptr←0; str_ptr←0;
< @<Make the first 128 strings@>;
---
> @!c:boolean; {check sum has been checked}
> begin pool_ptr:=0; str_ptr:=0; str_start[0]:=0;
> @<Make the first 256 strings@>;
1063c1172
< or give an error message and return |false|@>;
---
> or give an error message and return |false|@>;
1067,1079c1176,1190
< @ @<Make the first 128...@>=
< for k←0 to 127 do
< begin if (k<" ")∧(@<Character |k| cannot be printed@>) then
< begin append_char("^"); append_char("^");
< append_char(k+@'100);
< end
< else if k=127 then
< begin append_char("^"); append_char("^");
< append_char("?");
< end
< else append_char(k);
< g←make_string;
< end
---
> @ @d app_lc_hex(#)==l:=#;
> if l<10 then append_char(l+"0")@+else append_char(l-10+"a")
>
> @<Make the first 256...@>=
> for k:=0 to 255 do
> begin if (@<Character |k| cannot be printed@>) then
> begin append_char("^"); append_char("^");
> if k<@'100 then append_char(k+@'100)
> else if k<@'200 then append_char(k-@'100)
> else begin app_lc_hex(k div 16); app_lc_hex(k mod 16);
> end;
> end
> else append_char(k);
> g:=make_string;
> end
1081c1192
< @ The first 128 strings will contain 95 standard ascii characters, and the
---
> @ The first 128 strings will contain 95 standard ASCII characters, and the
1084c1195
< an extended character set, where for example |xchr[@'32]=@t\.{\'\NE\'}@>|,
---
> an extended character set, where for example |xchr[@'32]=@t\.{\'^^Z\'}@>|,
1092,1096c1203,1215
< The boolean expression defined here should be |true| unless \TeX\ internal code
< number@@$k$ corresponds to a non-troublesome visible symbol in the local
< char\-ac\-ter set, given that |k<@'40|.
< At MIT, for example, the appropriate formula would be
< `|k in [0,@'10..@'12,@'14,@'15,@'33]|'.
---
> Unprintable characters of codes 128--255 are, similarly, rendered
> \.{\^\^80}--\.{\^\^ff}.
>
> The boolean expression defined here should be |true| unless \TeX\
> internal code number~|k| corresponds to a non-troublesome visible
> symbol in the local character set. An appropriate formula for the
> extended character set recommended in {\sl The \TeX book\/} would, for
> example, be `|k in [0,@'10..@'12,@'14,@'15,@'33,@'177..@'377]|'.
> If character |k| cannot be printed, and |k<@'200|, then character |k+@'100| or
> |k-@'100| must be printable; moreover, ASCII codes |[@'41..@'46,
> @'60..@'71, @'136, @'141..@'146, @'160..@'171]| must be printable.
> Thus, at least 81 printable characters are needed.
> @:TeXbook}{\sl The \TeX book@>
1101c1220
< true
---
> (k<" ")or(k>"~")
1104c1223
< de\-scription that you are now reading, it outputs the \PASCAL\ program
---
> description that you are now reading, it outputs the \PASCAL\ program
1112c1231,1232
< @!pool_file:alpha_file; {the string-pool file output by \.{TANGLE}}
---
> @!init @!pool_file:alpha_file; {the string-pool file output by \.{TANGLE}}
> tini
1114,1115c1234,1236
< @ @d bad_pool(#)==begin write_ln(term_out,#); init_strings←false; return;
< end
---
> @ @d bad_pool(#)==begin wake_up_terminal; write_ln(term_out,#);
> a_close(pool_file); get_strings_started:=false; return;
> end
1117c1238
< name_of_file←pool_name; {we needn't set |name_length|}
---
> name_of_file:=pool_name; {we needn't set |name_length|}
1119,1125c1240,1246
< begin c←false;
< repeat @<Read one string, but return |false| if the
< string memory space is getting too tight for comfort@>;
< until c;
< init_strings←true;
< end
< else bad_pool('! I can''t read TEX.POOL.')
---
> begin c:=false;
> repeat @<Read one string, but return |false| if the
> string memory space is getting too tight for comfort@>;
> until c;
> a_close(pool_file); get_strings_started:=true;
> end
> else bad_pool('! I can''t read TEX.POOL.')
1133,1135c1254,1256
< else begin if (xord[m]<"0")∨(xord[m]>"9")∨@|
< (xord[n]<"0")∨(xord[n]>"9") then
< bad_pool('! TEX.POOL line doesn''t begin with two digits.');
---
> else begin if (xord[m]<"0")or(xord[m]>"9")or@|
> (xord[n]<"0")or(xord[n]>"9") then
> bad_pool('! TEX.POOL line doesn''t begin with two digits.');
1137,1139c1258,1260
< l←xord[m]*10+xord[n]-"0"*11; {compute the length}
< if pool_ptr+l+string_vacancies>pool_size then
< bad_pool('! You have to increase POOLSIZE.');
---
> l:=xord[m]*10+xord[n]-"0"*11; {compute the length}
> if pool_ptr+l+string_vacancies>pool_size then
> bad_pool('! You have to increase POOLSIZE.');
1141,1147c1262,1267
< for k←1 to l do
< begin if eoln(pool_file) then bad_pool('! TEX.POOL line too short.');
< @.TEX.POOL line too short@>
< read(pool_file,m); append_char(xord[m]);
< end;
< read_ln(pool_file); g←make_string;
< end;
---
> for k:=1 to l do
> begin if eoln(pool_file) then m:=' '@+else read(pool_file,m);
> append_char(xord[m]);
> end;
> read_ln(pool_file); g:=make_string;
> end;
1150c1270
< @ The \.{WEB} operation \.{\at\$} denotes the value that should be at the
---
> @ The \.{WEB} operation \.{@@\$} denotes the value that should be at the
1156,1158c1276,1278
< begin a←0; k←1;
< loop@+ begin if (xord[n]<"0")∨(xord[n]>"9") then
< bad_pool('! TEX.POOL check sum doesn''t have nine digits.');
---
> begin a:=0; k:=1;
> loop@+ begin if (xord[n]<"0")or(xord[n]>"9") then
> bad_pool('! TEX.POOL check sum doesn''t have nine digits.');
1160,1164c1280,1284
< a←10*a+xord[n]-"0";
< if k=9 then goto done;
< incr(k); read(pool_file,n);
< end;
< done: if a≠@$ then bad_pool('! TEX.POOL doesn''t match; TANGLE me again.');
---
> a:=10*a+xord[n]-"0";
> if k=9 then goto done;
> incr(k); read(pool_file,n);
> end;
> done: if a<>@$ then bad_pool('! TEX.POOL doesn''t match; TANGLE me again.');
1166c1286
< c←true;
---
> c:=true;
1167a1288
>
1169c1290
< Messages that are sent to a user's terminal and to the error-transcript file
---
> Messages that are sent to a user's terminal and to the transcript-log file
1176,1177c1297,1298
< \hang |term_and_err|, the normal setting, prints on the terminal and on the
< error-transcript file.
---
> \hang |term_and_log|, the normal setting, prints on the terminal and on the
> transcript file.
1179c1300
< \hang |err_only|, prints only on the error-transcript file.
---
> \hang |log_only|, prints only on the transcript file.
1184c1305
< before the error-transcript file is open.
---
> before the transcript file is open.
1186,1188c1307,1309
< \hang |pseudo|, puts output into a cyclic buffer that is used
< by the |show_context| routine; see that routine for the
< reasoning behind this curious mode.
---
> \hang |pseudo|, puts output into a cyclic buffer that is used
> by the |show_context| routine; when we get to that routine we shall discuss
> the reasoning behind this curious mode.
1191c1312
< string pool.
---
> string pool.
1193c1314
< \hang 0 to 15, prints on one of the sixteen files for \.{\\send} output.
---
> \hang 0 to 15, prints on one of the sixteen files for \.{\\write} output.
1196c1317
< \noindent The symbolic names `|term_and_err|', etc., have been assigned
---
> \noindent The symbolic names `|term_and_log|', etc., have been assigned
1198c1319
< |no_print+2=err_only|, |term_only+2=err_only+1=term_and_err|.
---
> |no_print+2=log_only|, |term_only+2=log_only+1=term_and_log|.
1200,1205c1321,1327
< Two additional global variables, |tally| and |offset|, record
< the number of characters that have been printed since they were most
< recently cleared to zero. We use |tally| to record the length of
< (possibly very long) stretches of printing; |offset|, on the other
< hand, keeps track of how many characters have appeared so far on the current
< line of text output.
---
> Three additional global variables, |tally| and |term_offset| and
> |file_offset|, record the number of characters that have been printed
> since they were most recently cleared to zero. We use |tally| to record
> the length of (possibly very long) stretches of printing; |term_offset|
> and |file_offset|, on the other hand, keep track of how many characters
> have appeared so far on the current line that has been output to the
> terminal or to the transcript file, respectively.
1209,1210c1331,1332
< @d err_only=18 {printing is destined for the transcript file only}
< @d term_and_err=19 {normal |selector| setting}
---
> @d log_only=18 {printing is destined for the transcript file only}
> @d term_and_log=19 {normal |selector| setting}
1215,1216c1337,1338
< @<Globals...@>=
< @!err_file : alpha_file; {transcript of \TeX\ session}
---
> @<Glob...@>=
> @!log_file : alpha_file; {transcript of \TeX\ session}
1218c1340
< @!dig : array[0..22] of 0..9; {digits in a number being output}
---
> @!dig : array[0..22] of 0..15; {digits in a number being output}
1220,1222c1342,1347
< @!offset : 0..max_print_line; {the number of characters on the current line}
< @!trick_buf:array[0..error_line] of ascii_code; {circular buffer for
< pseudoprinting}
---
> @!term_offset : 0..max_print_line;
> {the number of characters on the current terminal line}
> @!file_offset : 0..max_print_line;
> {the number of characters on the current file line}
> @!trick_buf:array[0..error_line] of ASCII_code; {circular buffer for
> pseudoprinting}
1227c1352,1365
< selector←term_only; tally←0; offset←0;
---
> selector:=term_only; tally:=0; term_offset:=0; file_offset:=0;
>
> @ Macro abbreviations for output to the terminal and to the log file are
> defined here for convenience. Some systems need special conventions
> for terminal output, and it is possible to adhere to those conventions
> by changing |wterm|, |wterm_ln|, and |wterm_cr| in this section.
> @^system dependencies@>
>
> @d wterm(#)==write(term_out,#)
> @d wterm_ln(#)==write_ln(term_out,#)
> @d wterm_cr==write_ln(term_out)
> @d wlog(#)==write(log_file,#)
> @d wlog_ln(#)==write_ln(log_file,#)
> @d wlog_cr==write_ln(log_file)
1233d1370
< label exit;
1235,1241c1372,1380
< term_and_err: begin write_ln(term_out); write_ln(err_file);
< end;
< err_only: write_ln(err_file);
< term_only: write_ln(term_out);
< no_print: do_nothing;
< pseudo,new_string: return;
< othercases write_ln(send_file[selector])
---
> term_and_log: begin wterm_cr; wlog_cr;
> term_offset:=0; file_offset:=0;
> end;
> log_only: begin wlog_cr; file_offset:=0;
> end;
> term_only: begin wterm_cr; term_offset:=0;
> end;
> no_print,pseudo,new_string: do_nothing;
> othercases write_ln(write_file[selector])
1243,1244c1382
< offset←0; {|tally| is not affected}
< exit:end;
---
> end; {|tally| is not affected}
1250,1251d1387
< @d preserve_offset=90 {go here when |offset| is not to be changed}
<
1253,1258c1389,1410
< procedure print_char(@!c:ascii_code); {prints a single character}
< label preserve_offset;
< begin case selector of
< term_and_err: begin write(term_out,xchr[c]); write(err_file,xchr[c]); end;
< err_only: write(err_file,xchr[c]);
< term_only: write(term_out,xchr[c]);
---
> procedure print_char(@!s:ASCII_code); {prints a single character}
> label exit;
> begin if @<Character |s| is the current new-line character@> then
> if selector<pseudo then
> begin print_ln; return;
> end;
> case selector of
> term_and_log: begin wterm(xchr[s]); wlog(xchr[s]);
> incr(term_offset); incr(file_offset);
> if term_offset=max_print_line then
> begin wterm_cr; term_offset:=0;
> end;
> if file_offset=max_print_line then
> begin wlog_cr; file_offset:=0;
> end;
> end;
> log_only: begin wlog(xchr[s]); incr(file_offset);
> if file_offset=max_print_line then print_ln;
> end;
> term_only: begin wterm(xchr[s]); incr(term_offset);
> if term_offset=max_print_line then print_ln;
> end;
1260,1268c1412,1415
< pseudo: begin if tally<trick_count then
< trick_buf[tally mod error_line]←c;
< goto preserve_offset;
< end;
< new_string: begin if pool_ptr<pool_size then append_char(c);
< goto preserve_offset; {drop characters if the string space is full}
< end;
< othercases begin write(send_file[selector],xchr[c]); goto preserve_offset;
< end
---
> pseudo: if tally<trick_count then trick_buf[tally mod error_line]:=s;
> new_string: begin if pool_ptr<pool_size then append_char(s);
> end; {we drop characters if the string space is full}
> othercases write(write_file[selector],xchr[s])
1270,1273c1417,1418
< incr(offset);
< if offset=max_print_line then print_ln;
< preserve_offset:incr(tally);
< end;
---
> incr(tally);
> exit:end;
1276c1421
< the single standard ascii character \.c, we could call |print("c")|, since
---
> the single standard ASCII character \.c, we could call |print("c")|, since
1279c1424,1426
< routine when it knows that this is safe.
---
> routine when it knows that this is safe. (The present implementation
> assumes that it is always safe to print a visible ASCII character.)
> @^system dependencies@>
1282a1430
> label exit;
1284,1285c1432,1452
< begin if (s<0)∨(s≥str_ptr) then s←0; {this can't happen}
< j←str_start[s];
---
> @!nl:integer; {new-line character to restore}
> begin if s>=str_ptr then s:="???" {this can't happen}
> @.???@>
> else if s<256 then
> if s<0 then s:="???" {can't happen}
> else begin if selector>pseudo then
> begin print_char(s); return; {internal strings are not expanded}
> end;
> if (@<Character |s| is the current new-line character@>) then
> if selector<pseudo then
> begin print_ln; return;
> end;
> nl:=new_line_char; new_line_char:=-1;
> {temporarily disable new-line character}
> j:=str_start[s];
> while j<str_start[s+1] do
> begin print_char(so(str_pool[j])); incr(j);
> end;
> new_line_char:=nl; return;
> end;
> j:=str_start[s];
1287,1288c1454,1470
< begin print_char(str_pool[j]); incr(j);
< end;
---
> begin print_char(so(str_pool[j])); incr(j);
> end;
> exit:end;
>
> @ Control sequence names, file names, and strings constructed with
> \.{\\string} might contain |ASCII_code| values that can't
> be printed using |print_char|. Therefore we use |slow_print| for them:
>
> @<Basic print...@>=
> procedure slow_print(@!s:integer); {prints string |s|}
> var j:pool_pointer; {current character code position}
> begin if (s>=str_ptr) or (s<256) then print(s)
> else begin j:=str_start[s];
> while j<str_start[s+1] do
> begin print(so(str_pool[j])); incr(j);
> end;
> end;
1292c1474
< the version number and format package. The |offset| variable is temporarily
---
> the version number and format package. The |term_offset| variable is temporarily
1298,1301c1480,1484
< write(term_out,banner);
< if format_ident=0 then write_ln(term_out,' (no format preloaded)')
< else begin print(format_ident); print_ln;
< end;
---
> wterm(banner);
> if format_ident=0 then wterm_ln(' (no format preloaded)')
> else begin slow_print(format_ident); print_ln;
> end;
> update_terminal;
1308c1491,1492
< begin if offset>0 then print_ln;
---
> begin if ((term_offset>0)and(odd(selector)))or@|
> ((file_offset>0)and(selector>=log_only)) then print_ln;
1313c1497
< a backslash.
---
> the user's escape character (which is usually a backslash).
1317c1501,1504
< begin print_char("\"); print(s);
---
> var c:integer; {the escape character code}
> begin @<Set variable |c| to the current escape character@>;
> if c>=0 then if c<256 then print(c);
> slow_print(s);
1320c1507
< @ An array of digits is printed by |print_digs|.
---
> @ An array of digits in the range |0..15| is printed by |print_the_digs|.
1323c1510,1511
< procedure print_digs(@!k:eight_bits); {prints |dig[k-1]|$\ldotsm$|dig[0]|}
---
> procedure print_the_digs(@!k:eight_bits);
> {prints |dig[k-1]|$\,\ldots\,$|dig[0]|}
1325,1326c1513,1516
< begin decr(k); print_char("0"+dig[k]);
< end;
---
> begin decr(k);
> if dig[k]<10 then print_char("0"+dig[k])
> else print_char("A"-10+dig[k]);
> end;
1337,1339c1527,1529
< var k:0..20; {index to current digit; we assume that $|n|<10^{20}$}
< @!m:nonnegative_integer; {used to negate |n| in possibly dangerous cases}
< begin k←0;
---
> var k:0..23; {index to current digit; we assume that $|n|<10^{23}$}
> @!m:integer; {used to negate |n| in possibly dangerous cases}
> begin k:=0;
1341,1349c1531,1539
< begin print_char("-");
< if n>-100000000 then n←-n
< else begin m←-1-n; n←m div 10; m←(m mod 10)+1; k←1;
< if m<10 then dig[0]←m
< else begin dig[0]←0; n←n+1;
< end;
< end;
< end;
< repeat dig[k]←n mod 10; n←n div 10; incr(k);
---
> begin print_char("-");
> if n>-100000000 then negate(n)
> else begin m:=-1-n; n:=m div 10; m:=(m mod 10)+1; k:=1;
> if m<10 then dig[0]:=m
> else begin dig[0]:=0; incr(n);
> end;
> end;
> end;
> repeat dig[k]:=n mod 10; n:=n div 10; incr(k);
1351c1541
< print_digs(k);
---
> print_the_digs(k);
1354c1544,1545
< @ Octal printing of nonnegative integers is accomplished by |print_octal|.
---
> @ Here is a trivial procedure to print two digits; it is usually called with
> a parameter in the range |0<=n<=99|.
1356,1361c1547,1549
< @p procedure print_octal(@!n:integer); {prints a positive integer in octal form}
< var k:0..22; {index to current digit; we assume that $0\L n<8^{22}$}
< begin k←0; print_char("'");
< repeat dig[k]←n mod 8; n←n div 8; incr(k);
< until n=0;
< print_digs(k);
---
> @p procedure print_two(@!n:integer); {prints two least significant digits}
> begin n:=abs(n) mod 100; print_char("0"+(n div 10));
> print_char("0"+(n mod 10));
1364,1365c1552
< @ In certain situations, \TeX\ prints either a standard visible ascii
< character or its octal ascii code.
---
> @ Hexadecimal printing of nonnegative integers is accomplished by |print_hex|.
1367,1371c1554,1560
< @p procedure print_ascii(@!c:integer); {prints a character or its code}
< begin if (c>" ") and (c≤"~") then print_char(c)
< else begin if c<0 then print_char("-");
< print_octal(abs(c)); print_char(" ");
< end;
---
> @p procedure print_hex(@!n:integer);
> {prints a positive integer in hexadecimal form}
> var k:0..22; {index to current digit; we assume that $0\L n<16^{22}$}
> begin k:=0; print_char("""");
> repeat dig[k]:=n mod 16; n:=n div 16; incr(k);
> until n=0;
> print_the_digs(k);
1374,1377c1563,1572
< @ Roman numerals are produced by the |print_roman_int| routine, whose
< argument should be a positive integer. Readers who like puzzles might enjoy
< trying to figure out how this tricky code works; therefore no explanation
< will be given.
---
> @ Old versions of \TeX\ needed a procedure called |print_ASCII| whose function
> is now subsumed by |print|. We retain the old name here as a possible aid to
> future software arch\ae ologists.
>
> @d print_ASCII == print
>
> @ Roman numerals are produced by the |print_roman_int| routine. Readers
> who like puzzles might enjoy trying to figure out how this tricky code
> works; therefore no explanation will be given. Notice that 1990 yields
> \.{mcmxc}, not \.{mxm}.
1379c1574
< @p procedure print_roman_int(@!n:nonnegative_integer);
---
> @p procedure print_roman_int(@!n:integer);
1383,1397c1578,1592
< begin j←str_start["m2d5c2l5x2v5i"]; v←1000;
< loop@+ begin while n≥v do
< begin print_char(str_pool[j]); n←n-v;
< end;
< if n=0 then return;
< k←j+2; u←v div (str_pool[k-1]-"0");
< if str_pool[k-1]="2" then
< begin k←k+2; u←u div (str_pool[k-1]-"0");
< end;
< if n+u≥v then
< begin print_char(str_pool[k]); n←n+u;
< end
< else begin j←j+2; v←v div (str_pool[j-1]-"0");
< end;
< end;
---
> begin j:=str_start["m2d5c2l5x2v5i"]; v:=1000;
> loop@+ begin while n>=v do
> begin print_char(so(str_pool[j])); n:=n-v;
> end;
> if n<=0 then return; {nonpositive input produces no output}
> k:=j+2; u:=v div (so(str_pool[k-1])-"0");
> if str_pool[k-1]=si("2") then
> begin k:=k+2; u:=u div (so(str_pool[k-1])-"0");
> end;
> if n+u>=v then
> begin print_char(so(str_pool[k])); n:=n+u;
> end
> else begin j:=j+2; v:=v div (so(str_pool[j-1])-"0");
> end;
> end;
1405c1600
< begin j←str_start[str_ptr];
---
> begin j:=str_start[str_ptr];
1407,1408c1602,1603
< begin print_char(str_pool[j]); incr(j);
< end;
---
> begin print_char(so(str_pool[j])); incr(j);
> end;
1412c1607
< assuming that the |selector| setting is either |term_only| or |term_and_err|.
---
> assuming that the |selector| setting is either |term_only| or |term_and_log|.
1418,1419c1613,1614
< @d prompt_input(#)==begin print(#); term_input;
< end {prints a string and gets a line of input}
---
> @d prompt_input(#)==begin wake_up_terminal; print(#); term_input;
> end {prints a string and gets a line of input}
1423,1425c1618,1621
< begin update_terminal; {Now the user sees the prompt for sure}
< if not input_ln(term_in) then fatal_error("! End of file on the terminal");
< @.End of file on the terminal...@>
---
> begin update_terminal; {now the user sees the prompt for sure}
> if not input_ln(term_in,true) then fatal_error("End of file on the terminal!");
> @.End of file on the terminal@>
> term_offset:=0; {the user's line ended with \<\rm return>}
1427,1428c1623,1624
< if last≠first then for k←first to last-1 do print(buffer[k]);
< print_ln; incr(selector); {restore previous status, with |offset=0|}
---
> if last<>first then for k:=first to last-1 do print(buffer[k]);
> print_ln; incr(selector); {restore previous status}
1429a1626
>
1433c1630
< |print_nl("! Something anomalous has been detected");|\cr
---
> |print_err("Something anomalous has been detected");|\cr
1440c1637
< official error message that was printed. (Outside of the U.S.A., the help
---
> official error message that was printed. (Outside the U.S.A., the help
1444a1642,1643
> The |print_err| procedure supplies a `\.!' before the official message,
> and makes sure that the terminal is awake if a stop is going to occur.
1457a1657,1659
> @d print_err(#)==begin if interaction=error_stop_mode then wake_up_terminal;
> print_nl("! "); print(#);
> end
1462c1664
< @ @<Set init...@>=interaction←error_stop_mode;
---
> @ @<Set init...@>=interaction:=error_stop_mode;
1469c1671
< and |err_file| not yet open);
---
> and |log_file| not yet open);
1471c1673
< \hang|term_only| (when |interaction>batch_mode| and |err_file| not yet open);
---
> \hang|term_only| (when |interaction>batch_mode| and |log_file| not yet open);
1473c1675
< \hang|err_only| (when |interaction=batch_mode| and |err_file| is open);
---
> \hang|log_only| (when |interaction=batch_mode| and |log_file| is open);
1475c1677
< \hang|term_and_err| (when |interaction>batch_mode| and |err_file| is open).
---
> \hang|term_and_log| (when |interaction>batch_mode| and |log_file| is open).
1478c1680
< if interaction=batch_mode then selector←no_print@+else selector←term_only
---
> if interaction=batch_mode then selector:=no_print@+else selector:=term_only
1482a1685
> A similar interlock is provided by |set_box_allowed|.
1485,1486c1688,1690
< The global variable |spotless| is set to false when the first error
< has been detected.
---
> The global variable |history| records the worst level of error that
> has been detected. It has four possible values: |spotless|, |warning_issued|,
> |error_message_issued|, and |fatal_error_stop|.
1492a1697,1701
> @d spotless=0 {|history| value when nothing has been amiss yet}
> @d warning_issued=1 {|history| value when |begin_diagnostic| has been called}
> @d error_message_issued=2 {|history| value when |error| has been called}
> @d fatal_error_stop=3 {|history| value when termination was premature}
>
1495c1704,1705
< @!spotless:boolean; {has the source input been clean so far?}
---
> @!set_box_allowed:boolean; {is it safe to do a \.{\\setbox} assignment?}
> @!history:spotless..fatal_error_stop; {has the source input been clean so far?}
1497c1707
< last paragraph ended}
---
> last paragraph ended}
1499,1500c1709,1714
< @ @<Set init...@>=
< deletions_allowed←true; spotless←true; error_count←0;
---
> @ The value of |history| is initially |fatal_error_stop|, but it will
> be changed to |spotless| if \TeX\ survives the initialization process.
>
> @<Set init...@>=
> deletions_allowed:=true; set_box_allowed:=true;
> error_count:=0; {|history| is initialized elsewhere}
1508c1722
< when |get_token| is being used to delete a token, or if some fatal error
---
> when |get_token| is being used to delete a token, and/or if some fatal error
1511c1725
< is never more than one level deep.
---
> is never more than two levels deep.
1513a1728
> procedure@?normalize_selector; forward;@t\2@>@/
1517a1733
> procedure@?open_log_file; forward;@t\2@>@/
1520c1736,1738
< @t\4@>@;@+debug@+procedure@?debug_help; forward;@;@+gubed
---
> procedure@?give_err_help; forward;@t\2@>@/
> @t\4\hskip-\fontdimen2\font@>@;@+@!debug@+procedure@?debug_help;
> forward;@;@+gubed
1524c1742
< in reverse order, i.e., with |help_line[0]| last.
---
> in reverse order, i.e., with |help_line[0]| appearing last.
1526,1538c1744,1756
< @d hlp1(#)==help_line[0]←#;@+end
< @d hlp2(#)==help_line[1]←#; hlp1
< @d hlp3(#)==help_line[2]←#; hlp2
< @d hlp4(#)==help_line[3]←#; hlp3
< @d hlp5(#)==help_line[4]←#; hlp4
< @d hlp6(#)==help_line[5]←#; hlp5
< @d help0==help_ptr←0 {sometimes there might be no help}
< @d help1==@+begin help_ptr←1; hlp1 {use this with one help line}
< @d help2==@+begin help_ptr←2; hlp2 {use this with two help lines}
< @d help3==@+begin help_ptr←3; hlp3 {use this with three help lines}
< @d help4==@+begin help_ptr←4; hlp4 {use this with four help lines}
< @d help5==@+begin help_ptr←5; hlp5 {use this with five help lines}
< @d help6==@+begin help_ptr←6; hlp6 {use this with six help lines}
---
> @d hlp1(#)==help_line[0]:=#;@+end
> @d hlp2(#)==help_line[1]:=#; hlp1
> @d hlp3(#)==help_line[2]:=#; hlp2
> @d hlp4(#)==help_line[3]:=#; hlp3
> @d hlp5(#)==help_line[4]:=#; hlp4
> @d hlp6(#)==help_line[5]:=#; hlp5
> @d help0==help_ptr:=0 {sometimes there might be no help}
> @d help1==@+begin help_ptr:=1; hlp1 {use this with one help line}
> @d help2==@+begin help_ptr:=2; hlp2 {use this with two help lines}
> @d help3==@+begin help_ptr:=3; hlp3 {use this with three help lines}
> @d help4==@+begin help_ptr:=4; hlp4 {use this with four help lines}
> @d help5==@+begin help_ptr:=5; hlp5 {use this with five help lines}
> @d help6==@+begin help_ptr:=6; hlp6 {use this with six help lines}
1542a1761,1764
> @!use_err_help:boolean; {should the |err_help| list be shown?}
>
> @ @<Set init...@>=
> help_ptr:=0; use_err_help:=false;
1544,1545c1766,1767
< @ The |quit| procedure just cuts across all active procedure levels and jumps
< out to |end_of_TEX|. This is the only nonlocal |@!goto| statement in the
---
> @ The |jump_out| procedure just cuts across all active procedure levels and
> goes to |end_of_TEX|. This is the only nontrivial |@!goto| statement in the
1550,1551c1772,1774
< In such cases the body of |quit| should simply be `|close_files_and_terminate|;'
< followed by a call on some system procedure that quietly terminates the program.
---
> In such cases the body of |jump_out| should simply be
> `|close_files_and_terminate|;\thinspace' followed by a call on some system
> procedure that quietly terminates the program.
1554c1777
< procedure quit;
---
> procedure jump_out;
1562,1565c1785,1790
< label continue, exit;
< var c:ascii_code; {what the user types}
< @!s1,@!s2,@!s3:integer; {used to save global variables when deleting tokens}
< begin print_char("."); show_context;
---
> label continue,exit;
> var c:ASCII_code; {what the user types}
> @!s1,@!s2,@!s3,@!s4:integer;
> {used to save global variables when deleting tokens}
> begin if history<error_message_issued then history:=error_message_issued;
> print_char("."); show_context;
1569c1794
< begin print_nl("(That makes 100 errors; please try again.)");
---
> begin print_nl("(That makes 100 errors; please try again.)");
1571,1572c1796,1797
< quit;
< end;
---
> history:=fatal_error_stop; jump_out;
> end;
1578,1582c1803,1808
< if last=first then return;
< c←buffer[first];
< if c≥"a" then c←c+"A"-"a"; {convert to upper case}
< @<Interpret code |c| and |return| if done@>;
< end
---
> @.?\relax@>
> if last=first then return;
> c:=buffer[first];
> if c>="a" then c:=c+"A"-"a"; {convert to uppercase}
> @<Interpret code |c| and |return| if done@>;
> end
1587,1591c1813,1815
< wizardry, so it is not standard in \TeX\ and not included here except
< as a recommendation. (The name of the file to edit, if an `\.E' option is
< added, is |input_stack[base_ptr].name_field|, provided that |base_ptr>0|;
< the value of |base_ptr| has been set by |show_context|.
< No input files are open when |base_ptr=0|.)
---
> wizardry, so the present implementation simply types out the name of the
> file that should be
> edited and the relevant line number.
1594,1595c1818,1819
< There is a secret `\.D' option available when the debugging routines have
< not been commented out.
---
> There is a secret `\.D' option available when the debugging routines haven't
> been commented~out.
1600,1603c1824,1834
< "1","2","3","4","5","6","7","8","9": if deletions_allowed then
< @<Delete |c-"0"| tokens, |goto continue|@>;
< @t\4\4@>@;@+debug "D": begin debug_help; goto continue;@+end;@+gubed@/
< "H": @<Print the help information, |goto continue|@>;
---
> "0","1","2","3","4","5","6","7","8","9": if deletions_allowed then
> @<Delete \(c)|c-"0"| tokens and |goto continue|@>;
> @t\4\4@>@;@+@!debug "D": begin debug_help; goto continue;@+end;@+gubed@/
> "E": if base_ptr>0 then
> begin print_nl("You want to edit file ");
> @.You want to edit file x@>
> slow_print(input_stack[base_ptr].name_field);
> print(" at line "); print_int(line);
> interaction:=scroll_mode; jump_out;
> end;
> "H": @<Print the help information and |goto continue|@>;
1606,1610c1837,1838
< "X":begin prompt_input("Type X again to exit:");
< if (last>first)∧((buffer[first]="x")∨(buffer[first]="X")) then
< begin interaction←scroll_mode; quit;
< end;
< end;
---
> "X":begin interaction:=scroll_mode; jump_out;
> end;
1615,1620c1843,1845
< @ The `\.E' option in the following menu
< should be taken out of braces if it is implemented.
< @^system dependencies@>
<
< @<Print the menu...@>=
< print("Type <return> to proceed, S to scroll future error messages,");@/
---
> @ @<Print the menu...@>=
> begin print("Type <return> to proceed, S to scroll future error messages,");@/
> @.Type <return> to proceed...@>
1622,1623c1847,1848
< print_nl("I to insert something, ");@/
< @{@,@,@+if base_ptr>0 then print("E to edit your file,");@;@+@}@/
---
> print_nl("I to insert something, ");
> if base_ptr>0 then print("E to edit your file,");
1625,1626c1850,1852
< print_nl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,");
< print_nl("H for help, X to quit.")
---
> print_nl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,");
> print_nl("H for help, X to quit.");
> end
1634,1636c1860,1868
< begin error_count←0; interaction←batch_mode+c-"Q";
< if c="Q" then decr(selector);
< print_ln; return;
---
> begin error_count:=0; interaction:=batch_mode+c-"Q";
> print("OK, entering ");
> case c of
> "Q":begin print_esc("batchmode"); decr(selector);
> end;
> "R":print_esc("nonstopmode");
> "S":print_esc("scrollmode");
> end; {there are no other cases}
> print("..."); print_ln; update_terminal; return;
1639,1642c1871,1874
< @ When the following code is executed, the material inserted by the user
< may appear in |buffer[(first+1)..(last-1)]|; otherwise another prompt
< will be given. In order to fully understand this part of the program,
< you need to be familiar with \TeX's input stacks.
---
> @ When the following code is executed, |buffer[(first+1)..(last-1)]| may
> contain the material inserted by the user; otherwise another prompt will
> be given. In order to understand this part of the program fully, you need
> to be familiar with \TeX's input stacks.
1646c1878
< {now |state←mid_line|, so an initial blank space will count as a blank}
---
> {now |state=mid_line|, so an initial blank space will count as a blank}
1648,1653c1880,1886
< begin loc←first+1; buffer[first]←" ";
< end
< else begin prompt_input("**"); loc←first;
< end;
< first←last;
< cur_input.limit_field←last-1; {no |carriage_return| ends this line}
---
> begin loc:=first+1; buffer[first]:=" ";
> end
> else begin prompt_input("insert>"); loc:=first;
> @.insert>@>
> end;
> first:=last;
> cur_input.limit_field:=last-1; {no |end_line_char| ends this line}
1659,1663c1892,1897
< @<Delete |c-"0"| tokens...@>=
< begin s1←cur_tok; s2←cur_cmd; s3←cur_chr; OK_to_interrupt←false;
< if (last>first+1) and (buffer[first+1]≥"0")∧(buffer[first+1]≤"9") then
< c←c*10+buffer[first+1]-"0"*11
< else c←c-"0";
---
> @<Delete \(c)|c-"0"| tokens...@>=
> begin s1:=cur_tok; s2:=cur_cmd; s3:=cur_chr; s4:=align_state;
> align_state:=1000000; OK_to_interrupt:=false;
> if (last>first+1) and (buffer[first+1]>="0")and(buffer[first+1]<="9") then
> c:=c*10+buffer[first+1]-"0"*11
> else c:=c-"0";
1665,1668c1899,1902
< begin get_token; {one-level recursive call of |error| is possible}
< decr(c);
< end;
< cur_tok←s1; cur_cmd←s2; cur_chr←s3; OK_to_interrupt←true;
---
> begin get_token; {one-level recursive call of |error| is possible}
> decr(c);
> end;
> cur_tok:=s1; cur_cmd:=s2; cur_chr:=s3; align_state:=s4; OK_to_interrupt:=true;
1675,1679c1909,1917
< begin if help_ptr=0 then
< help2("Sorry, I don't know how to help in this situation.")@/
< ("Maybe you should try asking a human?");
< repeat decr(help_ptr); print(help_line[help_ptr]); print_ln;
< until help_ptr=0;
---
> begin if use_err_help then
> begin give_err_help; use_err_help:=false;
> end
> else begin if help_ptr=0 then
> help2("Sorry, I don't know how to help in this situation.")@/
> @t\kern1em@>("Maybe you should try asking a human?");
> repeat decr(help_ptr); print(help_line[help_ptr]); print_ln;
> until help_ptr=0;
> end;
1681,1683c1919,1921
< ("Maybe you should try asking a human?")@/
< ("An error might have occurred before I noticed any problems.")@/
< ("``If all else fails, read the instructions.''");
---
> ("Maybe you should try asking a human?")@/
> ("An error might have occurred before I noticed any problems.")@/
> ("``If all else fails, read the instructions.''");@/
1689,1691c1927,1932
< while help_ptr>0 do
< begin decr(help_ptr); print_nl(help_line[help_ptr]);
< end;
---
> if use_err_help then
> begin print_ln; give_err_help;
> end
> else while help_ptr>0 do
> begin decr(help_ptr); print_nl(help_line[help_ptr]);
> end;
1693c1934
< if interaction>batch_mode then incr(selector); {enable terminal output}
---
> if interaction>batch_mode then incr(selector); {re-enable terminal output}
1702a1944,1954
> @ In anomalous cases, the print selector might be in an unknown state;
> the following subroutine is called to fix things just enough to keep
> running a bit longer.
>
> @p procedure normalize_selector;
> begin if log_opened then selector:=term_and_log
> else selector:=term_only;
> if job_name=0 then open_log_file;
> if interaction=batch_mode then decr(selector);
> end;
>
1706,1708c1958,1962
< interaction←scroll_mode; {no more interaction}
< error; quit; {irrecoverable error}
< end
---
> interaction:=scroll_mode; {no more interaction}
> if log_opened then error;
> @!debug if interaction>batch_mode then debug_help;@+gubed@;@/
> history:=fatal_error_stop; jump_out; {irrecoverable error}
> end
1712c1966,1967
< begin print_nl("! Emergency stop"); help1(s); succumb;
---
> begin normalize_selector;@/
> print_err("Emergency stop"); help1(s); succumb;
1720,1722c1975,1978
< begin print_nl("! TeX capacity exceeded, sorry [");
< @.TeX capacity exceeded...@>
< print(s); print_char("="); print_int(n); print_char("]");
---
> begin normalize_selector;
> print_err("TeX capacity exceeded, sorry [");
> @.TeX capacity exceeded ...@>
> print(s); print_char("="); print_int(n); print_char("]");
1724c1980
< ("you can ask a wizard to enlarge me.");
---
> ("you can ask a wizard to enlarge me.");
1728,1730c1984,1989
< @ The program might sometime run completely amok and print out the
< following message, which is really intended for the \TeX\ maintenance
< person instead of the user.
---
> @ The program might sometime run completely amok, at which point there is
> no choice but to stop. If no previous error has been detected, that's bad
> news; a message is printed that is really intended for the \TeX\
> maintenance person instead of the user (unless the user has been
> particularly diabolical). The index entries for `this can't happen' may
> help to pinpoint the problem.
1735,1737c1994,1997
< {consistency check violated; |s| tells where}
< begin if spotless then
< begin print_nl("! This can't happen ("); print(s); print_char(")");
---
> {consistency check violated; |s| tells where}
> begin normalize_selector;
> if history<error_message_issued then
> begin print_err("This can't happen ("); print(s); print_char(")");
1739,1741c1999,2001
< help1("I'm broken. Please show this to someone who can fix can fix");
< end
< else begin print_nl("! I can't go on meeting you like this");
---
> help1("I'm broken. Please show this to someone who can fix can fix");
> end
> else begin print_err("I can't go on meeting you like this");
1743,1745c2003,2005
< help2("One of your earlier faux pas has wounded me deeply,")@/
< ("so I'm barely conscious. Please fix it and try again.");
< end;
---
> help2("One of your faux pas seems to have wounded me deeply...")@/
> ("in fact, I'm barely conscious. Please fix it and try again.");
> end;
1757,1758c2017,2018
< @d check_interrupt==begin if interrupt≠0 then pause_for_instructions;
< end
---
> @d check_interrupt==begin if interrupt<>0 then pause_for_instructions;
> end
1761c2021
< @!interrupt:integer; {should \TeX\ pause for instruction?}
---
> @!interrupt:integer; {should \TeX\ pause for instructions?}
1765c2025
< interrupt←0; OK_to_interrupt←true;
---
> interrupt:=0; OK_to_interrupt:=true;
1767,1768c2027,2028
< @ When an interrupt has been detected, the program comes goes into its
< highest interaction level and lets the user have the full flexibility of
---
> @ When an interrupt has been detected, the program goes into its
> highest interaction level and lets the user have nearly the full flexibility of
1774,1777c2034,2037
< begin interaction←error_stop_mode;
< if (selector=err_only)∨(selector=no_print) then
< incr(selector);
< print_nl("! Interruption");
---
> begin interaction:=error_stop_mode;
> if (selector=log_only)or(selector=no_print) then
> incr(selector);
> print_err("Interruption");
1779,1784c2039,2044
< help3("You rang?")@/
< ("Try to insert some instructions for me (e.g.,`I\showlists'),")@/
< ("unless you just want to quit by typing `X'.");
< deletions_allowed←false; error; deletions_allowed←true;
< interrupt←0;
< end;
---
> help3("You rang?")@/
> ("Try to insert some instructions for me (e.g.,`I\showlists'),")@/
> ("unless you just want to quit by typing `X'.");
> deletions_allowed:=false; error; deletions_allowed:=true;
> interrupt:=0;
> end;
1785a2046
>
1802c2063,2066
< numerator. These are harmless; see |div| in the index.)
---
> numerator. These are harmless; see |div| in the index. Also if the user
> sets the \.{\\time} or the \.{\\year} to a negative value, some diagnostic
> information will involve negative-numerator division. The same remarks
> apply for |mod| as well as for |div|.)
1808,1809c2072,2073
< begin if odd(x) then half←(x+1) div 2
< else half←x @!div 2;
---
> begin if odd(x) then half:=(x+1) div 2
> else half:=x @!div 2;
1824,1825c2088,2089
< @ The following function is used to create a scaled integer from a decimal
< fraction $(.d↓0d↓1\ldotsm d↓{k-1})$, where |0≤k≤16|. The digit $d↓i$ is
---
> @ The following function is used to create a scaled integer from a given decimal
> fraction $(.d_0d_1\ldots d_{k-1})$, where |0<=k<=17|. The digit $d_i$ is
1829c2093
< {converts a decimal fraction}
---
> {converts a decimal fraction}
1831c2095
< begin a←0;
---
> begin a:=0;
1833,1835c2097,2099
< begin decr(k); a←(a+dig[k]*two) div 10;
< end;
< round_decimals←(a+1) div 2;
---
> begin decr(k); a:=(a+dig[k]*two) div 10;
> end;
> round_decimals:=(a+1) div 2;
1841,1844c2105,2112
< be reproduced exactly. [{\sl Proof:\/} If round$(x)=\lfloor
< x+{1\over2}\rfloor$ and if $\alpha<1$, it is not difficult to verify that
< round$(\alpha\,\hbox{round}( \alpha^{-1}n))=n$ for all integers $n$. In
< our case $\alpha=2^{16}/10^5$.]
---
> be reproduced exactly; the ``simplest'' such decimal number is output,
> but there is always at least one digit following the decimal point.
>
> The invariant relation in the \&{repeat} loop is that a sequence of
> decimal digits yet to be printed will yield the original number if and only if
> they form a fraction~$f$ in the range $s-\delta\L10\cdot2^{16}f<s$.
> We can stop if and only if $f=0$ satisfies this condition; the loop will
> terminate before $s$ can possibly become zero.
1847,1848c2115,2116
< digits}
< var k:0..4; {index to current digit of the fraction part}
---
> digits}
> var delta:scaled; {amount of allowable inaccuracy}
1850,1851c2118,2119
< begin print_char("-"); s←-s; {print the sign, if negative}
< end;
---
> begin print_char("-"); negate(s); {print the sign, if negative}
> end;
1853,1854d2120
< s←((s mod unity) * 3125 + 1024) div 2048;
< {now |0≤s<100000| is the fraction part}
1856,1857c2122,2125
< repeat print_char("0"+(s div 10000)); s←10*(s mod 10000);
< until s=0;
---
> s:=10*(s mod unity)+5; delta:=10;
> repeat if delta>unity then s:=s+@'100000-50000; {round the last digit}
> print_char("0"+(s div unity)); s:=10*(s mod unity); delta:=delta*10;
> until s<=delta;
1871c2139
< @^Overflow in arithmetic@>
---
> @^overflow in arithmetic@>
1873c2141
< few dozen tests of the form `\!|if x≥@'10000000000 then
---
> few dozen tests of the form `\ignorespaces|if x>=@'10000000000 then
1890c2158,2159
< and@@|y| are |scaled| and |n| is an integer.
---
> and~|y| are |scaled| and |n| is an integer. We will also use it to
> multiply integers.
1892c2161,2164
< @p function nx_plus_y(@!n:integer;@!x,@!y:scaled):scaled;
---
> @d nx_plus_y(#)==mult_and_add(#,@'7777777777)
> @d mult_integers(#)==mult_and_add(#,0,@'17777777777)
>
> @p function mult_and_add(@!n:integer;@!x,@!y,@!max_answer:scaled):scaled;
1894,1900c2166,2172
< begin x←-x; n←-n;
< end;
< if n=0 then nx_plus_y←y
< else if ((x≤(@'7777777777-y) div n)∧(-x≤(@'7777777777+y) div n)) then
< nx_plus_y←n*x+y
< else begin arith_error←true; nx_plus_y←0;
< end;
---
> begin negate(x); negate(n);
> end;
> if n=0 then mult_and_add:=y
> else if ((x<=(max_answer-y) div n)and(-x<=(max_answer+y) div n)) then
> mult_and_add:=n*x+y
> else begin arith_error:=true; mult_and_add:=0;
> end;
1906,1907c2178,2179
< var negate:boolean; {should |remainder| be negated?}
< begin negate←false;
---
> var negative:boolean; {should |remainder| be negated?}
> begin negative:=false;
1909,1920c2181,2192
< begin arith_error←true; x_over_n←0; remainder←x;
< end
< else begin if n<0 then
< begin x←-x; n←-n; negate←true;
< end;
< if x≥0 then
< begin x_over_n←x div n; remainder←x mod n;
< end
< else begin x_over_n←-((-x) div n); remainder←-((-x) mod n);
< end;
< end;
< if negate then remainder←-remainder;
---
> begin arith_error:=true; x_over_n:=0; remainder:=x;
> end
> else begin if n<0 then
> begin negate(x); negate(n); negative:=true;
> end;
> if x>=0 then
> begin x_over_n:=x div n; remainder:=x mod n;
> end
> else begin x_over_n:=-((-x) div n); remainder:=-((-x) mod n);
> end;
> end;
> if negative then negate(remainder);
1924,1926c2196,2198
< where |n| and |d| are nonnegative integers |≤@t$2^{16}$@>| and |d| is
< positive. It would be too dangerous to multiply by@@|n| and then divide
< by@@|d|, in separate operations, since overflow might well occur; and it
---
> where |n| and |d| are nonnegative integers |<=@t$2^{16}$@>| and |d| is
> positive. It would be too dangerous to multiply by~|n| and then divide
> by~|d|, in separate operations, since overflow might well occur; and it
1931c2203
< var positive:boolean; {was |x≥0|?}
---
> var positive:boolean; {was |x>=0|?}
1933,1940c2205,2212
< begin if x≥0 then positive←true
< else begin x←-x; positive←false;
< end;
< t←(x mod @'100000)*n;
< u←(x div @'100000)*n+(t div @'100000);
< v←(u mod d)*@'100000 + (t mod @'100000);
< if u div d≥@'100000 then arith_error←true
< else u←@'100000*(u div d) + (v div d);
---
> begin if x>=0 then positive:=true
> else begin negate(x); positive:=false;
> end;
> t:=(x mod @'100000)*n;
> u:=(x div @'100000)*n+(t div @'100000);
> v:=(u mod d)*@'100000 + (t mod @'100000);
> if u div d>=@'100000 then arith_error:=true
> else u:=@'100000*(u div d) + (v div d);
1942,1945c2214,2217
< begin xn_over_d←u; remainder←v mod d;
< end
< else begin xn_over_d←-u; remainder←-(v mod d);
< end;
---
> begin xn_over_d:=u; remainder:=v mod d;
> end
> else begin xn_over_d:=-u; remainder:=-(v mod d);
> end;
1949,1950c2221,2222
< total@@|t| is supposed to be made from amounts that sum to@@|s|. According
< to the \TeX\ manual, the badness of this situation is $100(t/s)^3$;
---
> total~|t| is supposed to be made from amounts that sum to~|s|. According
> to {\sl The \TeX book}, the badness of this situation is $100(t/s)^3$;
1953a2226
> @:TeXbook}{\sl The \TeX book@>
1961,1962c2234,2235
< It is not difficult to prove that $$\hbox{|badness(t+1,s)≥badness(t,s)
< ≥badness(t,s+1)|}$$. The badness function defined here is capable of
---
> It is not difficult to prove that $$\hbox{|badness(t+1,s)>=badness(t,s)
> >=badness(t,s+1)|}.$$ The badness function defined here is capable of
1967c2240
< @p function badness(@!t,@!s:scaled):halfword; {compute badness, given |t≥0|}
---
> @p function badness(@!t,@!s:scaled):halfword; {compute badness, given |t>=0|}
1969,1977c2242,2250
< 100\cdot2^{18}$}
< begin if t=0 then badness←0
< else if s≤0 then badness←inf_bad
< else begin if t≤7230584 then r←(t*297) div s {$297^3=99.94\times2^{18}$}
< else if s≥1663497 then r←t div (s div 297)
< else r←t;
< if r>1290 then badness←inf_bad {$1290^3<2^{31}<1291^3$}
< else badness←(r*r*r+@'400000) div @'1000000;
< end; {that was $r^3/2^{18}$, rounded to the nearest integer}
---
> 100\cdot2^{18}$}
> begin if t=0 then badness:=0
> else if s<=0 then badness:=inf_bad
> else begin if t<=7230584 then r:=(t*297) div s {$297^3=99.94\times2^{18}$}
> else if s>=1663497 then r:=t div (s div 297)
> else r:=t;
> if r>1290 then badness:=inf_bad {$1290^3<2^{31}<1291^3$}
> else badness:=(r*r*r+@'400000) div @'1000000;
> end; {that was $r^3/2^{18}$, rounded to the nearest integer}
1987c2260
< An unsigned glue ratio should take the same amount of memory as an
---
> A glue ratio should take the same amount of memory as an
1990c2263
< |short_real| in some implementations of \PASCAL. Alter\-natively,
---
> |short_real| in some implementations of \PASCAL. Alternatively,
1992c2265,2266
< arithmetic; see {\sl TUGboat \bf3} (1982), 10--27.
---
> arithmetic; see {\sl TUGboat \bf3},1 (March 1982), 10--27. (But the
> routines cited there must be modified to allow negative glue ratios.)
1994a2269,2274
> @d set_glue_ratio_zero(#) == #:=0.0 {store the representation of zero ratio}
> @d set_glue_ratio_one(#) == #:=1.0 {store the representation of unit ratio}
> @d float(#) == # {convert from |glue_ratio| to type |real|}
> @d unfloat(#) == # {convert from |real| to type |glue_ratio|}
> @d float_constant(#) == #.0 {convert |integer| constant to |real|}
>
1996a2277
>
2000c2281
< possibly scaled, or an (unsigned) |glue_ratio|, or a small number of
---
> possibly scaled, or a (signed) |glue_ratio|, or a small number of
2012c2293
< field)\cr
---
> field)\cr
2014c2295
< &\qquad\qquad\qquad(four quarterword fields)\cr}}$$
---
> &\qquad\qquad\qquad(four quarterword fields)\cr}}$$
2039c2320
< so it makes rather general assumptions. If integers having the subrange
---
> so it makes few assumptions. If integers having the subrange
2057,2064c2338,2350
< if (min_quarterword>0)∨(max_quarterword<127) then bad←11;
< if (min_halfword>0)∨(max_halfword<32767) then bad←12;
< if (min_quarterword<min_halfword)∨@|
< (max_quarterword>max_halfword) then bad←13;
< if (mem_base<min_halfword)∨(mem_max≥max_halfword) then bad←14;
< if (font_base<min_quarterword)∨(font_max>max_quarterword) then bad←15;
< if (save_size>max_halfword)∨(max_strings>max_halfword) then bad←16;
< if (buf_size>max_halfword) then bad←17;
---
> init if (mem_min<>mem_bot)or(mem_max<>mem_top) then bad:=10;@+tini@;@/
> if (mem_min>mem_bot)or(mem_max<mem_top) then bad:=10;
> if (min_quarterword>0)or(max_quarterword<127) then bad:=11;
> if (min_halfword>0)or(max_halfword<32767) then bad:=12;
> if (min_quarterword<min_halfword)or@|
> (max_quarterword>max_halfword) then bad:=13;
> if (mem_min<min_halfword)or(mem_max>=max_halfword)or@|
> (mem_bot-mem_min>max_halfword+1) then bad:=14;
> if (font_base<min_quarterword)or(font_max>max_quarterword) then bad:=15;
> if font_max>font_base+256 then bad:=16;
> if (save_size>max_halfword)or(max_strings>max_halfword) then bad:=17;
> if buf_size>max_halfword then bad:=18;
> if max_quarterword-min_quarterword<255 then bad:=19;
2074c2360
< @^inner loop@>
---
> @^inner loop@>@^system dependencies@>
2076,2079c2362,2369
< @d qi(#)==(#+min_quarterword)
< {to put an |eight_bits| item into a quarterword}
< @d qo(#)==(#-min_quarterword)
< {to take an |eight_bits| item out of a quarterword}
---
> @d qi(#)==#+min_quarterword
> {to put an |eight_bits| item into a quarterword}
> @d qo(#)==#-min_quarterword
> {to take an |eight_bits| item out of a quarterword}
> @d hi(#)==#+min_halfword
> {to put a sixteen-bit item into a halfword}
> @d ho(#)==#-min_halfword
> {to take a sixteen-bit item from a halfword}
2092,2096c2382,2386
< @!rh:halfword;
< case two_choices of
< 1: (@!lh:halfword);
< 2: (@!b0:quarterword; @!b1:quarterword);
< end;
---
> @!rh:halfword;
> case two_choices of
> 1: (@!lh:halfword);
> 2: (@!b0:quarterword; @!b1:quarterword);
> end;
2098,2109c2388,2399
< @!b0:quarterword;
< @!b1:quarterword;
< @!b2:quarterword;
< @!b3:quarterword;
< end;
< @!memory_word = packed record@;@/
< case four_choices of
< 1: (@!int:integer);
< 2: (@!gr:glue_ratio);
< 3: (@!hh:two_halves);
< 4: (@!qqqq:four_quarters);
< end;
---
> @!b0:quarterword;
> @!b1:quarterword;
> @!b2:quarterword;
> @!b3:quarterword;
> end;
> @!memory_word = record@;@/
> case four_choices of
> 1: (@!int:integer);
> 2: (@!gr:glue_ratio);
> 3: (@!hh:two_halves);
> 4: (@!qqqq:four_quarters);
> end;
2116c2406,2407
< @p debug procedure print_memory_word(@!w:memory_word); {prints |w| in all ways}
---
> @p @!debug procedure print_word(@!w:memory_word);
> {prints |w| in all ways}
2119c2410,2411
< print_scaled(round(unity*w.gr)); print_ln;@/
---
> print_scaled(round(unity*float(w.gr))); print_ln;@/
> @^real multiplication@>
2125a2418
>
2127c2420
< The \TeX\ system does nearly all of its own mem\-ory allocation, so that it
---
> The \TeX\ system does nearly all of its own memory allocation, so that it
2135c2428
< called |eqtb| that will be explained below. A pointer variable might
---
> called |eqtb| that will be explained later. A pointer variable might
2138c2431
< value represents a null pointer.
---
> value represents a null pointer. \TeX\ does not assume that |mem[null]| exists.
2146,2147c2439,2442
< @ The |mem| array is divided once and for all into two regions that are
< allocated separately. Locations less than |hi_mem_base| are used for storing
---
> @ The |mem| array is divided into two regions that are allocated separately,
> but the dividing line between these two regions is not fixed; they grow
> together until finding their ``natural'' size in a particular job.
> Locations less than or equal to |lo_mem_max| are used for storing
2151,2162c2446,2466
< appears in the allocated nodes: the program is responsible for knowing the
< relevant size when a node is freed. The remaining region of |mem| is
< allocated in single words using a conventional \.{AVAIL} stack.
<
< Incidentally, it would be feasible to construct implementations of \TeX\ that
< are based on 16-bit words instead of 32-bit words, for machines having
< comparatively small memories. In such cases it would be desirable to have
< two parallel arrays for the upper part of memory, called say \\{mem\_link}|[p]|
< and \\{mem\_info}|[p]|,
< since the single-word region in the present implementation
< consists entirely of |memory_word| items of type |two_halves|.
< @^small computers@>
---
> appears in the allocated nodes; the program is responsible for knowing the
> relevant size when a node is freed. Locations greater than or equal to
> |hi_mem_min| are used for storing one-word records; a conventional
> \.{AVAIL} stack is used for allocation in this region.
>
> Locations of |mem| between |mem_bot| and |mem_top| may be dumped as part
> of preloaded format files, by the \.{INITEX} preprocessor.
> @.INITEX@>
> Production versions of \TeX\ may extend the memory at both ends in order to
> provide more space; locations between |mem_min| and |mem_bot| are always
> used for variable-size nodes, and locations between |mem_top| and |mem_max|
> are always used for single-word nodes.
>
> The key pointers that govern |mem| allocation have a prescribed order:
> $$\advance\thickmuskip-2mu
> \hbox{|null<=mem_min<=mem_bot<lo_mem_max<
> hi_mem_min<mem_top<=mem_end<=mem_max|.}$$
>
> Empirical tests show that the present implementation of \TeX\ tends to
> spend about 9\pct! of its running time allocating nodes, and about 6\pct!
> deallocating them after their use.
2164,2165c2468,2471
< @<Globals...@>=
< @!mem : array[mem_base..mem_max] of memory_word; {the big dynamic storage area}
---
> @<Glob...@>=
> @!mem : array[mem_min..mem_max] of memory_word; {the big dynamic storage area}
> @!lo_mem_max : pointer; {the largest location of variable-size memory in use}
> @!hi_mem_min : pointer; {the smallest location of one-word memory in use}
2169c2475
< maximum memory usage. When code between the delimiters |stat| $\ldots$
---
> maximum memory usage. When code between the delimiters |@!stat| $\ldots$
2171,2172c2477
< report these statistics whenever a page is output and |tracing_stats| is
< nonzero.
---
> report these statistics when |tracing_stats| is sufficiently large.
2174c2479
< @<Globals...@>=
---
> @<Glob...@>=
2176d2480
< @!max_var_used : integer; {how much memory was in use}
2181c2485
< occur between |hi_mem_base| and |mem_end|, inclusive, are of type
---
> occur between |hi_mem_min| and |mem_end|, inclusive, are of type
2191c2495
< @<Globals...@>=
---
> @<Glob...@>=
2195c2499
< @ If one-word memory is exhausted, it might mean that the user has forgotten
---
> @ If memory is exhausted, it might mean that the user has forgotten
2203a2508,2513
> @^inner loop@>
>
> If the available-space list is empty, i.e., if |avail=null|,
> we try first to increase |mem_end|. If that cannot be done, i.e., if
> |mem_end=mem_max|, we try to decrease |hi_mem_min|. If that cannot be
> done, i.e., if |hi_mem_min=lo_mem_max+1|, we have to quit.
2207,2208c2517,2518
< begin p←avail; {get top location in the |avail| stack}
< if p≠null then avail←link(avail) {and pop it off}
---
> begin p:=avail; {get top location in the |avail| stack}
> if p<>null then avail:=link(avail) {and pop it off}
2210,2217c2520,2532
< begin incr(mem_end); p←mem_end;
< end
< else begin runaway; {if memory is exhausted, display possible runaway text}
< overflow("memory size",mem_max-mem_base); {quit; all one-word nodes are busy}
< end;
< link(p)←null; {provide an oft-desired initialization of the new node}
< stat incr(dyn_used);@+tats@;{maintain statistics}
< get_avail←p;
---
> begin incr(mem_end); p:=mem_end;
> end
> else begin decr(hi_mem_min); p:=hi_mem_min;
> if hi_mem_min<=lo_mem_max then
> begin runaway; {if memory is exhausted, display possible runaway text}
> overflow("main memory size",mem_max+1-mem_min);
> {quit; all one-word nodes are busy}
> @:TeX capacity exceeded main memory size}{\quad main memory size@>
> end;
> end;
> link(p):=null; {provide an oft-desired initialization of the new node}
> @!stat incr(dyn_used);@+tats@;{maintain statistics}
> get_avail:=p;
2225,2227c2540,2555
< begin link(#)←avail; avail←#;
< stat decr(dyn_used);@+tats@/
< end
---
> begin link(#):=avail; avail:=#;
> @!stat decr(dyn_used);@+tats@/
> end
>
> @ There's also a |fast_get_avail| routine, which saves the procedure-call
> overhead at the expense of extra programming. This routine is used in
> the places that would otherwise account for the most calls of |get_avail|.
> @^inner loop@>
>
> @d fast_get_avail(#)==@t@>@;@/
> begin #:=avail; {avoid |get_avail| if possible, to save time}
> if #=null then #:=get_avail
> else begin avail:=link(#); link(#):=null;
> @!stat incr(dyn_used);@+tats@/
> end;
> end
2230a2559
> @^inner loop@>
2233,2237c2562,2569
< available}
< var q:pointer; {the successor of node |p|}
< begin while p≠null do
< begin q←link(p); free_avail(p); p←q;
< end;
---
> available}
> var @!q,@!r:pointer; {list traversers}
> begin if p<>null then
> begin r:=p;
> repeat q:=r; r:=link(r); @!stat decr(dyn_used);@+tats@/
> until r=null; {now |q| is the last node on the list}
> link(q):=avail; avail:=p;
> end;
2252a2585,2587
> (We require |mem_max<max_halfword| because terrible things can happen
> when |max_halfword| appears in the |link| field of a nonempty node.)
>
2259c2594
< @<Globals...@>=
---
> @<Glob...@>=
2263c2598
< of size@@|s|, which must be 2@@or more. The |link| field of the first word
---
> of size~|s|, which must be 2~or more. The |link| field of the first word
2270,2271c2605,2606
< @p function get_node(@!s:integer):pointer; {variable-size node liberation}
< label found,exit;
---
> @p function get_node(@!s:integer):pointer; {variable-size node allocation}
> label found,exit,restart;
2275c2610,2611
< begin p←rover; {start at some free node in the ring}
---
> @!t:integer; {temporary register}
> begin restart: p:=rover; {start at some free node in the ring}
2277,2278c2613,2615
< and |goto found| if allocation was possible@>;
< p←rlink(p); {move to the next node in the ring}
---
> and |goto found| if allocation was possible@>;
> @^inner loop@>
> p:=rlink(p); {move to the next node in the ring}
2281,2286c2618,2626
< begin get_node←max_halfword; return;
< end;
< overflow("var size",hi_mem_base-mem_base); {sorry, nothing satisfactory is left}
< found: link(r)←null; {this node is now nonempty}
< stat var_used←var_used+s; {maintain usage statistics}
< if var_used>max_var_used then max_var_used←var_used;
---
> begin get_node:=max_halfword; return;
> end;
> if lo_mem_max+2<hi_mem_min then if lo_mem_max+2<=mem_bot+max_halfword then
> @<Grow more variable-size memory and |goto restart|@>;
> overflow("main memory size",mem_max+1-mem_min);
> {sorry, nothing satisfactory is left}
> @:TeX capacity exceeded main memory size}{\quad main memory size@>
> found: link(r):=null; {this node is now nonempty}
> @!stat var_used:=var_used+s; {maintain usage statistics}
2288c2628
< get_node←r;
---
> get_node:=r;
2291,2292c2631,2666
< @ The following operations remove an empty node from the doubly-linked
< list, knowing that it is not the only item in the list.
---
> @ The lower part of |mem| grows by 1000 words at a time, unless
> we are very close to going under. When it grows, we simply link
> a new node into the available-space list. This method of controlled
> growth helps to keep the |mem| usage consecutive when \TeX\ is
> implemented on ``virtual memory'' systems.
> @^virtual memory@>
>
> @<Grow more variable-size memory and |goto restart|@>=
> begin if hi_mem_min-lo_mem_max>=1998 then t:=lo_mem_max+1000
> else t:=lo_mem_max+1+(hi_mem_min-lo_mem_max) div 2;
> {|lo_mem_max+2<=t<hi_mem_min|}
> p:=llink(rover); q:=lo_mem_max; rlink(p):=q; llink(rover):=q;@/
> if t>mem_bot+max_halfword then t:=mem_bot+max_halfword;
> rlink(q):=rover; llink(q):=p; link(q):=empty_flag; node_size(q):=t-lo_mem_max;@/
> lo_mem_max:=t; link(lo_mem_max):=null; info(lo_mem_max):=null;
> rover:=q; goto restart;
> end
>
> @ Empirical tests show that the routine in this section performs a
> node-merging operation about 0.75 times per allocation, on the average,
> after which it finds that |r>p+1| about 95\pct! of the time.
>
> @<Try to allocate...@>=
> q:=p+node_size(p); {find the physical successor}
> @^inner loop@>
> while is_empty(q) do {merge node |p| with node |q|}
> begin t:=rlink(q);
> if q=rover then rover:=t;
> llink(t):=llink(q); rlink(llink(q)):=t;@/
> q:=q+node_size(q);
> end;
> r:=q-s;
> if r>p+1 then @<Allocate from the top of node |p| and |goto found|@>;
> if r=p then if rlink(p)<>p then
> @<Allocate entire node |p| and |goto found|@>;
> node_size(p):=q-p {reset the size in case it grew}
2294,2312c2668,2671
< @d remove_node(#) ==@;
< if #=rover then rover←rlink(#);
< llink(rlink(#))←llink(#);
< rlink(llink(#))←rlink(#)
<
< @ @<Try to allocate...@>=
< q←p+node_size(p); {find the physical successor}
< while is_empty(q) do {merge |p| with |q|}
< begin remove_node(q); q←q+node_size(q);
< end;
< r←q-s;
< if r>p+1 then @<Allocate from top of node |p| and |goto found|@>;
< if (r=p) and ((rlink(p)≠rover) or (llink(p)≠rover)) then
< @<Allocate entire node |p| and |goto found|@>;
< node_size(p)←q-p {reset the size in case it grew}
<
< @ @<Allocate from top...@>=
< begin node_size(p)←r-p; {store the remaining size}
< rover←p; {start searching here next time}
---
> @ @<Allocate from the top...@>=
> begin node_size(p):=r-p; {store the remaining size}
> @^inner loop@>
> rover:=p; {start searching here next time}
2316,2318c2675,2679
< @ @<Allocate entire...@>=
< begin remove_node(p); {delete node |p| from the ring}
< rover←rlink(p); {let |rover| rove around}
---
> @ Here we delete node |p| from the ring, and let |rover| rove around.
>
> @<Allocate entire...@>=
> begin rover:=rlink(p); t:=llink(p);
> llink(rover):=t; rlink(t):=rover;
2324a2686
> @^inner loop@>
2327c2689
< liberation}
---
> liberation}
2329,2335c2691,2694
< begin if @<Node |p| isn't in the variable-size |mem|@> then
< confusion("freenode");
< @:confusion free_node}{\quad freenode@>
< node_size(p)←s; link(p)←empty_flag;
< q←llink(rover); llink(p)←q; rlink(p)←rover; {set both links}
< llink(rover)←p; rlink(q)←p; {insert |p| into the ring}
< stat var_used←var_used-s;@+tats@;{maintain statistics}
---
> begin node_size(p):=s; link(p):=empty_flag;
> q:=llink(rover); llink(p):=q; rlink(p):=rover; {set both links}
> llink(rover):=p; rlink(q):=p; {insert |p| into the ring}
> @!stat var_used:=var_used-s;@+tats@;{maintain statistics}
2343,2344c2702,2703
< @p init procedure sort_avail; {sorts the available variable-size nodes
< by location}
---
> @p @!init procedure sort_avail; {sorts the available variable-size nodes
> by location}
2347,2355c2706,2714
< begin p←get_node(@'10000000000); {merge adjacent free areas}
< p←rlink(rover); rlink(rover)←max_halfword; old_rover←rover;
< while p≠old_rover do @<Sort |p| into the list starting at |rover|
< and advance |p| to |rlink(p)|@>;
< p←rover;
< while rlink(p)≠max_halfword do
< begin llink(rlink(p))←p; p←rlink(p);
< end;
< rlink(p)←rover; llink(rover)←p;
---
> begin p:=get_node(@'10000000000); {merge adjacent free areas}
> p:=rlink(rover); rlink(rover):=max_halfword; old_rover:=rover;
> while p<>old_rover do @<Sort \(p)|p| into the list starting at |rover|
> and advance |p| to |rlink(p)|@>;
> p:=rover;
> while rlink(p)<>max_halfword do
> begin llink(rlink(p)):=p; p:=rlink(p);
> end;
> rlink(p):=rover; llink(rover):=p;
2359c2718,2719
< @ The following |while| loop terminates, since the list that starts at
---
> @ The following |while| loop is guaranteed to
> terminate, since the list that starts at
2362c2722
< @<Sort |p|...@>=
---
> @<Sort \(p)|p|...@>=
2364,2369c2724,2730
< begin q←p; p←rlink(q); rlink(q)←rover; rover←q;
< end
< else begin q←rover;
< while rlink(q)<p do q←rlink(q);
< r←rlink(p); rlink(p)←rlink(q); rlink(q)←p; p←r;
< end
---
> begin q:=p; p:=rlink(q); rlink(q):=rover; rover:=q;
> end
> else begin q:=rover;
> while rlink(q)<p do q:=rlink(q);
> r:=rlink(p); rlink(p):=rlink(q); rlink(q):=p; p:=r;
> end
>
2390c2751
< two words, and they appear in |mem| locations less than |hi_mem_base|.
---
> two words, and they appear in |mem| locations less than |hi_mem_min|.
2398,2400c2759,2761
< and most fonts will stick to characters less than 128 (since higher codes
< are accessed outside of math mode only via ligatures and the \.{\\char}
< operator).
---
> and most fonts will stick to characters whose codes are
> less than 128 (since higher codes
> are more difficult to access on most keyboards).
2407,2410c2768,2770
< entries: The first of these would identify the font and the character
< dimensions, and it would also link to the second, where the full halfword
< |info| field would address the desired character. Such an extension of
< \TeX\ would not be difficult; further details are left to the reader.
---
> entries: The first of these has |font=font_base|, and its |link| points
> to the second;
> the second identifies the font and the character dimensions.
2412c2772,2776
< the same box dimensions.
---
> the same box dimensions. The |character| field of the first |char_node|
> is a ``\\{charext}'' that distinguishes between graphic symbols whose
> dimensions are identical for typesetting purposes. (See the \MF\ manual.)
> Such an extension of \TeX\ would not be difficult; further details are
> left to the reader.
2419,2420c2783,2784
< @d is_char_node(#) == (#>hi_mem_base)
< {does the argument point to a |char_node|?}
---
> @d is_char_node(#) == (#>=hi_mem_min)
> {does the argument point to a |char_node|?}
2458c2822,2824
< @d glue_set(#) == mem[#+6].gr {a word of type |glue_ratio| for glue setting}
---
> @d glue_offset = 6 {position of |glue_set| in a box node}
> @d glue_set(#) == mem[#+glue_offset].gr
> {a word of type |glue_ratio| for glue setting}
2462,2463c2828,2829
< The |subtype| field is set to |min_quarterword|, since that is the |span_count|
< value that is desired in case this |hlist_node| is changed to an |unset_node|.
---
> The |subtype| field is set to |min_quarterword|, since that's the desired
> |span_count| value if this |hlist_node| is changed to an |unset_node|.
2467,2471c2833,2837
< begin p←get_node(box_node_size); type(p)←hlist_node;
< subtype(p)←min_quarterword;
< width(p)←0; depth(p)←0; height(p)←0; shift_amount(p)←0; list_ptr(p)←null;
< glue_sign(p)←normal; glue_order(p)←normal; glue_set(p)←0.0;
< new_null_box←p;
---
> begin p:=get_node(box_node_size); type(p):=hlist_node;
> subtype(p):=min_quarterword;
> width(p):=0; depth(p):=0; height(p):=0; shift_amount(p):=0; list_ptr(p):=null;
> glue_sign(p):=normal; glue_order(p):=normal; set_glue_ratio_zero(glue_set(p));
> new_null_box:=p;
2475c2841
< was made from a vertical list.
---
> contains a vertical list.
2484c2850
< an hlist; the |height| and |depth| are never running in a vlist.
---
> an hlist; the |height| and |depth| are never running in a~vlist.
2497,2500c2863,2866
< begin p←get_node(rule_node_size); type(p)←rule_node;
< subtype(p)←0; {the |subtype| is not used}
< width(p)←null_flag; depth(p)←null_flag; height(p)←null_flag;
< new_rule←p;
---
> begin p:=get_node(rule_node_size); type(p):=rule_node;
> subtype(p):=0; {the |subtype| is not used}
> width(p):=null_flag; depth(p):=null_flag; height(p):=null_flag;
> new_rule:=p;
2506c2872
< The |width| field of an |ins_node| is slightly misnamed; it actually holds
---
> The |height| field of an |ins_node| is slightly misnamed; it actually holds
2508,2510c2874,2879
< There is one more field, the |ins_ptr|, which points to the beginning of
< the vlist for the insertion. In the present implementation, |ins_ptr|
< occupies a full word, although half a word would be enough.
---
> The |depth| field holds the |split_max_depth| to be used in case this
> insertion is split, and the |split_top_ptr| points to the corresponding
> |split_top_skip|. The |float_cost| field holds the |floating_penalty| that
> will be used if this insertion floats to a subsequent page after a
> split insertion of the same class. There is one more field, the
> |ins_ptr|, which points to the beginning of the vlist for the insertion.
2513,2514c2882,2885
< @d ins_node_size=3 {number of words to allocate for an insertion}
< @d ins_ptr(#)==mem[#+2].int {the vertical list to be inserted}
---
> @d ins_node_size=5 {number of words to allocate for an insertion}
> @d float_cost(#)==mem[#+1].int {the |floating_penalty| to be used}
> @d ins_ptr(#)==info(#+4) {the vertical list to be inserted}
> @d split_top_ptr(#)==link(#+4) {the |split_top_skip| to be used}
2517,2518c2888,2889
< of a token list that contains the user's \.{\\mark} text. Like the |ins_ptr|
< field, this one occupies a full word instead of a halfword just because
---
> of a token list that contains the user's \.{\\mark} text.
> This field occupies a full word instead of a halfword, because
2526,2529c2897,2901
< @ An |adjust_node|, which occurs only in horizontal lists, specifies
< material that will be moved out into the surrounding vertical list;
< i.e., it is used to implement \TeX's `\.{\\vadjust}' operation.
< The |adjust_ptr| field points to the vlist containing this material.
---
> @ An |adjust_node|, which occurs only in horizontal lists,
> specifies material that will be moved out into the surrounding
> vertical list; i.e., it is used to implement \TeX's `\.{\\vadjust}'
> operation. The |adjust_ptr| field points to the vlist containing this
> material.
2534,2540c2906,2918
< @ A |ligature_node|, which occurs only in horizontal lists, specifies a
< composite character that was formed from two or more actual characters.
< The second word of the node, which is called the |lig_char| word, contains
< |font| and |character| fields just as in a |char_node|. The characters
< that generated the ligature have not been forgotten, since they are needed
< for diagnostic messages and for hyphenation; the |lig_ptr| field points to
< a linked list of character nodes for those characters.
---
> @ A |ligature_node|, which occurs only in horizontal lists, specifies
> a character that was fabricated from the interaction of two or more
> actual characters. The second word of the node, which is called the
> |lig_char| word, contains |font| and |character| fields just as in a
> |char_node|. The characters that generated the ligature have not been
> forgotten, since they are needed for diagnostic messages and for
> hyphenation; the |lig_ptr| field points to a linked list of character
> nodes for all original characters that have been deleted. (This list
> might be empty if the characters that generated the ligature were
> retained in other nodes.)
>
> The |subtype| field is 0, plus 2 and/or 1 if the original source of the
> ligature included implicit left and/or right boundaries.
2547c2925,2928
< contents of the |font|, |character|, and |lig_ptr| fields.
---
> contents of the |font|, |character|, and |lig_ptr| fields. We also have
> a |new_lig_item| function, which returns a two-word node having a given
> |character| field. Such nodes are used for temporary processing as ligatures
> are being created.
2551,2554c2932,2940
< begin p←get_node(small_node_size); type(p)←ligature_node;
< subtype(p)←0; {the |subtype| is not used}
< font(lig_char(p))←f; character(lig_char(p))←c; lig_ptr(p)←q;
< new_ligature←p;
---
> begin p:=get_node(small_node_size); type(p):=ligature_node;
> font(lig_char(p)):=f; character(lig_char(p)):=c; lig_ptr(p):=q;
> subtype(p):=0; new_ligature:=p;
> end;
> @#
> function new_lig_item(@!c:quarterword):pointer;
> var p:pointer; {the new node}
> begin p:=get_node(small_node_size); character(p):=c; lig_ptr(p):=null;
> new_lig_item:=p;
2565c2951
< lists that consist entirely of character, kern, and ligature nodes.
---
> lists that consist entirely of character, kern, box, rule, and ligature nodes.
2581,2583c2967,2969
< begin p←get_node(small_node_size); type(p)←disc_node;
< replace_count(p)←0; pre_break(p)←null; post_break(p)←null;
< new_disc←p;
---
> begin p:=get_node(small_node_size); type(p):=disc_node;
> replace_count(p):=0; pre_break(p):=null; post_break(p):=null;
> new_disc:=p;
2592c2978
< things by adding code to these extension modules. For example, there
---
> things by adding code at the end of the program. For example, there
2598c2984
< `\.{\\send}' and `\.{\\xsend}' as if they were extensions, in order to
---
> `\.{\\write}' and `\.{\\special}' as if they were extensions, in order to
2615,2616c3001,3002
< begin p←get_node(small_node_size); type(p)←math_node;
< subtype(p)←s; width(p)←w; new_math←p;
---
> begin p:=get_node(small_node_size); type(p):=math_node;
> subtype(p):=s; width(p):=w; new_math:=p;
2623,2624c3009,3010
< |type| of the previous node is |math_node| or less. Furthermore, a
< node is discarded after a break if its type is |math_node| or more.
---
> |type| of the previous node is less than |math_node|. Furthermore, a
> node is discarded after a break if its type is |math_node| or~more.
2626c3012
< @d precedes_break(#)==(type(#)≤math_node)
---
> @d precedes_break(#)==(type(#)<math_node)
2647c3033
< will be the same as the parameter number, plus one.
---
> will be the same as the parameter number, plus~one.
2654c3040
<
---
>
2656,2657c3042,3043
< @d mu_glue=98 {|subtype| for mskip glue}
< @d cond_math_glue=99 {special |subtype| to suppress glue in the next node}
---
> @d cond_math_glue=98 {special |subtype| to suppress glue in the next node}
> @d mu_glue=99 {|subtype| for math glue}
2691a3078,3079
> The reference count in the copy is |null|, because there is assumed
> to be exactly one reference to the new specification.
2695,2698c3083,3086
< begin q←get_node(glue_spec_size);@/
< mem[q]←mem[p]; glue_ref_count(q)←null;@/
< width(q)←width(p); stretch(q)←stretch(p); shrink(q)←shrink(p);
< new_spec←q;
---
> begin q:=get_node(glue_spec_size);@/
> mem[q]:=mem[p]; glue_ref_count(q):=null;@/
> width(q):=width(p); stretch(q):=stretch(p); shrink(q):=shrink(p);
> new_spec:=q;
2701,2703c3089,3092
< @ And here's a function that creates a glue node for a given parameter;
< for example, |new_param_glue(disp_skip_code)| returns a pointer to a glue
< node for the current \.{\\dispskip}.
---
> @ And here's a function that creates a glue node for a given parameter
> identified by its code number; for example,
> |new_param_glue(line_skip_code)| returns a pointer to a glue node for the
> current \.{\\lineskip}.
2708,2712c3097,3101
< begin p←get_node(small_node_size); type(p)←glue_node; subtype(p)←n+1;
< leader_ptr(p)←null;@/
< q←@<Current |mem| equivalent of glue parameter number |n|@>@t@>;
< glue_ptr(p)←q; incr(glue_ref_count(q));
< new_param_glue←p;
---
> begin p:=get_node(small_node_size); type(p):=glue_node; subtype(p):=n+1;
> leader_ptr(p):=null;@/
> q:=@<Current |mem| equivalent of glue parameter number |n|@>@t@>;
> glue_ptr(p):=q; incr(glue_ref_count(q));
> new_param_glue:=p;
2720,2722c3109,3111
< begin p←get_node(small_node_size); type(p)←glue_node; subtype(p)←normal;
< leader_ptr(p)←null; glue_ptr(p)←q; incr(glue_ref_count(q));
< new_glue←p;
---
> begin p:=get_node(small_node_size); type(p):=glue_node; subtype(p):=normal;
> leader_ptr(p):=null; glue_ptr(p):=q; incr(glue_ref_count(q));
> new_glue:=p;
2725c3114
< @ Still another subroutine is needed: this one is sort of a combination
---
> @ Still another subroutine is needed: This one is sort of a combination
2734,2736c3123,3125
< begin temp_ptr←new_spec(@<Current |mem| equivalent of glue parameter...@>);
< p←new_glue(temp_ptr); glue_ref_count(temp_ptr)←null; subtype(p)←n+1;
< new_skip_param←p;
---
> begin temp_ptr:=new_spec(@<Current |mem| equivalent of glue parameter...@>);
> p:=new_glue(temp_ptr); glue_ref_count(temp_ptr):=null; subtype(p):=n+1;
> new_skip_param:=p;
2744,2746c3133,3137
< spacing in the vertical direction. The |subtype| is either |normal| or
< |mu_glue|, where the latter is used for \.{\\mkern} specifications
< in math formulas.
---
> spacing in the vertical direction. The |subtype| is either |normal| (for
> kerns inserted from font information or math mode calculations) or |explicit|
> (for kerns inserted from \.{\\kern} and \.{\\/} commands) or |acc_kern|
> (for kerns inserted from non-math accents) or |mu_glue| (for kerns
> inserted from \.{\\mkern} specifications in math formulas).
2748a3140,3141
> @d explicit=1 {|subtype| of kern nodes from \.{\\kern} and \.{\\/}}
> @d acc_kern=2 {|subtype| of kern nodes from accents}
2754,2757c3147,3150
< begin p←get_node(small_node_size); type(p)←kern_node;
< subtype(p)←normal;
< width(p)←w;
< new_kern←p;
---
> begin p:=get_node(small_node_size); type(p):=kern_node;
> subtype(p):=normal;
> width(p):=w;
> new_kern:=p;
2762c3155
< the full range of integer values is not used: Any penalty |≥10000| is
---
> the full range of integer values is not used: Any penalty |>=10000| is
2764c3157
< Similarly, any penalty |≤-10000| is treated as negative infinity, and a
---
> Similarly, any penalty |<=-10000| is treated as negative infinity, and a
2777,2779c3170,3172
< begin p←get_node(small_node_size); type(p)←penalty_node;
< subtype(p)←0; {the |subtype| is not used}
< penalty(p)←m; new_penalty←p;
---
> begin p:=get_node(small_node_size); type(p):=penalty_node;
> subtype(p):=0; {the |subtype| is not used}
> penalty(p):=m; new_penalty:=p;
2797c3190
< @d glue_stretch(#)==mem[#+6].sc {total stretch in an unset node}
---
> @d glue_stretch(#)==mem[#+glue_offset].sc {total stretch in an unset node}
2808,2810c3201,3206
< below may have to be changed. However, other references to the nodes are made
< symbolically in terms of the \.{WEB} macro definitions above, so format changes
< will leave \TeX's other algorithms intact.
---
> below may have to be changed. Such potentially dangerous parts of the
> program are listed in the index under `data structure assumptions'.
> @!@^data structure assumptions@>
> However, other references to the nodes are made symbolically in terms of
> the \.{WEB} macro definitions above, so that format changes will leave
> \TeX's other algorithms intact.
2811a3208
>
2815c3212
< example, locations |mem_base| to |mem_base+3| are always used to store the
---
> example, locations |mem_bot| to |mem_bot+3| are always used to store the
2818,2821c3215,3218
< symbolic names to the fixed positions. Dynamic allocation of variable-size
< nodes is restricted to locations |first_mem| through |(hi_mem_base-1)|,
< and single-word nodes are dynamically allocated in locations |second_mem|
< through |mem_max|, inclusive.
---
> symbolic names to the fixed positions. Static variable-size nodes appear
> in locations |mem_bot| through |lo_mem_stat_max|, and static single-word nodes
> appear in locations |hi_mem_stat_min| through |mem_top|, inclusive. It is
> harmless to let |lig_trick| and |garbage| share the same location of |mem|.
2823c3220
< @d zero_glue==mem_base {specification for \.{0pt plus 0pt minus 0pt}}
---
> @d zero_glue==mem_bot {specification for \.{0pt plus 0pt minus 0pt}}
2828,2829c3225,3226
< @d first_mem==fil_neg_glue+glue_spec_size {first dynamically allocatable word
< in the variable-size |mem|}
---
> @d lo_mem_stat_max==fil_neg_glue+glue_spec_size-1 {largest statically
> allocated word in the variable-size |mem|}
2831,2847c3228,3244
< @d page_ins_head==hi_mem_base {list of insertion data for current page}
< @d contrib_head==hi_mem_base+1 {vlist of items not yet on current page}
< @d page_head==hi_mem_base+2 {vlist for current page}
< @d temp_head==hi_mem_base+3 {head of a temporary list of some kind}
< @d hold_head==hi_mem_base+4 {head of a temporary list of another kind}
< @d scan_head==hi_mem_base+5 {head of token list built by |scan_keyword|}
< @d adjust_head==hi_mem_base+6 {head of adjustment list returned by |hpack|}
< @d active==hi_mem_base+7 {head of active list in |line_break|, needs two words}
< @d align_head==hi_mem_base+9 {head of preamble list for alignments}
< @d end_span==hi_mem_base+10 {tail of spanned-width lists}
< @d omit_template==hi_mem_base+11 {a constant token list}
< @d lig_trick==hi_mem_base+12 {a ligature masquerading as a |char_node|}
< @d garbage==hi_mem_base+13 {used for scrap information}
< @d second_mem==hi_mem_base+14 {first dynamically allocatable word in
< the one-word |mem|}
<
< @<Node |p| isn't in the variable-size |mem|@>=(p<first_mem)∨(p≥hi_mem_base)
---
> @d page_ins_head==mem_top {list of insertion data for current page}
> @d contrib_head==mem_top-1 {vlist of items not yet on current page}
> @d page_head==mem_top-2 {vlist for current page}
> @d temp_head==mem_top-3 {head of a temporary list of some kind}
> @d hold_head==mem_top-4 {head of a temporary list of another kind}
> @d adjust_head==mem_top-5 {head of adjustment list returned by |hpack|}
> @d active==mem_top-7 {head of active list in |line_break|, needs two words}
> @d align_head==mem_top-8 {head of preamble list for alignments}
> @d end_span==mem_top-9 {tail of spanned-width lists}
> @d omit_template==mem_top-10 {a constant token list}
> @d null_list==mem_top-11 {permanently empty list}
> @d lig_trick==mem_top-12 {a ligature masquerading as a |char_node|}
> @d garbage==mem_top-12 {used for scrap information}
> @d backup_head==mem_top-13 {head of token list built by |scan_keyword|}
> @d hi_mem_stat_min==mem_top-13 {smallest statically allocated word in
> the one-word |mem|}
> @d hi_mem_stat_usage=14 {the number of one-word nodes always present}
2850c3247
< initializing itself the slow way.
---
> initializing itself the slow~way.
2856,2873c3253,3273
< for k←mem_base+1 to first_mem-1 do mem[k].sc←0;
< {all glue dimensions are zeroed}
< k←mem_base;@+while k<first_mem do {set first words of glue specifications}
< begin glue_ref_count(k)←null+1;
< stretch_order(k)←normal; shrink_order(k)←normal;
< k←k+glue_spec_size;
< end;
< stretch(fil_glue)←unity; stretch_order(fil_glue)←fil;@/
< stretch(fill_glue)←unity; stretch_order(fill_glue)←fill;@/
< stretch(ss_glue)←unity; stretch_order(ss_glue)←fil;@/
< shrink(ss_glue)←unity; shrink_order(ss_glue)←fil;@/
< stretch(fil_neg_glue)←-unity; stretch_order(fil_neg_glue)←fil;@/
< rover←first_mem; link(rover)←empty_flag; {now initialize the dynamic memory}
< node_size(rover)←hi_mem_base-rover; {which is one big available node}
< llink(rover)←rover; rlink(rover)←rover;@/
< link(hi_mem_base)←null; info(hi_mem_base)←null;
< for k←hi_mem_base+1 to second_mem-1 do
< mem[k]←mem[hi_mem_base];{clear list heads}
---
> for k:=mem_bot+1 to lo_mem_stat_max do mem[k].sc:=0;
> {all glue dimensions are zeroed}
> @^data structure assumptions@>
> k:=mem_bot;@+while k<=lo_mem_stat_max do
> {set first words of glue specifications}
> begin glue_ref_count(k):=null+1;
> stretch_order(k):=normal; shrink_order(k):=normal;
> k:=k+glue_spec_size;
> end;
> stretch(fil_glue):=unity; stretch_order(fil_glue):=fil;@/
> stretch(fill_glue):=unity; stretch_order(fill_glue):=fill;@/
> stretch(ss_glue):=unity; stretch_order(ss_glue):=fil;@/
> shrink(ss_glue):=unity; shrink_order(ss_glue):=fil;@/
> stretch(fil_neg_glue):=-unity; stretch_order(fil_neg_glue):=fil;@/
> rover:=lo_mem_stat_max+1;
> link(rover):=empty_flag; {now initialize the dynamic memory}
> node_size(rover):=1000; {which is a 1000-word available node}
> llink(rover):=rover; rlink(rover):=rover;@/
> lo_mem_max:=rover+1000; link(lo_mem_max):=null; info(lo_mem_max):=null;@/
> for k:=hi_mem_stat_min to mem_top do
> mem[k]:=mem[lo_mem_max]; {clear list heads}
2875,2877c3275,3278
< avail←null; mem_end←second_mem-1; {initialize the one-word memory}
< var_used←first_mem-mem_base; dyn_used←second_mem-hi_mem_base;
< max_var_used←var_used; {initialize statistics}
---
> avail:=null; mem_end:=mem_top;
> hi_mem_min:=hi_mem_stat_min; {initialize the one-word memory}
> var_used:=lo_mem_stat_max+1-mem_bot; dyn_used:=hi_mem_stat_usage;
> {initialize statistics}
2887,2888c3288
< are debugging; decreasing |mem_max| saves space and time,
< and decreasing |hi_mem_base| saves time.)
---
> are debugging.)
2890,2895c3290,3296
< @<Globals...@>=
< debug @!free: packed array [mem_base..mem_max] of boolean; {free cells}
< @t\hskip1em@>@!was_free: packed array [mem_base..mem_max] of boolean;
< {previously free cells}
< @t\hskip1em@>@!was_mem_end: pointer; {previous |mem_end|}
< @t\hskip1em@>@!panicking:boolean; {do we want to check memory constantly?}
---
> @<Glob...@>=
> @!debug @!free: packed array [mem_min..mem_max] of boolean; {free cells}
> @t\hskip10pt@>@!was_free: packed array [mem_min..mem_max] of boolean;
> {previously free cells}
> @t\hskip10pt@>@!was_mem_end,@!was_lo_max,@!was_hi_min: pointer;
> {previous |mem_end|, |lo_mem_max|, and |hi_mem_min|}
> @t\hskip10pt@>@!panicking:boolean; {do we want to check memory constantly?}
2899,2900c3300,3302
< debug was_mem_end←mem_base; {indicate that everything was previously free}
< panicking←false;
---
> @!debug was_mem_end:=mem_min; {indicate that everything was previously free}
> was_lo_max:=mem_min; was_hi_min:=mem_max;
> panicking:=false;
2907c3309
< @p debug procedure check_mem(@!print_locs : boolean);
---
> @p @!debug procedure check_mem(@!print_locs : boolean);
2911,2912c3313,3315
< begin for p←mem_base to mem_end do free[p]←false; {you can probably
< do this faster}
---
> begin for p:=mem_min to lo_mem_max do free[p]:=false; {you can probably
> do this faster}
> for p:=hi_mem_min to mem_end do free[p]:=false; {ditto}
2917,2918c3320,3323
< for p←0 to mem_end do was_free[p]←free[p]; {|was_free←free| might be faster}
< was_mem_end←mem_end;
---
> for p:=mem_min to lo_mem_max do was_free[p]:=free[p];
> for p:=hi_mem_min to mem_end do was_free[p]:=free[p];
> {|was_free:=free| might be faster}
> was_mem_end:=mem_end; was_lo_max:=lo_mem_max; was_hi_min:=hi_mem_min;
2923,2932c3328,3338
< p←avail; q←null; clobbered←false;
< while p≠null do
< begin if (p>mem_end)∨(p<second_mem) then clobbered←true
< else if free[p] then clobbered←true;
< if clobbered then
< begin print_nl("AVAIL list clobbered at ");
< print_int(q); goto done1;
< end;
< free[p]←true; q←p; p←link(q);
< end;
---
> p:=avail; q:=null; clobbered:=false;
> while p<>null do
> begin if (p>mem_end)or(p<hi_mem_min) then clobbered:=true
> else if free[p] then clobbered:=true;
> if clobbered then
> begin print_nl("AVAIL list clobbered at ");
> @.AVAIL list clobbered...@>
> print_int(q); goto done1;
> end;
> free[p]:=true; q:=p; p:=link(q);
> end;
2936,2952c3342,3359
< p←rover; q←null; clobbered←false;
< repeat if (p≥hi_mem_base)∨(p<first_mem) then clobbered←true
< else if (rlink(p)≥hi_mem_base)∨(rlink(p)<first_mem) then clobbered←true
< else if ¬(is_empty(p))∨(node_size(p)<2)∨@|
< (p+node_size(p)>hi_mem_base)∨@| (llink(rlink(p))≠p) then clobbered←true;
< if clobbered then
< begin print_nl("Double-AVAIL list clobbered at ");
< print_int(q); goto done2;
< end;
< for q←p to p+node_size(p)-1 do {mark all locations free}
< begin if free[q] then
< begin print_nl("Doubly free location at ");
< print_int(q); goto done2;
< end;
< free[q]←true;
< end;
< q←p; p←rlink(p);
---
> p:=rover; q:=null; clobbered:=false;
> repeat if (p>=lo_mem_max)or(p<mem_min) then clobbered:=true
> else if (rlink(p)>=lo_mem_max)or(rlink(p)<mem_min) then clobbered:=true
> else if not(is_empty(p))or(node_size(p)<2)or@|
> (p+node_size(p)>lo_mem_max)or@| (llink(rlink(p))<>p) then clobbered:=true;
> if clobbered then
> begin print_nl("Double-AVAIL list clobbered at ");
> print_int(q); goto done2;
> end;
> for q:=p to p+node_size(p)-1 do {mark all locations free}
> begin if free[q] then
> begin print_nl("Doubly free location at ");
> @.Doubly free location...@>
> print_int(q); goto done2;
> end;
> free[q]:=true;
> end;
> q:=p; p:=rlink(p);
2957,2964c3364,3372
< p←mem_base;
< while p≤hi_mem_base do {node |p| should not be empty}
< begin if is_empty(p) then
< begin print_nl("Bad flag at "); print_int(p);
< end;
< while (p≤hi_mem_base) and not free[p] do incr(p);
< while (p≤hi_mem_base) and free[p] do incr(p);
< end
---
> p:=mem_min;
> while p<=lo_mem_max do {node |p| should not be empty}
> begin if is_empty(p) then
> begin print_nl("Bad flag at "); print_int(p);
> @.Bad flag...@>
> end;
> while (p<=lo_mem_max) and not free[p] do incr(p);
> while (p<=lo_mem_max) and free[p] do incr(p);
> end
2968,2971c3376,3384
< for p←mem_base to mem_end do
< if not free[p] and ((p>was_mem_end) or was_free[p]) then
< begin print_char(" "); print_int(p);
< end;
---
> for p:=mem_min to lo_mem_max do
> if not free[p] and ((p>was_lo_max) or was_free[p]) then
> begin print_char(" "); print_int(p);
> end;
> for p:=hi_mem_min to mem_end do
> if not free[p] and
> ((p<was_hi_min) or (p>was_mem_end) or was_free[p]) then
> begin print_char(" "); print_int(p);
> end;
2975c3388
< to node@@|p|?'' In doing so, it fetches |link| and |info| fields of |mem|
---
> to node~|p|?'' In doing so, it fetches |link| and |info| fields of |mem|
2983,2993c3396,3416
< @p debug procedure search_mem(@!p:pointer); {look for pointers to |p|}
< var q:pointer; {current position being searched}
< begin for q←mem_base to mem_end do
< begin if link(q)=p then
< begin print_nl("LINK("); print_int(q); print_char(")");
< end;
< if info(q)=p then
< begin print_nl("INFO("); print_int(q); print_char(")");
< end;
< end;
< @<Search |eqtb| for equivalents equal to |p|@>;
---
> @p @!debug procedure search_mem(@!p:pointer); {look for pointers to |p|}
> var q:integer; {current position being searched}
> begin for q:=mem_min to lo_mem_max do
> begin if link(q)=p then
> begin print_nl("LINK("); print_int(q); print_char(")");
> end;
> if info(q)=p then
> begin print_nl("INFO("); print_int(q); print_char(")");
> end;
> end;
> for q:=hi_mem_min to mem_end do
> begin if link(q)=p then
> begin print_nl("LINK("); print_int(q); print_char(")");
> end;
> if info(q)=p then
> begin print_nl("INFO("); print_int(q); print_char(")");
> end;
> end;
> @<Search |eqtb| for equivalents equal to |p|@>;
> @<Search |save_stack| for equivalents that point to |p|@>;
> @<Search |hyph_list| for pointers to |p|@>;
2995a3419
>
3022,3037c3446,3461
< begin while p>null do
< begin if is_char_node(p) then
< begin if p≤mem_end then
< begin if font(p)≠font_in_short_display then
< begin print_esc(":");
< if (font(p)<0)∨(font(p)>font_max) then
< print_char("*")
< else print_int(font_code[font(p)]);
< print_char(" "); font_in_short_display←font(p);
< end;
< print_ascii(qo(character(p)));
< end;
< end
< else @<Print a short indication of the contents of node |p|@>;
< p←link(p);
< end;
---
> begin while p>mem_min do
> begin if is_char_node(p) then
> begin if p<=mem_end then
> begin if font(p)<>font_in_short_display then
> begin if (font(p)<font_base)or(font(p)>font_max) then
> print_char("*")
> @.*\relax@>
> else @<Print the font identifier for |font(p)|@>;
> print_char(" "); font_in_short_display:=font(p);
> end;
> print_ASCII(qo(character(p)));
> end;
> end
> else @<Print a short indication of the contents of node |p|@>;
> p:=link(p);
> end;
3039c3463
<
---
>
3043c3467
< unset_node: print("[]");
---
> unset_node: print("[]");
3045c3469
< glue_node: if glue_ptr(p)≠zero_glue then print_char(" ");
---
> glue_node: if glue_ptr(p)<>zero_glue then print_char(" ");
3049,3054c3473,3479
< short_display(post_break(p));@/
< n←replace_count(p);
< while n>0 do
< begin p←link(p); decr(n);
< end;
< end;
---
> short_display(post_break(p));@/
> n:=replace_count(p);
> while n>0 do
> begin if link(p)<>null then p:=link(p);
> decr(n);
> end;
> end;
3064,3068c3489,3493
< else begin print_esc(":");
< if (font(p)<0)∨(font(p)>font_max) then print_char("*")
< else print_int(font_code[font(p)]);
< print_char(" "); print_ascii(qo(character(p)));
< end;
---
> else begin if (font(p)<font_base)or(font(p)>font_max) then print_char("*")
> @.*\relax@>
> else @<Print the font identifier for |font(p)|@>;
> print_char(" "); print_ASCII(qo(character(p)));
> end;
3073c3498
< if (p<hi_mem_base)∨(p>mem_end) then print_esc("CLOBBERED.")
---
> if (p<hi_mem_min)or(p>mem_end) then print_esc("CLOBBERED.")
3079a3505
> @.*\relax@>
3086c3512
< {prints a glue component}
---
> {prints a glue component}
3088c3514
< if (order<normal)∨(order>filll) then print("foul")
---
> if (order<normal)or(order>filll) then print("foul")
3090,3095c3516,3521
< begin print("fil");
< while order>fil do
< begin print_char("l"); decr(order);
< end;
< end
< else if s≠0 then print(s);
---
> begin print("fil");
> while order>fil do
> begin print_char("l"); decr(order);
> end;
> end
> else if s<>0 then print(s);
3100,3111c3526,3538
< @p procedure print_spec(@!p:pointer;@!s:str_number);
< {prints a glue specification}
< begin if (p<mem_base)∨(p≥hi_mem_base) then print_char("*")
< else begin print_scaled(width(p));
< if s≠0 then print(s);
< if stretch(p)≠0 then
< begin print(" plus "); print_glue(stretch(p),stretch_order(p),s);
< end;
< if shrink(p)≠0 then
< begin print(" minus "); print_glue(shrink(p),shrink_order(p),s);
< end;
< end;
---
> @p procedure print_spec(@!p:integer;@!s:str_number);
> {prints a glue specification}
> begin if (p<mem_min)or(p>=lo_mem_max) then print_char("*")
> @.*\relax@>
> else begin print_scaled(width(p));
> if s<>0 then print(s);
> if stretch(p)<>0 then
> begin print(" plus "); print_glue(stretch(p),stretch_order(p),s);
> end;
> if shrink(p)<>0 then
> begin print(" minus "); print_glue(shrink(p),shrink_order(p),s);
> end;
> end;
3115c3542
< docu\-mentation.
---
> documentation.
3129,3130c3556,3557
< begin append_char("."); show_node_list(#); flush_char;
< end {|str_room| need not be checked; see |show_box| below}
---
> begin append_char("."); show_node_list(#); flush_char;
> end {|str_room| need not be checked; see |show_box| below}
3139c3566
< @<Globals...@>=
---
> @<Glob...@>=
3155c3582
< @p procedure show_node_list(@!p:pointer); {prints a node list symbolically}
---
> @p procedure show_node_list(@!p:integer); {prints a node list symbolically}
3157a3585
> @!g:real; {a glue ratio, as a floating point number}
3159,3174c3587,3604
< begin if p>null then print("[]");
< {indicate that there's been some truncation}
< return;
< end;
< n←0;
< while p>null do
< begin print_ln; print_current_string; {display the nesting history}
< if p>mem_end then {pointer out of range}
< begin print("Bad link, display aborted."); return;
< end;
< incr(n); if n>breadth_max then {time to stop}
< begin print("etc."); return;
< end;
< @<Display node |p|@>;
< p←link(p);
< end;
---
> begin if p>null then print(" []");
> {indicate that there's been some truncation}
> return;
> end;
> n:=0;
> while p>mem_min do
> begin print_ln; print_current_string; {display the nesting history}
> if p>mem_end then {pointer out of range}
> begin print("Bad link, display aborted."); return;
> @.Bad link...@>
> end;
> incr(n); if n>breadth_max then {time to stop}
> begin print("etc."); return;
> @.etc@>
> end;
> @<Display node |p|@>;
> p:=link(p);
> end;
3180,3195c3610,3625
< else case type(p) of
< hlist_node,vlist_node,unset_node: @<Display box |p|@>;
< rule_node: @<Display rule |p|@>;
< ins_node: @<Display insertion |p|@>;
< whatsit_node: @<Display the whatsit node |p|@>;
< glue_node: @<Display glue |p|@>;
< kern_node: @<Display kern |p|@>;
< math_node: @<Display math node |p|@>;
< ligature_node: @<Display ligature |p|@>;
< penalty_node: @<Display penalty |p|@>;
< disc_node: @<Display discretionary |p|@>;
< mark_node: @<Display mark |p|@>;
< adjust_node: @<Display adjustment |p|@>;
< @t\4@>@<Cases of |show_node_list| that arise in mlists only@>@;
< othercases print("Unknown node type!")
< endcases
---
> else case type(p) of
> hlist_node,vlist_node,unset_node: @<Display box |p|@>;
> rule_node: @<Display rule |p|@>;
> ins_node: @<Display insertion |p|@>;
> whatsit_node: @<Display the whatsit node |p|@>;
> glue_node: @<Display glue |p|@>;
> kern_node: @<Display kern |p|@>;
> math_node: @<Display math node |p|@>;
> ligature_node: @<Display ligature |p|@>;
> penalty_node: @<Display penalty |p|@>;
> disc_node: @<Display discretionary |p|@>;
> mark_node: @<Display mark |p|@>;
> adjust_node: @<Display adjustment |p|@>;
> @t\4@>@<Cases of |show_node_list| that arise in mlists only@>@;
> othercases print("Unknown node type!")
> endcases
3204,3209c3634,3639
< @<Display special fields of the unset node |p|@>
< else begin @<Display the value of |glue_set(p)|@>;
< if shift_amount(p)≠0 then
< begin print(", shifted "); print_scaled(shift_amount(p));
< end;
< end;
---
> @<Display special fields of the unset node |p|@>
> else begin @<Display the value of |glue_set(p)|@>;
> if shift_amount(p)<>0 then
> begin print(", shifted "); print_scaled(shift_amount(p));
> end;
> end;
3214,3219c3644,3653
< begin if span_count(p)≠min_quarterword then
< begin print(" ("); print_int(qo(span_count(p))+1);
< print(" columns)");
< end;
< print(", stretch "); print_glue(glue_stretch(p),glue_order(p),0);
< print(", shrink "); print_glue(glue_shrink(p),glue_sign(p),0);
---
> begin if span_count(p)<>min_quarterword then
> begin print(" ("); print_int(qo(span_count(p))+1);
> print(" columns)");
> end;
> if glue_stretch(p)<>0 then
> begin print(", stretch "); print_glue(glue_stretch(p),glue_order(p),0);
> end;
> if glue_shrink(p)<>0 then
> begin print(", shrink "); print_glue(glue_shrink(p),glue_sign(p),0);
> end;
3223c3657,3664
< a structured type instead of an ordinary |real|.
---
> a structured type instead of an ordinary |real|. Note that this routine
> should avoid arithmetic errors even if the |glue_set| field holds an
> arbitrary random value. The following code assumes that a properly
> formed nonzero |real| number has absolute value $2^{20}$ or more when
> it is regarded as an integer; this precaution was adequate to prevent
> floating point underflow on the author's computer.
> @^system dependencies@>
> @^dirty \PASCAL@>
3226,3235c3667,3679
< if glue_set(p)≠0 then
< begin print(", glue set ");
< if glue_sign(p)=shrinking then print("- ");
< if abs(glue_set(p))>20000.0 then
< begin if glue_set(p)>0 then print_char(">")
< else print("< -");
< print_glue(20000*unity,glue_order(p),0);
< end
< else print_glue(round(glue_set(p)*unity),glue_order(p),0);
< end
---
> g:=float(glue_set(p));
> if (g<>float_constant(0))and(glue_sign(p)<>normal) then
> begin print(", glue set ");
> if glue_sign(p)=shrinking then print("- ");
> if abs(mem[p+glue_offset].int)<@'4000000 then print("?.?")
> else if abs(g)>float_constant(20000) then
> begin if g>float_constant(0) then print_char(">")
> else print("< -");
> print_glue(20000*unity,glue_order(p),0);
> end
> else print_glue(round(unity*g),glue_order(p),0);
> @^real multiplication@>
> end
3244c3688,3691
< print(", natural size "); print_scaled(width(p));
---
> print(", natural size "); print_scaled(height(p));
> print("; split("); print_spec(split_top_ptr(p),0);
> print_char(","); print_scaled(depth(p));
> print("); float cost "); print_int(float_cost(p));
3249,3264c3696,3711
< if subtype(p)≥a_leaders then @<Display leaders |p|@>
< else begin print_esc("glue");
< if subtype(p)≠normal then
< begin print_char("(");
< if subtype(p)<cond_math_glue then
< print_skip_param(subtype(p)-1)
< else if subtype(p)=cond_math_glue then print_esc("non_script")
< else print_esc("mskip");
< print_char(")");
< end;
< if subtype(p)≠cond_math_glue then
< begin print_char(" ");
< if subtype(p)<cond_math_glue then print_spec(glue_ptr(p),0)
< else print_spec(glue_ptr(p),"mu");
< end;
< end
---
> if subtype(p)>=a_leaders then @<Display leaders |p|@>
> else begin print_esc("glue");
> if subtype(p)<>normal then
> begin print_char("(");
> if subtype(p)<cond_math_glue then
> print_skip_param(subtype(p)-1)
> else if subtype(p)=cond_math_glue then print_esc("nonscript")
> else print_esc("mskip");
> print_char(")");
> end;
> if subtype(p)<>cond_math_glue then
> begin print_char(" ");
> if subtype(p)<cond_math_glue then print_spec(glue_ptr(p),0)
> else print_spec(glue_ptr(p),"mu");
> end;
> end
3267c3714
< begin print_char("\");
---
> begin print_esc("");
3274,3279c3721,3732
< @ @<Display kern |p|@>=
< if subtype(p)=normal then
< begin print_esc("kern"); print_scaled(width(p));
< end
< else begin print_esc("mkern"); print_scaled(width(p)); print("mu");
< end
---
> @ An ``explicit'' kern value is indicated implicitly by an explicit space.
>
> @<Display kern |p|@>=
> if subtype(p)<>mu_glue then
> begin print_esc("kern");
> if subtype(p)<>normal then print_char(" ");
> print_scaled(width(p));
> if subtype(p)=acc_kern then print(" (for accent)");
> @.for accent@>
> end
> else begin print_esc("mkern"); print_scaled(width(p)); print("mu");
> end
3285,3287c3738,3740
< if width(p)≠0 then
< begin print(", surrounded "); print_scaled(width(p));
< end;
---
> if width(p)<>0 then
> begin print(", surrounded "); print_scaled(width(p));
> end;
3292,3293c3745,3748
< font_in_short_display←font(lig_char(p));
< short_display(lig_ptr(p)); print_char(")");
---
> if subtype(p)>1 then print_char("|");
> font_in_short_display:=font(lig_char(p)); short_display(lig_ptr(p));
> if odd(subtype(p)) then print_char("|");
> print_char(")");
3306,3309c3761,3763
< begin print(" replacing "); print_int(replace_count(p));
< end;
< if pre_break(p)=null then print(" (exhyphen)")
< else node_list_display(pre_break(p)); {recursive call}
---
> begin print(" replacing "); print_int(replace_count(p));
> end;
> node_list_display(pre_break(p)); {recursive call}
3325,3330c3779,3784
< begin @<Assign the values |depth_threshold←show_box_depth| and
< |breadth_max←show_box_breadth|@>;
< if breadth_max≤0 then breadth_max←5;
< if pool_ptr+depth_threshold≥pool_size then
< depth_threshold←pool_size-pool_ptr-1;
< {now there's enough room for prefix string}
---
> begin @<Assign the values |depth_threshold:=show_box_depth| and
> |breadth_max:=show_box_breadth|@>;
> if breadth_max<=0 then breadth_max:=5;
> if pool_ptr+depth_threshold>=pool_size then
> depth_threshold:=pool_size-pool_ptr-1;
> {now there's enough room for prefix string}
3333a3788
>
3349c3804
< of a token list that is losing one reference}
---
> of a token list that is losing one reference}
3356a3812,3815
> @d fast_delete_glue_ref(#)==@t@>@;@/
> begin if glue_ref_count(#)=null then free_node(#,glue_spec_size)
> else decr(glue_ref_count(#));
> end
3359,3361c3818
< begin if glue_ref_count(p)=null then free_node(p,glue_spec_size)
< else decr(glue_ref_count(p));
< end;
---
> fast_delete_glue_ref(p);
3363a3821,3822
> In practice, the nodes deleted are usually charnodes (about 2/3 of the time),
> and they are glue nodes in about half of the remaining cases.
3369,3398c3828,3860
< begin while p≠null do
< begin q←link(p);
< if is_char_node(p) then free_avail(p)
< else begin case type(p) of
< hlist_node,vlist_node,unset_node: begin flush_node_list(list_ptr(p));
< free_node(p,box_node_size); goto done;
< end;
< rule_node: begin free_node(p,rule_node_size); goto done;
< end;
< ins_node: begin flush_node_list(ins_ptr(p));
< free_node(p,ins_node_size); goto done;
< end;
< whatsit_node: @<Wipe out the whatsit node |p| and |goto done|@>;
< glue_node: begin delete_glue_ref(glue_ptr(p));
< flush_node_list(leader_ptr(p));
< end;
< kern_node,math_node,penalty_node: do_nothing;
< ligature_node: flush_node_list(lig_ptr(p));
< mark_node: delete_token_ref(mark_ptr(p));
< disc_node: begin flush_node_list(pre_break(p));
< flush_node_list(post_break(p));
< end;
< adjust_node: flush_node_list(adjust_ptr(p));
< othercases confusion("flushing")
< @:confusion flushing}{\quad flushing@>
< endcases;@/
< free_node(p,small_node_size);
< done:end;
< p←q;
< end;
---
> begin while p<>null do
> @^inner loop@>
> begin q:=link(p);
> if is_char_node(p) then free_avail(p)
> else begin case type(p) of
> hlist_node,vlist_node,unset_node: begin flush_node_list(list_ptr(p));
> free_node(p,box_node_size); goto done;
> end;
> rule_node: begin free_node(p,rule_node_size); goto done;
> end;
> ins_node: begin flush_node_list(ins_ptr(p));
> delete_glue_ref(split_top_ptr(p));
> free_node(p,ins_node_size); goto done;
> end;
> whatsit_node: @<Wipe out the whatsit node |p| and |goto done|@>;
> glue_node: begin fast_delete_glue_ref(glue_ptr(p));
> if leader_ptr(p)<>null then flush_node_list(leader_ptr(p));
> end;
> kern_node,math_node,penalty_node: do_nothing;
> ligature_node: flush_node_list(lig_ptr(p));
> mark_node: delete_token_ref(mark_ptr(p));
> disc_node: begin flush_node_list(pre_break(p));
> flush_node_list(post_break(p));
> end;
> adjust_node: flush_node_list(adjust_ptr(p));
> @t\4@>@<Cases of |flush_node_list| that arise in mlists only@>@;
> othercases confusion("flushing")
> @:this can't happen flushing}{\quad flushing@>
> endcases;@/
> free_node(p,small_node_size);
> done:end;
> p:=q;
> end;
3399a3862
>
3401,3406c3864,3868
< Another recursive operation on boxes is sometimes needed: The procedure
< @^recursion@>
< |copy_node_list| returns a pointer to another node list that has the
< same structure and meaning as the original. Note that since glue
< specifications and token lists have reference counts, we need not
< make copies of them. Reference counts can never get too large to fit in a
---
> Another recursive operation that acts on boxes is sometimes needed: The
> procedure |copy_node_list| returns a pointer to another node list that has
> the same structure and meaning as the original. Note that since glue
> specifications and token lists have reference counts, we need not make
> copies of them. Reference counts can never get too large to fit in a
3408a3871
> @^recursion@>
3421a3885
> @^data structure assumptions@>
3424c3888
< node list that starts at |p| and returns a pointer to the new list}
---
> node list that starts at |p| and returns a pointer to the new list}
3429,3435c3893,3899
< begin h←get_avail; q←h;
< while p≠null do
< begin @<Make a copy of node |p| in node |r|@>;
< link(q)←r; q←r; p←link(p);
< end;
< link(q)←null; q←link(h); free_avail(h);
< copy_node_list←q;
---
> begin h:=get_avail; q:=h;
> while p<>null do
> begin @<Make a copy of node |p| in node |r|@>;
> link(q):=r; q:=r; p:=link(p);
> end;
> link(q):=null; q:=link(h); free_avail(h);
> copy_node_list:=q;
3439,3440c3903,3904
< words←1; {this setting occurs in more branches than any other}
< if is_char_node(p) then r←get_avail
---
> words:=1; {this setting occurs in more branches than any other}
> if is_char_node(p) then r:=get_avail
3442c3906
< of initial words not yet copied@>;
---
> of initial words not yet copied@>;
3444,3445c3908,3909
< begin decr(words); mem[r+words]←mem[p+words];
< end
---
> begin decr(words); mem[r+words]:=mem[p+words];
> end
3449,3458c3913,3924
< hlist_node,vlist_node,unset_node: begin r←get_node(box_node_size);
< mem[r+6]←mem[p+6]; mem[r+5]←mem[p+5]; {copy the last two words}
< list_ptr(r)←copy_node_list(list_ptr(p)); {this affects |mem[r+5]|}
< words←5;
< end;
< rule_node: begin r←get_node(rule_node_size); words←rule_node_size;
< end;
< ins_node: begin r←get_node(ins_node_size);
< ins_ptr(r)←copy_node_list(ins_ptr(p)); words←ins_node_size-1;
< end;
---
> hlist_node,vlist_node,unset_node: begin r:=get_node(box_node_size);
> mem[r+6]:=mem[p+6]; mem[r+5]:=mem[p+5]; {copy the last two words}
> list_ptr(r):=copy_node_list(list_ptr(p)); {this affects |mem[r+5]|}
> words:=5;
> end;
> rule_node: begin r:=get_node(rule_node_size); words:=rule_node_size;
> end;
> ins_node: begin r:=get_node(ins_node_size); mem[r+4]:=mem[p+4];
> add_glue_ref(split_top_ptr(p));
> ins_ptr(r):=copy_node_list(ins_ptr(p)); {this affects |mem[r+4]|}
> words:=ins_node_size-1;
> end;
3460,3480c3926,3946
< point to it; set |words| to the number of initial words not yet copied@>;
< glue_node: begin r←get_node(small_node_size); add_glue_ref(glue_ptr(p));
< glue_ptr(r)←glue_ptr(p); leader_ptr(r)←copy_node_list(leader_ptr(p));
< end;
< kern_node,math_node,penalty_node: begin r←get_node(small_node_size);
< words←small_node_size;
< end;
< ligature_node: begin r←get_node(small_node_size);
< mem[lig_char(r)]←mem[lig_char(p)]; {copy |font| and |character|}
< lig_ptr(r)←copy_node_list(lig_ptr(p));
< end;
< disc_node: begin r←get_node(small_node_size);
< pre_break(r)←copy_node_list(pre_break(p));
< post_break(r)←copy_node_list(post_break(p));
< end;
< mark_node: begin r←get_node(small_node_size); add_token_ref(mark_ptr(p));
< words←small_node_size;
< end;
< adjust_node: begin r←get_node(small_node_size);
< adjust_ptr(r)←copy_node_list(adjust_ptr(p));
< end;
---
> point to it; set |words| to the number of initial words not yet copied@>;
> glue_node: begin r:=get_node(small_node_size); add_glue_ref(glue_ptr(p));
> glue_ptr(r):=glue_ptr(p); leader_ptr(r):=copy_node_list(leader_ptr(p));
> end;
> kern_node,math_node,penalty_node: begin r:=get_node(small_node_size);
> words:=small_node_size;
> end;
> ligature_node: begin r:=get_node(small_node_size);
> mem[lig_char(r)]:=mem[lig_char(p)]; {copy |font| and |character|}
> lig_ptr(r):=copy_node_list(lig_ptr(p));
> end;
> disc_node: begin r:=get_node(small_node_size);
> pre_break(r):=copy_node_list(pre_break(p));
> post_break(r):=copy_node_list(post_break(p));
> end;
> mark_node: begin r:=get_node(small_node_size); add_token_ref(mark_ptr(p));
> words:=small_node_size;
> end;
> adjust_node: begin r:=get_node(small_node_size);
> adjust_ptr(r):=copy_node_list(adjust_ptr(p));
> end; {|words=1=small_node_size-1|}
3482c3948
< @:confusion copying}{\quad copying@>
---
> @:this can't happen copying}{\quad copying@>
3483a3950
>
3489,3490c3956,3957
< e.g., `\.{\\chcode \`\\\${} = 3}' to make \.{\char'44} a math delimiter,
< and the command code |math_delim| is equal to@@3. Some other codes have
---
> e.g., `\.{\\catcode \`\\\${} = 3}' to make \.{\char'44} a math delimiter,
> and the command code |math_shift| is equal to~3. Some other codes have
3496,3497c3963,3964
< ``chcode'' commands, several of which are used also as ordinary commands
< when the chcode cannot emerge from \TeX's scanning routine.
---
> ``catcode'' commands, several of which share their numeric codes with
> ordinary commands when the catcode cannot emerge from \TeX's scanning routine.
3499,3505c3966,3973
< @d escape=0 {escape delimiter (called \.{\\} in the \TeX\ manual)}
< @d relax=0 { do nothing ( \.{\\relax} )}
< @d left_brace=1 {beginning of a group ( \.{\{} )}
< @d right_brace=2 {ending of a group ( \.{\}} )}
< @d math_delim=3 {mathematics delimiter ( \.{\$} )}
< @d tab_mark=4 {alignment delimiter ( \.{\&}, \.{\\span} )}
< @d car_ret=5 {carriage return ( |carriage_return|, also \.{\\cr} )}
---
> @d escape=0 {escape delimiter (called \.\\ in {\sl The \TeX book\/})}
> @:TeXbook}{\sl The \TeX book@>
> @d relax=0 {do nothing ( \.{\\relax} )}
> @d left_brace=1 {beginning of a group ( \.\{ )}
> @d right_brace=2 {ending of a group ( \.\} )}
> @d math_shift=3 {mathematics shift character ( \.\$ )}
> @d tab_mark=4 {alignment delimiter ( \.\&, \.{\\span} )}
> @d car_ret=5 {end of line ( |carriage_return|, \.{\\cr}, \.{\\crcr} )}
3507c3975
< @d mac_param=6 {macro parameter symbol ( \.{\#} )}
---
> @d mac_param=6 {macro parameter symbol ( \.\# )}
3509,3511c3977,3979
< @d sub_mark=8 {subscript ( \.{\char'176} )}
< @d ignore=9 {characters to ignore ( \.{\^\^J} )}
< @d endv=9 {end of \<v↓j> list in alignment template}
---
> @d sub_mark=8 {subscript ( \.{\char'137} )}
> @d ignore=9 {characters to ignore ( \.{\^\^@@} )}
> @d endv=9 {end of \<v_j> list in alignment template}
3515c3983
< @d active_char=13 {characters that invoke macros ( \.{\^\^[} )}
---
> @d active_char=13 {characters that invoke macros ( \.{\char`\~} )}
3518c3986
< @d end_line=14 {characters that introduce comments ( \.{\char'45} )}
---
> @d comment=14 {characters that introduce comments ( \.\% )}
3520c3988
< @d stop=14 {end of input ( \.{\\end}, \.{\\dump} )}
---
> @d stop=14 {end of job ( \.{\\end}, \.{\\dump} )}
3523c3991
< @d max_char_code=15 {largest chcode for individual characters}
---
> @d max_char_code=15 {largest catcode for individual characters}
3525c3993,3995
< @ Next are the ordinary run-of-the-mill command codes.
---
> @ Next are the ordinary run-of-the-mill command codes. Codes that are
> |min_internal| or more represent internal quantities that might be
> expanded by `\.{\\the}'.
3530,3538c4000,4009
< @d input=19 {input a source file ( \.{\\input} )}
< @d xray=20 {peek inside of \TeX\ ( \.{\\show}, \.{\\showbox}, etc.@@)}
< @d make_box=21 {make a box ( \.{\\box}, \.{\\copy}, \.{\\hbox}, etc.@@)}
< @d hmove=22 {horizontal motion ( \.{\\moveleft}, \.{\\moveright} )}
< @d vmove=23 {vertical motion ( \.{\\raise}, \.{\\lower} )}
< @d unbox=24 {unglue a box ( \.{\\unbox} )}
< @d unskip=25 {nullify glue ( \.{\\unskip} )}
< @d hskip=26 {horizontal glue ( \.{\\hskip}, \.{\\hfil}, etc.@@)}
< @d vskip=27 {vertical glue ( \.{\\vskip}, \.{\\vfil}, etc.@@)}
---
> @d xray=19 {peek inside of \TeX\ ( \.{\\show}, \.{\\showbox}, etc.~)}
> @d make_box=20 {make a box ( \.{\\box}, \.{\\copy}, \.{\\hbox}, etc.~)}
> @d hmove=21 {horizontal motion ( \.{\\moveleft}, \.{\\moveright} )}
> @d vmove=22 {vertical motion ( \.{\\raise}, \.{\\lower} )}
> @d un_hbox=23 {unglue a box ( \.{\\unhbox}, \.{\\unhcopy} )}
> @d un_vbox=24 {unglue a box ( \.{\\unvbox}, \.{\\unvcopy} )}
> @d remove_item=25 {nullify last item ( \.{\\unpenalty},
> \.{\\unkern}, \.{\\unskip} )}
> @d hskip=26 {horizontal glue ( \.{\\hskip}, \.{\\hfil}, etc.~)}
> @d vskip=27 {vertical glue ( \.{\\vskip}, \.{\\vfil}, etc.~)}
3540c4011
< @d kern=29 {fixed space ( \.{kern})}
---
> @d kern=29 {fixed space ( \.{\\kern})}
3542c4013
< @d leader_ship=31 {use a box ( \.{\\shipout}, \.{\\leaders}, etc.@@)}
---
> @d leader_ship=31 {use a box ( \.{\\shipout}, \.{\\leaders}, etc.~)}
3550,3568c4021,4039
< @d ignore_space=39 {gobble |spacer| tokens ( \.{\\ignorespace} )}
< @d break_penalty=40 {additional badness ( \.{\\penalty}, \.{\\dpenalty}@@)}
< @d start_par=41 {begin paragraph ( \.{\\indent}, \.{\\noindent} )}
< @d ital_corr=42 {italic correction ( \.{\\/} )}
< @d accent=43 {attach accent in text ( \.{\\accent} )}
< @d math_accent=44 {attach accent in math ( \.{\\mathaccent} )}
< @d discretionary=45 {discretionary texts ( \.{\\discretionary} )}
< @d eq_no=46 {equation number ( \.{\\eqno}, \.{\\leqno} )}
< @d left_right=47 {variable delimiter ( \.{\\left}, \.{\\right} )}
< @d math_comp=48 {component of formula ( \.{\\mathbin}, etc.@@)}
< @d limit_switch=49 {diddle limit conventions ( \.{\\limitswitch}@@)}
< @d above=50 {generalized fraction ( \.{\\above}, \.{\\atop}, etc.@@)}
< @d math_style=51 {style specification ( \.{\\displaystyle}, etc.@@)}
< @d non_script=52 {conditional math glue ( \.{\\nonscript} )}
< @d vcenter=53 {vertically center a vbox ( \.{\\vcenter} )}
< @d case_shift=54 {force specific case ( \.{\\lowercase}, \.{\\uppercase}@@)}
< @d if_test=55 {select conditional text ( \.{\\if}, \.{\\ifeven}, etc.@@)}
< @d case_branch=56 {choose numbered text ( \.{\\case} )}
< @d else_code=57 {delimiter for conditionals ( \.{\\else} )}
---
> @d ignore_spaces=39 {gobble |spacer| tokens ( \.{\\ignorespaces} )}
> @d after_assignment=40 {save till assignment is done ( \.{\\afterassignment} )}
> @d after_group=41 {save till group is done ( \.{\\aftergroup} )}
> @d break_penalty=42 {additional badness ( \.{\\penalty} )}
> @d start_par=43 {begin paragraph ( \.{\\indent}, \.{\\noindent} )}
> @d ital_corr=44 {italic correction ( \.{\\/} )}
> @d accent=45 {attach accent in text ( \.{\\accent} )}
> @d math_accent=46 {attach accent in math ( \.{\\mathaccent} )}
> @d discretionary=47 {discretionary texts ( \.{\\-}, \.{\\discretionary} )}
> @d eq_no=48 {equation number ( \.{\\eqno}, \.{\\leqno} )}
> @d left_right=49 {variable delimiter ( \.{\\left}, \.{\\right} )}
> @d math_comp=50 {component of formula ( \.{\\mathbin}, etc.~)}
> @d limit_switch=51 {diddle limit conventions ( \.{\\displaylimits}, etc.~)}
> @d above=52 {generalized fraction ( \.{\\above}, \.{\\atop}, etc.~)}
> @d math_style=53 {style specification ( \.{\\displaystyle}, etc.~)}
> @d math_choice=54 {choice specification ( \.{\\mathchoice} )}
> @d non_script=55 {conditional math glue ( \.{\\nonscript} )}
> @d vcenter=56 {vertically center a vbox ( \.{\\vcenter} )}
> @d case_shift=57 {force specific case ( \.{\\lowercase}, \.{\\uppercase}~)}
3570,3581c4041,4055
< @d extension=59 {extensions to \TeX\ ( \.{\\send}, \.{\\open}, etc.@@)}
< @d group_begin=60 {begin local grouping ( \.{\\groupbegin} )}
< @d group_end=61 {end local grouping ( \.{\\groupend} )}
< @d omit=62 {omit alignment template ( \.{\\omit} )}
< @d ex_space=63 {explicit space ( \.{\\\ } )}
< @d radical=64 {square root and similar signs ( \.{\\radical} )}
< @d the=66 {convert to arabic or roman numerals ( \.{\\number} )}
< @d number=65 {read a parameter or register ( \.{\\the}, \.{\\minus} )}
< @d register=67 {read a register ( \.{\\count}, \.{\\dimen}, \.{\\skip} )}
< @d last_skip=68 {most recent glue ( \.{\\lastskip} )}
< @d set_aux=69 {specify state info ( \.{\\spacefactor}, \.{\\prevdepth} )}
< @d max_non_prefixed_command=69 {largest command code that can't be \.{\\global}}
---
> @d extension=59 {extensions to \TeX\ ( \.{\\write}, \.{\\special}, etc.~)}
> @d in_stream=60 {files for reading ( \.{\\openin}, \.{\\closein} )}
> @d begin_group=61 {begin local grouping ( \.{\\begingroup} )}
> @d end_group=62 {end local grouping ( \.{\\endgroup} )}
> @d omit=63 {omit alignment template ( \.{\\omit} )}
> @d ex_space=64 {explicit space ( \.{\\\ } )}
> @d no_boundary=65 {suppress boundary ligatures ( \.{\\noboundary} )}
> @d radical=66 {square root and similar signs ( \.{\\radical} )}
> @d end_cs_name=67 {end control sequence ( \.{\\endcsname} )}
> @d min_internal=68 {the smallest code that can follow \.{\\the}}
> @d char_given=68 {character code defined by \.{\\chardef}}
> @d math_given=69 {math code defined by \.{\\mathchardef}}
> @d last_item=70 {most recent item ( \.{\\lastpenalty},
> \.{\\lastkern}, \.{\\lastskip} )}
> @d max_non_prefixed_command=70 {largest command code that can't be \.{\\global}}
3584a4059,4060
> Codes that are |max_internal| or less represent internal quantities
> that might be expanded by `\.{\\the}'.
3586,3612c4062,4095
< @d assign_toks=70 {special token list ( \.{\\output}, \.{\\everypar} )}
< @d assign_int=71 {user-defined integer ( \.{\\tolerance}, \.{\\day}, etc.@@)}
< @d assign_dimen=72 {user-defined length ( \.{\\hsize}, etc.@@)}
< @d assign_glue=73 {user-defined glue ( \.{\\baselineskip}, etc.@@)}
< @d assign_tex_info=74 {user-defined font parameter ( \.{\\texinfo} )}
< @d hang_indent=75 {specify hanging indentation ( \.{\\hangindent} )}
< @d def_code=76 {define a character code ( \.{\\chcode}, etc.@@)}
< @d def_family=77 {declare math fonts ( \.{\\textfont}, etc.@@)}
< @d set_font=78 {set current font ( \.{\\:} )}
< @d set_family=79 {set current family ( \.{\\fam} )}
< @d prefix=80 {qualify a definition ( \.{\\global}, \.{\\long}, \.{\\outer} )}
< @d let=81 {alternative name for a control sequence ( \.{\\let} )}
< @d def=82 {macro definition ( \.{\\def}, \.{\\gdef}, \.{\\xdef}, \.{\\edef} )}
< @d def_font=83 {define a font file ( \.{\\font} )}
< @d set_register=84 {set a register ( \.{\\setcount}, \.{\\setdimen},
< \.{\\setskip} )}
< @d adv_register=85 {advance a register ( \.{\\advcount}, \.{\\advdimen},
< \.{\\advskip} )}
< @d mult_register=86 {multiply a register ( \.{\\multcount}, \.{\\multdimen},
< \.{\\multskip} )}
< @d div_register=87 {divide a register ( \.{\\divcount}, \.{\\divdimen},
< \.{\\divskip} )}
< @d set_box=88 {set a box ( \.{\\setbox} )}
< @d set_shape=89 {specify fancy paragraph shape ( \.{\\parshape} )}
< @d hyph_data=90 {hyphenation data ( \.{\\hyphenation}, \.{\\patterns} )}
< @d set_interaction=91 {define level of interaction ( \.{\\batchmode}, etc.@@)}
< @d max_command=91 {the largest command code seen at |big_switch|}
---
> @d toks_register=71 {token list register ( \.{\\toks} )}
> @d assign_toks=72 {special token list ( \.{\\output}, \.{\\everypar}, etc.~)}
> @d assign_int=73 {user-defined integer ( \.{\\tolerance}, \.{\\day}, etc.~)}
> @d assign_dimen=74 {user-defined length ( \.{\\hsize}, etc.~)}
> @d assign_glue=75 {user-defined glue ( \.{\\baselineskip}, etc.~)}
> @d assign_mu_glue=76 {user-defined muglue ( \.{\\thinmuskip}, etc.~)}
> @d assign_font_dimen=77 {user-defined font dimension ( \.{\\fontdimen} )}
> @d assign_font_int=78 {user-defined font integer ( \.{\\hyphenchar},
> \.{\\skewchar} )}
> @d set_aux=79 {specify state info ( \.{\\spacefactor}, \.{\\prevdepth} )}
> @d set_prev_graf=80 {specify state info ( \.{\\prevgraf} )}
> @d set_page_dimen=81 {specify state info ( \.{\\pagegoal}, etc.~)}
> @d set_page_int=82 {specify state info ( \.{\\deadcycles},
> \.{\\insertpenalties} )}
> @d set_box_dimen=83 {change dimension of box ( \.{\\wd}, \.{\\ht}, \.{\\dp} )}
> @d set_shape=84 {specify fancy paragraph shape ( \.{\\parshape} )}
> @d def_code=85 {define a character code ( \.{\\catcode}, etc.~)}
> @d def_family=86 {declare math fonts ( \.{\\textfont}, etc.~)}
> @d set_font=87 {set current font ( font identifiers )}
> @d def_font=88 {define a font file ( \.{\\font} )}
> @d register=89 {internal register ( \.{\\count}, \.{\\dimen}, etc.~)}
> @d max_internal=89 {the largest code that can follow \.{\\the}}
> @d advance=90 {advance a register or parameter ( \.{\\advance} )}
> @d multiply=91 {multiply a register or parameter ( \.{\\multiply} )}
> @d divide=92 {divide a register or parameter ( \.{\\divide} )}
> @d prefix=93 {qualify a definition ( \.{\\global}, \.{\\long}, \.{\\outer} )}
> @d let=94 {assign a command code ( \.{\\let}, \.{\\futurelet} )}
> @d shorthand_def=95 {code definition ( \.{\\chardef}, \.{\\countdef}, etc.~)}
> @d read_to_cs=96 {read into a control sequence ( \.{\\read} )}
> @d def=97 {macro definition ( \.{\\def}, \.{\\gdef}, \.{\\xdef}, \.{\\edef} )}
> @d set_box=98 {set a box ( \.{\\setbox} )}
> @d hyph_data=99 {hyphenation data ( \.{\\hyphenation}, \.{\\patterns} )}
> @d set_interaction=100 {define level of interaction ( \.{\\batchmode}, etc.~)}
> @d max_command=100 {the largest command code seen at |big_switch|}
3616c4099,4100
< than |max_command| so that their special nature is easily discernable.
---
> than |max_command| so that their special nature is easily discernible.
> The ``expandable'' commands come first.
3619,3627c4103,4122
< @d top_bot_mark=max_command+2 {inserted mark ( \.{\\topmark}, etc.\ }
< @d call=max_command+3 {non-long, non-outer control sequence}
< @d long_call=max_command+4 {long, non-outer control sequence}
< @d outer_call=max_command+5 {non-long, outer control sequence}
< @d long_outer_call=max_command+6 {long, outer control sequence}
< @d glue_ref=max_command+7 {pointer to a glue specification}
< @d shape_ref=max_command+8 {pointer to a parshape specification}
< @d box_ref=max_command+9 {pointer to a box node, or |null|}
< @d data=max_command+10 {the equivalent is simply a halfword number}
---
> @d expand_after=max_command+2 {special expansion ( \.{\\expandafter} )}
> @d no_expand=max_command+3 {special nonexpansion ( \.{\\noexpand} )}
> @d input=max_command+4 {input a source file ( \.{\\input}, \.{\\endinput} )}
> @d if_test=max_command+5 {conditional text ( \.{\\if}, \.{\\ifcase}, etc.~)}
> @d fi_or_else=max_command+6 {delimiters for conditionals ( \.{\\else}, etc.~)}
> @d cs_name=max_command+7 {make a control sequence from tokens ( \.{\\csname} )}
> @d convert=max_command+8 {convert to text ( \.{\\number}, \.{\\string}, etc.~)}
> @d the=max_command+9 {expand an internal quantity ( \.{\\the} )}
> @d top_bot_mark=max_command+10 {inserted mark ( \.{\\topmark}, etc.~)}
> @d call=max_command+11 {non-long, non-outer control sequence}
> @d long_call=max_command+12 {long, non-outer control sequence}
> @d outer_call=max_command+13 {non-long, outer control sequence}
> @d long_outer_call=max_command+14 {long, outer control sequence}
> @d end_template=max_command+15 {end of an alignment template}
> @d dont_expand=max_command+16 {the following token was marked by \.{\\noexpand}}
> @d glue_ref=max_command+17 {the equivalent points to a glue specification}
> @d shape_ref=max_command+18 {the equivalent points to a parshape specification}
> @d box_ref=max_command+19 {the equivalent points to a box node, or is |null|}
> @d data=max_command+20 {the equivalent is simply a halfword number}
>
3654,3655c4149,4150
< \yskip\noindent The mode is temporarily set to zero while processing \.{\\send}
< texts in the |ship_out| routine.
---
> \yskip\noindent The mode is temporarily set to zero while processing \.{\\write}
> texts in the |ship_out| routine.
3666c4161
< @p procedure print_mode(@!m:integer); {prints the current mode}
---
> @p procedure print_mode(@!m:integer); {prints the mode represented by |m|}
3668,3677c4163,4173
< case m div (max_command+1) of
< 0:print("vertical");
< 1:print("horizontal");
< 2:print("displayed math");
< end
< else case (-m) div (max_command+1) of
< 0:print("internal vertical");
< 1:print("restricted horizontal");
< 2:print("math");
< end;
---
> case m div (max_command+1) of
> 0:print("vertical");
> 1:print("horizontal");
> 2:print("display math");
> end
> else if m=0 then print("no")
> else case (-m) div (max_command+1) of
> 0:print("internal vertical");
> 1:print("restricted horizontal");
> 2:print("math");
> end;
3694c4190
< \yskip\hang|already| is the number of lines of the current paragraph that
---
> \yskip\hang|prev_graf| is the number of lines of the current paragraph that
3697c4193
< \yskip\hang|aux| is an auxiliary integer that gives further information
---
> \yskip\hang|aux| is an auxiliary |memory_word| that gives further information
3703c4199
< calculations, or it is |≤1000|pt if the next box on the vertical list is to
---
> calculations, or it is |<=-1000|pt if the next box on the vertical list is to
3705,3706c4201,4204
< known as |space_factor|; it holds the current space factor use in spacing
< calculations. In math mode, |aux| is also known as |incompleat_noad|; if
---
> known as |space_factor| and |clang|; it holds the current space factor used in
> spacing calculations, and the current language used for hyphenation.
> (The value of |clang| is undefined in restricted horizontal mode.)
> In math mode, |aux| is also known as |incompleat_noad|; if
3711c4209
< There is also a sixth quantity, |mode_line|, which is used to correlate
---
> There is also a sixth quantity, |mode_line|, which correlates
3714c4212
< of this line number is used as the |mode_line| at the level of the
---
> of this line number is the |mode_line| at the level of the
3716a4215,4216
> In horizontal mode, the |prev_graf| field is used for initial language data.
>
3718c4218
< |tail|, |already|, |aux|, and |mode_line| values for all semantic levels
---
> |tail|, |prev_graf|, |aux|, and |mode_line| values for all semantic levels
3720c4220
< level is kept in the global quantities |mode|, |head|, |tail|, |already|,
---
> level is kept in the global quantities |mode|, |head|, |tail|, |prev_graf|,
3727,3730c4227,4231
< @!list_state_record=record@!mode_field:-mmode..mmode;
< @!head_field,@!tail_field: pointer;
< @!already_field,@!aux_field,@!ml_field: integer;
< end;
---
> @!list_state_record=record@!mode_field:-mmode..mmode;@+
> @!head_field,@!tail_field: pointer;
> @!pg_field,@!ml_field: integer;@+
> @!aux_field: memory_word;
> end;
3735c4236
< @d already==cur_list.already_field {number of paragraph lines accumulated}
---
> @d prev_graf==cur_list.pg_field {number of paragraph lines accumulated}
3737,3739c4238,4241
< @d prev_depth==aux {the name of |aux| in vertical mode}
< @d space_factor==aux {the name of |aux| in horizontal mode}
< @d incompleat_noad==aux {the name of |aux| in math mode}
---
> @d prev_depth==aux.sc {the name of |aux| in vertical mode}
> @d space_factor==aux.hh.lh {part of |aux| in horizontal mode}
> @d clang==aux.hh.rh {the other part of |aux| in horizontal mode}
> @d incompleat_noad==aux.int {the name of |aux| in math mode}
3742d4243
<
3752,3753c4253,4254
< @d tail_append(#)==begin link(tail)←#; tail←link(tail);
< end
---
> @d tail_append(#)==begin link(tail):=#; tail:=link(tail);
> end
3764,3766c4265,4268
< nest_ptr←0; max_nest_stack←0;
< mode←vmode; head←contrib_head; tail←contrib_head;
< prev_depth←ignore_depth; mode_line←0; already←0; shown_mode←0;@/
---
> nest_ptr:=0; max_nest_stack:=0;
> mode:=vmode; head:=contrib_head; tail:=contrib_head;
> prev_depth:=ignore_depth; mode_line:=0;
> prev_graf:=0; shown_mode:=0;
3775,3779c4277,4282
< begin max_nest_stack←nest_ptr;
< if nest_ptr=nest_size then overflow("semantic nest size",nest_size);
< end;
< nest[nest_ptr]←cur_list; {stack the record}
< incr(nest_ptr); head←get_avail; tail←head; already←0; mode_line←line;
---
> begin max_nest_stack:=nest_ptr;
> if nest_ptr=nest_size then overflow("semantic nest size",nest_size);
> @:TeX capacity exceeded semantic nest size}{\quad semantic nest size@>
> end;
> nest[nest_ptr]:=cur_list; {stack the record}
> incr(nest_ptr); head:=get_avail; tail:=head; prev_graf:=0; mode_line:=line;
3788c4291
< begin free_avail(head); decr(nest_ptr); cur_list←nest[nest_ptr];
---
> begin free_avail(head); decr(nest_ptr); cur_list:=nest[nest_ptr];
3793c4296,4297
< @p procedure show_activities;
---
> @p procedure@?print_totals; forward;@t\2@>
> procedure show_activities;
3796c4300
< @!a:integer; {auxiliary}
---
> @!a:memory_word; {auxiliary}
3798,3827c4302,4346
< begin nest[nest_ptr]←cur_list; {put the top level into the array}
< print_nl("");
< for p←nest_ptr downto 0 do
< begin m←nest[p].mode_field; a←nest[p].aux_field;
< print_nl("### "); print_mode(m);
< print(" entered at line "); print_int(abs(nest[p].ml_field));
< if nest[p].ml_field<0 then print(" (\output routine)");
< if p=0 then
< begin print_nl("### current page:");
< @<Show the status of the current page@>;
< print_nl("### recent contributions:");
< end;
< show_box(link(nest[p].head_field));
< case abs(m) div (max_command+1) of
< 0: begin print_nl("prevdepth ");
< if a≤ignore_depth then print("ignored")
< else print_scaled(a);
< if nest[p].already_field≠0 then
< begin print(", already ");
< print_int(nest[p].already_field);
< end;
< end;
< 1: begin print_nl("spacefactor "); print_int(a);
< end;
< 2: if a≠null then
< begin print("this will be denominator of:"); show_box(a);
< end;
< end; {there are no other cases}
< end;
< end;
---
> @!t:integer; {ditto}
> begin nest[nest_ptr]:=cur_list; {put the top level into the array}
> print_nl(""); print_ln;
> for p:=nest_ptr downto 0 do
> begin m:=nest[p].mode_field; a:=nest[p].aux_field;
> print_nl("### "); print_mode(m);
> print(" entered at line "); print_int(abs(nest[p].ml_field));
> if m=hmode then if nest[p].pg_field <> @'40600000 then
> begin print(" (language"); print_int(nest[p].pg_field mod @'200000);
> print(":hyphenmin"); print_int(nest[p].pg_field div @'20000000);
> print_char(","); print_int((nest[p].pg_field div @'200000) mod @'100);
> print_char(")");
> end;
> if nest[p].ml_field<0 then print(" (\output routine)");
> if p=0 then
> begin @<Show the status of the current page@>;
> if link(contrib_head)<>null then
> print_nl("### recent contributions:");
> end;
> show_box(link(nest[p].head_field));
> @<Show the auxiliary field, |a|@>;
> end;
> end;
>
> @ @<Show the auxiliary...@>=
> case abs(m) div (max_command+1) of
> 0: begin print_nl("prevdepth ");
> if a.sc<=ignore_depth then print("ignored")
> else print_scaled(a.sc);
> if nest[p].pg_field<>0 then
> begin print(", prevgraf ");
> print_int(nest[p].pg_field); print(" line");
> if nest[p].pg_field<>1 then print_char("s");
> end;
> end;
> 1: begin print_nl("spacefactor "); print_int(a.hh.lh);
> if m>0 then@+ if a.hh.rh>0 then
> begin print(", current language "); print_int(a.hh.rh);@+
> end;
> end;
> 2: if a.int<>null then
> begin print("this will be denominator of:"); show_box(a.int);@+
> end;
> end {there are no other cases}
>
3830,3831c4349,4351
< let us consider the data structures used by its syntactic routines. In
< other words, we turn now to the tables that \TeX\ looks at when it is scanning
---
> we ought to consider the data structures used by its syntactic routines. In
> other words, our next concern will be
> the tables that \TeX\ looks at when it is scanning
3835c4355
< current ``equiv\-a\-lents'' of things; i.e., it explains what things mean
---
> current ``equivalents'' of things; i.e., it explains what things mean
3840c4360
< \yskip\hang 1) |eqtb[single_base..(hash_base-1)]| holds the current
---
> \yskip\hangg 1) |eqtb[active_base..(hash_base-1)]| holds the current
3843,3844c4363,4364
< \yskip\hang 2) |eqtb[hash_base..(glue_base-1)]| holds the current
< equivalents of multi-letter control sequences.
---
> \yskip\hangg 2) |eqtb[hash_base..(glue_base-1)]| holds the current
> equivalents of multiletter control sequences.
3846c4366
< \yskip\hang 3) |eqtb[glue_base..(local_base-1)]| holds the current
---
> \yskip\hangg 3) |eqtb[glue_base..(local_base-1)]| holds the current
3849c4369
< \yskip\hang 4) |eqtb[local_base..(int_base-1)]| holds the current
---
> \yskip\hangg 4) |eqtb[local_base..(int_base-1)]| holds the current
3851c4371
< the current ``chcodes,'' the current font, and a pointer to the current
---
> the current ``catcodes,'' the current font, and a pointer to the current
3854c4374
< \yskip\hang 5) |eqtb[int_base..(dimen_base-1)]| holds the current
---
> \yskip\hangg 5) |eqtb[int_base..(dimen_base-1)]| holds the current
3858,3859c4378,4379
< \yskip\hang 6) |eqtb[dimen_base..eqtb_size]| holds the current equivalents
< of fullword di\-men\-sion parameters like the current hsize or amount of
---
> \yskip\hangg 6) |eqtb[dimen_base..eqtb_size]| holds the current equivalents
> of fullword dimension parameters like the current hsize or amount of
3864c4384
< in region@@3 of |eqtb|, while the current meaning of the control sequence
---
> in region~3 of |eqtb|, while the current meaning of the control sequence
3866c4386
< \.{\\let}) appears in region@@2.
---
> \.{\\let}) appears in region~2.
3871c4391
< \yskip\hang 1) The |eq_level| (a quarterword) is the level of grouping at
---
> \yskip\hangg 1) The |eq_level| (a quarterword) is the level of grouping at
3878c4398
< \yskip\hang 2) The |eq_type| (another quarterword) specifies what kind of
---
> \yskip\hangg 2) The |eq_type| (another quarterword) specifies what kind of
3883c4403
< \yskip\hang 3) The |equiv| (a halfword) is the current equivalent value.
---
> \yskip\hangg 3) The |equiv| (a halfword) is the current equivalent value.
3900,3902c4420,4422
< In the first region we have 128 equivalents for single-character control
< sequences, followed by 128 equivalents for ``active characters'' that
< act as control sequences.
---
> In the first region we have 256 equivalents for ``active characters'' that
> act as control sequences, followed by 256 equivalents for single-character
> control sequences.
3904c4424
< Then comes region@@2, which corresponds to the hash table that we will
---
> Then comes region~2, which corresponds to the hash table that we will
3906,3907c4426,4427
< control sequence that is perpetually undefined. There also are three
< locations for special control sequences that are perpetually defined
---
> control sequence that is perpetually undefined. There also are several
> locations for control sequences that are perpetually defined
3910,3914c4430,4450
< @d single_base=1 {beginning of region 1, for single-letter control sequences}
< @d active_base=single_base+128 {equivalents of active characters}
< @d hash_base=active_base+128 {beginning of region 2, for the hash table}
< @d special_control_sequence=hash_base+hash_size {for error recovery}
< @d undefined_control_sequence=hash_base+hash_size+3 {dummy location}
---
> @d active_base=1 {beginning of region 1, for active character equivalents}
> @d single_base=active_base+256 {equivalents of one-character control sequences}
> @d null_cs=single_base+256 {equivalent of \.{\\csname\\endcsname}}
> @d hash_base=null_cs+1 {beginning of region 2, for the hash table}
> @d frozen_control_sequence=hash_base+hash_size {for error recovery}
> @d frozen_protection=frozen_control_sequence {inaccessible but definable}
> @d frozen_cr=frozen_control_sequence+1 {permanent `\.{\\cr}'}
> @d frozen_end_group=frozen_control_sequence+2 {permanent `\.{\\endgroup}'}
> @d frozen_right=frozen_control_sequence+3 {permanent `\.{\\right}'}
> @d frozen_fi=frozen_control_sequence+4 {permanent `\.{\\fi}'}
> @d frozen_end_template=frozen_control_sequence+5 {permanent `\.{\\endtemplate}'}
> @d frozen_endv=frozen_control_sequence+6 {second permanent `\.{\\endtemplate}'}
> @d frozen_relax=frozen_control_sequence+7 {permanent `\.{\\relax}'}
> @d end_write=frozen_control_sequence+8 {permanent `\.{\\endwrite}'}
> @d frozen_dont_expand=frozen_control_sequence+9
> {permanent `\.{\\notexpanded:}'}
> @d frozen_null_font=frozen_control_sequence+10
> {permanent `\.{\\nullfont}'}
> @d font_id_base=frozen_null_font-font_base
> {begins table of 257 permanent font identifiers}
> @d undefined_control_sequence=frozen_null_font+257 {dummy location}
3918,3922c4454,4469
< eq_type(undefined_control_sequence)←undefined_cs;
< equiv(undefined_control_sequence)←null;
< eq_level(undefined_control_sequence)←level_zero;
< for k←single_base to undefined_control_sequence-1 do
< eqtb[k]←eqtb[undefined_control_sequence];
---
> eq_type(undefined_control_sequence):=undefined_cs;
> equiv(undefined_control_sequence):=null;
> eq_level(undefined_control_sequence):=level_zero;
> for k:=active_base to undefined_control_sequence-1 do
> eqtb[k]:=eqtb[undefined_control_sequence];
>
> @ Here is a routine that displays the current meaning of an |eqtb| entry
> in region 1 or~2. (Similar routines for the other regions will appear
> below.)
>
> @<Show equivalent |n|, in region 1 or 2@>=
> begin sprint_cs(n); print_char("="); print_cmd_chr(eq_type(n),equiv(n));
> if eq_type(n)>=call then
> begin print_char(":"); show_token_list(link(equiv(n)),null,32);
> end;
> end
3925c4472
< glue parameters defined here. It is important that the ``mskip''
---
> glue parameters defined here. It is important that the ``muskip''
3928c4475
< @d line_skip_code=0 {interline glue if |baseline_skip| is unfeasible}
---
> @d line_skip_code=0 {interline glue if |baseline_skip| is infeasible}
3931,3945c4478,4495
< @d disp_skip_code=3 {extra glue just above and below displayed math}
< @d disp_a_skip_code=4 {glue above displayed math following short lines}
< @d disp_b_skip_code=5 {glue below displayed math following short lines}
< @d left_skip_code=6 {glue at left of justified lines}
< @d right_skip_code=7 {glue at right of justified lines}
< @d top_skip_code=8 {glue at top of main pages}
< @d split_top_skip_code=9 {glue at top of split pages}
< @d tab_skip_code=10 {glue between aligned entries}
< @d space_skip_code=11 {glue between words (if not |zero_glue|)}
< @d xspace_skip_code=12 {glue after sentences (if not |zero_glue|)}
< @d par_fill_skip_code=13 {glue on last line of paragraph}
< @d thin_mskip_code=14 {thin space in math formula}
< @d med_mskip_code=15 {medium space in math formula}
< @d thick_mskip_code=16 {thick space in math formula}
< @d glue_pars=17 {total number of glue parameters}
---
> @d above_display_skip_code=3 {extra glue just above displayed math}
> @d below_display_skip_code=4 {extra glue just below displayed math}
> @d above_display_short_skip_code=5
> {glue above displayed math following short lines}
> @d below_display_short_skip_code=6
> {glue below displayed math following short lines}
> @d left_skip_code=7 {glue at left of justified lines}
> @d right_skip_code=8 {glue at right of justified lines}
> @d top_skip_code=9 {glue at top of main pages}
> @d split_top_skip_code=10 {glue at top of split pages}
> @d tab_skip_code=11 {glue between aligned entries}
> @d space_skip_code=12 {glue between words (if not |zero_glue|)}
> @d xspace_skip_code=13 {glue after sentences (if not |zero_glue|)}
> @d par_fill_skip_code=14 {glue on last line of paragraph}
> @d thin_mu_skip_code=15 {thin space in math formula}
> @d med_mu_skip_code=16 {medium space in math formula}
> @d thick_mu_skip_code=17 {thick space in math formula}
> @d glue_pars=18 {total number of glue parameters}
3947c4497,4498
< @d local_base=skip_base+256 {beginning of region 6}
---
> @d mu_skip_base=skip_base+256 {table of 256 ``muskip'' registers}
> @d local_base=mu_skip_base+256 {beginning of region 4}
3949a4501
> @d mu_skip(#)==equiv(mu_skip_base+#) {|mem| location of math glue spec}
3954,3956c4506,4509
< @d disp_skip==glue_par(disp_skip_code)
< @d disp_a_skip==glue_par(disp_a_skip_code)
< @d disp_b_skip==glue_par(disp_b_skip_code)
---
> @d above_display_skip==glue_par(above_display_skip_code)
> @d below_display_skip==glue_par(below_display_skip_code)
> @d above_display_short_skip==glue_par(above_display_short_skip_code)
> @d below_display_short_skip==glue_par(below_display_short_skip_code)
3965,3967c4518,4520
< @d thin_mskip==glue_par(thin_mskip_code)
< @d med_mskip==glue_par(med_mskip_code)
< @d thick_mskip==glue_par(thick_mskip_code)
---
> @d thin_mu_skip==glue_par(thin_mu_skip_code)
> @d med_mu_skip==glue_par(med_mu_skip_code)
> @d thick_mu_skip==glue_par(thick_mu_skip_code)
3981,3983c4534,4537
< disp_skip_code: print_esc("dispskip");
< disp_a_skip_code: print_esc("dispaskip");
< disp_b_skip_code: print_esc("dispbskip");
---
> above_display_skip_code: print_esc("abovedisplayskip");
> below_display_skip_code: print_esc("belowdisplayskip");
> above_display_short_skip_code: print_esc("abovedisplayshortskip");
> below_display_short_skip_code: print_esc("belowdisplayshortskip");
3992,3994c4546,4548
< thin_mskip_code: print_esc("thinmskip");
< med_mskip_code: print_esc("medmskip");
< thick_mskip_code: print_esc("thickmskip");
---
> thin_mu_skip_code: print_esc("thinmuskip");
> med_mu_skip_code: print_esc("medmuskip");
> thick_mu_skip_code: print_esc("thickmuskip");
4004c4558
< primitive("lineskip",assign_glue,line_skip_code);@/
---
> primitive("lineskip",assign_glue,glue_base+line_skip_code);@/
4006c4560
< primitive("baselineskip",assign_glue,baseline_skip_code);@/
---
> primitive("baselineskip",assign_glue,glue_base+baseline_skip_code);@/
4008c4562
< primitive("parskip",assign_glue,par_skip_code);@/
---
> primitive("parskip",assign_glue,glue_base+par_skip_code);@/
4010,4016c4564,4574
< primitive("dispskip",assign_glue,disp_skip_code);@/
< @!@:disp_skip_}{\.{\\dispskip} primitive@>
< primitive("dispaskip",assign_glue,disp_a_skip_code);@/
< @!@:disp_a_skip_}{\.{\\dispaskip} primitive@>
< primitive("dispbskip",assign_glue,disp_b_skip_code);@/
< @!@:disp_b_skip_}{\.{\\dispbskip} primitive@>
< primitive("leftskip",assign_glue,left_skip_code);@/
---
> primitive("abovedisplayskip",assign_glue,glue_base+above_display_skip_code);@/
> @!@:above_display_skip_}{\.{\\abovedisplayskip} primitive@>
> primitive("belowdisplayskip",assign_glue,glue_base+below_display_skip_code);@/
> @!@:below_display_skip_}{\.{\\belowdisplayskip} primitive@>
> primitive("abovedisplayshortskip",
> assign_glue,glue_base+above_display_short_skip_code);@/
> @!@:above_display_short_skip_}{\.{\\abovedisplayshortskip} primitive@>
> primitive("belowdisplayshortskip",
> assign_glue,glue_base+below_display_short_skip_code);@/
> @!@:below_display_short_skip_}{\.{\\belowdisplayshortskip} primitive@>
> primitive("leftskip",assign_glue,glue_base+left_skip_code);@/
4018c4576
< primitive("rightskip",assign_glue,right_skip_code);@/
---
> primitive("rightskip",assign_glue,glue_base+right_skip_code);@/
4020c4578
< primitive("topskip",assign_glue,top_skip_code);@/
---
> primitive("topskip",assign_glue,glue_base+top_skip_code);@/
4022c4580
< primitive("splittopskip",assign_glue,split_top_skip_code);@/
---
> primitive("splittopskip",assign_glue,glue_base+split_top_skip_code);@/
4024c4582
< primitive("tabskip",assign_glue,tab_skip_code);@/
---
> primitive("tabskip",assign_glue,glue_base+tab_skip_code);@/
4026c4584
< primitive("spaceskip",assign_glue,space_skip_code);@/
---
> primitive("spaceskip",assign_glue,glue_base+space_skip_code);@/
4028c4586
< primitive("xspaceskip",assign_glue,xspace_skip_code);@/
---
> primitive("xspaceskip",assign_glue,glue_base+xspace_skip_code);@/
4030c4588
< primitive("parfillskip",assign_glue,par_fill_skip_code);@/
---
> primitive("parfillskip",assign_glue,glue_base+par_fill_skip_code);@/
4032,4037c4590,4595
< primitive("thinmskip",assign_glue,thin_mskip_code);@/
< @!@:thin_mskip_}{\.{\\thinskip} primitive@>
< primitive("medmskip",assign_glue,med_mskip_code);@/
< @!@:med_mskip_}{\.{\\medmskip} primitive@>
< primitive("thickmskip",assign_glue,thick_mskip_code);@/
< @!@:thick_mskip_}{\.{\\thickmskip} primitive@>
---
> primitive("thinmuskip",assign_mu_glue,glue_base+thin_mu_skip_code);@/
> @!@:thin_mu_skip_}{\.{\\thinmuskip} primitive@>
> primitive("medmuskip",assign_mu_glue,glue_base+med_mu_skip_code);@/
> @!@:med_mu_skip_}{\.{\\medmuskip} primitive@>
> primitive("thickmuskip",assign_mu_glue,glue_base+thick_mu_skip_code);@/
> @!@:thick_mu_skip_}{\.{\\thickmuskip} primitive@>
4040c4598,4604
< assign_glue:print_skip_param(chr_code);
---
> assign_glue,assign_mu_glue: if chr_code<skip_base then
> print_skip_param(chr_code-glue_base)
> else if chr_code<mu_skip_base then
> begin print_esc("skip"); print_int(chr_code-skip_base);
> end
> else begin print_esc("muskip"); print_int(chr_code-mu_skip_base);
> end;
4045,4048c4609,4626
< equiv(glue_base)←zero_glue; eq_level(glue_base)←level_one;
< eq_type(glue_base)←glue_ref;
< for k←glue_base+1 to local_base-1 do eqtb[k]←eqtb[glue_base];
< glue_ref_count(zero_glue)←glue_ref_count(zero_glue)+local_base-glue_base;
---
> equiv(glue_base):=zero_glue; eq_level(glue_base):=level_one;
> eq_type(glue_base):=glue_ref;
> for k:=glue_base+1 to local_base-1 do eqtb[k]:=eqtb[glue_base];
> glue_ref_count(zero_glue):=glue_ref_count(zero_glue)+local_base-glue_base;
>
> @ @<Show equivalent |n|, in region 3@>=
> if n<skip_base then
> begin print_skip_param(n-glue_base); print_char("=");
> if n<glue_base+thin_mu_skip_code then print_spec(equiv(n),"pt")
> else print_spec(equiv(n),"mu");
> end
> else if n<mu_skip_base then
> begin print_esc("skip"); print_int(n-skip_base); print_char("=");
> print_spec(equiv(n),"pt");
> end
> else begin print_esc("muskip"); print_int(n-mu_skip_base); print_char("=");
> print_spec(equiv(n),"mu");
> end
4051c4629
< bulk of this region is taken up by five tables that are indexed by seven-bit
---
> bulk of this region is taken up by five tables that are indexed by eight-bit
4054c4632,4633
< token parameters, as well as the table of 256 \.{\\box} registers.
---
> token parameters, as well as the tables of \.{\\toks} and \.{\\box}
> registers.
4059c4638,4646
< @d box_base=local_base+3 {table of 256 box registers}
---
> @d every_math_loc=local_base+3 {points to token list for \.{\\everymath}}
> @d every_display_loc=local_base+4 {points to token list for \.{\\everydisplay}}
> @d every_hbox_loc=local_base+5 {points to token list for \.{\\everyhbox}}
> @d every_vbox_loc=local_base+6 {points to token list for \.{\\everyvbox}}
> @d every_job_loc=local_base+7 {points to token list for \.{\\everyjob}}
> @d every_cr_loc=local_base+8 {points to token list for \.{\\everycr}}
> @d err_help_loc=local_base+9 {points to token list for \.{\\errhelp}}
> @d toks_base=local_base+10 {table of 256 token list registers}
> @d box_base=toks_base+256 {table of 256 box registers}
4062,4068c4649,4655
< @d cur_fam_loc=math_font_base+48 {current font family}
< @d ch_code_base=cur_fam_loc+1 {table of 128 character command codes}
< @d math_code_base=ch_code_base+128 {table of 128 math mode mappings}
< @d lc_code_base=math_code_base+128 {table of 128 lower case mappings}
< @d uc_code_base=lc_code_base+128 {table of 128 upper case mappings}
< @d sf_code_base=uc_code_base+128 {table of 128 space factor mappings}
< @d int_base=sf_code_base+128 {beginning of region 5}
---
> @d cat_code_base=math_font_base+48
> {table of 256 command codes (the ``catcodes'')}
> @d lc_code_base=cat_code_base+256 {table of 256 lowercase mappings}
> @d uc_code_base=lc_code_base+256 {table of 256 uppercase mappings}
> @d sf_code_base=uc_code_base+256 {table of 256 spacefactor mappings}
> @d math_code_base=sf_code_base+256 {table of 256 math mode mappings}
> @d int_base=math_code_base+256 {beginning of region 5}
4072a4660,4667
> @d every_math==equiv(every_math_loc)
> @d every_display==equiv(every_display_loc)
> @d every_hbox==equiv(every_hbox_loc)
> @d every_vbox==equiv(every_vbox_loc)
> @d every_job==equiv(every_job_loc)
> @d every_cr==equiv(every_cr_loc)
> @d err_help==equiv(err_help_loc)
> @d toks(#)==equiv(toks_base+#)
4075d4669
< @d cur_fam==equiv(cur_fam_loc)
4077,4078c4671
< @d ch_code(#)==equiv(ch_code_base+#)
< @d math_code(#)==equiv(math_code_base+#)
---
> @d cat_code(#)==equiv(cat_code_base+#)
4081a4675,4676
> @d math_code(#)==equiv(math_code_base+#)
> {Note: |math_code(c)| is the true math code plus |min_halfword|}
4087a4683,4696
> primitive("everymath",assign_toks,every_math_loc);
> @!@:every_math_}{\.{\\everymath} primitive@>
> primitive("everydisplay",assign_toks,every_display_loc);
> @!@:every_display_}{\.{\\everydisplay} primitive@>
> primitive("everyhbox",assign_toks,every_hbox_loc);
> @!@:every_hbox_}{\.{\\everyhbox} primitive@>
> primitive("everyvbox",assign_toks,every_vbox_loc);
> @!@:every_vbox_}{\.{\\everyvbox} primitive@>
> primitive("everyjob",assign_toks,every_job_loc);
> @!@:every_job_}{\.{\\everyjob} primitive@>
> primitive("everycr",assign_toks,every_cr_loc);
> @!@:every_cr_}{\.{\\everycr} primitive@>
> primitive("errhelp",assign_toks,err_help_loc);
> @!@:err_help_}{\.{\\errhelp} primitive@>
4090,4091c4699,4712
< assign_toks: if chr_code=output_routine_loc then print_esc("output")
< else print_esc("everypar");
---
> assign_toks: if chr_code>=toks_base then
> begin print_esc("toks"); print_int(chr_code-toks_base);
> end
> else case chr_code of
> output_routine_loc: print_esc("output");
> every_par_loc: print_esc("everypar");
> every_math_loc: print_esc("everymath");
> every_display_loc: print_esc("everydisplay");
> every_hbox_loc: print_esc("everyhbox");
> every_vbox_loc: print_esc("everyvbox");
> every_job_loc: print_esc("everyjob");
> every_cr_loc: print_esc("everycr");
> othercases print_esc("errhelp")
> endcases;
4097c4718,4722
< conventional interpretation of ascii code.
---
> conventional interpretation of ASCII code. These initial values should
> not be changed when \TeX\ is adapted for use with non-English languages;
> all changes to the initialization conventions should be made in format
> packages, not in \TeX\ itself, so that global interchange of formats is
> possible.
4099c4724,4725
< @d undefined_font==font_base
---
> @d null_font==font_base
> @d var_code==@'70000 {math code meaning ``use the current family''}
4102,4124c4728,4811
< par_shape_ptr←null; eq_type(par_shape_loc)←shape_ref;
< eq_level(par_shape_loc)←level_one;@/
< eqtb[output_routine_loc]←eqtb[undefined_control_sequence];
< eqtb[every_par_loc]←eqtb[undefined_control_sequence];
< box(0)←null; eq_type(box_base)←box_ref; eq_level(box_base)←level_one;
< for k←box_base+1 to box_base+255 do eqtb[k]←eqtb[box_base];
< cur_font←undefined_font; eq_type(cur_font_loc)←data;
< eq_level(cur_font_loc)←level_one;@/
< for k←math_font_base to math_font_base+47 do eqtb[k]←eqtb[cur_font_loc];
< cur_fam←0; eq_type(cur_fam_loc)←data; eq_level(cur_fam_loc)←level_one;@/
< for k←ch_code_base to int_base-1 do eqtb[k]←eqtb[cur_fam_loc];
< for k←0 to 127 do
< begin ch_code(k)←other_char; math_code(k)←k; sf_code(k)←1000;
< end;
< ch_code(carriage_return)←car_ret; ch_code(" ")←spacer; ch_code("\")←escape;
< ch_code(invalid_code)←invalid_char; ch_code(null_code)←ignore;
< for k←"A" to "Z" do
< begin ch_code(k)←letter; ch_code(k+"a"-"A")←letter;@/
< math_code(k)←k+@'70400; math_code(k+"a"-"A")←k+"a"-"A"+@'70400;@/
< lc_code(k)←k+"a"-"A"; lc_code(k+"a"-"A")←k+"a"-"A";@/
< uc_code(k)←k; uc_code(k+"a"-"A")←k;@/
< sf_code(k)←999;
< end;
---
> par_shape_ptr:=null; eq_type(par_shape_loc):=shape_ref;
> eq_level(par_shape_loc):=level_one;@/
> for k:=output_routine_loc to toks_base+255 do
> eqtb[k]:=eqtb[undefined_control_sequence];
> box(0):=null; eq_type(box_base):=box_ref; eq_level(box_base):=level_one;
> for k:=box_base+1 to box_base+255 do eqtb[k]:=eqtb[box_base];
> cur_font:=null_font; eq_type(cur_font_loc):=data;
> eq_level(cur_font_loc):=level_one;@/
> for k:=math_font_base to math_font_base+47 do eqtb[k]:=eqtb[cur_font_loc];
> equiv(cat_code_base):=0; eq_type(cat_code_base):=data;
> eq_level(cat_code_base):=level_one;@/
> for k:=cat_code_base+1 to int_base-1 do eqtb[k]:=eqtb[cat_code_base];
> for k:=0 to 255 do
> begin cat_code(k):=other_char; math_code(k):=hi(k); sf_code(k):=1000;
> end;
> cat_code(carriage_return):=car_ret; cat_code(" "):=spacer;
> cat_code("\"):=escape; cat_code("%"):=comment;
> cat_code(invalid_code):=invalid_char; cat_code(null_code):=ignore;
> for k:="0" to "9" do math_code(k):=hi(k+var_code);
> for k:="A" to "Z" do
> begin cat_code(k):=letter; cat_code(k+"a"-"A"):=letter;@/
> math_code(k):=hi(k+var_code+@"100);
> math_code(k+"a"-"A"):=hi(k+"a"-"A"+var_code+@"100);@/
> lc_code(k):=k+"a"-"A"; lc_code(k+"a"-"A"):=k+"a"-"A";@/
> uc_code(k):=k; uc_code(k+"a"-"A"):=k;@/
> sf_code(k):=999;
> end;
>
> @ @<Show equivalent |n|, in region 4@>=
> if n=par_shape_loc then
> begin print_esc("parshape"); print_char("=");
> if par_shape_ptr=null then print_char("0")
> else print_int(info(par_shape_ptr));
> end
> else if n<toks_base then
> begin print_cmd_chr(assign_toks,n); print_char("=");
> if equiv(n)<>null then show_token_list(link(equiv(n)),null,32);
> end
> else if n<box_base then
> begin print_esc("toks"); print_int(n-toks_base); print_char("=");
> if equiv(n)<>null then show_token_list(link(equiv(n)),null,32);
> end
> else if n<cur_font_loc then
> begin print_esc("box"); print_int(n-box_base); print_char("=");
> if equiv(n)=null then print("void")
> else begin depth_threshold:=0; breadth_max:=1; show_node_list(equiv(n));
> end;
> end
> else if n<cat_code_base then @<Show the font identifier in |eqtb[n]|@>
> else @<Show the halfword code in |eqtb[n]|@>
>
> @ @<Show the font identifier in |eqtb[n]|@>=
> begin if n=cur_font_loc then print("current font")
> else if n<math_font_base+16 then
> begin print_esc("textfont"); print_int(n-math_font_base);
> end
> else if n<math_font_base+32 then
> begin print_esc("scriptfont"); print_int(n-math_font_base-16);
> end
> else begin print_esc("scriptscriptfont"); print_int(n-math_font_base-32);
> end;
> print_char("=");@/
> print_esc(hash[font_id_base+equiv(n)].rh);
> {that's |font_id_text(equiv(n))|}
> end
>
> @ @<Show the halfword code in |eqtb[n]|@>=
> if n<math_code_base then
> begin if n<lc_code_base then
> begin print_esc("catcode"); print_int(n-cat_code_base);
> end
> else if n<uc_code_base then
> begin print_esc("lccode"); print_int(n-lc_code_base);
> end
> else if n<sf_code_base then
> begin print_esc("uccode"); print_int(n-uc_code_base);
> end
> else begin print_esc("sfcode"); print_int(n-sf_code_base);
> end;
> print_char("="); print_int(equiv(n));
> end
> else begin print_esc("mathcode"); print_int(n-math_code_base);
> print_char("="); print_int(ho(equiv(n)));
> end
4128c4815
< |ch_code..sf_code| tables that precede it, since delimiter codes are
---
> |cat_code..math_code| tables that precede it, since delimiter codes are
4130c4817,4819
< halfword. This is what makes region@@5 different from region 4.
---
> halfword. This is what makes region~5 different from region~4. We will
> store the |eq_level| information in an auxiliary array of quarterwords
> that will be defined later.
4137,4171c4826,4878
< @d widow_penalty_code=5 {penalty for creating a widow line}
< @d display_widow_penalty_code=6 {ditto, just before a display}
< @d broken_penalty_code=7 {penalty for breaking a page at a broken line}
< @d bin_op_penalty_code=8 {penalty for breaking after a binary operation}
< @d rel_penalty_code=9 {penalty for breaking after a relation}
< @d pre_display_penalty_code=10
< {penalty for breaking just before a displayed formula}
< @d post_display_penalty_code=11
< {penalty for breaking just after a displayed formula}
< @d inter_line_penalty_code=12 {additional penalty between lines}
< @d double_hyphen_demerits_code=13 {demerits for double hyphen break}
< @d final_hyphen_demerits_code=14 {demerits for final hyphen break}
< @d adj_demerits_code=15 {demerits for adjacent incompatible lines}
< @d mag_code=16 {magnification ratio}
< @d delimiter_factor_code=17 {ratio for variable-size delimiters}
< @d looseness_code=18 {change in number of lines for a paragraph}
< @d time_code=19 {current time of day}
< @d day_code=20 {current day of the month}
< @d month_code=21 {current month of the year}
< @d year_code=22 {current year of our Lord}
< @d show_box_breadth_code=23 {nodes per level in |show_box|}
< @d show_box_depth_code=24 {maximum level in |show_box|}
< @d hbadness_code=25 {show hboxes exceeding this badness}
< @d vbadness_code=26 {show vboxes exceeding this badness}
< @d pause_code=27 {pause after each line is read from a file}
< @d tracing_online_code=28 {show diagnostic output on terminal}
< @d tracing_macros_code=29 {show macros as they are being expanded}
< @d tracing_stats_code=30 {show memory usage if \TeX\ knows it}
< @d tracing_output_code=31 {show boxes when they are shipped out}
< @d tracing_lost_chars_code=32 {show characters that aren't in the font}
< @d tracing_commands_code=33 {show command codes at |big_switch|}
< @d uc_hyph_code=34 {hyphenate words beginning with a capital letter}
< @d output_penalty_code=35 {penalty found at current page break}
< @d hang_after_code=36 {hanging indentation changes after this many lines}
< @d int_pars=37 {total number of integer parameters}
---
> @d club_penalty_code=5 {penalty for creating a club line}
> @d widow_penalty_code=6 {penalty for creating a widow line}
> @d display_widow_penalty_code=7 {ditto, just before a display}
> @d broken_penalty_code=8 {penalty for breaking a page at a broken line}
> @d bin_op_penalty_code=9 {penalty for breaking after a binary operation}
> @d rel_penalty_code=10 {penalty for breaking after a relation}
> @d pre_display_penalty_code=11
> {penalty for breaking just before a displayed formula}
> @d post_display_penalty_code=12
> {penalty for breaking just after a displayed formula}
> @d inter_line_penalty_code=13 {additional penalty between lines}
> @d double_hyphen_demerits_code=14 {demerits for double hyphen break}
> @d final_hyphen_demerits_code=15 {demerits for final hyphen break}
> @d adj_demerits_code=16 {demerits for adjacent incompatible lines}
> @d mag_code=17 {magnification ratio}
> @d delimiter_factor_code=18 {ratio for variable-size delimiters}
> @d looseness_code=19 {change in number of lines for a paragraph}
> @d time_code=20 {current time of day}
> @d day_code=21 {current day of the month}
> @d month_code=22 {current month of the year}
> @d year_code=23 {current year of our Lord}
> @d show_box_breadth_code=24 {nodes per level in |show_box|}
> @d show_box_depth_code=25 {maximum level in |show_box|}
> @d hbadness_code=26 {hboxes exceeding this badness will be shown by |hpack|}
> @d vbadness_code=27 {vboxes exceeding this badness will be shown by |vpack|}
> @d pausing_code=28 {pause after each line is read from a file}
> @d tracing_online_code=29 {show diagnostic output on terminal}
> @d tracing_macros_code=30 {show macros as they are being expanded}
> @d tracing_stats_code=31 {show memory usage if \TeX\ knows it}
> @d tracing_paragraphs_code=32 {show line-break calculations}
> @d tracing_pages_code=33 {show page-break calculations}
> @d tracing_output_code=34 {show boxes when they are shipped out}
> @d tracing_lost_chars_code=35 {show characters that aren't in the font}
> @d tracing_commands_code=36 {show command codes at |big_switch|}
> @d tracing_restores_code=37 {show equivalents when they are restored}
> @d uc_hyph_code=38 {hyphenate words beginning with a capital letter}
> @d output_penalty_code=39 {penalty found at current page break}
> @d max_dead_cycles_code=40 {bound on consecutive dead cycles of output}
> @d hang_after_code=41 {hanging indentation changes after this many lines}
> @d floating_penalty_code=42 {penalty for insertions heldover after a split}
> @d global_defs_code=43 {override \.{\\global} specifications}
> @d cur_fam_code=44 {current family}
> @d escape_char_code=45 {escape character for token output}
> @d default_hyphen_char_code=46 {value of \.{\\hyphenchar} when a font is loaded}
> @d default_skew_char_code=47 {value of \.{\\skewchar} when a font is loaded}
> @d end_line_char_code=48 {character placed at the right end of the buffer}
> @d new_line_char_code=49 {character that prints as |print_ln|}
> @d language_code=50 {current hyphenation table}
> @d left_hyphen_min_code=51 {minimum left hyphenation fragment size}
> @d right_hyphen_min_code=52 {minimum right hyphenation fragment size}
> @d holding_inserts_code=53 {do not remove insertion nodes from \.{\\box255}}
> @d error_context_lines_code=54 {maximum intermediate line pairs shown}
> @d int_pars=55 {total number of integer parameters}
4173,4174c4880,4881
< @d del_code_base=count_base+256 {128 delimiter code mappings}
< @d dimen_base=del_code_base+128 {beginning of region 6}
---
> @d del_code_base=count_base+256 {256 delimiter code mappings}
> @d dimen_base=del_code_base+256 {beginning of region 6}
4183a4891
> @d club_penalty==int_par(club_penalty_code)
4206c4914
< @d pause==int_par(pause_code)
---
> @d pausing==int_par(pausing_code)
4209a4918,4919
> @d tracing_paragraphs==int_par(tracing_paragraphs_code)
> @d tracing_pages==int_par(tracing_pages_code)
4212a4923
> @d tracing_restores==int_par(tracing_restores_code)
4214a4926
> @d max_dead_cycles==int_par(max_dead_cycles_code)
4216,4219c4928,4944
<
< @<Assign the values |depth_threshold←show_box_depth|...@>=
< depth_threshold←show_box_depth;
< breadth_max←show_box_breadth
---
> @d floating_penalty==int_par(floating_penalty_code)
> @d global_defs==int_par(global_defs_code)
> @d cur_fam==int_par(cur_fam_code)
> @d escape_char==int_par(escape_char_code)
> @d default_hyphen_char==int_par(default_hyphen_char_code)
> @d default_skew_char==int_par(default_skew_char_code)
> @d end_line_char==int_par(end_line_char_code)
> @d new_line_char==int_par(new_line_char_code)
> @d language==int_par(language_code)
> @d left_hyphen_min==int_par(left_hyphen_min_code)
> @d right_hyphen_min==int_par(right_hyphen_min_code)
> @d holding_inserts==int_par(holding_inserts_code)
> @d error_context_lines==int_par(error_context_lines_code)
>
> @<Assign the values |depth_threshold:=show_box_depth|...@>=
> depth_threshold:=show_box_depth;
> breadth_max:=show_box_breadth
4229a4955
> club_penalty_code:print_esc("clubpenalty");
4252c4978
< pause_code:print_esc("pause");
---
> pausing_code:print_esc("pausing");
4255a4982,4983
> tracing_paragraphs_code:print_esc("tracingparagraphs");
> tracing_pages_code:print_esc("tracingpages");
4258a4987
> tracing_restores_code:print_esc("tracingrestores");
4260a4990
> max_dead_cycles_code:print_esc("maxdeadcycles");
4261a4992,5004
> floating_penalty_code:print_esc("floatingpenalty");
> global_defs_code:print_esc("globaldefs");
> cur_fam_code:print_esc("fam");
> escape_char_code:print_esc("escapechar");
> default_hyphen_char_code:print_esc("defaulthyphenchar");
> default_skew_char_code:print_esc("defaultskewchar");
> end_line_char_code:print_esc("endlinechar");
> new_line_char_code:print_esc("newlinechar");
> language_code:print_esc("language");
> left_hyphen_min_code:print_esc("lefthyphenmin");
> right_hyphen_min_code:print_esc("righthyphenmin");
> holding_inserts_code:print_esc("holdinginserts");
> error_context_lines_code:print_esc("errorcontextlines");
4269c5012
< primitive("pretolerance",assign_int,pretolerance_code);@/
---
> primitive("pretolerance",assign_int,int_base+pretolerance_code);@/
4271c5014
< primitive("tolerance",assign_int,tolerance_code);@/
---
> primitive("tolerance",assign_int,int_base+tolerance_code);@/
4273c5016
< primitive("linepenalty",assign_int,line_penalty_code);@/
---
> primitive("linepenalty",assign_int,int_base+line_penalty_code);@/
4275c5018
< primitive("hyphenpenalty",assign_int,hyphen_penalty_code);@/
---
> primitive("hyphenpenalty",assign_int,int_base+hyphen_penalty_code);@/
4277c5020
< primitive("exhyphenpenalty",assign_int,ex_hyphen_penalty_code);@/
---
> primitive("exhyphenpenalty",assign_int,int_base+ex_hyphen_penalty_code);@/
4279c5022,5024
< primitive("widowpenalty",assign_int,widow_penalty_code);@/
---
> primitive("clubpenalty",assign_int,int_base+club_penalty_code);@/
> @!@:club_penalty_}{\.{\\clubpenalty} primitive@>
> primitive("widowpenalty",assign_int,int_base+widow_penalty_code);@/
4281c5026,5027
< primitive("displaywidowpenalty",assign_int,display_widow_penalty_code);@/
---
> primitive("displaywidowpenalty",
> assign_int,int_base+display_widow_penalty_code);@/
4283c5029
< primitive("brokenpenalty",assign_int,broken_penalty_code);@/
---
> primitive("brokenpenalty",assign_int,int_base+broken_penalty_code);@/
4285c5031
< primitive("binoppenalty",assign_int,bin_op_penalty_code);@/
---
> primitive("binoppenalty",assign_int,int_base+bin_op_penalty_code);@/
4287c5033
< primitive("relpenalty",assign_int,rel_penalty_code);@/
---
> primitive("relpenalty",assign_int,int_base+rel_penalty_code);@/
4289c5035
< primitive("predisplaypenalty",assign_int,pre_display_penalty_code);@/
---
> primitive("predisplaypenalty",assign_int,int_base+pre_display_penalty_code);@/
4291c5037
< primitive("postdisplaypenalty",assign_int,post_display_penalty_code);@/
---
> primitive("postdisplaypenalty",assign_int,int_base+post_display_penalty_code);@/
4293c5039
< primitive("interlinepenalty",assign_int,inter_line_penalty_code);@/
---
> primitive("interlinepenalty",assign_int,int_base+inter_line_penalty_code);@/
4295c5041,5042
< primitive("doublehyphendemerits",assign_int,double_hyphen_demerits_code);@/
---
> primitive("doublehyphendemerits",
> assign_int,int_base+double_hyphen_demerits_code);@/
4297c5044,5045
< primitive("finalhyphendemerits",assign_int,final_hyphen_demerits_code);@/
---
> primitive("finalhyphendemerits",
> assign_int,int_base+final_hyphen_demerits_code);@/
4299c5047
< primitive("adjdemerits",assign_int,adj_demerits_code);@/
---
> primitive("adjdemerits",assign_int,int_base+adj_demerits_code);@/
4301c5049
< primitive("mag",assign_int,mag_code);@/
---
> primitive("mag",assign_int,int_base+mag_code);@/
4303c5051
< primitive("delimiterfactor",assign_int,delimiter_factor_code);@/
---
> primitive("delimiterfactor",assign_int,int_base+delimiter_factor_code);@/
4305c5053
< primitive("looseness",assign_int,looseness_code);@/
---
> primitive("looseness",assign_int,int_base+looseness_code);@/
4307c5055
< primitive("time",assign_int,time_code);@/
---
> primitive("time",assign_int,int_base+time_code);@/
4309c5057
< primitive("day",assign_int,day_code);@/
---
> primitive("day",assign_int,int_base+day_code);@/
4311c5059
< primitive("month",assign_int,month_code);@/
---
> primitive("month",assign_int,int_base+month_code);@/
4313c5061
< primitive("year",assign_int,year_code);@/
---
> primitive("year",assign_int,int_base+year_code);@/
4315c5063
< primitive("showboxbreadth",assign_int,show_box_breadth_code);@/
---
> primitive("showboxbreadth",assign_int,int_base+show_box_breadth_code);@/
4317c5065
< primitive("showboxdepth",assign_int,show_box_depth_code);@/
---
> primitive("showboxdepth",assign_int,int_base+show_box_depth_code);@/
4319c5067
< primitive("hbadness",assign_int,hbadness_code);@/
---
> primitive("hbadness",assign_int,int_base+hbadness_code);@/
4321c5069
< primitive("vbadness",assign_int,vbadness_code);@/
---
> primitive("vbadness",assign_int,int_base+vbadness_code);@/
4323,4325c5071,5073
< primitive("pause",assign_int,pause_code);@/
< @!@:pause_}{\.{\\pause} primitive@>
< primitive("tracingonline",assign_int,tracing_online_code);@/
---
> primitive("pausing",assign_int,int_base+pausing_code);@/
> @!@:pausing_}{\.{\\pausing} primitive@>
> primitive("tracingonline",assign_int,int_base+tracing_online_code);@/
4327c5075
< primitive("tracingmacros",assign_int,tracing_macros_code);@/
---
> primitive("tracingmacros",assign_int,int_base+tracing_macros_code);@/
4329c5077
< primitive("tracingstats",assign_int,tracing_stats_code);@/
---
> primitive("tracingstats",assign_int,int_base+tracing_stats_code);@/
4331c5079,5083
< primitive("tracingoutput",assign_int,tracing_output_code);@/
---
> primitive("tracingparagraphs",assign_int,int_base+tracing_paragraphs_code);@/
> @!@:tracing_paragraphs_}{\.{\\tracingparagraphs} primitive@>
> primitive("tracingpages",assign_int,int_base+tracing_pages_code);@/
> @!@:tracing_pages_}{\.{\\tracingpages} primitive@>
> primitive("tracingoutput",assign_int,int_base+tracing_output_code);@/
4333c5085
< primitive("tracinglostchars",assign_int,tracing_lost_chars_code);@/
---
> primitive("tracinglostchars",assign_int,int_base+tracing_lost_chars_code);@/
4335c5087
< primitive("tracingcommands",assign_int,tracing_commands_code);@/
---
> primitive("tracingcommands",assign_int,int_base+tracing_commands_code);@/
4337c5089,5091
< primitive("uchyph",assign_int,uc_hyph_code);@/
---
> primitive("tracingrestores",assign_int,int_base+tracing_restores_code);@/
> @!@:tracing_restores_}{\.{\\tracingrestores} primitive@>
> primitive("uchyph",assign_int,int_base+uc_hyph_code);@/
4339c5093
< primitive("outputpenalty",assign_int,output_penalty_code);@/
---
> primitive("outputpenalty",assign_int,int_base+output_penalty_code);@/
4341c5095,5097
< primitive("hangafter",assign_int,hang_after_code);@/
---
> primitive("maxdeadcycles",assign_int,int_base+max_dead_cycles_code);@/
> @!@:max_dead_cycles_}{\.{\\maxdeadcycles} primitive@>
> primitive("hangafter",assign_int,int_base+hang_after_code);@/
4342a5099,5124
> primitive("floatingpenalty",assign_int,int_base+floating_penalty_code);@/
> @!@:floating_penalty_}{\.{\\floatingpenalty} primitive@>
> primitive("globaldefs",assign_int,int_base+global_defs_code);@/
> @!@:global_defs_}{\.{\\globaldefs} primitive@>
> primitive("fam",assign_int,int_base+cur_fam_code);@/
> @!@:fam_}{\.{\\fam} primitive@>
> primitive("escapechar",assign_int,int_base+escape_char_code);@/
> @!@:escape_char_}{\.{\\escapechar} primitive@>
> primitive("defaulthyphenchar",assign_int,int_base+default_hyphen_char_code);@/
> @!@:default_hyphen_char_}{\.{\\defaulthyphenchar} primitive@>
> primitive("defaultskewchar",assign_int,int_base+default_skew_char_code);@/
> @!@:default_skew_char_}{\.{\\defaultskewchar} primitive@>
> primitive("endlinechar",assign_int,int_base+end_line_char_code);@/
> @!@:end_line_char_}{\.{\\endlinechar} primitive@>
> primitive("newlinechar",assign_int,int_base+new_line_char_code);@/
> @!@:new_line_char_}{\.{\\newlinechar} primitive@>
> primitive("language",assign_int,int_base+language_code);@/
> @!@:language_}{\.{\\language} primitive@>
> primitive("lefthyphenmin",assign_int,int_base+left_hyphen_min_code);@/
> @!@:left_hyphen_min_}{\.{\\lefthyphenmin} primitive@>
> primitive("righthyphenmin",assign_int,int_base+right_hyphen_min_code);@/
> @!@:right_hyphen_min_}{\.{\\righthyphenmin} primitive@>
> primitive("holdinginserts",assign_int,int_base+holding_inserts_code);@/
> @!@:holding_inserts_}{\.{\\holdinginserts} primitive@>
> primitive("errorcontextlines",assign_int,int_base+error_context_lines_code);@/
> @!@:error_context_lines_}{\.{\\errorcontextlines} primitive@>
4345c5127,5129
< assign_int: print_param(chr_code);
---
> assign_int: if chr_code<count_base then print_param(chr_code-int_base)
> else begin print_esc("count"); print_int(chr_code-count_base);
> end;
4349a5134
> @^null delimiter@>
4352,4354c5137,5141
< for k←int_base to del_code_base-1 do eqtb[k].int←0;
< mag←1000; tolerance←10000;
< for k←0 to 127 do del_code(k)←-1;
---
> for k:=int_base to del_code_base-1 do eqtb[k].int:=0;
> mag:=1000; tolerance:=10000; hang_after:=1; max_dead_cycles:=25;
> escape_char:="\"; end_line_char:=carriage_return;
> for k:=0 to 255 do del_code(k):=-1;
> del_code("."):=0; {this null delimiter is used in error recovery}
4364,4367c5151,5180
< begin time←12*60; {minutes since midnight}
< day←4; {fourth day of the month}
< month←7; {seventh month of the year}
< year←1776; {Anno Domini}
---
> begin time:=12*60; {minutes since midnight}
> day:=4; {fourth day of the month}
> month:=7; {seventh month of the year}
> year:=1776; {Anno Domini}
> end;
>
> @ @<Show equivalent |n|, in region 5@>=
> begin if n<count_base then print_param(n-int_base)
> else if n<del_code_base then
> begin print_esc("count"); print_int(n-count_base);
> end
> else begin print_esc("delcode"); print_int(n-del_code_base);
> end;
> print_char("="); print_int(eqtb[n].int);
> end
>
> @ @<Set variable |c| to the current escape character@>=c:=escape_char
>
> @ @<Character |s| is the current new-line character@>=s=new_line_char
>
> @ \TeX\ is occasionally supposed to print diagnostic information that
> goes only into the transcript file, unless |tracing_online| is positive.
> Here are two routines that adjust the destination of print commands:
>
> @p procedure begin_diagnostic; {prepare to do some tracing}
> begin old_setting:=selector;
> if (tracing_online<=0)and(selector=term_and_log) then
> begin decr(selector);
> if history=spotless then history:=warning_issued;
> end;
4368a5182,5194
> @#
> procedure end_diagnostic(@!blank_line:boolean);
> {restore proper conditions after tracing}
> begin print_nl("");
> if blank_line then print_ln;
> selector:=old_setting;
> end;
>
> @ Of course we had better declare another global variable, if the previous
> routines are going to work.
>
> @<Glob...@>=
> @!old_setting:0..max_selector;
4371,4372c5197
< here, and the 256 \.{\\dimen} registers. It also contains the current
< amount of hanging indentation, which is slightly special.
---
> here, and the 256 \.{\\dimen} registers.
4376,4381c5201,5206
< @d var_unit_code=2 {variable unit for dimensions}
< @d line_skip_limit_code=3 {threshold for |line_skip| instead of |baseline_skip|}
< @d hsize_code=4 {line width in horizontal mode}
< @d vsize_code=5 {page height in vertical mode}
< @d max_depth_code=6 {maximum depth of boxes on main pages}
< @d split_max_depth_code=7 {maximum depth of boxes on split pages}
---
> @d line_skip_limit_code=2 {threshold for |line_skip| instead of |baseline_skip|}
> @d hsize_code=3 {line width in horizontal mode}
> @d vsize_code=4 {page height in vertical mode}
> @d max_depth_code=5 {maximum depth of boxes on main pages}
> @d split_max_depth_code=6 {maximum depth of boxes on split pages}
> @d box_max_depth_code=7 {maximum depth of explicit vboxes}
4384c5209
< @d delimiter_limit_code=10 {maximum amount uncovered by variable delimiters}
---
> @d delimiter_shortfall_code=10 {maximum amount uncovered by variable delimiters}
4391,4394c5216,5222
< @d dimen_pars=17 {total number of dimension parameters}
< @d hanging_indent_code=dimen_pars {amount of hanging indentation}
< @d scaled_base=dimen_base+dimen_pars+1
< {table of 256 user-defined \.{\\dimen} registers}
---
> @d hang_indent_code=17 {amount of hanging indentation}
> @d h_offset_code=18 {amount of horizontal offset when shipping pages out}
> @d v_offset_code=19 {amount of vertical offset when shipping pages out}
> @d emergency_stretch_code=20 {reduces badnesses on final pass of line-breaking}
> @d dimen_pars=21 {total number of dimension parameters}
> @d scaled_base=dimen_base+dimen_pars
> {table of 256 user-defined \.{\\dimen} registers}
4401d5228
< @d var_unit==dimen_par(var_unit_code)
4406a5234
> @d box_max_depth==dimen_par(box_max_depth_code)
4409c5237
< @d delimiter_limit==dimen_par(delimiter_limit_code)
---
> @d delimiter_shortfall==dimen_par(delimiter_shortfall_code)
4416c5244,5247
< @d hanging_indent==dimen_par(hanging_indent_code)
---
> @d hang_indent==dimen_par(hang_indent_code)
> @d h_offset==dimen_par(h_offset_code)
> @d v_offset==dimen_par(v_offset_code)
> @d emergency_stretch==dimen_par(emergency_stretch_code)
4422d5252
< var_unit_code:print_esc("varunit");
4427a5258
> box_max_depth_code:print_esc("boxmaxdepth");
4430c5261
< delimiter_limit_code:print_esc("delimiterlimit");
---
> delimiter_shortfall_code:print_esc("delimitershortfall");
4436a5268,5271
> hang_indent_code:print_esc("hangindent");
> h_offset_code:print_esc("hoffset");
> v_offset_code:print_esc("voffset");
> emergency_stretch_code:print_esc("emergencystretch");
4442c5277
< primitive("parindent",assign_dimen,par_indent_code);@/
---
> primitive("parindent",assign_dimen,dimen_base+par_indent_code);@/
4444c5279
< primitive("mathsurround",assign_dimen,math_surround_code);@/
---
> primitive("mathsurround",assign_dimen,dimen_base+math_surround_code);@/
4446,4448c5281
< primitive("varunit",assign_dimen,var_unit_code);@/
< @!@:var_unit_}{\.{\\varunit} primitive@>
< primitive("lineskiplimit",assign_dimen,line_skip_limit_code);@/
---
> primitive("lineskiplimit",assign_dimen,dimen_base+line_skip_limit_code);@/
4450c5283
< primitive("hsize",assign_dimen,hsize_code);@/
---
> primitive("hsize",assign_dimen,dimen_base+hsize_code);@/
4452c5285
< primitive("vsize",assign_dimen,vsize_code);@/
---
> primitive("vsize",assign_dimen,dimen_base+vsize_code);@/
4454c5287
< primitive("maxdepth",assign_dimen,max_depth_code);@/
---
> primitive("maxdepth",assign_dimen,dimen_base+max_depth_code);@/
4456c5289
< primitive("splitmaxdepth",assign_dimen,split_max_depth_code);@/
---
> primitive("splitmaxdepth",assign_dimen,dimen_base+split_max_depth_code);@/
4458c5291,5293
< primitive("hfuzz",assign_dimen,hfuzz_code);@/
---
> primitive("boxmaxdepth",assign_dimen,dimen_base+box_max_depth_code);@/
> @!@:box_max_depth_}{\.{\\boxmaxdepth} primitive@>
> primitive("hfuzz",assign_dimen,dimen_base+hfuzz_code);@/
4460c5295
< primitive("vfuzz",assign_dimen,vfuzz_code);@/
---
> primitive("vfuzz",assign_dimen,dimen_base+vfuzz_code);@/
4462,4464c5297,5301
< primitive("delimiterlimit",assign_dimen,delimiter_limit_code);@/
< @!@:delimiter_limit_}{\.{\\delimiterlimit} primitive@>
< primitive("nulldelimiterspace",assign_dimen,null_delimiter_space_code);@/
---
> primitive("delimitershortfall",
> assign_dimen,dimen_base+delimiter_shortfall_code);@/
> @!@:delimiter_shortfall_}{\.{\\delimitershortfall} primitive@>
> primitive("nulldelimiterspace",
> assign_dimen,dimen_base+null_delimiter_space_code);@/
4466c5303
< primitive("scriptspace",assign_dimen,script_space_code);@/
---
> primitive("scriptspace",assign_dimen,dimen_base+script_space_code);@/
4468c5305
< primitive("predisplaysize",assign_dimen,pre_display_size_code);@/
---
> primitive("predisplaysize",assign_dimen,dimen_base+pre_display_size_code);@/
4470c5307
< primitive("displaywidth",assign_dimen,display_width_code);@/
---
> primitive("displaywidth",assign_dimen,dimen_base+display_width_code);@/
4472c5309
< primitive("displayindent",assign_dimen,display_indent_code);@/
---
> primitive("displayindent",assign_dimen,dimen_base+display_indent_code);@/
4474c5311
< primitive("overfullrule",assign_dimen,overfull_rule_code);@/
---
> primitive("overfullrule",assign_dimen,dimen_base+overfull_rule_code);@/
4475a5313,5320
> primitive("hangindent",assign_dimen,dimen_base+hang_indent_code);@/
> @!@:hang_indent_}{\.{\\hangindent} primitive@>
> primitive("hoffset",assign_dimen,dimen_base+h_offset_code);@/
> @!@:h_offset_}{\.{\\hoffset} primitive@>
> primitive("voffset",assign_dimen,dimen_base+v_offset_code);@/
> @!@:v_offset_}{\.{\\voffset} primitive@>
> primitive("emergencystretch",assign_dimen,dimen_base+emergency_stretch_code);@/
> @!@:emergency_stretch_}{\.{\\emergencystretch} primitive@>
4478c5323,5326
< assign_dimen:print_length_param(chr_code);
---
> assign_dimen: if chr_code<scaled_base then
> print_length_param(chr_code-dimen_base)
> else begin print_esc("dimen"); print_int(chr_code-scaled_base);
> end;
4481c5329,5351
< for k←dimen_base to eqtb_size do eqtb[k].sc←0;
---
> for k:=dimen_base to eqtb_size do eqtb[k].sc:=0;
>
> @ @<Show equivalent |n|, in region 6@>=
> begin if n<scaled_base then print_length_param(n-dimen_base)
> else begin print_esc("dimen"); print_int(n-scaled_base);
> end;
> print_char("="); print_scaled(eqtb[n].sc); print("pt");
> end
>
> @ Here is a procedure that displays the contents of |eqtb[n]|
> symbolically.
>
> @p@t\4@>@<Declare the procedure called |print_cmd_chr|@>@;@/
> @!stat procedure show_eqtb(@!n:pointer);
> begin if n<active_base then print_char("?") {this can't happen}
> else if n<glue_base then @<Show equivalent |n|, in region 1 or 2@>
> else if n<local_base then @<Show equivalent |n|, in region 3@>
> else if n<int_base then @<Show equivalent |n|, in region 4@>
> else if n<dimen_base then @<Show equivalent |n|, in region 5@>
> else if n<=eqtb_size then @<Show equivalent |n|, in region 6@>
> else print_char("?"); {this can't happen either}
> end;
> tats
4488,4489c5358,5359
< @<Globals...@>=
< @!eqtb:array[single_base..eqtb_size] of memory_word;
---
> @<Glob...@>=
> @!eqtb:array[active_base..eqtb_size] of memory_word;
4493c5363
< for k←int_base to eqtb_size do xeq_level[k]←level_one;
---
> for k:=int_base to eqtb_size do xeq_level[k]:=level_one;
4496,4497c5366,5367
< given value, it is interested only in regions 1 to@@3 of@@|eqtb|, and in the
< first part of region@@4.
---
> given value, it is interested only in regions 1 to~3 of~|eqtb|, and in the
> first part of region~4.
4500,4522c5370,5374
< for q←single_base to box_base+255 do
< begin if equiv(q)=p then
< begin print_nl("EQUIV("); print_int(q); print_char(")");
< end;
< end
<
< @ \TeX\ is occasionally supposed to print diagnostic information that
< goes only into the transcript file, unless |tracing_online| is nonzero.
< Here are two routines that adjust the destination of print commands:
<
< @p procedure begin_diagnostic; {prepare to do some tracing}
< begin old_setting←selector; save_offset←offset;
< if (tracing_online=0)∧(selector=term_and_err) then decr(selector);
< end;
< @#
< procedure end_diagnostic; {restore proper conditions after tracing}
< begin if offset>0 then print_ln;
< selector←old_setting;
< if (tracing_online=0)∧(old_setting=term_and_err) then offset←save_offset;
< end;
<
< @ Of course we had better declare two more global variables, if the previous
< routines are going to work.
---
> for q:=active_base to box_base+255 do
> begin if equiv(q)=p then
> begin print_nl("EQUIV("); print_int(q); print_char(")");
> end;
> end
4524,4526d5375
< @<Glob...@>=
< @!old_setting:0..max_selector;
< @!save_offset:0..max_print_line;
4531c5380
< table, it is never removed again, because there are complicated situations
---
> table, it is never removed, because there are complicated situations
4540c5389
< belonging to the same coalesced list as the identifier corresponding to@@|p|;
---
> belonging to the same coalesced list as the identifier corresponding to~|p|;
4542c5391
< |p|'s identifier. If position@@|p| of the hash table is empty, we have
---
> |p|'s identifier. If position~|p| of the hash table is empty, we have
4545,4546c5394,5395
< |hash_used| is maintained in such a way that all locations |p≥hash_used|
< are nonempty. The global variable |cs_count| tells how many multi-letter
---
> |hash_used| is maintained in such a way that all locations |p>=hash_used|
> are nonempty. The global variable |cs_count| tells how many multiletter
4550,4552c5399
< |true| during the time that new hash table entries are forbidden. Another
< global variable, |cs_ptr|, records the position in |eqtb| of the most recently
< found control sequence.
---
> |true| during the time that new hash table entries are forbidden.
4556a5404
> @d font_id_text(#) == text(font_id_base+#) {a frozen font identifier's name}
4558c5406
< @<Globals...@>=
---
> @<Glob...@>=
4560c5408
< {the hash table}
---
> {the hash table}
4563d5410
< @!cs_ptr:pointer; {control sequence found here, zero if none found}
4567,4569c5414,5416
< no_new_control_sequence←true; {new identifiers are usually forbidden}
< next(hash_base)←0; text(hash_base)←0;
< for k←hash_base+1 to undefined_control_sequence-1 do hash[k]←hash[hash_base];
---
> no_new_control_sequence:=true; {new identifiers are usually forbidden}
> next(hash_base):=0; text(hash_base):=0;
> for k:=hash_base+1 to undefined_control_sequence-1 do hash[k]:=hash[hash_base];
4572,4573c5419,5423
< hash_used←special_control_sequence; {nothing is used}
< cs_count←0;
---
> hash_used:=frozen_control_sequence; {nothing is used}
> cs_count:=0;
> eq_type(frozen_dont_expand):=dont_expand;
> text(frozen_dont_expand):="notexpanded:";
> @.notexpanded:@>
4585a5436
> @!d:integer; {number of characters in incomplete current string}
4589,4601c5440,5452
< p←h+hash_base; {we start searching here; note that |0≤h<hash_prime|}
< loop@+begin if (text(p)>0) and (length(text(p))=l) then
< if str_eq_buf(text(p),j) then goto found;
< if next(p)=0 then
< begin if no_new_control_sequence then
< p←undefined_control_sequence
< else @<Insert a new control sequence after |p|, then make
< |p| point to it@>;
< goto found;
< end;
< p←next(p);
< end;
< found: id_lookup←p;
---
> p:=h+hash_base; {we start searching here; note that |0<=h<hash_prime|}
> loop@+begin if text(p)>0 then if length(text(p))=l then
> if str_eq_buf(text(p),j) then goto found;
> if next(p)=0 then
> begin if no_new_control_sequence then
> p:=undefined_control_sequence
> else @<Insert a new control sequence after |p|, then make
> |p| point to it@>;
> goto found;
> end;
> p:=next(p);
> end;
> found: id_lookup:=p;
4606,4614c5457,5469
< begin repeat if hash_is_full then overflow("hash size",hash_size);
< decr(hash_used);
< until text(hash_used)=0; {search for an empty location in |hash|}
< next(p)←hash_used; p←hash_used;
< end;
< str_room(l);
< for k←j to j+l-1 do append_char(buffer[k]);
< text(p)←make_string;
< stat incr(cs_count);@+tats@;@/
---
> begin repeat if hash_is_full then overflow("hash size",hash_size);
> @:TeX capacity exceeded hash size}{\quad hash size@>
> decr(hash_used);
> until text(hash_used)=0; {search for an empty location in |hash|}
> next(p):=hash_used; p:=hash_used;
> end;
> str_room(l); d:=cur_length;
> while pool_ptr>str_start[str_ptr] do
> begin decr(pool_ptr); str_pool[pool_ptr+l]:=str_pool[pool_ptr];
> end; {move current string up to make room for another}
> for k:=j to j+l-1 do append_char(buffer[k]);
> text(p):=make_string; pool_ptr:=pool_ptr+d;
> @!stat incr(cs_count);@+tats@;@/
4617c5472
< @ The value of |hash_prime| should be roughly 85\%\ of |hash_size|, and it
---
> @ The value of |hash_prime| should be roughly 85\pct! of |hash_size|, and it
4619a5475,5476
> [See J.~S. Vitter, {\sl Journal of the ACM\/ \bf30} (1983), 231--258.]
> @^Vitter, Jeffrey Scott@>
4622,4626c5479,5483
< h←buffer[j];
< for k←j+1 to j+l-1 do
< begin h←h+h+buffer[k];
< while h≥hash_prime do h←h-hash_prime;
< end
---
> h:=buffer[j];
> for k:=j+1 to j+l-1 do
> begin h:=h+h+buffer[k];
> while h>=hash_prime do h:=h-hash_prime;
> end
4632,4633c5489,5492
< if it consists entirely of letters. This procedure might be invoked with
< invalid data, so it is ``extra robust''.
---
> unless it is a single nonletter or an active character. This procedure
> might be invoked with invalid data, so it is ``extra robust.'' The
> individual characters must be printed one at a time using |print|, since
> they may be unprintable.
4636c5495
< procedure print_cs(@!p:pointer); {prints a purported control sequence}
---
> procedure print_cs(@!p:integer); {prints a purported control sequence}
4638,4646c5497,5512
< if p≥active_base then print(p-active_base)
< else if p<single_base then print_esc("IMPOSSIBLE.")
< else begin print_esc(p-single_base);
< if ch_code(p)=letter then print_char(" ");
< end
< else if p≥undefined_control_sequence then print_esc("IMPOSSIBLE.")
< else if text(p)=0 then print_esc("NONEXISTENT.")
< else begin print_esc(text(p)); print_char(" ");
< end;
---
> if p>=single_base then
> if p=null_cs then
> begin print_esc("csname"); print_esc("endcsname"); print_char(" ");
> end
> else begin print_esc(p-single_base);
> if cat_code(p-single_base)=letter then print_char(" ");
> end
> else if p<active_base then print_esc("IMPOSSIBLE.")
> @.IMPOSSIBLE@>
> else print(p-active_base)
> else if p>=undefined_control_sequence then print_esc("IMPOSSIBLE.")
> else if (text(p)<0)or(text(p)>=str_ptr) then print_esc("NONEXISTENT.")
> @.NONEXISTENT@>
> else begin print_esc(text(p));
> print_char(" ");
> end;
4652c5518,5519
< @p procedure sprint_cs(@!p:pointer); {prints a control sequence}
---
> @<Basic printing procedures@>=
> procedure sprint_cs(@!p:pointer); {prints a control sequence}
4654,4655c5521,5524
< if p<active_base then print_esc(p-single_base)
< else print(p-active_base)
---
> if p<single_base then print(p-active_base)
> else if p<null_cs then print_esc(p-single_base)
> else begin print_esc("csname"); print_esc("endcsname");
> end
4665c5534
< @p init procedure primitive(@!s:str_number;@!c:quarterword;@!o:halfword);
---
> @p @!init procedure primitive(@!s:str_number;@!c:quarterword;@!o:halfword);
4669,4676c5538,5545
< begin if s<128 then cur_val←s+single_base
< else begin k←str_start[s]; l←str_start[s+1]-k;
< {we will move |s| into the (empty) |buffer|}
< for j←0 to l-1 do buffer[j]←str_pool[k+j];
< cur_val←id_lookup(0,l); {|no_new_control_sequence| is |false|}
< flush_string; text(cur_val)←s; {we don't want to have the string twice}
< end;
< eq_level(cur_val)←level_one; eq_type(cur_val)←c; equiv(cur_val)←o;
---
> begin if s<256 then cur_val:=s+single_base
> else begin k:=str_start[s]; l:=str_start[s+1]-k;
> {we will move |s| into the (empty) |buffer|}
> for j:=0 to l-1 do buffer[j]:=so(str_pool[k+j]);
> cur_val:=id_lookup(0,l); {|no_new_control_sequence| is |false|}
> flush_string; text(cur_val):=s; {we don't want to have the string twice}
> end;
> eq_level(cur_val):=level_one; eq_type(cur_val):=c; equiv(cur_val):=o;
4685,4688c5554,5567
< primitive("relax",relax,0);@/
< @!@:relax_}{\.{\\relax} primitive@>
< primitive("let",let,0);@/
< @!@:let_}{\.{\\let} primitive@>
---
> primitive(" ",ex_space,0);@/
> @!@:Single-character primitives /}{\quad\.{\\\ }@>
> primitive("/",ital_corr,0);@/
> @!@:Single-character primitives /}{\quad\.{\\/}@>
> primitive("accent",accent,0);@/
> @!@:accent_}{\.{\\accent} primitive@>
> primitive("advance",advance,0);@/
> @!@:advance_}{\.{\\advance} primitive@>
> primitive("afterassignment",after_assignment,0);@/
> @!@:after_assignment_}{\.{\\afterassignment} primitive@>
> primitive("aftergroup",after_group,0);@/
> @!@:after_group_}{\.{\\aftergroup} primitive@>
> primitive("begingroup",begin_group,0);@/
> @!@:begin_group_}{\.{\\begingroup} primitive@>
4691,4698c5570,5582
< primitive("mathchar",math_char_num,0);@/
< @!@:math_char_}{\.{\\mathchar} primitive@>
< primitive("mark",mark,0);@/
< @!@:mark_}{\.{\\mark} primitive@>
< primitive("input",input,0);@/
< @!@:input_}{\.{\\input} primitive@>
< primitive("penalty",break_penalty,0);@/
< @!@:penalty_}{\.{\\penalty} primitive@>
---
> primitive("csname",cs_name,0);@/
> @!@:cs_name_}{\.{\\csname} primitive@>
> primitive("delimiter",delim_num,0);@/
> @!@:delimiter_}{\.{\\delimiter} primitive@>
> primitive("divide",divide,0);@/
> @!@:divide_}{\.{\\divide} primitive@>
> primitive("endcsname",end_cs_name,0);@/
> @!@:end_cs_name_}{\.{\\endcsname} primitive@>
> primitive("endgroup",end_group,0);
> @!@:end_group_}{\.{\\endgroup} primitive@>
> text(frozen_end_group):="endgroup"; eqtb[frozen_end_group]:=eqtb[cur_val];@/
> primitive("expandafter",expand_after,0);@/
> @!@:expand_after_}{\.{\\expandafter} primitive@>
4701,4714c5585,5586
< primitive(":",set_font,0);@/
< @!@:Single-character primitives :}{\quad\.{\\:}@>
< primitive("fam",set_family,0);@/
< @!@:fam_}{\.{\\fam} primitive@>
< primitive("number",number,0);@/
< @!@:number_}{\.{\\number} primitive@>
< primitive("setbox",set_box,0);@/
< @!@:set_box_}{\.{\\setbox} primitive@>
< primitive("unbox",unbox,0);@/
< @!@:unbox_}{\.{\\unbox} primitive@>
< primitive("unskip",unskip,0);@/
< @!@:unskip_}{\.{\\unskip} primitive@>
< primitive("lastskip",last_skip,0);@/
< @!@:last_skip_}{\.{\\lastskip} primitive@>
---
> primitive("fontdimen",assign_font_dimen,0);@/
> @!@:font_dimen_}{\.{\\fontdimen} primitive@>
4717,4722d5588
< primitive("valign",valign,0);@/
< @!@:valign_}{\.{\\valign} primitive@>
< primitive("noalign",no_align,0);@/
< @!@:no_align_}{\.{\\noalign} primitive@>
< primitive("vrule",vrule,0);@/
< @!@:vrule_}{\.{\\vrule} primitive@>
4724a5591,5592
> primitive("ignorespaces",ignore_spaces,0);@/
> @!@:ignore_spaces_}{\.{\\ignorespaces} primitive@>
4727,4736c5595,5596
< primitive("vadjust",vadjust,0);@/
< @!@:vadjust_}{\.{\\vadjust} primitive@>
< primitive("ignorespace",ignore_space,0);@/
< @!@:ignore_space_}{\.{\\ignorespace} primitive@>
< primitive("parshape",set_shape,0);@/
< @!@:par_shape_}{\.{\\parshape} primitive@>
< primitive("/",ital_corr,0);@/
< @!@:Single-character primitives /}{\quad\.{\\/}@>
< primitive("accent",accent,0);@/
< @!@:accent_}{\.{\\accent} primitive@>
---
> primitive("mark",mark,0);@/
> @!@:mark_}{\.{\\mark} primitive@>
4739,4744c5599,5610
< primitive("texinfo",assign_tex_info,0);@/
< @!@:tex_info_}{\.{\\texinfo} primitive@>
< primitive("delimiter",delim_num,0);@/
< @!@:delimiter_}{\.{\\delimiter} primitive@>
< primitive("limitswitch",limit_switch,0);@/
< @!@:limit_switch_}{\.{\\limitswitch} primitive@>
---
> primitive("mathchar",math_char_num,0);@/
> @!@:math_char_}{\.{\\mathchar} primitive@>
> primitive("mathchoice",math_choice,0);@/
> @!@:math_choice_}{\.{\\mathchoice} primitive@>
> primitive("multiply",multiply,0);@/
> @!@:multiply_}{\.{\\multiply} primitive@>
> primitive("noalign",no_align,0);@/
> @!@:no_align_}{\.{\\noalign} primitive@>
> primitive("noboundary",no_boundary,0);@/
> @!@:no_boundary_}{\.{\\noboundary} primitive@>
> primitive("noexpand",no_expand,0);@/
> @!@:no_expand_}{\.{\\noexpand} primitive@>
4747,4752d5612
< primitive("vcenter",vcenter,0);@/
< @!@:vcenter_}{\.{\\vcenter} primitive@>
< primitive("case",case_branch,0);@/
< @!@:case_}{\.{\\case} primitive@>
< primitive("else",else_code,0);@/
< @!@:else_}{\.{\\else} primitive@>
4755,4760c5615,5620
< primitive("groupbegin",group_begin,0);@/
< @!@:group_begin_}{\.{\\groupbegin} primitive@>
< primitive("groupend",group_end,0);@/
< @!@:group_end_}{\.{\\groupend} primitive@>
< primitive(" ",ex_space,0);@/
< @!@:Single-character primitives /}{\quad\.{\\\ }@>
---
> primitive("parshape",set_shape,0);@/
> @!@:par_shape_}{\.{\\parshape} primitive@>
> primitive("penalty",break_penalty,0);@/
> @!@:penalty_}{\.{\\penalty} primitive@>
> primitive("prevgraf",set_prev_graf,0);@/
> @!@:prev_graf_}{\.{\\prevgraf} primitive@>
4762a5623,5641
> primitive("read",read_to_cs,0);@/
> @!@:read_}{\.{\\read} primitive@>
> primitive("relax",relax,256); {cf.\ |scan_file_name|}
> @!@:relax_}{\.{\\relax} primitive@>
> text(frozen_relax):="relax"; eqtb[frozen_relax]:=eqtb[cur_val];@/
> primitive("setbox",set_box,0);@/
> @!@:set_box_}{\.{\\setbox} primitive@>
> primitive("the",the,0);@/
> @!@:the_}{\.{\\the} primitive@>
> primitive("toks",toks_register,0);@/
> @!@:toks_}{\.{\\toks} primitive@>
> primitive("vadjust",vadjust,0);@/
> @!@:vadjust_}{\.{\\vadjust} primitive@>
> primitive("valign",valign,0);@/
> @!@:valign_}{\.{\\valign} primitive@>
> primitive("vcenter",vcenter,0);@/
> @!@:vcenter_}{\.{\\vcenter} primitive@>
> primitive("vrule",vrule,0);@/
> @!@:vrule_}{\.{\\vrule} primitive@>
4768c5647
< explained below.
---
> below.
4771,4776c5650,5655
< relax: print_esc("relax");
< let: print_esc("let");
< char_num: print_esc("char");
< math_char_num: print_esc("mathchar");
< mark: print_esc("mark");
< input: print_esc("input");
---
> accent: print_esc("accent");
> advance: print_esc("advance");
> after_assignment: print_esc("afterassignment");
> after_group: print_esc("aftergroup");
> assign_font_dimen: print_esc("fontdimen");
> begin_group: print_esc("begingroup");
4777a5657,5658
> char_num: print_esc("char");
> cs_name: print_esc("csname");
4779,4785c5660,5665
< set_font: print_esc(":");
< set_family: print_esc("fam");
< number: print_esc("number");
< set_box: print_esc("setbox");
< unbox: print_esc("unbox");
< unskip: print_esc("unskip");
< last_skip: print_esc("lastskip");
---
> delim_num: print_esc("delimiter");
> divide: print_esc("divide");
> end_cs_name: print_esc("endcsname");
> end_group: print_esc("endgroup");
> ex_space: print_esc(" ");
> expand_after: print_esc("expandafter");
4787,4789d5666
< valign: print_esc("valign");
< no_align: print_esc("noalign");
< vrule: print_esc("vrule");
4790a5668
> ignore_spaces: print_esc("ignorespaces");
4792,4794d5669
< vadjust: print_esc("vadjust");
< ignore_space: print_esc("ignorespace");
< set_shape: print_esc("parshape");
4796c5671
< accent: print_esc("accent");
---
> mark: print_esc("mark");
4798,4800c5673,5678
< assign_tex_info: print_esc("texinfo");
< delim_num: print_esc("delimiter");
< limit_switch: print_esc("limitswitch");
---
> math_char_num: print_esc("mathchar");
> math_choice: print_esc("mathchoice");
> multiply: print_esc("multiply");
> no_align: print_esc("noalign");
> no_boundary:print_esc("noboundary");
> no_expand: print_esc("noexpand");
4802,4804d5679
< vcenter: print_esc("vcenter");
< case_branch: print_esc("case");
< else_code: print_esc("else");
4806,4808d5680
< group_begin: print_esc("groupbegin");
< group_end: print_esc("groupend");
< ex_space: print_esc(" ");
4810,4813c5682,5696
<
< @ We will deal with the other primitives later, at some point in the program
< where their |eq_type| and |equiv| values are more meaningful. For example,
< the primitives for math mode will be loaded when we consider the routines
---
> read_to_cs: print_esc("read");
> relax: print_esc("relax");
> set_box: print_esc("setbox");
> set_prev_graf: print_esc("prevgraf");
> set_shape: print_esc("parshape");
> the: print_esc("the");
> toks_register: print_esc("toks");
> vadjust: print_esc("vadjust");
> valign: print_esc("valign");
> vcenter: print_esc("vcenter");
> vrule: print_esc("vrule");
>
> @ We will deal with the other primitives later, at some point in the program
> where their |eq_type| and |equiv| values are more meaningful. For example,
> the primitives for math mode will be loaded when we consider the routines
4816c5699
< module where |"radical"| entered |eqtb| is listed under `\.{\\radical}
---
> section where |"radical"| entered |eqtb| is listed under `\.{\\radical}
4819a5703,5709
>
> Meanwhile, this is a convenient place to catch up on something we were unable
> to do before the hash table was defined:
>
> @<Print the font identifier for |font(p)|@>=
> print_esc(font_id_text(font(p)))
>
4821c5711
< The nested structure provided by `$\.{\char'173}\ldotsm\.{\char'175}$' groups
---
> The nested structure provided by `$\.{\char'173}\ldots\.{\char'175}$' groups
4834c5724
< interpreted in one of three ways:
---
> interpreted in one of four ways:
4836c5726
< \yskip\hang 1) If |save_type(p)=restore_old_value|, then
---
> \yskip\hangg 1) If |save_type(p)=restore_old_value|, then
4839c5729
< Furthermore if |save_index(p)≥int_base|, then |save_level(p)|
---
> Furthermore if |save_index(p)>=int_base|, then |save_level(p)|
4842c5732
< \yskip\hang 2) If |save_type(p)=restore_zero|, then |save_index(p)|
---
> \yskip\hangg 2) If |save_type(p)=restore_zero|, then |save_index(p)|
4844c5734,5735
< of the current group and replaced by |eqtb[undefined_control_sequence]|.
---
> of the current group, when it should be
> replaced by the current value of |eqtb[undefined_control_sequence]|.
4846c5737,5741
< \yskip\hang 3) If |save_type(p)=level_boundary|, then |save_level(p)|
---
> \yskip\hangg 3) If |save_type(p)=insert_token|, then |save_index(p)|
> is a token that should be inserted into \TeX's input when the current
> group ends.
>
> \yskip\hangg 4) If |save_type(p)=level_boundary|, then |save_level(p)|
4853c5748
< {saved level for regions 6 and 7, or group code}
---
> {saved level for regions 5 and 6, or group code}
4855c5750
< {|eqtb| location or |save_stack| location}
---
> {|eqtb| location or token or |save_stack| location}
4858c5753,5754
< @d level_boundary=2 {|save_type| corresponding to beginning of group}
---
> @d insert_token=2 {|save_type| when a token is being saved for later use}
> @d level_boundary=3 {|save_type| corresponding to beginning of group}
4866c5762
< the `\.\$' that begins a math formula causes a |math_delim_group| to
---
> the `\.\$' that begins a math formula causes a |math_shift_group| to
4869c5765
< one that starts with \.{\\groupbegin} should end with \.{\\groupend}.
---
> one that starts with \.{\\begingroup} should end with \.{\\endgroup}.
4874,4889c5770,5784
< @d vbox_group=3 {code for `\.{\\vbox}\grp'}
< @d vtop_group=4 {code for `\.{\\vtop}\grp'}
< @d true_group=5 {code for `\.{\\if...}\grp'}
< @d false_group=6 {code for `\.{\\else}\grp'}
< @d case_group=7 {code for `\.{\\case}\grp'}
< @d align_group=8 {code for `\.{\\halign}\grp', `\.{\\valign}\grp'}
< @d no_align_group=9 {code for `\.{\\noalign}\grp'}
< @d output_group=10 {code for output routine}
< @d math_group=11 {code for, e.g, `\.{\char'176}\grp'}
< @d disc_group=12 {code for `\.{\\discretionary}\grp\grp\grp'}
< @d insert_group=13 {code for `\.{\\insert}\grp', `\.{\\vadjust}\grp'}
< @d vcenter_group=14 {code for `\.{\\vcenter}\grp'}
< @d semi_simple_group=15 {code for `\.{\\groupbegin...\\groupend}'}
< @d math_delim_group=16 {code for `\.{\$...\$}'}
< @d math_left_group=17 {code for `\.{\\left...\\right}'}
< @d max_group_code=17
---
> @d adjusted_hbox_group=3 {code for `\.{\\hbox}\grp' in vertical mode}
> @d vbox_group=4 {code for `\.{\\vbox}\grp'}
> @d vtop_group=5 {code for `\.{\\vtop}\grp'}
> @d align_group=6 {code for `\.{\\halign}\grp', `\.{\\valign}\grp'}
> @d no_align_group=7 {code for `\.{\\noalign}\grp'}
> @d output_group=8 {code for output routine}
> @d math_group=9 {code for, e.g., `\.{\char'136}\grp'}
> @d disc_group=10 {code for `\.{\\discretionary}\grp\grp\grp'}
> @d insert_group=11 {code for `\.{\\insert}\grp', `\.{\\vadjust}\grp'}
> @d vcenter_group=12 {code for `\.{\\vcenter}\grp'}
> @d math_choice_group=13 {code for `\.{\\mathchoice}\grp\grp\grp\grp'}
> @d semi_simple_group=14 {code for `\.{\\begingroup...\\endgroup}'}
> @d math_shift_group=15 {code for `\.{\$...\$}'}
> @d math_left_group=16 {code for `\.{\\left...\\right}'}
> @d max_group_code=16
4892c5787
< @!group_code=0..max_group_code; {|save_index| for a level boundary}
---
> @!group_code=0..max_group_code; {|save_level| for a level boundary}
4896,4898c5791,5792
< topmost |level_boundary| word. And |cur_level| is the current depth
< of nesting, not counting |true_group| and |false_group| and |case_group|
< levels. The routines are designed to preserve the condition that no entry
---
> topmost |level_boundary| word. And |cur_level| is the current depth of
> nesting. The routines are designed to preserve the condition that no entry
4901c5795
< @ @<Globals...@>=
---
> @ @<Glob...@>=
4915,4916c5809,5810
< save_ptr←0; cur_level←level_one; cur_group←bottom_level; cur_boundary←0;
< max_save_stack←0;
---
> save_ptr:=0; cur_level:=level_one; cur_group:=bottom_level; cur_boundary:=0;
> max_save_stack:=0;
4923,4925c5817,5820
< begin max_save_stack←save_ptr;
< if max_save_stack>save_size-6 then overflow("save size",save_size);
< end
---
> begin max_save_stack:=save_ptr;
> if max_save_stack>save_size-6 then overflow("save size",save_size);
> @:TeX capacity exceeded save size}{\quad save size@>
> end
4931c5826
< In some cases a few integer-valued items are placed onto the
---
> In some cases integer-valued items are placed onto the
4946,4947c5841,5842
< save_type(save_ptr)←level_boundary; save_level(save_ptr)←cur_group;
< save_index(save_ptr)←cur_boundary;
---
> save_type(save_ptr):=level_boundary; save_level(save_ptr):=cur_group;
> save_index(save_ptr):=cur_boundary;
4949,4951c5844,5847
< max_quarterword-min_quarterword);
< {quit if |(cur_level+1)| is too big to be stored in |eqtb|}
< cur_boundary←save_ptr; incr(cur_level); incr(save_ptr); cur_group←c;
---
> @:TeX capacity exceeded grouping levels}{\quad grouping levels@>
> max_quarterword-min_quarterword);
> {quit if |(cur_level+1)| is too big to be stored in |eqtb|}
> cur_boundary:=save_ptr; incr(cur_level); incr(save_ptr); cur_group:=c;
4956c5852
< to keep in mind that reference counts in |m| include references from
---
> to keep in mind that reference counts in |mem| include references from
4957a5854
> @^reference counts@>
4964,4966c5861,5863
< shape_ref: begin q←equiv_field(w); {we need to free a \.{\\parshape} block}
< if q≠null then free_node(q,link(q)+link(q)+1);
< end;
---
> shape_ref: begin q:=equiv_field(w); {we need to free a \.{\\parshape} block}
> if q<>null then free_node(q,info(q)+info(q)+1);
> end; {such a block is |2n+1| words long, where |n=info(q)|}
4972c5869
< @ To save a value of |eqtb[p]| that was defined at level |l|, we
---
> @ To save a value of |eqtb[p]| that was established at level |l|, we
4977,4981c5874,5878
< if l=level_zero then save_type(save_ptr)←restore_zero
< else begin save_stack[save_ptr]←eqtb[p]; incr(save_ptr);
< save_type(save_ptr)←restore_old_value;
< end;
< save_level(save_ptr)←l; save_index(save_ptr)←p; incr(save_ptr);
---
> if l=level_zero then save_type(save_ptr):=restore_zero
> else begin save_stack[save_ptr]:=eqtb[p]; incr(save_ptr);
> save_type(save_ptr):=restore_old_value;
> end;
> save_level(save_ptr):=l; save_index(save_ptr):=p; incr(save_ptr);
4993c5890
< {new data for |eqtb|}
---
> {new data for |eqtb|}
4996c5893
< eq_level(p)←cur_level; eq_type(p)←t; equiv(p)←e;
---
> eq_level(p):=cur_level; eq_type(p):=t; equiv(p):=e;
5000c5897
< |eqtb| is called |eq_word_define|. Since |xeq_level[p]≥level_one| for all
---
> |eqtb| is called |eq_word_define|. Since |xeq_level[p]>=level_one| for all
5004,5007c5901,5904
< begin if xeq_level[p]≠cur_level then
< begin eq_save(p,xeq_level[p]); xeq_level[p]←cur_level;
< end;
< eqtb[p].int←w;
---
> begin if xeq_level[p]<>cur_level then
> begin eq_save(p,xeq_level[p]); xeq_level[p]:=cur_level;
> end;
> eqtb[p].int:=w;
5012c5909
< Global defi\-ni\-tions are done in almost the same way, but there is no need
---
> Global definitions are done in almost the same way, but there is no need
5016c5913
< {global |eq_define|}
---
> {global |eq_define|}
5018c5915
< eq_level(p)←level_one; eq_type(p)←t; equiv(p)←e;
---
> eq_level(p):=level_one; eq_type(p):=t; equiv(p):=e;
5022c5919
< begin eqtb[p].int←w; xeq_level[p]←level_one;
---
> begin eqtb[p].int:=w; xeq_level[p]:=level_one;
5025,5027c5922,5930
< @ The |unsave| routine goes the other way, taking items off of |save_stack|;
< it is not used when |cur_group| is |true_group|, |false_group|, or |case_group|,
< since those groups are ``transparent'' with respect to their environment.
---
> @ Subroutine |save_for_after| puts a token on the stack for save-keeping.
>
> @p procedure save_for_after(@!t:halfword);
> begin if cur_level>level_one then
> begin check_full_save_stack;
> save_type(save_ptr):=insert_token; save_level(save_ptr):=level_zero;
> save_index(save_ptr):=t; incr(save_ptr);
> end;
> end;
5028a5932
> @ The |unsave| routine goes the other way, taking items off of |save_stack|.
5032c5936,5938
< @p procedure unsave; {pops the top level off the save stack}
---
> @p@t\4@>@<Declare the procedure called |restore_trace|@>@;@/
> procedure@?back_input; forward; @t\2@>
> procedure unsave; {pops the top level off the save stack}
5035a5942
> @!t:halfword; {saved value of |cur_tok|}
5037,5039c5944,5946
< begin decr(cur_level);
< @<Clear off top level from |save_stack|@>;
< end
---
> begin decr(cur_level);
> @<Clear off top level from |save_stack|@>;
> end
5041c5948
< @:confusion curlevel}{\quad curlevel@>
---
> @:this can't happen curlevel}{\quad curlevel@>
5046,5055c5953,5965
< if save_type(save_ptr)=level_boundary then goto done;
< p←save_index(save_ptr);
< if save_type(save_ptr)=restore_old_value then
< begin l←save_level(save_ptr); decr(save_ptr);
< end
< else save_stack[save_ptr]←eqtb[undefined_control_sequence];
< @<Store \(s)|save_stack[save_ptr]| in |eqtb[p]|, unless
< |eqtb[p]| holds a global value@>;
< end;
< done: cur_group←save_level(save_ptr); cur_boundary←save_index(save_ptr)
---
> if save_type(save_ptr)=level_boundary then goto done;
> p:=save_index(save_ptr);
> if save_type(save_ptr)=insert_token then
> @<Insert token |p| into \TeX's input@>
> else begin if save_type(save_ptr)=restore_old_value then
> begin l:=save_level(save_ptr); decr(save_ptr);
> end
> else save_stack[save_ptr]:=eqtb[undefined_control_sequence];
> @<Store \(s)|save_stack[save_ptr]| in |eqtb[p]|, unless
> |eqtb[p]| holds a global value@>;
> end;
> end;
> done: cur_group:=save_level(save_ptr); cur_boundary:=save_index(save_ptr)
5065,5090c5975,6018
< if eq_level(p)=level_one then
< eq_destroy(save_stack[save_ptr]) {destroy the saved value}
< else begin eq_destroy(eqtb[p]); {destroy the current value}
< eqtb[p]←save_stack[save_ptr]; {restore the saved value}
< end
< else if xeq_level[p]≠level_one then
< begin eqtb[p]←save_stack[save_ptr]; xeq_level[p]←l;
< end
<
< @ When a |true_group| or one of its relatives comes to an end, we merely
< want to delete the top |level_boundary| word, restoring the former
< values of |cur_group| and |cur_boundary|. The |leave_transparent_group|
< routine does this.
<
< @p procedure leave_transparent_group;
< var j,@!k:0..save_size; {indices into |save_stack|}
< begin j←save_index(cur_boundary); cur_group←save_level(cur_boundary);
< if save_ptr>1 then
< for k←cur_boundary to save_ptr-2 do save_stack[k]←save_stack[k+1];
< decr(save_ptr); cur_boundary←j;
< end;
<
< @ The magnification parameter should not be varied during a \TeX\ job, since
< a single magnification is applied to an entire run. The global variable
< |mag_set| is set to the current magnification whenever it becomes necessary
< to ``freeze'' the magnification at a particular value.
---
> if eq_level(p)=level_one then
> begin eq_destroy(save_stack[save_ptr]); {destroy the saved value}
> @!stat if tracing_restores>0 then restore_trace(p,"retaining");@+tats@;@/
> end
> else begin eq_destroy(eqtb[p]); {destroy the current value}
> eqtb[p]:=save_stack[save_ptr]; {restore the saved value}
> @!stat if tracing_restores>0 then restore_trace(p,"restoring");@+tats@;@/
> end
> else if xeq_level[p]<>level_one then
> begin eqtb[p]:=save_stack[save_ptr]; xeq_level[p]:=l;
> @!stat if tracing_restores>0 then restore_trace(p,"restoring");@+tats@;@/
> end
> else begin
> @!stat if tracing_restores>0 then restore_trace(p,"retaining");@+tats@;@/
> end
>
> @ @<Declare the procedure called |restore_trace|@>=
> @!stat procedure restore_trace(@!p:pointer;@!s:str_number);
> {|eqtb[p]| has just been restored or retained}
> begin begin_diagnostic; print_char("{"); print(s); print_char(" ");
> show_eqtb(p); print_char("}");
> end_diagnostic(false);
> end;
> tats
>
> @ When looking for possible pointers to a memory location, it is helpful
> to look for references from |eqtb| that might be waiting on the
> save stack. Of course, we might find spurious pointers too; but this
> routine is merely an aid when debugging, and at such times we are
> grateful for any scraps of information, even if they prove to be irrelevant.
> @^dirty \PASCAL@>
>
> @<Search |save_stack| for equivalents that point to |p|@>=
> if save_ptr>0 then for q:=0 to save_ptr-1 do
> begin if equiv_field(save_stack[q])=p then
> begin print_nl("SAVE("); print_int(q); print_char(")");
> end;
> end
>
> @ Most of the parameters kept in |eqtb| can be changed freely, but there's
> an exception: The magnification should not be used with two different
> values during any \TeX\ job, since a single magnification is applied to an
> entire run. The global variable |mag_set| is set to the current magnification
> whenever it becomes necessary to ``freeze'' it at a particular value.
5096c6024
< mag_set←0;
---
> mag_set:=0;
5102,5103c6030,6031
< begin if (mag_set>0)∧(mag≠mag_set) then
< begin print_nl("! Incompatible magnification ("); print_int(mag);
---
> begin if (mag_set>0)and(mag<>mag_set) then
> begin print_err("Incompatible magnification ("); print_int(mag);
5105,5112c6033,6040
< print("); the previous value will be retained");
< help2("I can handle only one magnification ratio per job. So I've")@/
< ("reverted to the magnification you used earlier on this run.");@/
< int_error(mag_set);
< geq_word_define(int_base+mag_code,mag_set); {|mag←mag_set|}
< end;
< if (mag≤0)∨(mag>32768) then
< begin print_nl("! Illegal magnification has been changed to 1000");@/
---
> print(");"); print_nl(" the previous value will be retained");
> help2("I can handle only one magnification ratio per job. So I've")@/
> ("reverted to the magnification you used earlier on this run.");@/
> int_error(mag_set);
> geq_word_define(int_base+mag_code,mag_set); {|mag:=mag_set|}
> end;
> if (mag<=0)or(mag>32768) then
> begin print_err("Illegal magnification has been changed to 1000");@/
5114,5117c6042,6045
< help1("The magnification ratio must be between 1 and 32768.");
< int_error(mag); geq_word_define(int_base+mag_code,1000);
< end;
< mag_set←mag;
---
> help1("The magnification ratio must be between 1 and 32768.");
> int_error(mag); geq_word_define(int_base+mag_code,1000);
> end;
> mag_set:=mag;
5118a6047
>
5122,5128c6051,6057
< represented internally in one of two ways: (1)@@A character whose ascii code
< number is |c| and whose command code is |m| is represented as the
< number $2^8m+c$; the command code is in the range
< |1≤m≤14|. (2)@@A control sequence whose |eqtb| address is |p| is
< represented as the number |cs_token_flag+p|. Here |cs_token_flag=@t$2^{12}$@>|
< is larger than $2^8m+c$, yet it is small enough that |cs_token_flag+p<
< max_halfword|; thus, a token fits comfortably in a halfword.
---
> represented internally in one of two ways: (1)~A character whose ASCII
> code number is |c| and whose command code is |m| is represented as the
> number $2^8m+c$; the command code is in the range |1<=m<=14|. (2)~A control
> sequence whose |eqtb| address is |p| is represented as the number
> |cs_token_flag+p|. Here |cs_token_flag=@t$2^{12}-1$@>| is larger than
> $2^8m+c$, yet it is small enough that |cs_token_flag+p< max_halfword|;
> thus, a token fits comfortably in a halfword.
5132,5133c6061,6062
< we have |left_brace_limit≤t<right_brace_limit|; and it represents a |match| or
< |end_match| command if and only if |match_token≤t≤end_match_token|.
---
> we have |left_brace_limit<=t<right_brace_limit|; and it represents a |match| or
> |end_match| command if and only if |match_token<=t<=end_match_token|.
5137,5138c6066,6067
< @d cs_token_flag==@'10000 {amount added to the |eqtb| location in a
< token that stands for a control sequence}
---
> @d cs_token_flag==@'7777 {amount added to the |eqtb| location in a
> token that stands for a control sequence; is a multiple of~256, less~1}
5143c6072,6073
< @d math_delim_token=@'1400 {$2^8\cdot|math_delim|$}
---
> @d math_shift_token=@'1400 {$2^8\cdot|math_shift|$}
> @d tab_token=@'2000 {$2^8\cdot|tab_mark|$}
5145d6074
< @d endv_token=@'4400 {$2^8\cdot|endv|$}
5153c6082
< if cs_token_flag+undefined_control_sequence>max_halfword then bad←21;
---
> if cs_token_flag+undefined_control_sequence>max_halfword then bad:=21;
5157,5158c6086,6088
< definitions, marks, and \.{\\send} texts are kept in \TeX's memory in the
< form of token lists, preceded by a node that has a reference count in its
---
> definitions, marks, \.{\\write} texts, and a few other things
> are remembered by \TeX\ in the form
> of token lists, usually preceded by a node with a reference count in its
5180c6110
< |letter|\,\.{\\b}, |end_match|,\cr
---
> \.{\\b}, |end_match|,\cr
5185c6115
< does the param\-eter matching.
---
> does the parameter matching.
5208c6138
< An additional parameter |q| is also given; this parameter is either zero
---
> An additional parameter |q| is also given; this parameter is either null
5210c6140
< takes place that will be explained later. (Basically, |q| is nonzero when
---
> takes place that will be explained later. (Basically, |q| is non-null when
5222c6152
< of printing exceeds a given limit@@|l|. Anomalous entries are printed in the
---
> of printing exceeds a given limit~|l|. Anomalous entries are printed in the
5231,5239c6161,6170
< @!match_chr:ascii_code; {character used in a `|match|'}
< @!n:ascii_code; {the highest parameter number, as an ascii digit}
< begin match_chr←"#"; n←"0"; tally←0;
< while (p≠null) and (tally<l) do
< begin if p=q then @<Do magic computation@>;
< @<Display token |p|, and |return| if there are problems@>;
< p←link(p);
< end;
< if p≠null then print_esc("ETC.");
---
> @!match_chr:ASCII_code; {character used in a `|match|'}
> @!n:ASCII_code; {the highest parameter number, as an ASCII digit}
> begin match_chr:="#"; n:="0"; tally:=0;
> while (p<>null) and (tally<l) do
> begin if p=q then @<Do magic computation@>;
> @<Display token |p|, and |return| if there are problems@>;
> p:=link(p);
> end;
> if p<>null then print_esc("ETC.");
> @.ETC@>
5244,5251c6175,6184
< if (p<hi_mem_base) or (p>mem_end) then
< begin print_esc("CLOBBERED."); return;
< end;
< if info(p)≥cs_token_flag then print_cs(info(p)-cs_token_flag)
< else begin m←info(p) div @'400; c←info(p) mod @'400;
< if (info(p)<0)∨(c>127) then print_esc("BAD.")
< else @<Display the token $(|m|,|c|)$@>;
< end
---
> if (p<hi_mem_min) or (p>mem_end) then
> begin print_esc("CLOBBERED."); return;
> @.CLOBBERED@>
> end;
> if info(p)>=cs_token_flag then print_cs(info(p)-cs_token_flag)
> else begin m:=info(p) div @'400; c:=info(p) mod @'400;
> if info(p)<0 then print_esc("BAD.")
> @.BAD@>
> else @<Display the token $(|m|,|c|)$@>;
> end
5254c6187
< param\-eters by seeing one in a |match| command before it runs into any
---
> parameters by seeing one in a |match| command before it runs into any
5259,5266c6192,6193
< right_brace,math_delim,tab_mark,sup_mark,sub_mark,spacer,
< letter,other_char: print(c);
< left_brace:begin if (link(p)≥hi_mem_base)∧(link(p)≤mem_end) then
< if info(link(p)) div @'400=end_match then
< print(match_chr);
< print(c);
< end;
< endv:print_esc("ENDTEMPLATE.");
---
> left_brace,right_brace,math_shift,tab_mark,sup_mark,sub_mark,spacer,
> letter,other_char: print(c);
5268c6195
< end;
---
> end;
5270,5276c6197,6203
< if c≤9 then print_char(c+"0")
< else begin print_char("!"); return;
< end;
< end;
< match: begin match_chr←c; print(c); incr(n); print_char(n);
< if n>"9" then return;
< end;
---
> if c<=9 then print_char(c+"0")
> else begin print_char("!"); return;
> end;
> end;
> match: begin match_chr:=c; print(c); incr(n); print_char(n);
> if n>"9" then return;
> end;
5277a6205
> @.->@>
5278a6207
> @.BAD@>
5285,5286c6214,6228
< begin if p=null then print("(null)")
< else show_token_list(link(p),null,1000);
---
> begin if p<>null then show_token_list(link(p),null,10000000);
> end;
>
> @ The |print_meaning| subroutine displays |cur_cmd| and |cur_chr| in
> symbolic form, including the expansion of a macro or mark.
>
> @p procedure print_meaning;
> begin print_cmd_chr(cur_cmd,cur_chr);
> if cur_cmd>=call then
> begin print_char(":"); print_ln; token_show(cur_chr);
> end
> else if cur_cmd=top_bot_mark then
> begin print_char(":"); print_ln;
> token_show(cur_mark[cur_chr]);
> end;
5287a6230
>
5303,5308c6246,6255
< sets the value of two variables |cur_cmd| and |cur_chr|, representing
< the next input token.
< $$\lpile{\hbox{|cur_cmd| denotes a command code from the long list of codes
< given above;}\cr
< \hbox{|cur_chr| denotes a character code or other modifier of the command
< code.}\cr}$$
---
> sets the value of three variables |cur_cmd|, |cur_chr|, and |cur_cs|,
> representing the next input token.
> $$\vbox{\halign{#\hfil\cr
> \hbox{|cur_cmd| denotes a command code from the long list of codes
> given above;}\cr
> \hbox{|cur_chr| denotes a character code or other modifier of the command
> code;}\cr
> \hbox{|cur_cs| is the |eqtb| location of the current control sequence,}\cr
> \hbox{\qquad if the current token was a control sequence,
> otherwise it's zero.}\cr}}$$
5331,5332c6278,6279
< @<Globals...@>=
< @!cur_cmd : eight_bits; {current command set by |get_next|}
---
> @<Glob...@>=
> @!cur_cmd: eight_bits; {current command set by |get_next|}
5334c6281,6282
< @!cur_tok:halfword; {packed representative of |cur_cmd| and |cur_chr|}
---
> @!cur_cs: pointer; {control sequence found here, zero if none found}
> @!cur_tok: halfword; {packed representative of |cur_cmd| and |cur_chr|}
5347,5348c6295,6296
< @d chr_cmd(#)==begin print(#); print_ascii(chr_code);
< end
---
> @d chr_cmd(#)==begin print(#); print_ASCII(chr_code);
> end
5350c6298,6299
< @p procedure print_cmd_chr(@!cmd:quarterword;@!chr_code:halfword);
---
> @<Declare the procedure called |print_cmd_chr|@>=
> procedure print_cmd_chr(@!cmd:quarterword;@!chr_code:halfword);
5354,5357c6303
< math_delim: chr_cmd("math mode character ");
< tab_mark: if chr_code=128 then print_esc("span") {|span_code=128|}
< else chr_cmd("alignment tab character ");
< car_ret: print_esc("cr");
---
> math_shift: chr_cmd("math shift character ");
5362c6308
< spacer: print("blank space");
---
> spacer: chr_cmd("blank space ");
5368a6315,6326
>
> @ Here is a procedure that displays the current command.
>
> @p procedure show_cur_cmd_chr;
> begin begin_diagnostic; print_nl("{");
> if mode<>shown_mode then
> begin print_mode(mode); print(": "); shown_mode:=mode;
> end;
> print_cmd_chr(cur_cmd,cur_chr); print_char("}");
> end_diagnostic(false);
> end;
>
5369a6328
> This implementation of
5373c6332
< \yskip\hang 1) If there is frequent access to the top entry, and if the
---
> \yskip\hangg 1) If there is frequent access to the top entry, and if the
5380c6339
< \yskip\hang 2) If there is infrequent top access, the entire stack contents
---
> \yskip\hangg 2) If there is infrequent top access, the entire stack contents
5388c6347
< convention@@(1), so it is declared in the following way:
---
> convention~(1), so it is declared in the following way:
5391,5394c6350,6353
< @!in_state_record = record
< @!state_field, @!index_field: quarterword;
< @!start_field,@!loc_field, @!limit_field, @!name_field: halfword;
< end;
---
> @!in_state_record = record
> @!state_field, @!index_field: quarterword;
> @!start_field,@!loc_field, @!limit_field, @!name_field: halfword;
> end;
5396c6355
< @ @<Globals...@>=
---
> @ @<Glob...@>=
5401c6360
< {the ``top'' input state, according to convention (1)}
---
> {the ``top'' input state, according to convention (1)}
5403c6362
< @ We've already defined the special variables |@!loc==cur_input.loc_field|
---
> @ We've already defined the special variable |loc==cur_input.loc_field|
5405c6364
< the |cur_input| are defined in the same way:
---
> |cur_input| are defined in the same way:
5413,5414c6372,6373
< @ Let's look more closely now at the six control variables
< (|state|,@@|index|,@@|start|,@@|loc|,@@|limit|,@@|name|),
---
> @ Let's look more closely now at the control variables
> (|state|,~|index|,~|start|,~|loc|,~|limit|,~|name|),
5419,5420c6378,6379
< levels of the input stack that are not yet completed. We will return to
< the other lines when we are finished with the present input file.
---
> levels of the input stack that are not yet completed. \TeX\ will return to
> the other lines when it is finished with the present input file.
5422c6381
< (Incidentally, on a machine with byte-oriented addressing, it would be
---
> (Incidentally, on a machine with byte-oriented addressing, it might be
5430,5431c6389,6390
< the line has been completely read. Usually |buffer[limit]| is a
< |carriage_return| character, denoting the end of a line, but this is not
---
> the line has been completely read. Usually |buffer[limit]| is the
> |end_line_char|, denoting the end of a line, but this is not
5433c6392
< terminal in response to an error message.
---
> terminal in response to an error message.
5436,5437c6395,6399
< the current file, if we are reading a text file; it is zero if we
< are reading from the terminal.
---
> the current file, if we are reading a text file. It is zero if we
> are reading from the terminal; it is |n+1| if we are reading from
> input stream |n|, where |0<=n<=16|. (Input stream 16 stands for
> an invalid stream number; in such cases the input is actually from
> the terminal, under control of the procedure |read_toks|.)
5463,5464c6425,6426
< stack come from token lists. For example, the instruction `\.{\\input paper}'
< might occur in a token list.
---
> stack may come from token lists. For example, the instruction `\.{\\input
> paper}' might occur in a token list.
5466c6428
< The variable |in_open| is equal to the |index|
---
> The global variable |in_open| is equal to the |index|
5471,5474c6433,6436
< If we are not currently reading from the terminal, we are reading from the
< file variable |input_file[index]|. We use the notation |terminal_input| as
< a convenient abbreviation for |name=0|, and |cur_file| as an abbreviation
< for |input_file[index]|.
---
> If we are not currently reading from the terminal, or from an input
> stream, we are reading from the file variable |input_file[index]|. We use
> the notation |terminal_input| as a convenient abbreviation for |name=0|,
> and |cur_file| as an abbreviation for |input_file[index]|.
5480c6442,6444
< file has been read.
---
> file has been read. Line numbers should never be negative, since the
> negative of the current line number is used to identify the user's output
> routine in the |mode_line| field of the semantic nest entries.
5486c6450
< `\unskip|@!page_stack:array[0..max_in_open] of integer|'
---
> `\ignorespaces|@!page_stack:array[1..max_in_open] of integer|\unskip'
5493c6457
< @<Globals...@>=
---
> @<Glob...@>=
5494a6459
> @!open_parens : 0..max_in_open; {the number of open text files}
5497c6462
< @!line_stack : array[0..max_in_open] of integer;
---
> @!line_stack : array[1..max_in_open] of integer;
5505c6470
< when a subfile ends. This variable has five possible values:
---
> when a subfile ends. This variable has six possible values:
5520a6486,6488
> \yskip\hang|absorbing|, means that a subfile shouldn't end now because we are
> reading a balanced token list for \.{\\message}, \.{\\write}, etc.
>
5529a6498
> @d absorbing=5 {|scanner_status| when reading a balanced text}
5531,5532c6500,6501
< @<Globals...@>=
< @!scanner_status : normal..aligning; {can a subfile end now?}
---
> @<Glob...@>=
> @!scanner_status : normal..absorbing; {can a subfile end now?}
5533a6503
> @!def_ref : pointer; {reference count of token list being defined}
5542,5552c6512,6525
< begin print_nl("Runaway ");
< case scanner_status of
< defining: begin print("definition?"); p←temp_head;
< end;
< matching: begin print("argument?"); p←temp_head;
< end;
< aligning: begin print("preamble?"); p←hold_head;
< end;
< end; {there are no other cases}
< print_ln; show_token_list(link(p),null,error_line-10);
< end;
---
> begin print_nl("Runaway ");
> @.Runaway...@>
> case scanner_status of
> defining: begin print("definition"); p:=def_ref;
> end;
> matching: begin print("argument"); p:=temp_head;
> end;
> aligning: begin print("preamble"); p:=hold_head;
> end;
> absorbing: begin print("text"); p:=def_ref;
> end;
> end; {there are no other cases}
> print_char("?");print_ln; show_token_list(link(p),null,error_line-10);
> end;
5585c6558
< \hang|u_template|, if the \<u↓j> part of an alignment
---
> \hang|u_template|, if the \<u_j> part of an alignment
5588c6561
< \hang|v_template|, if the \<v↓j> part of an alignment
---
> \hang|v_template|, if the \<v_j> part of an alignment
5590a6564,6566
> \hang|backed_up|, if the token list being scanned has been inserted as
> `to be read again'.
>
5592,5593c6568
< `to be read again' or as the text expansion of a \.{\\count} or similar
< variable;
---
> the text expansion of a \.{\\count} or similar variable;
5601c6576,6582
< \hang|mark_text|, if the text of a \.{\\mark} is being scanned.
---
> \hang|every_math_text|, if the text of \.{\\everymath} is being scanned;
>
> \hang|every_display_text|, if the text of \.{\\everydisplay} is being scanned;
>
> \hang|every_hbox_text|, if the text of \.{\\everyhbox} is being scanned;
>
> \hang|every_vbox_text|, if the text of \.{\\everyvbox} is being scanned;
5603c6584,6590
< \hang|send_text|, if the text of a \.{\\send} is being scanned.
---
> \hang|every_job_text|, if the text of \.{\\everyjob} is being scanned;
>
> \hang|every_cr_text|, if the text of \.{\\everycr} is being scanned;
>
> \hang|mark_text|, if the text of a \.{\\mark} is being scanned;
>
> \hang|write_text|, if the text of a \.{\\write} is being scanned.
5606,5607c6593,6596
< The token list begins with a reference count if and only if |token_type≥
< macro|.
---
> The codes for |output_text|, |every_par_text|, etc., are equal to a constant
> plus the corresponding codes for token list parameters |output_routine_loc|,
> |every_par_loc|, etc. The token list begins with a reference count if and
> only if |token_type>=macro|.
5614,5621c6603,6617
< @d u_template=1 {|token_type| code for \<u↓j> template}
< @d v_template=2 {|token_type| code for \<v↓j> template}
< @d inserted=3 {|token_type| code for short inserted texts}
< @d macro=4 {|token_type| code for defined control sequences}
< @d output_text=5 {|token_type| code for output routines}
< @d every_par_text=6 {|token_type| code for \.{\\everypar}}
< @d mark_text=7 {|token_type| code for \.{\\topmark}, etc.}
< @d send_text=8 {|token_type| code for \.{\\send}}
---
> @d u_template=1 {|token_type| code for \<u_j> template}
> @d v_template=2 {|token_type| code for \<v_j> template}
> @d backed_up=3 {|token_type| code for text to be reread}
> @d inserted=4 {|token_type| code for inserted texts}
> @d macro=5 {|token_type| code for defined control sequences}
> @d output_text=6 {|token_type| code for output routines}
> @d every_par_text=7 {|token_type| code for \.{\\everypar}}
> @d every_math_text=8 {|token_type| code for \.{\\everymath}}
> @d every_display_text=9 {|token_type| code for \.{\\everydisplay}}
> @d every_hbox_text=10 {|token_type| code for \.{\\everyhbox}}
> @d every_vbox_text=11 {|token_type| code for \.{\\everyvbox}}
> @d every_job_text=12 {|token_type| code for \.{\\everyjob}}
> @d every_cr_text=13 {|token_type| code for \.{\\everycr}}
> @d mark_text=14 {|token_type| code for \.{\\topmark}, etc.}
> @d write_text=15 {|token_type| code for \.{\\write}}
5628c6624
< @<Globals...@>=
---
> @<Glob...@>=
5630c6626
< {token list pointers for parameters}
---
> {token list pointers for parameters}
5633c6629
< {largest value of |param_ptr|, will be |≤param_size+9|}
---
> {largest value of |param_ptr|, will be |<=param_size+9|}
5638,5642c6634,6638
< \<v↓j> template text in the scanner. This magic is accomplished by an
< |align_state| variable that is increased by@@1 when a `\.{\char'173}' is
< scanned and decreased by@@1 when a `\.{\char'175}' is scanned. The |align_state|
< is nonzero during the \<u↓j> template, after which it is set to zero; the
< \<v↓j> template begins when a tab mark or \.{\\cr} occurs at a time that
---
> \<v_j> template text in the scanner. This magic is accomplished by an
> |align_state| variable that is increased by~1 when a `\.{\char'173}' is
> scanned and decreased by~1 when a `\.{\char'175}' is scanned. The |align_state|
> is nonzero during the \<u_j> template, after which it is set to zero; the
> \<v_j> template begins when a tab mark or \.{\\cr} occurs at a time that
5645c6641
< @<Globals...@>=
---
> @<Glob...@>=
5648c6644
< @ Thus, the ``current input state'' can be very complicated indeed, since there
---
> @ Thus, the ``current input state'' can be very complicated indeed; there
5663,5664c6659,6660
< at most |error_line|. Input levels whose |token_type| is `|inserted|'
< are shown only if they have not been fully read.
---
> at most |error_line|. Non-current input levels whose |token_type| is
> `|backed_up|' are shown only if they have not been fully read.
5668a6665,6666
> @!nn:integer; {number of contexts shown so far, less one}
> @!bottom_line:boolean; {have we reached the final context to be shown?}
5670,5678c6668,6682
< begin base_ptr←input_ptr; input_stack[base_ptr]←cur_input;
< {store current state}
< loop@+begin cur_input←input_stack[base_ptr]; {enter into the context}
< @<Display the current context@>;
< if (state≠token_list) then
< if (not terminal_input) or (base_ptr=0) then goto done;
< decr(base_ptr);
< end;
< done: cur_input←input_stack[input_ptr]; {restore original state}
---
> begin base_ptr:=input_ptr; input_stack[base_ptr]:=cur_input;
> {store current state}
> nn:=-1; bottom_line:=false;
> loop@+begin cur_input:=input_stack[base_ptr]; {enter into the context}
> if (state<>token_list) then
> if (name>17) or (base_ptr=0) then bottom_line:=true;
> if (base_ptr=input_ptr)or bottom_line or(nn<error_context_lines) then
> @<Display the current context@>
> else if nn=error_context_lines then
> begin print_nl("..."); incr(nn); {omitted if |error_context_lines<0|}
> end;
> if bottom_line then goto done;
> decr(base_ptr);
> end;
> done: cur_input:=input_stack[input_ptr]; {restore original state}
5682,5695c6686,6702
< if (state≠token_list) or (token_type≠inserted) or (loc≠null) then
< {we omit inserted token lists that have already been read}
< begin tally←0; {get ready to count characters}
< old_setting←selector;
< if state≠token_list then
< begin @<Print location of current line@>;
< @<Pseudoprint the line@>;
< end
< else begin @<Print type of token list@>;
< @<Pseudoprint the token list@>;
< end;
< selector←old_setting; {stop pseudoprinting}
< @<Print two lines using the tricky pseudoprinted information@>;
< end
---
> begin if (base_ptr=input_ptr) or (state<>token_list) or
> (token_type<>backed_up) or (loc<>null) then
> {we omit backed-up token lists that have already been read}
> begin tally:=0; {get ready to count characters}
> old_setting:=selector;
> if state<>token_list then
> begin @<Print location of current line@>;
> @<Pseudoprint the line@>;
> end
> else begin @<Print type of token list@>;
> @<Pseudoprint the token list@>;
> end;
> selector:=old_setting; {stop pseudoprinting}
> @<Print two lines using the tricky pseudoprinted information@>;
> incr(nn);
> end;
> end
5703,5706c6710,6719
< if terminal_input then
< if base_ptr=0 then print_nl("<*>") else print_nl("<**>")
< else begin print_nl("l."); print_int(line);
< end;
---
> if name<=17 then
> if terminal_input then
> if base_ptr=0 then print_nl("<*>") else print_nl("<insert> ")
> else begin print_nl("<read ");
> if name=17 then print_char("*")@+else print_int(name-1);
> @.*\relax@>
> print_char(">");
> end
> else begin print_nl("l."); print_int(line);
> end;
5713c6726,6728
< inserted: print_nl("<to be read again> ");
---
> backed_up: if loc=null then print_nl("<recently read> ")
> else print_nl("<to be read again> ");
> inserted: print_nl("<inserted text> ");
5715c6730
< end;
---
> end;
5717a6733,6738
> every_math_text: print_nl("<everymath> ");
> every_display_text: print_nl("<everydisplay> ");
> every_hbox_text: print_nl("<everyhbox> ");
> every_vbox_text: print_nl("<everyvbox> ");
> every_job_text: print_nl("<everyjob> ");
> every_cr_text: print_nl("<everycr> ");
5719c6740
< send_text: print_nl("<send> ");
---
> write_text: print_nl("<write> ");
5728c6749
< that stores char\-acters into a buffer of length |error_line|, where character
---
> that stores characters into a buffer of length |error_line|, where character
5731c6752
< |tally←0| and |trick_count←1000000|; then when we reach the
---
> |tally:=0| and |trick_count:=1000000|; then when we reach the
5733c6754
< set |first_count←tally| and |trick_count←@tmax@>(error_line,
---
> set |first_count:=tally| and |trick_count:=@tmax@>(error_line,
5742c6763
< gathered for line@@2 is $m=\min(|tally|, |trick_count|)-k$. If |l+k≤h|,
---
> gathered for line~2 is $m=\min(|tally|, |trick_count|)-k$. If |l+k<=h|,
5744,5745c6765,6766
< descriptive information on line@@1, and set |n←l+k|; here |n| is the
< length of line@@1. If $l+k>h$, some cropping is necessary, so we set |n←h|
---
> descriptive information on line~1, and set |n:=l+k|; here |n| is the
> length of line~1. If $l+k>h$, some cropping is necessary, so we set |n:=h|
5749c6770
< second line consists of |n|@@spaces followed by |trick_buf[k..(k+m-1)]|,
---
> second line consists of |n|~spaces followed by |trick_buf[k..(k+m-1)]|,
5766,5768c6787,6789
< begin l←tally; tally←0; selector←pseudo;
< trick_count←1000000;
< end
---
> begin l:=tally; tally:=0; selector:=pseudo;
> trick_count:=1000000;
> end
5770,5773c6791,6794
< begin first_count←tally;
< trick_count←tally+1+error_line-half_error_line;
< if trick_count<error_line then trick_count←error_line;
< end
---
> begin first_count:=tally;
> trick_count:=tally+1+error_line-half_error_line;
> if trick_count<error_line then trick_count:=error_line;
> end
5779,5788c6800,6809
< {|set_trick_count| must be performed}
< if tally<trick_count then m←tally-first_count
< else m←trick_count-first_count; {context on line 2}
< if l+first_count≤half_error_line then
< begin p←0; n←l+first_count;
< end
< else begin print("..."); p←l+first_count-half_error_line+3;
< n←half_error_line;
< end;
< for q←p to first_count-1 do print_char(trick_buf[q mod error_line]);
---
> {|set_trick_count| must be performed}
> if tally<trick_count then m:=tally-first_count
> else m:=trick_count-first_count; {context on line 2}
> if l+first_count<=half_error_line then
> begin p:=0; n:=l+first_count;
> end
> else begin print("..."); p:=l+first_count-half_error_line+3;
> n:=half_error_line;
> end;
> for q:=p to first_count-1 do print_char(trick_buf[q mod error_line]);
5790,5792c6811,6813
< for q←1 to n do print_char(" "); {print |n| spaces to begin line@@2}
< if m+n≤error_line then p←first_count+m else p←first_count+(error_line-n-3);
< for q←first_count to p-1 do print_char(trick_buf[q mod error_line]);
---
> for q:=1 to n do print_char(" "); {print |n| spaces to begin line~2}
> if m+n<=error_line then p:=first_count+m else p:=first_count+(error_line-n-3);
> for q:=first_count to p-1 do print_char(trick_buf[q mod error_line]);
5801,5806c6822,6827
< if buffer[limit]=carriage_return then j←limit
< else j←limit+1; {determine the effective end of the line}
< if j>0 then for i←start to j-1 do
< begin if i=loc then set_trick_count;
< print(buffer[i]);
< end
---
> if buffer[limit]=end_line_char then j:=limit
> else j:=limit+1; {determine the effective end of the line}
> if j>0 then for i:=start to j-1 do
> begin if i=loc then set_trick_count;
> print(buffer[i]);
> end
5814c6835
< token beginning line@@2 is about to be shown:
---
> token beginning line~2 is about to be shown:
5816a6838
>
5823,5830c6845,6853
< @p procedure push_input; {enter a new input level, save the old}
< begin if input_ptr>max_in_stack then
< begin max_in_stack←input_ptr;
< if input_ptr=stack_size then overflow("input stack size",stack_size);
< end;
< input_stack[input_ptr]←cur_input; {stack the record}
< incr(input_ptr);
< end;
---
> @d push_input==@t@> {enter a new input level, save the old}
> begin if input_ptr>max_in_stack then
> begin max_in_stack:=input_ptr;
> if input_ptr=stack_size then overflow("input stack size",stack_size);
> @:TeX capacity exceeded input stack size}{\quad input stack size@>
> end;
> input_stack[input_ptr]:=cur_input; {stack the record}
> incr(input_ptr);
> end
5834,5836c6857,6859
< @p procedure pop_input; {leave an input level, re-enter the old}
< begin decr(input_ptr); cur_input←input_stack[input_ptr];
< end;
---
> @d pop_input==@t@> {leave an input level, re-enter the old}
> begin decr(input_ptr); cur_input:=input_stack[input_ptr];
> end
5841a6865
> @d back_list(#)==begin_token_list(#,backed_up) {backs up a simple token list}
5845,5850c6869,6885
< begin push_input; state←token_list; start←p; token_type←t;
< if t≥macro then {the token list starts with a reference count}
< begin add_token_ref(p);
< if t=macro then param_start←param_ptr@+else loc←link(p);
< end
< else loc←p;
---
> begin push_input; state:=token_list; start:=p; token_type:=t;
> if t>=macro then {the token list starts with a reference count}
> begin add_token_ref(p);
> if t=macro then param_start:=param_ptr
> else begin loc:=link(p);
> if tracing_macros>1 then
> begin begin_diagnostic; print_nl("");
> case t of
> mark_text:print_esc("mark");
> write_text:print_esc("write");
> othercases print_cmd_chr(assign_toks,t-output_text+output_routine_loc)
> endcases;@/
> print("->"); token_show(p); end_diagnostic(false);
> end;
> end;
> end
> else loc:=p;
5854c6889,6891
< should be done as we leave that level of input.
---
> should be done as we leave that level of input. The |token_type| tends
> to be equal to either |backed_up| or |inserted| about 2/3 of the time.
> @^inner loop@>
5857,5867c6894,6907
< begin if token_type≥inserted then {token list to be deleted}
< begin if token_type=inserted then flush_list(start)
< else begin delete_token_ref(start); {update reference count}
< if token_type=macro then {parameters must be flushed}
< while param_ptr>param_start do
< begin decr(param_ptr);
< flush_list(param_stack[param_ptr]);
< end;
< end;
< end
< else if token_type=u_template then align_state←0;
---
> begin if token_type>=backed_up then {token list to be deleted}
> begin if token_type<=inserted then flush_list(start)
> else begin delete_token_ref(start); {update reference count}
> if token_type=macro then {parameters must be flushed}
> while param_ptr>param_start do
> begin decr(param_ptr);
> flush_list(param_stack[param_ptr]);
> end;
> end;
> end
> else if token_type=u_template then
> if align_state>500000 then align_state:=0
> else fatal_error("(interwoven alignment preambles are not allowed)");
> @.interwoven alignment preambles...@>
5872c6912
< @ Sometimes \TeX\ has read too far and it wants to ``unscan'' what it has
---
> @ Sometimes \TeX\ has read too far and wants to ``unscan'' what it has
5876c6916,6918
< replaced.
---
> replaced. Some applications of \TeX\ use this procedure a lot,
> so it has been slightly optimized for speed.
> @^inner loop@>
5880c6922,6924
< begin p←get_avail; info(p)←cur_tok;
---
> begin while (state=token_list)and(loc=null)and(token_type<>v_template) do
> end_token_list; {conserve stack space}
> p:=get_avail; info(p):=cur_tok;
5882,5884c6926,6929
< if cur_tok<left_brace_limit then decr(align_state)
< else incr(align_state);
< ins_list(p);
---
> if cur_tok<left_brace_limit then decr(align_state)
> else incr(align_state);
> push_input; state:=token_list; start:=p; token_type:=backed_up;
> loc:=p; {that was |back_list(p)|, without procedure overhead}
5886a6932,6935
> @ @<Insert token |p| into \TeX's input@>=
> begin t:=cur_tok; cur_tok:=p; back_input; cur_tok:=t;
> end
>
5889c6938,6939
< requires that |cur_tok| has been set.
---
> requires that |cur_tok| has been set. We disable interrupts during the
> call of |back_input| so that the help message won't be lost.
5892c6942,6947
< begin back_input; error;
---
> begin OK_to_interrupt:=false; back_input; OK_to_interrupt:=true; error;
> end;
> @#
> procedure ins_error; {back up one inserted token and call |error|}
> begin OK_to_interrupt:=false; back_input; token_type:=inserted;
> OK_to_interrupt:=true; error;
5902a6958
> @:TeX capacity exceeded text input levels}{\quad text input levels@>
5904,5906c6960,6963
< incr(in_open); push_input; index←in_open;
< line_stack[index]←line; start←first; state←mid_line;
< name←0; {|terminal_input| is now |true|}
---
> @:TeX capacity exceeded buffer size}{\quad buffer size@>
> incr(in_open); push_input; index:=in_open;
> line_stack[index]:=line; start:=first; state:=mid_line;
> name:=0; {|terminal_input| is now |true|}
5913,5914c6970,6971
< begin first←start; line←line_stack[index];
< if not terminal_input then a_close(cur_file); {forget it}
---
> begin first:=start; line:=line_stack[index];
> if name>17 then a_close(cur_file); {forget it}
5923,5924c6980,6981
< begin while (state≠token_list)∧ terminal_input ∧@|
< (input_ptr>0)∧(loc>limit) do end_file_reading;
---
> begin while (state<>token_list)and terminal_input and@|
> (input_ptr>0)and(loc>limit) do end_file_reading;
5932,5937c6989,6996
< begin input_ptr←0; max_in_stack←0;
< in_open←0; max_buf_stack←0;
< param_ptr←0; max_param_stack←0;
< scanner_status←normal; first←0;
< state←new_line; start←0; index←0; line←0; name←0;
< align_state←1000000;@/
---
> begin input_ptr:=0; max_in_stack:=0;
> in_open:=0; open_parens:=0; max_buf_stack:=0;
> param_ptr:=0; max_param_stack:=0;
> first:=buf_size; repeat buffer[first]:=0; decr(first); until first=0;
> scanner_status:=normal; warning_index:=null; first:=1;
> state:=new_line; start:=1; index:=0; line:=0; name:=0;
> force_eof:=false;
> align_state:=1000000;@/
5939,5940c6998
< {|init_terminal| sets |loc| and |last|}
< limit←last; first←last+1;
---
> limit:=last; first:=last+1; {|init_terminal| has set |loc| and |last|}
5941a7000
>
5944,5947c7003,7007
< we shall develop in the next few paragraphs. Perhaps we shouldn't actually
< call it the ``heart,'' however, because it really acts as \TeX's eyes and
< mouth, reading the source files and gobbling them up. And it also helps
< \TeX\ to regurgitate stored token lists that are to be processed again.
---
> we shall develop in the next few sections of the program. Perhaps we
> shouldn't actually call it the ``heart,'' however, because it really acts
> as \TeX's eyes and mouth, reading the source files and gobbling them up.
> And it also helps \TeX\ to regurgitate stored token lists that are to be
> processed again.
5953c7013
< sequence is stored in |cs_ptr|; otherwise |cs_ptr| is set to zero.
---
> sequence is stored in |cur_cs|; otherwise |cur_cs| is set to zero.
5956c7016
< because of all the cases that need to be handled, as explained above.
---
> because of all the cases that need to be handled.
5958a7019,7023
> When |get_next| is asked to get the next token of a \.{\\read} line,
> it sets |cur_cmd=cur_chr=cur_cs=0| in the case that no more tokens
> appear on that line. (There might not be any tokens at all, if the
> |end_line_char| has |ignore| as its catcode.)
>
5961c7026
< to the appearance of \.{\\par}; we must set |cs_ptr←par_loc|
---
> to the appearance of \.{\\par}; we must set |cur_cs:=par_loc|
5964c7029
< @<Globals...@>=
---
> @<Glob...@>=
5966c7031
< @!par_token:halfword; {token representing '\.{\\par}'}
---
> @!par_token:halfword; {token representing `\.{\\par}'}
5969c7034
< primitive("par",par_end,0); par_loc←cur_val; par_token←cs_token_flag+par_loc;
---
> primitive("par",par_end,256); {cf.\ |scan_file_name|}
5970a7036
> par_loc:=cur_val; par_token:=cs_token_flag+par_loc;
5978c7044
< by |cs_ptr|, which is zero at the end of a file.
---
> by |cur_cs|, which is zero at the end of a file.
5982,5991c7048,7079
< begin if scanner_status≠normal then
< if scanner_status>skipping then @<Tell the user what has run away@>
< else if cs_ptr=0 then
< begin print_nl("! File ended in skipped conditional text");
< @.File ended in skipped...text@>
< help3("This kind of error happens when you say something like")@/
< ("`\if...{...' or `\else{...' and forget the matching `}'.")@/
< ("You probably should type `I}' now."); error;
< end;
< end;
---
> @!q:pointer; {auxiliary pointer}
> begin if scanner_status<>normal then
> begin deletions_allowed:=false;
> @<Back up an outer control sequence so that it can be reread@>;
> if scanner_status>skipping then
> @<Tell the user what has run away and try to recover@>
> else begin print_err("Incomplete "); print_cmd_chr(if_test,cur_if);
> @.Incomplete \\if...@>
> print("; all text was ignored after line "); print_int(skip_line);
> help3("A forbidden control sequence occurred in skipped text.")@/
> ("This kind of error happens when you say `\if...' and forget")@/
> ("the matching `\fi'. I've inserted a `\fi'; this might work.");
> if cur_cs<>0 then cur_cs:=0
> else help_line[2]:=@|
> "The file ended while I was skipping conditional text.";
> cur_tok:=cs_token_flag+frozen_fi; ins_error;
> end;
> deletions_allowed:=true;
> end;
> end;
>
> @ An outer control sequence that occurs in a \.{\\read} will not be reread,
> since the error recovery for \.{\\read} is not very powerful.
>
> @<Back up an outer control sequence so that it can be reread@>=
> if cur_cs<>0 then
> begin if (state=token_list)or(name<1)or(name>17) then
> begin p:=get_avail; info(p):=cs_token_flag+cur_cs;
> back_list(p); {prepare to read the control sequence again}
> end;
> cur_cmd:=spacer; cur_chr:=" "; {replace it by a space}
> end
5993c7081
< @ @<Tell the user what has run away@>=
---
> @ @<Tell the user what has run away...@>=
5995c7083
< if cs_ptr=0 then print_nl("! File ended")
---
> if cur_cs=0 then print_err("File ended")
5997,6000c7085
< else begin p←get_avail; info(p)←cs_token_flag+cs_ptr;
< ins_list(p); {prepare to read the control sequence again}
< cs_ptr←0; cur_cmd←spacer; cur_chr←" "; {replace it by a space}
< print_nl("! Forbidden control sequence found");
---
> else begin cur_cs:=0; print_err("Forbidden control sequence found");
6002c7087
< end;
---
> end;
6004,6008c7089,7090
< case scanner_status of
< defining:print("definition");
< matching:print("use");
< aligning:print("preamble");
< end; {there are no other cases}
---
> @<Print either `\.{definition}' or `\.{use}' or `\.{preamble}' or `\.{text}',
> and insert tokens that should lead to recovery@>;
6012,6014c7094,7096
< ("Either type `I}' to try recovering,")@/
< ("or type 'X' and fix your file.");@/
< deletions_allowed←false; error; deletions_allowed←true;
---
> ("I'll try to recover; but if the error is serious,")@/
> ("you'd better type `E' or `X' now and fix your file.");@/
> error;
6017c7099,7122
< @ We need to mention two procedures here that may be called by |get_next|.
---
> @ The recovery procedure can't be fully understood without knowing more
> about the \TeX\ routines that should be aborted, but we can sketch the
> ideas here: For a runaway definition we will insert a right brace; for a
> runaway preamble, we will insert a special \.{\\cr} token and a right
> brace; and for a runaway argument, we will set |long_state| to
> |outer_call| and insert \.{\\par}.
>
> @<Print either `\.{definition}' or ...@>=
> p:=get_avail;
> case scanner_status of
> defining:begin print("definition"); info(p):=right_brace_token+"}";
> end;
> matching:begin print("use"); info(p):=par_token; long_state:=outer_call;
> end;
> aligning:begin print("preamble"); info(p):=right_brace_token+"}"; q:=p;
> p:=get_avail; link(p):=q; info(p):=cs_token_flag+frozen_cr;
> align_state:=-1000000;
> end;
> absorbing:begin print("text"); info(p):=right_brace_token+"}";
> end;
> end; {there are no other cases}
> ins_list(p)
>
> @ We need to mention a procedure here that may be called by |get_next|.
6019,6020c7124
< @p procedure@?open_err_file; forward;@t\2@>
< procedure@?firm_up_the_line; forward;
---
> @p procedure@?firm_up_the_line; forward;
6022,6023c7126,7128
< @ Now we're ready to take the plunge into |get_next| itself.
< @^mastication@>
---
> @ Now we're ready to take the plunge into |get_next| itself. Parts of
> this routine are executed more often than any other instructions of \TeX.
> @^mastication@>@^inner loop@>
6028c7133
< @p procedure get_next; {sets |cur_cmd|, |cur_chr|, |cs_ptr| to next token}
---
> @p procedure get_next; {sets |cur_cmd|, |cur_chr|, |cur_cs| to next token}
6030,6033c7135,7139
< switch, {go here to eat the next character from a file}
< reswitch, {go here to digest it again}
< start_cs, {go here to start looking for a control sequence}
< found; {go here when a control sequence has been found}
---
> switch, {go here to eat the next character from a file}
> reswitch, {go here to digest it again}
> start_cs, {go here to start looking for a control sequence}
> found, {go here when a control sequence has been found}
> exit; {go here when the next input token has been got}
6036,6037c7142,7146
< begin restart: cs_ptr←0;
< if state≠token_list then
---
> @!cat:0..max_char_code; {|cat_code(cur_chr)|, usually}
> @!c,@!cc:ASCII_code; {constituents of a possible expanded code}
> @!d:2..3; {number of excess characters in an expanded code}
> begin restart: cur_cs:=0;
> if state<>token_list then
6040,6043c7149,7151
< if a parameter needs to be expanded@>;
< if @<End of alignment entry sensed@> then
< @<Insert the \(v)\<v↓j> template and |goto restart|@>;
< end;
---
> if a parameter needs to be expanded@>;
> @<If an alignment entry has just ended, take appropriate action@>;
> exit:end;
6048c7156,7157
< returned to the value it had after the \<u↓j> template for that entry.
---
> returned to the value it had after the \<u_j> template for that entry.
> @^inner loop@>
6050,6051c7159,7161
< @<End of alignment entry sensed@>=
< (align_state=0)∧(cur_cmd≤car_ret)∧(cur_cmd≥tab_mark)
---
> @<If an alignment entry has just ended, take appropriate action@>=
> if cur_cmd<=car_ret then if cur_cmd>=tab_mark then if align_state=0 then
> @<Insert the \(v)\<v_j> template and |goto restart|@>
6054,6066c7164,7179
< begin switch: if loc≤limit then {current line not yet finished}
< begin cur_chr←buffer[loc]; incr(loc);
< reswitch: cur_cmd←ch_code(cur_chr);
< @<Change state if necessary, and |goto switch| if the
< current character should be ignored,
< or |goto reswitch| if the current character
< changes to another@>;
< end
< else begin @<Move to next line of file,
< or |goto restart| if there is no next line@>;
< check_interrupt;
< goto switch;
< end;
---
> @^inner loop@>
> begin switch: if loc<=limit then {current line not yet finished}
> begin cur_chr:=buffer[loc]; incr(loc);
> reswitch: cur_cmd:=cat_code(cur_chr);
> @<Change state if necessary, and |goto switch| if the
> current character should be ignored,
> or |goto reswitch| if the current character
> changes to another@>;
> end
> else begin state:=new_line;@/
> @<Move to next line of file,
> or |goto restart| if there is no next line,
> or |return| if a \.{\\read} line has finished@>;
> check_interrupt;
> goto switch;
> end;
6072c7185
< |(max_char_code+1)| apart from each other, so we can add a character's
---
> apart from each other by |max_char_code+1|, so we can add a character's
6081c7194
< and set |state←skip_blanks|@>;
---
> and set |state:=skip_blanks| or |mid_line|@>;
6083,6085c7196,7199
< and set |state←mid_line|@>;
< any_state_plus(sup_mark): @<If this |sup_mark| starts a control character
< like@@\.{\^\^A}, then |goto reswitch|, otherwise set |state←mid_line|@>;
---
> and set |state:=mid_line|@>;
> any_state_plus(sup_mark): @<If this |sup_mark| starts an expanded character
> like~\.{\^\^A} or~\.{\^\^df}, then |goto reswitch|,
> otherwise set |state:=mid_line|@>;
6087c7201
< |goto switch|@>;
---
> |goto restart|@>;
6095,6096c7209,7214
< @ @<Decry the invalid...@>=
< begin print_nl("! Text line contains an invalid character");
---
> @ We go to |restart| instead of to |switch|, because |state| might equal
> |token_list| after the error has been dealt with
> (cf.\ |clear_for_error_prompt|).
>
> @<Decry the invalid...@>=
> begin print_err("Text line contains an invalid character");
6099,6100c7217,7219
< ("Continue, and I'll forget that it ever happened.");
< goto switch;
---
> ("Continue, and I'll forget that it ever happened.");@/
> deletions_allowed:=false; error; deletions_allowed:=true;
> goto restart;
6103,6104c7222,7223
< @ @d add_delims_to(#)==#+math_delim,#+tab_mark,#+mac_param,
< #+sub_mark,#+letter,#+other_char
---
> @ @d add_delims_to(#)==#+math_shift,#+tab_mark,#+mac_param,
> #+sub_mark,#+letter,#+other_char
6108,6110c7227,7229
< mid_line+car_ret:@<Enter |new_line| state, finish line, emit a space@>;
< skip_blanks+car_ret,any_state_plus(end_line):
< @<Enter |new_line| state, finish line, |goto switch|@>;
---
> mid_line+car_ret:@<Finish line, emit a space@>;
> skip_blanks+car_ret,any_state_plus(comment):
> @<Finish line, |goto switch|@>;
6114,6115c7233,7234
< state←mid_line; incr(align_state);
< end;
---
> state:=mid_line; incr(align_state);
> end;
6118,6120c7237,7239
< state←mid_line; decr(align_state);
< end;
< add_delims_to(skip_blanks),add_delims_to(new_line): state←mid_line;
---
> state:=mid_line; decr(align_state);
> end;
> add_delims_to(skip_blanks),add_delims_to(new_line): state:=mid_line;
6123c7242
< changed to $\.{"\ "}=@'40$. This means that the ascii codes for tab and space,
---
> changed to $\.{"\ "}=@'40$. This means that the ASCII codes for tab and space,
6128,6129c7247,7248
< @<Enter |new_line| state, finish line, emit a space@>=
< begin state←new_line; loc←limit+1; cur_cmd←spacer; cur_chr←" ";
---
> @<Finish line, emit a space@>=
> begin loc:=limit+1; cur_cmd:=spacer; cur_chr:=" ";
6135c7254
< begin state←skip_blanks; cur_chr←" ";
---
> begin state:=skip_blanks; cur_chr:=" ";
6138,6139c7257,7258
< @ @<Enter |new_line| state, finish line, |goto switch|@>=
< begin state←new_line; loc←limit+1; goto switch;
---
> @ @<Finish line, |goto switch|@>=
> begin loc:=limit+1; goto switch;
6143,6145c7262,7264
< begin loc←limit+1; cs_ptr←par_loc; cur_cmd←eq_type(cs_ptr);
< cur_chr←equiv(cs_ptr);
< if cur_cmd≥outer_call then check_outer_validity;
---
> begin loc:=limit+1; cur_cs:=par_loc; cur_cmd:=eq_type(cur_cs);
> cur_chr:=equiv(cur_cs);
> if cur_cmd>=outer_call then check_outer_validity;
6148,6155c7267,7288
< @ @<If this |sup_mark| starts a control character...@>=
< begin if (cur_chr=buffer[loc])∧(loc<limit) then
< if (buffer[loc+1]≤"_")∧(buffer[loc+1]≥"?") then
< begin if buffer[loc+1]="?" then cur_chr←@'177
< else cur_chr←buffer[loc+1]-"@@";
< loc←loc+2; goto reswitch;
< end;
< state←mid_line;
---
> @ Notice that a code like \.{\^\^8} becomes \.x if not followed by a hex digit.
>
> @d is_hex(#)==(((#>="0")and(#<="9"))or((#>="a")and(#<="f")))
> @d hex_to_cur_chr==
> if c<="9" then cur_chr:=c-"0" @+else cur_chr:=c-"a"+10;
> if cc<="9" then cur_chr:=16*cur_chr+cc-"0"
> else cur_chr:=16*cur_chr+cc-"a"+10
>
> @<If this |sup_mark| starts an expanded character...@>=
> begin if cur_chr=buffer[loc] then if loc<limit then
> begin c:=buffer[loc+1]; @+if c<@'200 then {yes we have an expanded char}
> begin loc:=loc+2;
> if is_hex(c) then if loc<=limit then
> begin cc:=buffer[loc]; @+if is_hex(cc) then
> begin incr(loc); hex_to_cur_chr; goto reswitch;
> end;
> end;
> if c<@'100 then cur_chr:=c+@'100 @+else cur_chr:=c-@'100;
> goto reswitch;
> end;
> end;
> state:=mid_line;
6157c7290
<
---
>
6159,6161c7292,7294
< begin cs_ptr←cur_chr+active_base;
< cur_cmd←eq_type(cs_ptr); cur_chr←equiv(cs_ptr); state←mid_line;
< if cur_cmd≥outer_call then check_outer_validity;
---
> begin cur_cs:=cur_chr+active_base;
> cur_cmd:=eq_type(cur_cs); cur_chr:=equiv(cur_cs); state:=mid_line;
> if cur_cmd>=outer_call then check_outer_validity;
6171c7304
< user tried something like `\.{\\chcode\'15=0}'. The algorithm might
---
> user tried something like `\.{\\catcode\'15=0}'. The algorithm might
6174c7307,7308
< If expanded control characters like `\.{\^\^A}' appear in or just following
---
> If expanded characters like `\.{\^\^A}' or `\.{\^\^df}'
> appear in or just following
6179,6192c7313,7329
< begin if loc>limit then cs_ptr←single_base+null_code
< else begin start_cs: k←loc; cur_chr←buffer[k]; incr(k);
< if (ch_code(cur_chr)=letter)∧(k≤limit) then
< @<Scan ahead in the buffer until finding a nonletter;
< if an expanded control code is encountered, reduce it
< and |goto start_cs|; otherwise if a multiletter control
< sequence is found, adjust |cs_ptr| and |loc|, and
< |goto found|@>
< else @<If an expanded control code is present, reduce it
< and |goto start_cs|@>;
< cs_ptr←single_base+buffer[loc]; incr(loc);
< end;
< found: cur_cmd←eq_type(cs_ptr); cur_chr←equiv(cs_ptr); state←skip_blanks;
< if cur_cmd≥outer_call then check_outer_validity;
---
> begin if loc>limit then cur_cs:=null_cs {|state| is irrelevant in this case}
> else begin start_cs: k:=loc; cur_chr:=buffer[k]; cat:=cat_code(cur_chr);
> incr(k);
> if cat=letter then state:=skip_blanks
> else if cat=spacer then state:=skip_blanks
> else state:=mid_line;
> if (cat=letter)and(k<=limit) then
> @<Scan ahead in the buffer until finding a nonletter;
> if an expanded code is encountered, reduce it
> and |goto start_cs|; otherwise if a multiletter control
> sequence is found, adjust |cur_cs| and |loc|, and
> |goto found|@>
> else @<If an expanded code is present, reduce it and |goto start_cs|@>;
> cur_cs:=single_base+buffer[loc]; incr(loc);
> end;
> found: cur_cmd:=eq_type(cur_cs); cur_chr:=equiv(cur_cs);
> if cur_cmd>=outer_call then check_outer_validity;
6196,6198c7333,7337
< |cur_chr=buffer[k-1]| and |k≤limit+1|. If an expanded control code like
< \.{\^\^A} appears in |buffer[(k-1)..(k+1)]|, we will store the corresponding
< code in |buffer[k-1]| and shift the rest of the buffer left two places.
---
> |cur_chr=buffer[k-1]| and |k<=limit+1| and |cat=cat_code(cur_chr)|. If an
> expanded code like \.{\^\^A} or \.{\^\^df} appears in |buffer[(k-1)..(k+1)]|
> or |buffer[(k-1)..(k+2)]|, we
> will store the corresponding code in |buffer[k-1]| and shift the rest of
> the buffer left two or three places.
6201,6213c7340,7357
< begin if (buffer[k]=cur_chr)∧(ch_code(cur_chr)=sup_mark)∧@|
< (k<limit) then
< begin cur_chr←buffer[k+1];
< if (cur_chr≤"_")∧(cur_chr≥"?") then
< begin if cur_chr>"?" then buffer[k-1]←cur_chr-"@@"
< else buffer[k-1]←@'177;
< limit←limit-2; first←first-2;
< while k≤limit do
< begin buffer[k]←buffer[k+2]; incr(k);
< end;
< goto start_cs;
< end;
< end;
---
> begin if buffer[k]=cur_chr then @+if cat=sup_mark then @+if k<limit then
> begin c:=buffer[k+1]; @+if c<@'200 then {yes, one is indeed present}
> begin d:=2;
> if is_hex(c) then @+if k+2<=limit then
> begin cc:=buffer[k+2]; @+if is_hex(cc) then incr(d);
> end;
> if d>2 then
> begin hex_to_cur_chr; buffer[k-1]:=cur_chr;
> end
> else if c<@'100 then buffer[k-1]:=c+@'100
> else buffer[k-1]:=c-@'100;
> limit:=limit-d; first:=first-d;
> while k<=limit do
> begin buffer[k]:=buffer[k+d]; incr(k);
> end;
> goto start_cs;
> end;
> end;
6217,6218c7361,7362
< begin repeat cur_chr←buffer[k]; incr(k);
< until (ch_code(cur_chr)≠letter)∨(k>limit);
---
> begin repeat cur_chr:=buffer[k]; cat:=cat_code(cur_chr); incr(k);
> until (cat<>letter)or(k>limit);
6220,6224c7364,7368
< if ch_code(buffer[k-1])≠letter then decr(k);
< {now |k| points to first nonletter}
< if k>loc+1 then {multi-letter control sequence has been scanned}
< begin cs_ptr←id_lookup(loc,k-loc); loc←k; goto found;
< end;
---
> if cat<>letter then decr(k);
> {now |k| points to first nonletter}
> if k>loc+1 then {multiletter control sequence has been scanned}
> begin cur_cs:=id_lookup(loc,k-loc); loc:=k; goto found;
> end;
6230,6249c7374,7411
< if a parameter needs to be expanded@>=
< if loc≠null then {list not exhausted}
< begin t←info(loc); loc←link(loc); {move to next}
< if t≥cs_token_flag then {a control sequence token}
< begin cs_ptr←t-cs_token_flag;
< cur_cmd←eq_type(cs_ptr); cur_chr←equiv(cs_ptr);
< if cur_cmd≥outer_call then check_outer_validity;
< end
< else begin cur_cmd←t div @'400; cur_chr←t mod @'400;
< case cur_cmd of
< left_brace: incr(align_state);
< right_brace: decr(align_state);
< out_param: @<Insert macro parameter and |goto restart|@>;
< othercases do_nothing
< endcases;
< end;
< end
< else begin {we are done with this token list}
< end_token_list; goto restart; {resume previous level}
< end
---
> if a parameter needs to be expanded@>=
> if loc<>null then {list not exhausted}
> @^inner loop@>
> begin t:=info(loc); loc:=link(loc); {move to next}
> if t>=cs_token_flag then {a control sequence token}
> begin cur_cs:=t-cs_token_flag;
> cur_cmd:=eq_type(cur_cs); cur_chr:=equiv(cur_cs);
> if cur_cmd>=outer_call then
> if cur_cmd=dont_expand then
> @<Get the next token, suppressing expansion@>
> else check_outer_validity;
> end
> else begin cur_cmd:=t div @'400; cur_chr:=t mod @'400;
> case cur_cmd of
> left_brace: incr(align_state);
> right_brace: decr(align_state);
> out_param: @<Insert macro parameter and |goto restart|@>;
> othercases do_nothing
> endcases;
> end;
> end
> else begin {we are done with this token list}
> end_token_list; goto restart; {resume previous level}
> end
>
> @ The present point in the program is reached only when the |expand|
> routine has inserted a special marker into the input. In this special
> case, |info(loc)| is known to be a control sequence token, and |link(loc)=null|.
>
> @d no_expand_flag=257 {this characterizes a special variant of |relax|}
>
> @<Get the next token, suppressing expansion@>=
> begin cur_cs:=info(loc)-cs_token_flag; loc:=null;@/
> cur_cmd:=eq_type(cur_cs); cur_chr:=equiv(cur_cs);
> if cur_cmd>max_command then
> begin cur_cmd:=relax; cur_chr:=no_expand_flag;
> end;
> end
6259,6274c7421,7447
< @<Move to next line of file, or |goto restart| if there is no next line@>=
< if not terminal_input then @<Read next line of file into |buffer|, or
< |goto restart| if the file has ended@>
< else begin if input_ptr>0 then {text was inserted during error recovery}
< begin end_file_reading; goto restart; {resume previous level}
< end;
< if selector<err_only then open_err_file;
< if interaction>nonstop_mode then
< begin if limit=start then {previous line was empty}
< print_nl("(Type a command or say `\end')");
< print_ln; first←start;
< prompt_input("*"); {input on-line into |buffer|}
< limit←last; buffer[limit]←carriage_return; first←last+1;
< loc←start;
< end
< else fatal_error("*** (job aborted, no legal \end found)");
---
> @d end_line_char_inactive == (end_line_char<0)or(end_line_char>255)
>
> @<Move to next line of file, or |goto restart|...@>=
> if name>17 then @<Read next line of file into |buffer|, or
> |goto restart| if the file has ended@>
> else begin if not terminal_input then {\.{\\read} line has ended}
> begin cur_cmd:=0; cur_chr:=0; return;
> end;
> if input_ptr>0 then {text was inserted during error recovery}
> begin end_file_reading; goto restart; {resume previous level}
> end;
> if selector<log_only then open_log_file;
> if interaction>nonstop_mode then
> begin if end_line_char_inactive then incr(limit);
> if limit=start then {previous line was empty}
> print_nl("(Please type a command or say `\end')");
> @.Please type...@>
> print_ln; first:=start;
> prompt_input("*"); {input on-line into |buffer|}
> @.*\relax@>
> limit:=last;
> if end_line_char_inactive then decr(limit)
> else buffer[limit]:=end_line_char;
> first:=limit+1;
> loc:=start;
> end
> else fatal_error("*** (job aborted, no legal \end found)");
6276,6278c7449,7457
< {nonstop mode, which is intended for overnight batch processing,
< never waits for on-line input}
< end
---
> {nonstop mode, which is intended for overnight batch processing,
> never waits for on-line input}
> end
>
> @ The global variable |force_eof| is normally |false|; it is set |true|
> by an \.{\\endinput} command.
>
> @<Glob...@>=
> @!force_eof:boolean; {should the next \.{\\input} be aborted early?}
6281,6290c7460,7476
< |goto restart| if the file has ended@>=
< begin incr(line); first←start;
< if input_ln(cur_file) then {not end of file}
< firm_up_the_line {this sets |limit|}
< else if limit≠start then limit←start {insert empty line at end of file}
< else begin check_outer_validity;
< print_char(")"); update_terminal; {show user that file has been read}
< end_file_reading; goto restart; {resume previous level}
< end;
< buffer[limit]←carriage_return; first←limit+1; loc←start; {ready to read}
---
> |goto restart| if the file has ended@>=
> begin incr(line); first:=start;
> if not force_eof then
> begin if input_ln(cur_file,true) then {not end of file}
> firm_up_the_line {this sets |limit|}
> else force_eof:=true;
> end;
> if force_eof then
> begin print_char(")"); decr(open_parens);
> update_terminal; {show user that file has been read}
> force_eof:=false;
> end_file_reading; {resume previous level}
> check_outer_validity; goto restart;
> end;
> if end_line_char_inactive then decr(limit)
> else buffer[limit]:=end_line_char;
> first:=limit+1; loc:=start; {ready to read}
6293c7479
< @ If the user has set the |pause| parameter to some nonzero value,
---
> @ If the user has set the |pausing| parameter to some positive value,
6302,6312c7488,7499
< begin limit←last;
< if (pause≠0)∧(interaction>nonstop_mode) then
< begin print_ln;
< if start<limit then for k←start to limit-1 do print(buffer[k]);
< first←limit; prompt_input("=>"); {wait for user response}
< if last>first then
< begin for k←first to last-1 do {move line down in buffer}
< buffer[k+start-first]←buffer[k];
< limit←start+last-first;
< end;
< end;
---
> begin limit:=last;
> if pausing>0 then if interaction>nonstop_mode then
> begin wake_up_terminal; print_ln;
> if start<limit then for k:=start to limit-1 do print(buffer[k]);
> first:=limit; prompt_input("=>"); {wait for user response}
> @.=>@>
> if last>first then
> begin for k:=first to last-1 do {move line down in buffer}
> buffer[k+start-first]:=buffer[k];
> limit:=start+last-first;
> end;
> end;
6321c7508
< \yskip\hang|get_nc_token|, meaning ``get the non-|call| token,'' is like
---
> \yskip\hang|get_x_token|, meaning ``get an expanded token,'' is like
6323,6324c7510,7513
< control sequence (i.e., a macro call), or something like \.{\\topmark},
< it is eliminated from the input by beginning the expansion of the macro.
---
> control sequence (i.e., a macro call), or a conditional,
> or something like \.{\\topmark} or \.{\\expandafter} or \.{\\csname},
> it is eliminated from the input by beginning the expansion of the macro
> or the evaluation of the conditional.
6326c7515
< \yskip\hang|nc_token| is like |get_nc_token| except that it assumes that
---
> \yskip\hang|x_token| is like |get_x_token| except that it assumes that
6330,6331c7519
< In fact, these three procedures account for {\sl all\/} uses of |get_next|,
< except for one place in the ``inner loop'' when |cur_tok| need not be set.
---
> In fact, these three procedures account for almost every use of |get_next|.
6333,6344c7521,7523
< @ The |get_token| routine also has a special test built into it to make
< sure that the token found is not `|endv|', i.e., the end of a template,
< since this would be a bad case of misalignment. We wouldn't want an |endv|
< to be deleted or to infiltrate another token list, and |get_token| is used
< only in the |error| routine or when building token lists, or in a few
< other very special cases. The |endv| problem
< hardly ever arises in a form where recovery is feasible, so no recovery
< mechanism has been provided.
<
< No new control sequences will be defined except during a call of
< |get_token|, because |no_new_control_sequence| is always |true| at
< other times.
---
> @ No new control sequences will be defined except during a call of
> |get_token|, or when \.{\\csname} compresses a token list, because
> |no_new_control_sequence| is always |true| at other times.
6347,6373c7526,7574
< begin no_new_control_sequence←false; get_next; no_new_control_sequence←true;
< if cs_ptr=0 then
< begin if cur_cmd=endv then
< fatal_error("(alignment is fouled up somehow)");
< @.alignment is fouled up@>
< cur_tok←(cur_cmd*@'400)+cur_chr;
< end
< else cur_tok←cs_token_flag+cs_ptr;
< end;
<
< @ The only command codes |>max_command| that can be returned by the
< |get_next| routine are |undefined_cs|, |top_bot_mark|, |call|, |long_call|,
< |outer_call|, and |long_outer_call|, in increasing numerical order.
<
< @p@t\4@>@<Declare the procedure called |macro_call|@>
< procedure get_nc_token; {sets |cur_cmd|, |cur_chr|, |cur_tok|,
< and expands macros}
< label done;
< begin loop begin get_next;
< if cur_cmd≤max_command then goto done;
< if cur_cmd≥call then macro_call
< else if cur_cmd=top_bot_mark then
< @<Insert the \(a)appropriate mark text into the scanner@>
< else @<Complain about an undefined macro@>;
< end;
< done: if cs_ptr=0 then cur_tok←(cur_cmd*@'400)+cur_chr
< else cur_tok←cs_token_flag+cs_ptr;
---
> begin no_new_control_sequence:=false; get_next; no_new_control_sequence:=true;
> @^inner loop@>
> if cur_cs=0 then cur_tok:=(cur_cmd*@'400)+cur_chr
> else cur_tok:=cs_token_flag+cur_cs;
> end;
>
> @* \[25] Expanding the next token.
> Only a dozen or so command codes |>max_command| can possibly be returned by
> |get_next|; in increasing order, they are |undefined_cs|, |expand_after|,
> |no_expand|, |input|, |if_test|, |fi_or_else|, |cs_name|, |convert|, |the|,
> |top_bot_mark|, |call|, |long_call|, |outer_call|, |long_outer_call|, and
> |end_template|.{\emergencystretch=40pt\par}
>
> The |expand| subroutine is used when |cur_cmd>max_command|. It removes a
> ``call'' or a conditional or one of the other special operations just
> listed. It follows that |expand| might invoke itself recursively. In all
> cases, |expand| destroys the current token, but it sets things up so that
> the next |get_next| will deliver the appropriate next token. The value of
> |cur_tok| need not be known when |expand| is called.
>
> Since several of the basic scanning routines communicate via global variables,
> their values are saved as local variables of |expand| so that
> recursive calls don't invalidate them.
> @^recursion@>
>
> @p@t\4@>@<Declare the procedure called |macro_call|@>@;@/
> @t\4@>@<Declare the procedure called |insert_relax|@>@;@/
> procedure@?pass_text; forward;@t\2@>
> procedure@?start_input; forward;@t\2@>
> procedure@?conditional; forward;@t\2@>
> procedure@?get_x_token; forward;@t\2@>
> procedure@?conv_toks; forward;@t\2@>
> procedure@?ins_the_toks; forward;@t\2@>
> procedure expand;
> var t:halfword; {token that is being ``expanded after''}
> @!p,@!q,@!r:pointer; {for list manipulation}
> @!j:0..buf_size; {index into |buffer|}
> @!cv_backup:integer; {to save the global quantity |cur_val|}
> @!cvl_backup,@!radix_backup,@!co_backup:small_number;
> {to save |cur_val_level|, etc.}
> @!backup_backup:pointer; {to save |link(backup_head)|}
> @!save_scanner_status:small_number; {temporary storage of |scanner_status|}
> begin cv_backup:=cur_val; cvl_backup:=cur_val_level; radix_backup:=radix;
> co_backup:=cur_order; backup_backup:=link(backup_head);
> if cur_cmd<call then @<Expand a nonmacro@>
> else if cur_cmd<end_template then macro_call
> else @<Insert a token containing |frozen_endv|@>;
> cur_val:=cv_backup; cur_val_level:=cvl_backup; radix:=radix_backup;
> cur_order:=co_backup; link(backup_head):=backup_backup;
6375a7577,7618
> @ @<Expand a nonmacro@>=
> begin if tracing_commands>1 then show_cur_cmd_chr;
> case cur_cmd of
> top_bot_mark:@<Insert the \(a)appropriate mark text into the scanner@>;
> expand_after:@<Expand the token after the next token@>;
> no_expand:@<Suppress expansion of the next token@>;
> cs_name:@<Manufacture a control sequence name@>;
> convert:conv_toks; {this procedure is discussed in Part 27 below}
> the:ins_the_toks; {this procedure is discussed in Part 27 below}
> if_test:conditional; {this procedure is discussed in Part 28 below}
> fi_or_else:@<Terminate the current conditional and skip to \.{\\fi}@>;
> input:@<Initiate or terminate input from a file@>;
> othercases @<Complain about an undefined macro@>
> endcases;
> end
>
> @ It takes only a little shuffling to do what \TeX\ calls \.{\\expandafter}.
>
> @<Expand the token after...@>=
> begin get_token; t:=cur_tok; get_token;
> if cur_cmd>max_command then expand@+else back_input;
> cur_tok:=t; back_input;
> end
>
> @ The implementation of \.{\\noexpand} is a bit trickier, because it is
> necessary to insert a special `|dont_expand|' marker into \TeX's reading
> mechanism. This special marker is processed by |get_next|, but it does
> not slow down the inner loop.
>
> Since \.{\\outer} macros might arise here, we must also
> clear the |scanner_status| temporarily.
>
> @<Suppress expansion...@>=
> begin save_scanner_status:=scanner_status; scanner_status:=normal;
> get_token; scanner_status:=save_scanner_status; t:=cur_tok;
> back_input; {now |start| and |loc| point to the backed-up token |t|}
> if t>=cs_token_flag then
> begin p:=get_avail; info(p):=cs_token_flag+frozen_dont_expand;
> link(p):=loc; start:=p; loc:=p;
> end;
> end
>
6377c7620
< begin print_nl("! Undefined control sequence");
---
> begin print_err("Undefined control sequence");
6387,6388c7630,7632
< @ The |get_nc_token| procedure is equivalent to two consecutive
< procedure calls: |get_next; nc_token|.
---
> @ The |expand| procedure and some other routines that construct token
> lists find it convenient to use the following macros, which are valid only if
> the variables |p| and |q| are reserved for token-list building.
6390,6400c7634,7747
< @p procedure nc_token; {|get_nc_token| without the initial |get_next|}
< label done;
< begin loop begin if cur_cmd≤max_command then goto done;
< if cur_cmd≥call then macro_call
< else if cur_cmd=top_bot_mark then
< @<Insert the \(a)appropriate mark text into the scanner@>
< else @<Complain about an undefined macro@>;
< get_next;
< end;
< done: if cs_ptr=0 then cur_tok←(cur_cmd*@'400)+cur_chr
< else cur_tok←cs_token_flag+cs_ptr;
---
> @d store_new_token(#)==begin q:=get_avail; link(p):=q; info(q):=#;
> p:=q; {|link(p)| is |null|}
> end
> @d fast_store_new_token(#)==begin fast_get_avail(q); link(p):=q; info(q):=#;
> p:=q; {|link(p)| is |null|}
> end
>
> @ @<Manufacture a control...@>=
> begin r:=get_avail; p:=r; {head of the list of characters}
> repeat get_x_token;
> if cur_cs=0 then store_new_token(cur_tok);
> until cur_cs<>0;
> if cur_cmd<>end_cs_name then @<Complain about missing \.{\\endcsname}@>;
> @<Look up the characters of list |r| in the hash table, and set |cur_cs|@>;
> flush_list(r);
> if eq_type(cur_cs)=undefined_cs then
> begin eq_define(cur_cs,relax,256); {N.B.: The |save_stack| might change}
> end; {the control sequence will now match `\.{\\relax}'}
> cur_tok:=cur_cs+cs_token_flag; back_input;
> end
>
> @ @<Complain about missing \.{\\endcsname}@>=
> begin print_err("Missing "); print_esc("endcsname"); print(" inserted");
> @.Missing \\endcsname...@>
> help2("The control sequence marked <to be read again> should")@/
> ("not appear between \csname and \endcsname.");
> back_error;
> end
>
> @ @<Look up the characters of list |r| in the hash table...@>=
> j:=first; p:=link(r);
> while p<>null do
> begin if j>=max_buf_stack then
> begin max_buf_stack:=j+1;
> if max_buf_stack=buf_size then
> overflow("buffer size",buf_size);
> @:TeX capacity exceeded buffer size}{\quad buffer size@>
> end;
> buffer[j]:=info(p) mod @'400; incr(j); p:=link(p);
> end;
> if j>first+1 then
> begin no_new_control_sequence:=false; cur_cs:=id_lookup(first,j-first);
> no_new_control_sequence:=true;
> end
> else if j=first then cur_cs:=null_cs {the list is empty}
> else cur_cs:=single_base+buffer[first] {the list has length one}
>
> @ An |end_template| command is effectively changed to an |endv| command
> by the following code. (The reason for this is discussed below; the
> |frozen_end_template| at the end of the template has passed the
> |check_outer_validity| test, so its mission of error detection has been
> accomplished.)
>
> @<Insert a token containing |frozen_endv|@>=
> begin cur_tok:=cs_token_flag+frozen_endv; back_input;
> end
>
> @ The processing of \.{\\input} involves the |start_input| subroutine,
> which will be declared later; the processing of \.{\\endinput} is trivial.
>
> @<Put each...@>=
> primitive("input",input,0);@/
> @!@:input_}{\.{\\input} primitive@>
> primitive("endinput",input,1);@/
> @!@:end_input_}{\.{\\endinput} primitive@>
>
> @ @<Cases of |print_cmd_chr|...@>=
> input: if chr_code=0 then print_esc("input")@+else print_esc("endinput");
>
> @ @<Initiate or terminate input...@>=
> if cur_chr>0 then force_eof:=true
> else if name_in_progress then insert_relax
> else start_input
>
> @ Sometimes the expansion looks too far ahead, so we want to insert
> a harmless \.{\\relax} into the user's input.
>
> @<Declare the procedure called |insert_relax|@>=
> procedure insert_relax;
> begin cur_tok:=cs_token_flag+cur_cs; back_input;
> cur_tok:=cs_token_flag+frozen_relax; back_input; token_type:=inserted;
> end;
>
> @ Here is a recursive procedure that is \TeX's usual way to get the
> next token of input. It has been slightly optimized to take account of
> common cases.
>
> @p procedure get_x_token; {sets |cur_cmd|, |cur_chr|, |cur_tok|,
> and expands macros}
> label restart,done;
> begin restart: get_next;
> @^inner loop@>
> if cur_cmd<=max_command then goto done;
> if cur_cmd>=call then
> if cur_cmd<end_template then macro_call
> else begin cur_cs:=frozen_endv; cur_cmd:=endv;
> goto done; {|cur_chr=null_list|}
> end
> else expand;
> goto restart;
> done: if cur_cs=0 then cur_tok:=(cur_cmd*@'400)+cur_chr
> else cur_tok:=cs_token_flag+cur_cs;
> end;
>
> @ The |get_x_token| procedure is equivalent to two consecutive
> procedure calls: |get_next; x_token|.
>
> @p procedure x_token; {|get_x_token| without the initial |get_next|}
> begin while cur_cmd>max_command do
> begin expand;
> get_next;
> end;
> if cur_cs=0 then cur_tok:=(cur_cmd*@'400)+cur_chr
> else cur_tok:=cs_token_flag+cur_cs;
6402,6403c7749,7750
< @* \[25] Expanding user macros.
< A control sequence that has been \.{\\def}'ed by the user is expanded by
---
>
> @ A control sequence that has been \.{\\def}'ed by the user is expanded by
6426c7773
< {token lists for marks}
---
> {token lists for marks}
6429,6430c7776,7777
< top_mark←null; first_mark←null; bot_mark←null;
< split_first_mark←null; split_bot_mark←null;
---
> top_mark:=null; first_mark:=null; bot_mark:=null;
> split_first_mark:=null; split_bot_mark:=null;
6446,6451c7793,7798
< first_mark_code: print_esc("firstmark");
< bot_mark_code: print_esc("botmark");
< split_first_mark_code: print_esc("splitfirstmark");
< split_bot_mark_code: print_esc("splitbotmark");
< othercases print_esc("topmark")
< endcases;
---
> first_mark_code: print_esc("firstmark");
> bot_mark_code: print_esc("botmark");
> split_first_mark_code: print_esc("splitfirstmark");
> split_bot_mark_code: print_esc("splitbotmark");
> othercases print_esc("topmark")
> endcases;
6457,6458c7804,7805
< begin if cur_mark[cur_chr]≠null then
< begin_token_list(cur_mark[cur_chr],mark_text);
---
> begin if cur_mark[cur_chr]<>null then
> begin_token_list(cur_mark[cur_chr],mark_text);
6461,6464c7808,7821
< @ Now let's consider |macro_call| itself, which is invoked when |cur_cmd|
< is either |call|, |long_call|, |outer_call|, or |long_outer_call|. The
< control sequence definition appears in the token list whose reference count
< is in location |cur_chr| of |mem|.
---
> @ Now let's consider |macro_call| itself, which is invoked when \TeX\ is
> scanning a control sequence whose |cur_cmd| is either |call|, |long_call|,
> |outer_call|, or |long_outer_call|. The control sequence definition
> appears in the token list whose reference count is in location |cur_chr|
> of |mem|.
>
> The global variable |long_state| will be set to |call| or to |long_call|,
> depending on whether or not the control sequence disallows \.{\\par}
> in its parameters. The |get_next| routine will set |long_state| to
> |outer_call| and emit \.{\\par}, if a file ends or if an \.{\\outer}
> control sequence occurs in the midst of an argument.
>
> @<Glob...@>=
> @!long_state:call..long_outer_call; {governs the acceptance of \.{\\par}}
6466,6467c7823,7824
< The parameters, if any, must be scanned before the macro is expanded.
< Pa\-ram\-eters are token lists without reference counts. They are placed on
---
> @ The parameters, if any, must be scanned before the macro is expanded.
> Parameters are token lists without reference counts. They are placed on
6480c7837
< top of the \TeX's input stack, so that |get_next| will proceed to read it
---
> top of\/ \TeX's input stack, so that |get_next| will proceed to read it
6483c7840
< The global variable |cs_ptr| contains the |eqtb| address of the control sequence
---
> The global variable |cur_cs| contains the |eqtb| address of the control sequence
6504d7860
< @!non_long:boolean; {is \.{\\par} forbidden in parameters?}
6507,6512c7863,7869
< begin save_scanner_status←scanner_status; save_warning_index←warning_index;
< warning_index←cs_ptr; ref_count←cur_chr; r←link(ref_count); n←0;
< if tracing_macros≠0 then @<Show the text of the macro being expanded@>;
< if info(r)≠end_match_token then
< @<Scan the parameters and make |link(r)| point to the macro body; but
< |return| if an illegal \.{\\par} is detected@>;
---
> @!match_chr:ASCII_code; {character used in parameter}
> begin save_scanner_status:=scanner_status; save_warning_index:=warning_index;
> warning_index:=cur_cs; ref_count:=cur_chr; r:=link(ref_count); n:=0;
> if tracing_macros>0 then @<Show the text of the macro being expanded@>;
> if info(r)<>end_match_token then
> @<Scan the parameters and make |link(r)| point to the macro body; but
> |return| if an illegal \.{\\par} is detected@>;
6514c7871
< exit:scanner_status←save_scanner_status; warning_index←save_warning_index;
---
> exit:scanner_status:=save_scanner_status; warning_index:=save_warning_index;
6522,6523c7879,7881
< while (state=token_list)∧(loc=null) do end_token_list; {conserve stack space}
< begin_token_list(ref_count,macro); name←warning_index; loc←link(r);
---
> while (state=token_list)and(loc=null)and(token_type<>v_template) do
> end_token_list; {conserve stack space}
> begin_token_list(ref_count,macro); name:=warning_index; loc:=link(r);
6525,6540c7883,7891
< begin if param_ptr+n>max_param_stack then
< begin max_param_stack←param_ptr+n;
< if max_param_stack>param_size then
< overflow("parameter stack size",param_size);
< end;
< for m←0 to n-1 do param_stack[param_ptr+m]←pstack[m];
< param_ptr←param_ptr+n;
< end
<
< @ The |macro_call| procedure and some other routines that construct token lists
< find it convenient to use the following macro, which is valid only if
< the variables |p| and |q| are reserved for token-list building.
<
< @d store_new_token(#)==begin q←get_avail; link(p)←q; info(q)←#;
< p←q; {|link(p)| is |null|}
< end
---
> begin if param_ptr+n>max_param_stack then
> begin max_param_stack:=param_ptr+n;
> if max_param_stack>param_size then
> overflow("parameter stack size",param_size);
> @:TeX capacity exceeded parameter stack size}{\quad parameter stack size@>
> end;
> for m:=0 to n-1 do param_stack[param_ptr+m]:=pstack[m];
> param_ptr:=param_ptr+n;
> end
6553,6558c7904,7911
< begin scanner_status←matching; unbalance←0;
< if (eq_type(cs_ptr)=call)∨(eq_type(cs_ptr)=outer_call) then non_long←true
< else non_long←false;
< repeat if (info(r)>match_token+255)∨(info(r)<match_token) then s←null
< else begin s←link(r); r←s; p←temp_head; link(p)←null; m←0;
< end;
---
> begin scanner_status:=matching; unbalance:=0;
> long_state:=eq_type(cur_cs);
> if long_state>=outer_call then long_state:=long_state-2;
> repeat link(temp_head):=null;
> if (info(r)>match_token+255)or(info(r)<match_token) then s:=null
> else begin match_chr:=info(r)-match_token; s:=link(r); r:=s;
> p:=temp_head; m:=0;
> end;
6560c7913
< simply scan the delimiter string@>;@/
---
> simply scan the delimiter string@>;@/
6566c7919
< any token found by |get_token|. Therefore an undelimiter parameter---i.e.,
---
> any token found by |get_token|. Therefore an undelimited parameter---i.e.,
6573,6574c7926,7927
< @<Advance \(r)|r|; |goto found| if the parameter delimiter has been
< fully matched, otherwise |goto continue|@>;
---
> @<Advance \(r)|r|; |goto found| if the parameter delimiter has been
> fully matched, otherwise |goto continue|@>;
6576,6578c7929,7932
< |goto continue| if a partial match is still in effect;
< but abort if |s=null|@>;
< if (cur_tok=par_token)∧non_long then @<Report a runaway argument and abort@>;
---
> |goto continue| if a partial match is still in effect;
> but abort if |s=null|@>;
> if cur_tok=par_token then if long_state<>long_call then
> @<Report a runaway argument and abort@>;
6580,6583c7934,7938
< if cur_tok<left_brace_limit then
< @<Contribute an entire group to the current parameter@>
< else @<Report an extra right brace and |goto continue|@>
< else store_new_token(cur_tok);
---
> if cur_tok<left_brace_limit then
> @<Contribute an entire group to the current parameter@>
> else @<Report an extra right brace and |goto continue|@>
> else @<Store the current token, but |goto continue| if it is
> a blank space that would become an undelimited parameter@>;
6585,6586c7940,7949
< if (info(r)<match_token)∨(info(r)>end_match_token) then goto continue;
< found: if s≠null then @<Tidy up the parameter just scanned, and tuck it away@>
---
> if info(r)>end_match_token then goto continue;
> if info(r)<match_token then goto continue;
> found: if s<>null then @<Tidy up the parameter just scanned, and tuck it away@>
>
> @ @<Store the current token, but |goto continue| if it is...@>=
> begin if cur_tok=space_token then
> if info(r)<=end_match_token then
> if info(r)>=match_token then goto continue;
> store_new_token(cur_tok);
> end
6594,6598c7957,7961
< begin r←link(r);
< if (info(r)≥match_token)∧(info(r)≤end_match_token) then
< begin if cur_tok<left_brace_limit then decr(align_state);
< goto found;
< end
---
> begin r:=link(r);
> if (info(r)>=match_token)and(info(r)<=end_match_token) then
> begin if cur_tok<left_brace_limit then decr(align_state);
> goto found;
> end
6603c7966,7967
< begin print_nl("Argument of "); sprint_cs(warning_index);
---
> begin back_input; print_err("Argument of "); sprint_cs(warning_index);
> @.Argument of \\x has...@>
6605,6611c7969,7979
< help5("I've deleted a `}' that doesn't seem to match anything.")@/
< ("For example, `\def\a#1{...}' and `\a}' would produce this")@/
< ("error. If your `}' was spurious, just proceed. Otherwise,")@/
< ("type `I\par}' (including the `}') and I'll tell you about")@/
< ("a runaway argument that might be the root of the problem.");
< incr(align_state); non_long←true; error;
< end
---
> help6("I've run across a `}' that doesn't seem to match anything.")@/
> ("For example, `\def\a#1{...}' and `\a}' would produce")@/
> ("this error. If you simply proceed now, the `\par' that")@/
> ("I've just inserted will cause me to report a runaway")@/
> ("argument that might be the root of the problem. But if")@/
> ("your `}' was spurious, just type `2' and it will go away.");
> incr(align_state); long_state:=call; cur_tok:=par_token; ins_error;
> goto continue;
> end {a white lie; the \.{\\par} won't always trigger a runaway}
>
> @ If |long_state=outer_call|, a runaway argument has already been reported.
6613,6614c7981,7983
< @ @<Report a runaway argument and abort@>=
< begin runaway; print_nl("! Paragraph ended before "); sprint_cs(warning_index);
---
> @<Report a runaway argument and abort@>=
> begin if long_state=call then
> begin runaway; print_err("Paragraph ended before ");
6616,6622c7985,7993
< print(" was complete");
< help3("I suspect you've forgotten a `}', causing me to apply this")@/
< ("control sequence to too much text. How can we recover?")@/
< ("My plan is to forget the whole thing and hope for the best.");
< pstack[n]←link(temp_head); align_state←align_state-unbalance;
< for m←0 to n do flush_list(pstack[m]);
< back_error; return;
---
> sprint_cs(warning_index); print(" was complete");
> help3("I suspect you've forgotten a `}', causing me to apply this")@/
> ("control sequence to too much text. How can we recover?")@/
> ("My plan is to forget the whole thing and hope for the best.");
> back_error;
> end;
> pstack[n]:=link(temp_head); align_state:=align_state-unbalance;
> for m:=0 to n do flush_list(pstack[m]);
> return;
6626c7997
< the predecessor of |r|, and we have found that |cur_tok≠info(r)|. An
---
> the predecessor of |r|, and we have found that |cur_tok<>info(r)|. An
6642,6655c8013,8027
< if s≠r then
< if s=null then @<Report an improper use of the macro and abort@>
< else begin t←s;
< repeat store_new_token(info(t)); incr(m); u←link(t); v←s;
< loop@+ begin if u=r then
< if cur_tok≠info(v) then goto done
< else begin r←link(v); goto continue;
< end;
< if info(u)≠info(v) then goto done;
< u←link(u); v←link(v);
< end;
< done: t←link(t);
< until t=r;
< end
---
> if s<>r then
> if s=null then @<Report an improper use of the macro and abort@>
> else begin t:=s;
> repeat store_new_token(info(t)); incr(m); u:=link(t); v:=s;
> loop@+ begin if u=r then
> if cur_tok<>info(v) then goto done
> else begin r:=link(v); goto continue;
> end;
> if info(u)<>info(v) then goto done;
> u:=link(u); v:=link(v);
> end;
> done: t:=link(t);
> until t=r;
> r:=s; {at this point, no tokens are recently matched}
> end
6658c8030
< begin print_nl("! Use of "); sprint_cs(warning_index);
---
> begin print_err("Use of "); sprint_cs(warning_index);
6662,6664c8034,8036
< ("put `1' after `\a', since control sequence names are")@/
< ("made up of letters only. The macro here has not been")@/
< ("followed by the required stuff, so I'm ignoring it.");
---
> ("put `1' after `\a', since control sequence names are")@/
> ("made up of letters only. The macro here has not been")@/
> ("followed by the required stuff, so I'm ignoring it.");
6669,6679c8041,8052
< begin unbalance←1;
< loop@+ begin store_new_token(cur_tok); get_token;
< if (cur_tok=par_token)∧ non_long then
< @<Report a runaway argument and abort@>;
< if cur_tok<right_brace_limit then
< if cur_tok<left_brace_limit then incr(unbalance)
< else begin decr(unbalance);
< if unbalance=0 then goto done1;
< end;
< end;
< done1: rbrace_ptr←p; store_new_token(cur_tok);
---
> begin unbalance:=1;
> @^inner loop@>
> loop@+ begin fast_store_new_token(cur_tok); get_token;
> if cur_tok=par_token then if long_state<>long_call then
> @<Report a runaway argument and abort@>;
> if cur_tok<right_brace_limit then
> if cur_tok<left_brace_limit then incr(unbalance)
> else begin decr(unbalance);
> if unbalance=0 then goto done1;
> end;
> end;
> done1: rbrace_ptr:=p; store_new_token(cur_tok);
6686,6690c8059,8063
< begin if (m=1)∧(info(p)<right_brace_limit)∧(p≠temp_head) then
< begin link(rbrace_ptr)←null; free_avail(p);
< p←link(temp_head); pstack[n]←link(p); free_avail(p);
< end
< else pstack[n]←link(temp_head);
---
> begin if (m=1)and(info(p)<right_brace_limit)and(p<>temp_head) then
> begin link(rbrace_ptr):=null; free_avail(p);
> p:=link(temp_head); pstack[n]:=link(p); free_avail(p);
> end
> else pstack[n]:=link(temp_head);
6692,6696c8065,8069
< if tracing_macros≠0 then
< begin begin_diagnostic; print_nl("#"); print_int(n);
< print("<-"); show_token_list(pstack[n-1],null,1000);
< end_diagnostic;
< end;
---
> if tracing_macros>0 then
> begin begin_diagnostic; print_nl(match_chr); print_int(n);
> print("<-"); show_token_list(pstack[n-1],null,1000);
> end_diagnostic(false);
> end;
6701c8074
< token_show(ref_count); end_diagnostic;
---
> token_show(ref_count); end_diagnostic(false);
6702a8076
>
6706c8080,8081
< some are quite elaborate.
---
> some are quite elaborate. Almost all of the routines call |get_x_token|,
> which can cause them to be invoked recursively.
6707a8083
> @^recursion@>
6711c8087,8088
< a character whose chcode is |left_brace|.)
---
> a character whose catcode is |left_brace|.) \TeX\ allows \.{\\relax} to
> appear before the |left_brace|.
6714,6729c8091,8106
< begin @<Get the next non-blank non-call token@>;
< if cur_cmd≠left_brace then
< begin print_nl("! Missing { inserted");
< @.Missing {\{} inserted@>
< help4("A left brace was mandatory here, so I've put one in.")@/
< ("You might want to delete and/or insert some corrections")@/
< ("so that I will find a matching right brace soon.")@/
< ("If you're confused by all this, try typing `I}' now.");
< back_error; cur_tok←left_brace_token+"{"; cur_cmd←left_brace;
< cur_chr←"{"; incr(align_state);
< end;
< end;
<
< @ @<Get the next non-blank non-call...@>=
< repeat get_nc_token;
< until cur_cmd≠spacer
---
> begin @<Get the next non-blank non-relax non-call token@>;
> if cur_cmd<>left_brace then
> begin print_err("Missing { inserted");
> @.Missing \{ inserted@>
> help4("A left brace was mandatory here, so I've put one in.")@/
> ("You might want to delete and/or insert some corrections")@/
> ("so that I will find a matching right brace soon.")@/
> ("(If you're confused by all this, try typing `I}' now.)");
> back_error; cur_tok:=left_brace_token+"{"; cur_cmd:=left_brace;
> cur_chr:="{"; incr(align_state);
> end;
> end;
>
> @ @<Get the next non-blank non-relax non-call token@>=
> repeat get_x_token;
> until (cur_cmd<>spacer)and(cur_cmd<>relax)
6732c8109
< by optional spaces.
---
> by optional spaces; `\.{\\relax}' is not ignored here.
6735,6759c8112,8113
< begin @<Get the next non-blank non-call...@>;
< if cur_tok≠other_token+"=" then back_input;
< end;
<
< @ Here is a procedure that ignores text until coming to a right brace at
< level zero, assuming that we start at a given level |l| of nested braces.
< The closing right brace is followed by an optional space.
<
< @p procedure pass_block(@!l:integer);
< label done;
< begin scanner_status←skipping;
< loop@+ begin get_token;
< if cur_cmd=right_brace then
< begin l←l-1;
< if l≤0 then goto done;
< end
< else if cur_cmd=left_brace then l←l+1;
< end;
< done: if l<0 then
< begin incr(align_state); print_nl("! Missing { inserted");
< @.Missing {\{} inserted@>
< help2("There should have been a `{' before the `}' that")@/
< ("I just looked at. So I put one in."); error;
< end;
< scanner_status←normal; @<Scan an optional space@>;
---
> begin @<Get the next non-blank non-call token@>;
> if cur_tok<>other_token+"=" then back_input;
6762,6764c8116,8118
< @ @<Scan an optional space@>=
< begin get_nc_token; if cur_cmd≠spacer then back_input;
< end
---
> @ @<Get the next non-blank non-call token@>=
> repeat get_x_token;
> until cur_cmd<>spacer
6767,6768c8121,8122
< Given a string of lower case letters, like `\.{pt}' or `\.{plus}' or
< `\.{after}', the |scan_keyword| routine checks to see whether the next
---
> Given a string of lowercase letters, like `\.{pt}' or `\.{plus}' or
> `\.{width}', the |scan_keyword| routine checks to see whether the next
6770c8124
< upper case letters will match their lower case counterparts; upper case
---
> uppercase letters will match their lowercase counterparts; uppercase
6779c8133
<
---
> @^inner loop@>
6786c8140
< begin p←scan_head; link(p)←null; k←str_start[s];
---
> begin p:=backup_head; link(p):=null; k:=str_start[s];
6788,6798c8142,8154
< begin get_nc_token;
< if (cur_cmd=letter)∧@|
< ((cur_chr=str_pool[k])∨(cur_chr=str_pool[k]-"a"+"A")) then
< begin store_new_token(cur_tok); incr(k)
< end
< else begin back_input;
< if p≠scan_head then ins_list(link(scan_head));
< scan_keyword←false; return;
< end;
< end;
< flush_list(link(scan_head)); scan_keyword←true;
---
> begin get_x_token; {recursion is possible here}
> @^recursion@>
> if (cur_cs=0)and@|
> ((cur_chr=so(str_pool[k]))or(cur_chr=so(str_pool[k])-"a"+"A")) then
> begin store_new_token(cur_tok); incr(k);
> end
> else if (cur_cmd<>spacer)or(p<>backup_head) then
> begin back_input;
> if p<>backup_head then back_list(link(backup_head));
> scan_keyword:=false; return;
> end;
> end;
> flush_list(link(backup_head)); scan_keyword:=true;
6801,6802c8157,8169
< @ The next routine `|scan_the|' is used to handle the `\.{\\the}' in
< constructions like `\.{\\the\\month}' and `\.{\\the\\hsize}' and
---
> @ Here is a procedure that sounds an alarm when mu and non-mu units
> are being switched.
>
> @p procedure mu_error;
> begin print_err("Incompatible glue units");
> @.Incompatible glue units@>
> help1("I'm going to assume that 1mu=1pt when they're mixed.");
> error;
> end;
>
> @ The next routine `|scan_something_internal|' is used to fetch internal
> numeric quantities like `\.{\\hsize}', and also to handle the `\.{\\the}'
> when expanding constructions like `\.{\\the\\toks0}' and
6804,6807c8171,8175
< procedure, which calls |scan_the|; on the other hand, |scan_the| also
< calls |scan_int|, for constructions like `\.{\\the\\chcode\`\\\$}' or
< `\.{\\the\\texinfo 20 3}'. So we have to declare |scan_int| as a
< |forward| procedure.
---
> procedure, which calls |scan_something_internal|; on the other hand,
> |scan_something_internal| also calls |scan_int|, for constructions like
> `\.{\\catcode\`\\\$}' or `\.{\\fontdimen} \.3 \.{\\ff}'. So we
> have to declare |scan_int| as a |forward| procedure. A few other
> procedures are also declared at this point.
6810c8178,8179
< @t\4\4@>@<Declare procedures that scan restricted classes of integers@>
---
> @t\4\4@>@<Declare procedures that scan restricted classes of integers@>@;
> @t\4\4@>@<Declare procedures that scan font-related stuff@>
6812,6815c8181,8183
< @ A single word `\.{\\the}' is used for integers, dimensions, and glue
< speci\-fi\-ca\-tions, so \TeX\ doesn't know exactly what to expect when
< |scan_the| begins. For example, any of the three types could occur
< immediately after `\.{\\hskip\\the}'; and one can even use \.{\\the} with
---
> @ \TeX\ doesn't know exactly what to expect when |scan_something_internal|
> begins. For example, an integer or dimension or glue value could occur
> immediately after `\.{\\hskip}'; and one can even say \.{\\the} with
6818,6830c8186,8201
< allowed after a construction like `\.{\\count\\the}'. To handle the
< various possibilities, |scan_the| has a |level| parameter, which tells the
< ``highest'' kind of quantity that |scan_the| is allowed to produce. Five
< levels are distinguished, namely |int_val|, |dimen_val|, |glue_val|,
< |mu_val|, and |tok_val|.
<
< The output of |scan_the| (and of the other routines |scan_int|, |scan_dimen|,
< and |scan_glue| below) is put into the global variable |cur_val|, and its
< level is put into |cur_val_level|. The highest values of |cur_val_level| are
< special: |mu_val| is used only when |cur_val| points to one of the three
< parameters \.{\\thinmskip}, \.{\\midmskip}, \.{\\thickmskip}, and |tok_val|
< is used only in cases that `\.{\\the\\output}' and `\.{\\the\\everypar}'
< are legitimate.
---
> allowed after a construction like `\.{\\count}'. To handle the various
> possibilities, |scan_something_internal| has a |level| parameter, which
> tells the ``highest'' kind of quantity that |scan_something_internal| is
> allowed to produce. Six levels are distinguished, namely |int_val|,
> |dimen_val|, |glue_val|, |mu_val|, |ident_val|, and |tok_val|.
>
> The output of |scan_something_internal| (and of the other routines
> |scan_int|, |scan_dimen|, and |scan_glue| below) is put into the global
> variable |cur_val|, and its level is put into |cur_val_level|. The highest
> values of |cur_val_level| are special: |mu_val| is used only when
> |cur_val| points to something in a ``muskip'' register, or to one of the
> three parameters \.{\\thinmuskip}, \.{\\medmuskip}, \.{\\thickmuskip};
> |ident_val| is used only when |cur_val| points to a font identifier;
> |tok_val| is used only when |cur_val| points to |null| or to the reference
> count of a token list. The last two cases are allowed only when
> |scan_something_internal| is called with |level=tok_val|.
6834,6835c8205,8206
< reference; if the output is a token list, |cur_val| will point to its
< reference count, but in this case the count will not have been updated.
---
> reference; if the output is a nonempty token list, |cur_val| will point to
> its reference count, but in this case the count will not have been updated.
6842c8213,8214
< @d tok_val=4 {token lists}
---
> @d ident_val=4 {font identifier}
> @d tok_val=5 {token lists}
6848,6854c8220,8223
< @ The hash table is initialized with `\.{\\count}', `\.{\\dimen}', and
< `\.{\\skip}' all having |register| as their command code; they are distinguished
< by the |chr_code|, which is either |int_val|, |dimen_val|, or |glue_val|.
< The `\.{\\hangindent}' primitive is constructed so that |scan_the| can
< treat it exactly like a dimension parameter. The two primitives whose
< command code is `|the|' are different solely because the |equiv| is
< zero for `\.{\\the}' and nonzero for `\.{\\minus}'.
---
> @ The hash table is initialized with `\.{\\count}', `\.{\\dimen}', `\.{\\skip}',
> and `\.{\\muskip}' all having |register| as their command code; they are
> distinguished by the |chr_code|, which is either |int_val|, |dimen_val|,
> |glue_val|, or |mu_val|.
6863,6868c8232,8233
< primitive("hangindent",hang_indent,hanging_indent_code);
< @!@:hangindent_}{\.{\\hangindent} primitive@>
< primitive("the",the,0);
< @!@:the_}{\.{\\the} primitive@>
< primitive("minus",the,1);
< @!@:minus_}{\.{\\minus} primitive@>
---
> primitive("muskip",register,mu_val);
> @!@:mu_skip_}{\.{\\muskip} primitive@>
6872,6879c8237,8245
< else if chr_code=dimen_val then print_esc("dimen")
< else print_esc("skip");
< hang_indent:print_esc("hangindent");
< the: if chr_code=0 then print_esc("the")@+else print_esc("minus");
<
< @ OK, we're ready for |scan_the| itself. A second parameter, |negative|,
< is set |true| if we want the value to be negated (e.g., if `\.{\\minus}'
< has appeared instead of `\.{\\the}').
---
> else if chr_code=dimen_val then print_esc("dimen")
> else if chr_code=glue_val then print_esc("skip")
> else print_esc("muskip");
>
> @ OK, we're ready for |scan_something_internal| itself. A second parameter,
> |negative|, is set |true| if the value that is found should be negated.
> It is assumed that |cur_cmd| and |cur_chr| represent the first token of
> the internal quantity to be scanned; an error will be signalled if
> |cur_cmd<min_internal| or |cur_cmd>max_internal|.
6881,6882c8247,8248
< @d scanned_result_end(#)==cur_val_level←#; end
< @d scanned_result(#)==@+begin cur_val←#;scanned_result_end
---
> @d scanned_result_end(#)==cur_val_level:=#;@+end
> @d scanned_result(#)==@+begin cur_val:=#;scanned_result_end
6884,6886c8250,8251
< @p procedure scan_the(@!level:small_number;@!negative:boolean);
< {fetch an internal parameter}
< label restart;
---
> @p procedure scan_something_internal(@!level:small_number;@!negative:boolean);
> {fetch an internal parameter}
6888c8253,8254
< begin restart: get_nc_token; m←cur_chr;
---
> @!p:0..nest_size; {index into |nest|}
> begin m:=cur_chr;
6891,6895c8257,8262
< assign_toks: @<Fetch a token list, provided that |level=tok_val|@>;
< assign_int: scanned_result(int_par(m))(int_val);
< assign_dimen,hang_indent: scanned_result(dimen_par(m))(dimen_val);
< assign_glue: if m≥thin_mskip then scanned_result(glue_par(m))(mu_val)
< else scanned_result(glue_par(m))(glue_val);
---
> toks_register,assign_toks,def_family,set_font,def_font: @<Fetch a token list or
> font identifier, provided that |level=tok_val|@>;
> assign_int: scanned_result(eqtb[m].int)(int_val);
> assign_dimen: scanned_result(eqtb[m].sc)(dimen_val);
> assign_glue: scanned_result(equiv(m))(glue_val);
> assign_mu_glue: scanned_result(equiv(m))(mu_val);
6897,6898c8264,8271
< set_family: scanned_result(cur_fam)(int_val);
< assign_tex_info: @<Fetch a font parameter@>;
---
> set_prev_graf: @<Fetch the |prev_graf|@>;
> set_page_int:@<Fetch the |dead_cycles| or the |insert_penalties|@>;
> set_page_dimen: @<Fetch something on the |page_so_far|@>;
> set_shape: @<Fetch the |par_shape| size@>;
> set_box_dimen: @<Fetch a box dimension@>;
> char_given,math_given: scanned_result(cur_chr)(int_val);
> assign_font_dimen: @<Fetch a font dimension@>;
> assign_font_int: @<Fetch a font integer@>;
6900,6905c8273
< last_skip: @<Fetch the glue in the current node, if any@>;
< set_font: scanned_result(font_code[cur_font])(int_val);
< def_family: @<Fetch a math font code@>;
< the: begin if m>0 then negative←¬ negative;
< goto restart;
< end;
---
> last_item: @<Fetch an item in the current node, if appropriate@>;
6913,6914c8281,8283
< begin scan_seven_bit_int;
< if m<del_code_base then scanned_result(equiv(m+cur_val))(int_val)
---
> begin scan_char_num;
> if m=math_code_base then scanned_result(ho(math_code(cur_val)))(int_val)
> else if m<math_code_base then scanned_result(equiv(m+cur_val))(int_val)
6918,6925c8287,8314
< @ @<Fetch a token list, provided that |level=tok_val|@>=
< if (level≠tok_val)∨ negative then
< begin print_nl("! Improper use of \the");
< @.Improper use of \\the@>
< help1("I'm forgetting what you said and using zero for this \the.");
< back_error; scanned_result(0)(dimen_val);
< end
< else scanned_result(equiv(m))(tok_val)
---
> @ @<Fetch a token list...@>=
> if level<>tok_val then
> begin print_err("Missing number, treated as zero");
> @.Missing number...@>
> help3("A number should have been here; I inserted `0'.")@/
> ("(If you can't figure out why I needed to see a number,")@/
> ("look up `weird error' in the index to The TeXbook.)");
> @:TeXbook}{\sl The \TeX book@>
> back_error; scanned_result(0)(dimen_val);
> end
> else if cur_cmd<=assign_toks then
> begin if cur_cmd<assign_toks then {|cur_cmd=toks_register|}
> begin scan_eight_bit_int; m:=toks_base+cur_val;
> end;
> scanned_result(equiv(m))(tok_val);
> end
> else begin back_input; scan_font_ident;
> scanned_result(font_id_base+cur_val)(ident_val);
> end
>
> @ Users refer to `\.{\\the\\spacefactor}' only in horizontal
> mode, and to `\.{\\the\\prevdepth}' only in vertical mode; so we put the
> associated mode in the modifier part of the |set_aux| command.
> The |set_page_int| command has modifier 0 or 1, for `\.{\\deadcycles}' and
> `\.{\\insertpenalties}', respectively. The |set_box_dimen| command is
> modified by either |width_offset|, |height_offset|, or |depth_offset|.
> And the |last_item| command is modified by either |int_val|, |dimen_val|,
> |glue_val|, |input_line_no_code|, or |badness_code|.
6927,6928c8316,8317
< @ A user is allowed to refer to `\.{\\the\\spacefactor}' only in horizontal
< mode, and to `\.{\\the\\prevdepth}' only in vertical mode.
---
> @d input_line_no_code=glue_val+1 {code for \.{\\inputlineno}}
> @d badness_code=glue_val+2 {code for \.{\\badness}}
6933c8322
< primitive("prevdepth",set_aux,vmode);
---
> primitive("prevdepth",set_aux,vmode);@/
6934a8324,8343
> primitive("deadcycles",set_page_int,0);
> @!@:dead_cycles_}{\.{\\deadcycles} primitive@>
> primitive("insertpenalties",set_page_int,1);
> @!@:insert_penalties_}{\.{\\insertpenalties} primitive@>
> primitive("wd",set_box_dimen,width_offset);
> @!@:wd_}{\.{\\wd} primitive@>
> primitive("ht",set_box_dimen,height_offset);
> @!@:ht_}{\.{\\ht} primitive@>
> primitive("dp",set_box_dimen,depth_offset);
> @!@:dp_}{\.{\\dp} primitive@>
> primitive("lastpenalty",last_item,int_val);
> @!@:last_penalty_}{\.{\\lastpenalty} primitive@>
> primitive("lastkern",last_item,dimen_val);
> @!@:last_kern_}{\.{\\lastkern} primitive@>
> primitive("lastskip",last_item,glue_val);
> @!@:last_skip_}{\.{\\lastskip} primitive@>
> primitive("inputlineno",last_item,input_line_no_code);
> @!@:input_line_no_}{\.{\\inputlineno} primitive@>
> primitive("badness",last_item,badness_code);
> @!@:badness_}{\.{\\badness} primitive@>
6938c8347,8359
< else print_esc("spacefactor");
---
> @+else print_esc("spacefactor");
> set_page_int: if chr_code=0 then print_esc("deadcycles")
> @+else print_esc("insertpenalties");
> set_box_dimen: if chr_code=width_offset then print_esc("wd")
> else if chr_code=height_offset then print_esc("ht")
> else print_esc("dp");
> last_item: case chr_code of
> int_val: print_esc("lastpenalty");
> dimen_val: print_esc("lastkern");
> glue_val: print_esc("lastskip");
> input_line_no_code: print_esc("inputlineno");
> othercases print_esc("badness")
> endcases;
6941,6965c8362,8385
< if abs(mode)≠m then
< begin print_nl("! Improper use of \the");
< @.Improper use of \\the@>
< help4("You can say \the\spacefactor only in horizontal mode,")@/
< ("and \the\prevdepth only in vertical mode; and")@/
< ("neither of these is meaningful inside \send. So")@/
< ("I'm forgetting what you said and using zero for this \the.");
< back_error; scanned_result(0)(dimen_val);
< end
< else begin cur_val←aux;
< if m=vmode then cur_val_level←dimen_val@+else cur_val_level←int_val;
< end
<
< @ Here is where \.{\\lastskip} is implemented. The reference count will be
< updated later.
< @:last_skip_}{\.{\\lastskip} primitive@>
<
< @<Fetch the glue in the current node, if any@>=
< begin cur_val←zero_glue;
< if not is_char_node(tail)∧(mode≠0) then
< begin if type(tail)=glue_node then cur_val←glue_ptr(tail);
< end
< else if (mode=vmode)∧(tail=head)∧(last_page_glue≠max_halfword) then
< cur_val←last_page_glue;
< cur_val_level←glue_val;
---
> if abs(mode)<>m then
> begin print_err("Improper "); print_cmd_chr(set_aux,m);
> @.Improper \\spacefactor@>
> @.Improper \\prevdepth@>
> help4("You can refer to \spacefactor only in horizontal mode;")@/
> ("you can refer to \prevdepth only in vertical mode; and")@/
> ("neither of these is meaningful inside \write. So")@/
> ("I'm forgetting what you said and using zero instead.");
> error;
> if level<>tok_val then scanned_result(0)(dimen_val)
> else scanned_result(0)(int_val);
> end
> else if m=vmode then scanned_result(prev_depth)(dimen_val)
> else scanned_result(space_factor)(int_val)
>
> @ @<Fetch the |dead_cycles| or the |insert_penalties|@>=
> begin if m=0 then cur_val:=dead_cycles@+else cur_val:=insert_penalties;
> cur_val_level:=int_val;
> end
>
> @ @<Fetch a box dimension@>=
> begin scan_eight_bit_int;
> if box(cur_val)=null then cur_val:=0 @+else cur_val:=mem[box(cur_val)+m].sc;
> cur_val_level:=dimen_val;
6968,6969c8388,8445
< @ @<Fetch a font parameter@>=
< begin scan_tex_info(false); font_info[fmem_ptr].sc←0;
---
> @ Inside an \.{\\output} routine, a user may wish to look at the page totals
> that were present at the moment when output was triggered.
>
> @d max_dimen==@'7777777777 {$2^{30}-1$}
>
> @<Fetch something on the |page_so_far|@>=
> begin if (page_contents=empty) and (not output_active) then
> if m=0 then cur_val:=max_dimen@+else cur_val:=0
> else cur_val:=page_so_far[m];
> cur_val_level:=dimen_val;
> end
>
> @ @<Fetch the |prev_graf|@>=
> if mode=0 then scanned_result(0)(int_val) {|prev_graf=0| within \.{\\write}}
> else begin nest[nest_ptr]:=cur_list; p:=nest_ptr;
> while abs(nest[p].mode_field)<>vmode do decr(p);
> scanned_result(nest[p].pg_field)(int_val);
> end
>
> @ @<Fetch the |par_shape| size@>=
> begin if par_shape_ptr=null then cur_val:=0
> else cur_val:=info(par_shape_ptr);
> cur_val_level:=int_val;
> end
>
> @ Here is where \.{\\lastpenalty}, \.{\\lastkern}, and \.{\\lastskip} are
> implemented. The reference count for \.{\\lastskip} will be updated later.
>
> We also handle \.{\\inputlineno} and \.{\\badness} here, because they are
> legal in similar contexts.
>
> @<Fetch an item in the current node...@>=
> if cur_chr>glue_val then
> begin if cur_chr=input_line_no_code then cur_val:=line
> else cur_val:=last_badness; {|cur_chr=badness_code|}
> cur_val_level:=int_val;
> end
> else begin if cur_chr=glue_val then cur_val:=zero_glue@+else cur_val:=0;
> cur_val_level:=cur_chr;
> if not is_char_node(tail)and(mode<>0) then
> case cur_chr of
> int_val: if type(tail)=penalty_node then cur_val:=penalty(tail);
> dimen_val: if type(tail)=kern_node then cur_val:=width(tail);
> glue_val: if type(tail)=glue_node then
> begin cur_val:=glue_ptr(tail);
> if subtype(tail)=mu_glue then cur_val_level:=mu_val;
> end;
> end {there are no other cases}
> else if (mode=vmode)and(tail=head) then
> case cur_chr of
> int_val: cur_val:=last_penalty;
> dimen_val: cur_val:=last_kern;
> glue_val: if last_glue<>max_halfword then cur_val:=last_glue;
> end; {there are no other cases}
> end
>
> @ @<Fetch a font dimension@>=
> begin find_font_dimen(false); font_info[fmem_ptr].sc:=0;
6972a8449,8454
> @ @<Fetch a font integer@>=
> begin scan_font_ident;
> if m=0 then scanned_result(hyphen_char[cur_val])(int_val)
> else scanned_result(skew_char[cur_val])(int_val);
> end
>
6976,6978c8458,8461
< int_val:cur_val←count(cur_val);
< dimen_val:cur_val←dimen(cur_val);
< glue_val:cur_val←skip(cur_val);
---
> int_val:cur_val:=count(cur_val);
> dimen_val:cur_val:=dimen(cur_val);
> glue_val: cur_val:=skip(cur_val);
> mu_val: cur_val:=mu_skip(cur_val);
6980,6984c8463
< cur_val_level←m;
< end
<
< @ @<Fetch a math font code@>=
< begin scan_four_bit_int; scanned_result(font_code[equiv(m+cur_val)])(int_val);
---
> cur_val_level:=m;
6988,6992c8467,8473
< begin print_nl("! You can't use "); print_cmd_chr(cur_cmd,cur_chr);
< @.You can't use x after \\the@>
< print(" after \the");
< help1("I'm forgetting what you said and using zero for this \the.");
< back_error; scanned_result(0)(dimen_val);
---
> begin print_err("You can't use `"); print_cmd_chr(cur_cmd,cur_chr);
> @.You can't use x after ...@>
> print("' after "); print_esc("the");
> help1("I'm forgetting what you said and using zero instead.");
> error;
> if level<>tok_val then scanned_result(0)(dimen_val)
> else scanned_result(0)(int_val);
7002c8483,8484
< begin if cur_val_level=glue_val then cur_val←width(cur_val);
---
> begin if cur_val_level=glue_val then cur_val:=width(cur_val)
> else if cur_val_level=mu_val then mu_error;
7007a8490
> If |negative| is |true|, |cur_val_level| is known to be |<=mu_val|.
7011,7017c8494,8506
< if cur_val_level≥glue_val then
< begin cur_val←new_spec(cur_val);
< @<Negate all three glue components of |cur_val|@>;
< end
< else cur_val←-cur_val
< else if (cur_val_level≥glue_val)∧(cur_val_level≠tok_val) then
< add_glue_ref(cur_val)
---
> if cur_val_level>=glue_val then
> begin cur_val:=new_spec(cur_val);
> @<Negate all three glue components of |cur_val|@>;
> end
> else negate(cur_val)
> else if (cur_val_level>=glue_val)and(cur_val_level<=mu_val) then
> add_glue_ref(cur_val)
>
> @ @<Negate all three...@>=
> begin negate(width(cur_val));
> negate(stretch(cur_val));
> negate(shrink(cur_val));
> end
7021,7032c8510,8511
< applications of |scan_int| that have already been made inside of |scan_the|:
<
< @<Declare procedures that scan restricted classes of integers@>=
< procedure scan_seven_bit_int;
< begin scan_int;
< if (cur_val<0)∨(cur_val>127) then
< begin print_nl("! Bad character code");
< @.Bad character code@>
< help2("The numeric code for a character must be between 0 and 127.")@/
< ("I changed this one to zero."); int_error(cur_val); cur_val←0;
< end;
< end;
---
> applications of |scan_int| that have already been made inside of
> |scan_something_internal|.
7037,7038c8516,8517
< if (cur_val<0)∨(cur_val>255) then
< begin print_nl("! Bad register code");
---
> if (cur_val<0)or(cur_val>255) then
> begin print_err("Bad register code");
7040,7042c8519,8521
< help2("Boxes, counts, dimens, and skips must be between 0 and 255.")@/
< ("I changed this one to zero."); int_error(cur_val); cur_val←0;
< end;
---
> help2("A register number must be between 0 and 255.")@/
> ("I changed this one to zero."); int_error(cur_val); cur_val:=0;
> end;
7046c8525
< procedure scan_four_bit_int;
---
> procedure scan_char_num;
7048,7053c8527,8532
< if (cur_val<0)∨(cur_val>15) then
< begin print_nl("! Bad number");
< @.Bad number@>
< help2("Since I expected to read a number between 0 and 15,")@/
< ("I changed this one to zero."); int_error(cur_val); cur_val←0;
< end;
---
> if (cur_val<0)or(cur_val>255) then
> begin print_err("Bad character code");
> @.Bad character code@>
> help2("A character number must be between 0 and 255.")@/
> ("I changed this one to zero."); int_error(cur_val); cur_val:=0;
> end;
7060c8539
< procedure scan_char_num;
---
> procedure scan_four_bit_int;
7062,7067c8541,8546
< if (cur_val<0)∨(cur_val>255) then
< begin print_nl("! Bad \char code");
< @.Bad \\char code@>
< help2("The numeric code following \char must be between 0 and 255.")@/
< ("I changed this one to zero."); int_error(cur_val); cur_val←0;
< end;
---
> if (cur_val<0)or(cur_val>15) then
> begin print_err("Bad number");
> @.Bad number@>
> help2("Since I expected to read a number between 0 and 15,")@/
> ("I changed this one to zero."); int_error(cur_val); cur_val:=0;
> end;
7073,7078c8552,8557
< if (cur_val<0)∨(cur_val>@'77777) then
< begin print_nl("! Bad \mathchar code");
< @.Bad \\mathchar code@>
< help2("A numeric \mathchar code must be between 0 and 32767.")@/
< ("I changed this one to zero."); int_error(cur_val); cur_val←0;
< end;
---
> if (cur_val<0)or(cur_val>@'77777) then
> begin print_err("Bad mathchar");
> @.Bad mathchar@>
> help2("A mathchar number must be between 0 and 32767.")@/
> ("I changed this one to zero."); int_error(cur_val); cur_val:=0;
> end;
7084,7085c8563,8564
< if (cur_val<0)∨(cur_val>@'777777777) then
< begin print_nl("! Bad delimiter code");
---
> if (cur_val<0)or(cur_val>@'777777777) then
> begin print_err("Bad delimiter code");
7087,7089c8566,8568
< help2("A numeric delimiter code must be between 0 and 2^{27}-1.")@/
< ("I changed this one to zero."); int_error(cur_val); cur_val←0;
< end;
---
> help2("A numeric delimiter code must be between 0 and 2^{27}-1.")@/
> ("I changed this one to zero."); int_error(cur_val); cur_val:=0;
> end;
7094,7097c8573,8575
< octal constant (i.e., radix 8, preceded by@@\.\'), a hexadecimal constant
< (radix 16, preceded by@@\."), an alphabetic constant (preceded by@@\.\`), or
< an internal variable obtained by prefixing \.{\\the}. (The `\.{\\the}'
< can be omitted before `\.{\\count}'.) After scanning is complete,
---
> octal constant (i.e., radix 8, preceded by~\.\'), a hexadecimal constant
> (radix 16, preceded by~\."), an alphabetic constant (preceded by~\.\`), or
> an internal variable. After scanning is complete,
7101c8579
< otherwise |radix| is set to zero. An optional space follows the number.
---
> otherwise |radix| is set to zero. An optional space follows a constant.
7103,7106d8580
< @d plus_token=other_token+"+" {plus sign}
< @d minus_token=other_token+"-" {minus sign}
< @d zero_token=other_token+"0" {zero, the smallest digit}
< @d A_token=letter_token+"A" {the smallest special hex digit}
7110a8585
> @d continental_point_token=other_token+"," {decimal point, Eurostyle}
7114a8590,8596
> @ We initialize the following global variables just in case |expand|
> comes into action before any of the basic scanning routines has assigned
> them a value.
>
> @<Set init...@>=
> cur_val:=0; cur_val_level:=int_val; radix:=0; cur_order:=normal;
>
7128c8610
< begin radix←0; OK_so_far←true;@/
---
> begin radix:=0; OK_so_far:=true;@/
7131c8613,8614
< else if (cur_cmd=the)∨(cur_cmd=register) then @<Fetch an internal integer@>
---
> else if (cur_cmd>=min_internal)and(cur_cmd<=max_internal) then
> scan_something_internal(int_val,false)
7133c8616
< if negative then cur_val←-cur_val;
---
> if negative then negate(cur_val);
7137c8620
< negative←false;
---
> negative:=false;
7139,7142c8622,8625
< if cur_tok=minus_token then
< begin negative ← ¬ negative; cur_tok←plus_token;
< end;
< until cur_tok≠plus_token
---
> if cur_tok=other_token+"-" then
> begin negative := not negative; cur_tok:=other_token+"+";
> end;
> until cur_tok<>other_token+"+"
7149,7154c8632,8642
< if cur_tok<cs_token_flag then cur_val←cur_chr
< else if cur_tok<cs_token_flag+active_base then
< cur_val←cur_tok-cs_token_flag-single_base
< else cur_val←cur_tok-cs_token_flag-active_base;
< if cur_val>127 then
< begin print_nl("! Improper alphabetic constant");
---
> if cur_tok<cs_token_flag then
> begin cur_val:=cur_chr;
> if cur_cmd<=right_brace then
> if cur_cmd=right_brace then incr(align_state)
> else decr(align_state);
> end
> else if cur_tok<cs_token_flag+single_base then
> cur_val:=cur_tok-cs_token_flag-active_base
> else cur_val:=cur_tok-cs_token_flag-single_base;
> if cur_val>255 then
> begin print_err("Improper alphabetic constant");
7156,7159c8644,8647
< help2("A one-character control sequence belongs after a ` mark.")@/
< ("So I'm essentially inserting \0 here.");
< cur_val←"0"; back_error;
< end
---
> help2("A one-character control sequence belongs after a ` mark.")@/
> ("So I'm essentially inserting \0 here.");
> cur_val:="0"; back_error;
> end
7163,7166c8651,8652
< @ @<Fetch an internal integer@>=
< begin if cur_cmd=register then back_input {implied `\.{\\the}'}
< else if cur_chr≠0 then negative ← ¬ negative; {handle `\.{\\minus}'}
< scan_the(int_val,false);
---
> @ @<Scan an optional space@>=
> begin get_x_token; if cur_cmd<>spacer then back_input;
7170c8656
< begin radix←10; m←214748364;
---
> begin radix:=10; m:=214748364;
7172,7173c8658,8659
< begin radix←8; m←@'2000000000; get_nc_token;
< end
---
> begin radix:=8; m:=@'2000000000; get_x_token;
> end
7175,7177c8661,8663
< begin radix←16; m←@'1000000000; get_nc_token;
< end;
< vacuous←true; cur_val←0;@/
---
> begin radix:=16; m:=@'1000000000; get_x_token;
> end;
> vacuous:=true; cur_val:=0;@/
7179,7180c8665,8666
< if vacuous then @<Express astonishment that no number was here@>;
< if cur_cmd≠spacer then back_input;
---
> if vacuous then @<Express astonishment that no number was here@>
> else if cur_cmd<>spacer then back_input;
7183a8670,8672
> @d zero_token=other_token+"0" {zero, the smallest digit}
> @d A_token=letter_token+"A" {the smallest special hex digit}
> @d other_A_token=other_token+"A" {special hex digit of type |other_char|}
7186,7194c8675,8686
< loop@+ begin if (cur_tok<zero_token+radix)∧(cur_tok≥zero_token)∧
< (cur_tok≤zero_token+9) then d←cur_tok-zero_token
< else if (radix=16)∧(cur_tok≤A_token+5)∧(cur_tok≥A_token) then
< d←cur_tok-A_token+10
< else goto done;
< vacuous←false;
< if (cur_val≥m)∧((cur_val>m)∨(d>7)∨(radix≠10)) then
< begin if OK_so_far then
< begin print_nl("! Number too big");
---
> loop@+ begin if (cur_tok<zero_token+radix)and(cur_tok>=zero_token)and
> (cur_tok<=zero_token+9) then d:=cur_tok-zero_token
> else if radix=16 then
> if (cur_tok<=A_token+5)and(cur_tok>=A_token) then d:=cur_tok-A_token+10
> else if (cur_tok<=other_A_token+5)and(cur_tok>=other_A_token) then
> d:=cur_tok-other_A_token+10
> else goto done
> else goto done;
> vacuous:=false;
> if (cur_val>=m)and((cur_val>m)or(d>7)or(radix<>10)) then
> begin if OK_so_far then
> begin print_err("Number too big");
7196,7203c8688,8695
< help2("I can only go up to 2147483647='17777777777=""7FFFFFFF,")@/
< ("so I'm using that number instead of yours.");
< error; cur_val←infinity; OK_so_far←false;
< end;
< end
< else cur_val←cur_val*radix+d;
< get_nc_token;
< end;
---
> help2("I can only go up to 2147483647='17777777777=""7FFFFFFF,")@/
> ("so I'm using that number instead of yours.");
> error; cur_val:=infinity; OK_so_far:=false;
> end;
> end
> else cur_val:=cur_val*radix+d;
> get_x_token;
> end;
7207,7208c8699,8700
< begin print_nl("! Missing number");
< @.Missing number@>
---
> begin print_err("Missing number, treated as zero");
> @.Missing number...@>
7210,7212c8702,8705
< ("(If you can't figure out why I needed to see a number,")@/
< ("look up `weird error' in the TeX manual index.)");
< error;
---
> ("(If you can't figure out why I needed to see a number,")@/
> ("look up `weird error' in the index to The TeXbook.)");
> @:TeXbook}{\sl The \TeX book@>
> back_error;
7243a8737
> @d scan_normal_dimen==scan_dimen(false,false,false)
7246,7247c8740,8741
< {sets |cur_val| to a dimension}
< label done, found, not_found, attach_fraction, attach_sign;
---
> {sets |cur_val| to a dimension}
> label done, done1, done2, found, not_found, attach_fraction, attach_sign;
7251c8745
< begin f←0; arith_error←false; cur_order←normal; negative←false;
---
> begin f:=0; arith_error:=false; cur_order:=normal; negative:=false;
7253,7266c8747,8762
< begin @<Get the next non-blank non-sign...@>;
< if (cur_cmd=the)∨(cur_cmd=register) then
< @<Fetch an internal dimension and |goto attach_sign|,
< or fetch an internal integer@>
< else begin back_input;
< if cur_tok≠point_token then scan_int
< else begin radix←10; cur_val←0;
< end;
< if (radix=10)∧(cur_tok=point_token) then @<Scan decimal fraction@>;
< end;
< end;
< if cur_val<0 then {in this case |f<0|}
< begin negative ← ¬ negative; cur_val←-cur_val;
< end;
---
> begin @<Get the next non-blank non-sign...@>;
> if (cur_cmd>=min_internal)and(cur_cmd<=max_internal) then
> @<Fetch an internal dimension and |goto attach_sign|,
> or fetch an internal integer@>
> else begin back_input;
> if cur_tok=continental_point_token then cur_tok:=point_token;
> if cur_tok<>point_token then scan_int
> else begin radix:=10; cur_val:=0;
> end;
> if cur_tok=continental_point_token then cur_tok:=point_token;
> if (radix=10)and(cur_tok=point_token) then @<Scan decimal fraction@>;
> end;
> end;
> if cur_val<0 then {in this case |f=0|}
> begin negative := not negative; negate(cur_val);
> end;
7268,7271c8764
< are $x$ units per sp@>;
< attach_sign: if negative then cur_val←-cur_val;
< if arith_error ∨(abs(cur_val)≥@'10000000000) then
< @<Report that this dimension is out of range@>;
---
> are |x| sp per unit; |goto attach_sign| if the units are internal@>;
7272a8766,8768
> attach_sign: if arith_error or(abs(cur_val)>=@'10000000000) then
> @<Report that this dimension is out of range@>;
> if negative then negate(cur_val);
7276,7280c8772,8780
< begin if cur_cmd=register then back_input {implied `\.{\\the}'}
< else if cur_chr≠0 then negative ← ¬ negative; {handle `\.{\\minus}'}
< scan_the(dimen_val,false);
< if cur_val_level=dimen_val then goto attach_sign;
< end
---
> if mu then
> begin scan_something_internal(mu_val,false);
> @<Coerce glue to a dimension@>;
> if cur_val_level=mu_val then goto attach_sign;
> if cur_val_level<>int_val then mu_error;
> end
> else begin scan_something_internal(dimen_val,false);
> if cur_val_level=dimen_val then goto attach_sign;
> end
7284,7285c8784,8785
< @!k:small_number; {number of digits in a decimal fraction}
< @!j:small_number; {index into a box node}
---
> @!k,@!kk:small_number; {number of digits in a decimal fraction}
> @!p,@!q:pointer; {top of decimal digit stack}
7287c8787,8796
< @!save_cur_val:scaled; {temporary storage of |cur_val|}
---
> @!save_cur_val:integer; {temporary storage of |cur_val|}
>
> @ The following code is executed when |scan_something_internal| was
> called asking for |mu_val|, when we really wanted a ``mudimen'' instead
> of ``muglue.''
>
> @<Coerce glue to a dimension@>=
> if cur_val_level>=glue_val then
> begin v:=width(cur_val); delete_glue_ref(cur_val); cur_val:=v;
> end
7296,7303c8805,8817
< begin k←0; get_token; {|point_token| is being re-scanned}
< loop@+ begin get_nc_token;
< if (cur_tok>zero_token+9)∨(cur_tok<zero_token) then goto done;
< if k<16 then {digits for |k≥16| cannot affect the result}
< begin dig[k]←cur_tok-zero_token; incr(k);
< end;
< end;
< done: f←round_decimals(k); back_input;
---
> begin k:=0; p:=null; get_token; {|point_token| is being re-scanned}
> loop@+ begin get_x_token;
> if (cur_tok>zero_token+9)or(cur_tok<zero_token) then goto done1;
> if k<17 then {digits for |k>=17| cannot affect the result}
> begin q:=get_avail; link(q):=p; info(q):=cur_tok-zero_token;
> p:=q; incr(k);
> end;
> end;
> done1: for kk:=k downto 1 do
> begin dig[kk-1]:=info(p); q:=p; p:=link(p); free_avail(q);
> end;
> f:=round_decimals(k);
> if cur_cmd<>spacer then back_input;
7311,7312c8825
< does not overflow. This section of the program is followed by the label
< |attach_sign|.
---
> does not overflow.
7315,7318c8828,8831
< if inf then @<Scan for \.{fil} units; |goto attach_fraction| if found@>;
< if mu then @<Scan for \.{mu} units and |goto attach_fraction|@>;
< @<Scan for units that are internal dimensions,
< and |goto attach_sign| if found@>;
---
> if inf then @<Scan for \(f)\.{fil} units; |goto attach_fraction| if found@>;
> @<Scan for \(u)units that are internal dimensions;
> |goto attach_sign| with |cur_val| set if found@>;
> if mu then @<Scan for \(m)\.{mu} units and |goto attach_fraction|@>;
7319a8833
> @.true@>
7321,7323c8835,8840
< @<Scan for all other units and adjust |cur_val| and |f| accordingly@>;
< attach_fraction: if cur_val≥@'40000 then arith_error←true
< else cur_val←cur_val*unity+f
---
> @.pt@>
> @<Scan for \(a)all other units and adjust |cur_val| and |f| accordingly;
> |goto done| in the case of scaled points@>;
> attach_fraction: if cur_val>=@'40000 then arith_error:=true
> else cur_val:=cur_val*unity+f;
> done:
7325c8842,8845
< @ @<Scan for \.{fil} units...@>=
---
> @ A specification like `\.{filllll}' or `\.{fill L L L}' will lead to two
> error messages (one for each additional keyword \.{"l"}).
>
> @<Scan for \(f)\.{fil} units...@>=
7327,7331c8847,8851
< begin cur_order←fil;
< while scan_keyword("l") do
< begin if cur_order=filll then
< begin help1("I dddon't go any higher than filll.");
< print_nl("! Illegal unit of measure (");
---
> @.fil@>
> begin cur_order:=fil;
> while scan_keyword("l") do
> begin if cur_order=filll then
> begin print_err("Illegal unit of measure (");
7333,7338c8853,8859
< print("replaced by filll)"); error;
< end
< else incr(cur_order);
< end;
< goto attach_fraction;
< end
---
> print("replaced by filll)");
> help1("I dddon't go any higher than filll."); error;
> end
> else incr(cur_order);
> end;
> goto attach_fraction;
> end
7340,7360c8861,8876
< @ @<Scan for \.{mu} units and |goto attach_fraction|@>=
< if scan_keyword("mu") then goto attach_fraction
< else begin print_nl("! Illegal unit of measure ("); print("mu inserted)");
< @.Illegal unit of measure@>
< help4("The unit of measurement in \mskip glue must be mu.")@/
< ("To recover gracefully from this error, it's best to")@/
< ("delete the erroneous units; e.g., type `2' to delete")@/
< ("two letters. (See Chapter 27 of the manual.)");
< error; goto attach_fraction;
< end
<
< @ @d set_internal_dimen(#)==begin v←#; goto found;
< end
<
< @<Scan for units that are internal dimensions...@>=
< if scan_keyword("em") then set_internal_dimen(@<The em width for |cur_font|@>);
< if scan_keyword("ex") then set_internal_dimen(@<The x-height for |cur_font|@>);
< if scan_keyword("vu") then set_internal_dimen(var_unit);
< if scan_keyword("wd") then j←width_offset
< else if scan_keyword("dp") then j←depth_offset
< else if scan_keyword("ht") then j←height_offset
---
> @ @<Scan for \(u)units that are internal dimensions...@>=
> save_cur_val:=cur_val;
> @<Get the next non-blank non-call...@>;
> if (cur_cmd<min_internal)or(cur_cmd>max_internal) then back_input
> else begin if mu then
> begin scan_something_internal(mu_val,false); @<Coerce glue...@>;
> if cur_val_level<>mu_val then mu_error;
> end
> else scan_something_internal(dimen_val,false);
> v:=cur_val; goto found;
> end;
> if mu then goto not_found;
> if scan_keyword("em") then v:=(@<The em width for |cur_font|@>)
> @.em@>
> else if scan_keyword("ex") then v:=(@<The x-height for |cur_font|@>)
> @.ex@>
7362,7365c8878,8879
< save_cur_val←cur_val; scan_eight_bit_int;
< if box(cur_val)=null then v←0@+else v←mem[box(cur_val)+j].sc;
< cur_val←save_cur_val;
< found:cur_val←nx_plus_y(cur_val,v,xn_over_d(v,f,@'200000));
---
> @<Scan an optional space@>;
> found:cur_val:=nx_plus_y(save_cur_val,v,xn_over_d(v,f,@'200000));
7369,7377c8883,8894
< @ @<Adjust \(f)for the magnification ratio@>=
< begin @<Scan an optional space@>;
< prepare_mag;
< if mag≠1000 then
< begin cur_val←xn_over_d(cur_val,1000,mag);
< f←(1000*f+@'200000*remainder) div mag;
< cur_val←cur_val+(f div @'200000); f←f mod @'200000;
< end;
< end
---
> @ @<Scan for \(m)\.{mu} units and |goto attach_fraction|@>=
> if scan_keyword("mu") then goto attach_fraction
> @.mu@>
> else begin print_err("Illegal unit of measure ("); print("mu inserted)");
> @.Illegal unit of measure@>
> help4("The unit of measurement in math glue must be mu.")@/
> ("To recover gracefully from this error, it's best to")@/
> ("delete the erroneous units; e.g., type `2' to delete")@/
> ("two letters. (See Chapter 27 of The TeXbook.)");
> @:TeXbook}{\sl The \TeX book@>
> error; goto attach_fraction;
> end
7379,7380c8896,8910
< @ All of the necessary conversion factors can be specified exactly as a
< fraction whose numerator and denominator are 65536 or less.
---
> @ @<Adjust \(f)for the magnification ratio@>=
> begin prepare_mag;
> if mag<>1000 then
> begin cur_val:=xn_over_d(cur_val,1000,mag);
> f:=(1000*f+@'200000*remainder) div mag;
> cur_val:=cur_val+(f div @'200000); f:=f mod @'200000;
> end;
> end
>
> @ The necessary conversion factors can all be specified exactly as
> fractions whose numerator and denominator sum to 32768 or less.
> According to the definitions here, $\rm2660\,dd\approx1000.33297\,mm$;
> this agrees well with the value $\rm1000.333\,mm$ cited by Bosshard
> @^Bosshard, Hans Rudolf@>
> in {\sl Technische Grundlagen zur Satzherstellung\/} (Bern, 1980).
7382,7383c8912,8913
< @d set_conversion_end(#)== denom←#; end
< @d set_conversion(#)==@+begin num←#; set_conversion_end
---
> @d set_conversion_end(#)== denom:=#; end
> @d set_conversion(#)==@+begin num:=#; set_conversion_end
7385c8915
< @<Scan for all other units and adjust |cur_val| and |f| accordingly@>=
---
> @<Scan for \(a)all other units and adjust |cur_val| and |f|...@>=
7386a8917
> @.in@>
7387a8919
> @.pc@>
7388a8921
> @.cm@>
7389a8923
> @.mm@>
7391,7397c8925,8936
< else if scan_keyword("dd") then set_conversion(215)(201)
< else if scan_keyword("cc") then set_conversion(2580)(201)
< else if scan_keyword("sp") then goto attach_sign
< else @<Complain about unknown unit and |goto attach_fraction|@>;
< cur_val←xn_over_d(cur_val,num,denom);
< f←(num*f+@'200000*remainder) div denom;@/
< cur_val←cur_val+(f div @'200000); f←f mod @'200000
---
> @.bp@>
> else if scan_keyword("dd") then set_conversion(1238)(1157)
> @.dd@>
> else if scan_keyword("cc") then set_conversion(14856)(1157)
> @.cc@>
> else if scan_keyword("sp") then goto done
> @.sp@>
> else @<Complain about unknown unit and |goto done2|@>;
> cur_val:=xn_over_d(cur_val,num,denom);
> f:=(num*f+@'200000*remainder) div denom;@/
> cur_val:=cur_val+(f div @'200000); f:=f mod @'200000;
> done2:
7400c8939
< begin print_nl("! Illegal unit of measure ("); print("pt inserted)");
---
> begin print_err("Illegal unit of measure ("); print("pt inserted)");
7402,7408c8941,8948
< help6("Dimensions can be in units of em, ex, vu, wd, dp, ht, in,")@/
< ("pt, pc, cm, mm, bp, dd, cc, or sp, but yours is a new one.")@/
< ("I'll assume that you meant to say pt, for printers' points.")@/
< ("To recover gracefully from this error, it's best to")@/
< ("delete the erroneous units; e.g., type `2' to delete")@/
< ("two letters. (See Chapter 27 of the manual.)");
< error; goto attach_fraction;
---
> help6("Dimensions can be in units of em, ex, in, pt, pc,")@/
> ("cm, mm, dd, cc, bp, or sp; but yours is a new one!")@/
> ("I'll assume that you meant to say pt, for printer's points.")@/
> ("To recover gracefully from this error, it's best to")@/
> ("delete the erroneous units; e.g., type `2' to delete")@/
> ("two letters. (See Chapter 27 of The TeXbook.)");
> @:TeXbook}{\sl The \TeX book@>
> error; goto done2;
7411d8950
< @ @d max_dimen==@'7777777777 {$2^{30}-1$}
7413,7414c8952,8953
< @<Report that this dimension is out of range@>=
< begin print_nl("! Dimension too large");
---
> @ @<Report that this dimension is out of range@>=
> begin print_err("Dimension too large");
7417,7418c8956,8957
< ("Continue and I'll use the largest value I can.");@/
< error; cur_val←max_dimen;
---
> ("Continue and I'll use the largest value I can.");@/
> error; cur_val:=max_dimen; arith_error:=false;
7423c8962
< glue spec will take account of the fact that |cur_val| is pointing to it.
---
> glue spec will take account of the fact that |cur_val| is pointing to~it.
7425,7426c8964
< As before, the |mu| parameter is |true| if the glue is supposed to be
< an \.{\\mskip}.
---
> The |level| parameter should be either |glue_val| or |mu_val|.
7430c8968
< most of the work has already been done for us.
---
> most of the work has already been done.
7432c8970,8971
< @p procedure scan_glue(@!mu:boolean); {sets |cur_val| to a glue spec pointer}
---
> @p procedure scan_glue(@!level:small_number);
> {sets |cur_val| to a glue spec pointer}
7436,7445c8975,8988
< begin @<Get the next non-blank non-sign...@>;
< if (cur_cmd=the)∨(cur_cmd=register) then
< begin if cur_cmd=register then back_input {implied `\.{\\the}'}
< else if cur_chr≠0 then negative ← ¬ negative; {handle `\.{\\minus}'}
< scan_the(glue_val,negative); negative←false;
< if cur_val_level=glue_val then return;
< if cur_val_level=int_val then scan_dimen(mu,false,true);
< end
< else begin back_input; scan_dimen(mu,false,false);
< end;
---
> @!mu:boolean; {does |level=mu_val|?}
> begin mu:=(level=mu_val); @<Get the next non-blank non-sign...@>;
> if (cur_cmd>=min_internal)and(cur_cmd<=max_internal) then
> begin scan_something_internal(level,negative);
> if cur_val_level>=glue_val then
> begin if cur_val_level<>level then mu_error;
> return;
> end;
> if cur_val_level=int_val then scan_dimen(mu,false,true)
> else if level=mu_val then mu_error;
> end
> else begin back_input; scan_dimen(mu,false,false);
> if negative then negate(cur_val);
> end;
7447,7448c8990
< stretch and shrink components@>;
< if negative then @<Negate all three glue components of |cur_val|@>;
---
> stretch and shrink components@>;
7452c8994
< q←new_spec(zero_glue); width(q)←cur_val;
---
> q:=new_spec(zero_glue); width(q):=cur_val;
7454,7456c8996,8999
< begin scan_dimen(mu,true,false);
< stretch(q)←cur_val; stretch_order(q)←cur_order;
< end;
---
> @.plus@>
> begin scan_dimen(mu,true,false);
> stretch(q):=cur_val; stretch_order(q):=cur_order;
> end;
7458,7467c9001,9005
< begin scan_dimen(mu,true,false);
< shrink(q)←cur_val; shrink_order(q)←cur_order;
< end;
< cur_val←q
<
< @ @<Negate all three...@>=
< begin width(cur_val)←-width(cur_val);
< stretch(cur_val)←-stretch(cur_val);
< shrink(cur_val)←-shrink(cur_val);
< end
---
> @.minus@>
> begin scan_dimen(mu,true,false);
> shrink(q):=cur_val; shrink_order(q):=cur_order;
> end;
> cur_val:=q
7476c9014
< @d default_rule=26215 {.40001 pt}
---
> @d default_rule=26214 {0.4\thinspace pt}
7481,7484c9019,9022
< begin q←new_rule; {|width|, |depth|, and |height| all equal |null_flag| now}
< if cur_cmd=vrule then width(q)←default_rule
< else begin height(q)←default_rule; depth(q)←0;
< end;
---
> begin q:=new_rule; {|width|, |depth|, and |height| all equal |null_flag| now}
> if cur_cmd=vrule then width(q):=default_rule
> else begin height(q):=default_rule; depth(q):=0;
> end;
7486,7487c9024,9026
< begin scan_dimen(false,false,false); width(q)←cur_val; goto reswitch;
< end;
---
> @.width@>
> begin scan_normal_dimen; width(q):=cur_val; goto reswitch;
> end;
7489,7490c9028,9030
< begin scan_dimen(false,false,false); height(q)←cur_val; goto reswitch;
< end;
---
> @.height@>
> begin scan_normal_dimen; height(q):=cur_val; goto reswitch;
> end;
7492,7494c9032,9035
< begin scan_dimen(false,false,false); depth(q)←cur_val; goto reswitch;
< end;
< scan_rule_spec←q;
---
> @.depth@>
> begin scan_normal_dimen; depth(q):=cur_val; goto reswitch;
> end;
> scan_rule_spec:=q;
7495a9037
>
7498,7506c9040
< and \.{\\send} are produced by a procedure called |scan_toks|.
<
< Before we get into the details of |scan_toks|, let's consider a much simpler
< task, that of converting the current string into a token list. The |str_toks|
< function does this; it classifies spaces as type |spacer|, characters |≥"a"|
< as type |letter|, and everything else as type |other_char|. (These
< three categories are sufficient, since |str_toks| is used only with the
< special strings that can occur when \.{\\the} or \.{\\number} constructions
< are being expanded.)
---
> and \.{\\write} are produced by a procedure called |scan_toks|.
7507a9042,9045
> Before we get into the details of |scan_toks|, let's consider a much
> simpler task, that of converting the current string into a token list.
> The |str_toks| function does this; it classifies spaces as type |spacer|
> and everything else as type |other_char|.
7512c9050,9051
< @p function str_toks:pointer; {changes the current string to a token list}
---
> @p function str_toks(@!b:pool_pointer):pointer;
> {changes the string |str_pool[b..pool_ptr]| to a token list}
7518c9057
< p←temp_head; link(p)←null; k←str_start[str_ptr];
---
> p:=temp_head; link(p):=null; k:=b;
7520,7527c9059,9065
< begin t←str_pool[k];
< if t=" " then t←space_token
< else if t≥"a" then t←letter_token+t
< else t←other_token+t;
< store_new_token(t);
< incr(k);
< end;
< pool_ptr←str_start[str_ptr]; str_toks←p;
---
> begin t:=so(str_pool[k]);
> if t=" " then t:=space_token
> else t:=other_token+t;
> fast_store_new_token(t);
> incr(k);
> end;
> pool_ptr:=b; str_toks:=p;
7531a9070
>
7533,7535c9072,9073
< i.e., whatever can follow `\.{\\the}' or `\.{\\minus}', and it
< constructs a token list containing something like `\.{-3.0pt
< minus 0.5fill}'.
---
> i.e., whatever can follow `\.{\\the}', and it constructs a token list
> containing something like `\.{-3.0pt minus 0.5fill}'.
7537c9075
< @p function the_toks(@!negative:boolean):pointer;
---
> @p function the_toks:pointer;
7540,7553c9078,9092
< begin scan_the(tok_val,negative);
< if cur_val_level=tok_val then @<Copy the token list@>
< else begin old_setting←selector; selector←new_string;
< case cur_val_level of
< int_val:print_int(cur_val);
< dimen_val:begin print_scaled(cur_val); print("pt");
< end;
< glue_val: begin print_spec(cur_val,"pt"); delete_glue_ref(cur_val);
< end;
< mu_val: begin print_spec(cur_val,"mu"); delete_glue_ref(cur_val);
< end;
< end; {there are no other cases}
< selector←old_setting; the_toks←str_toks;
< end;
---
> @!b:pool_pointer; {base of temporary string}
> begin get_x_token; scan_something_internal(tok_val,false);
> if cur_val_level>=ident_val then @<Copy the token list@>
> else begin old_setting:=selector; selector:=new_string; b:=pool_ptr;
> case cur_val_level of
> int_val:print_int(cur_val);
> dimen_val:begin print_scaled(cur_val); print("pt");
> end;
> glue_val: begin print_spec(cur_val,"pt"); delete_glue_ref(cur_val);
> end;
> mu_val: begin print_spec(cur_val,"mu"); delete_glue_ref(cur_val);
> end;
> end; {there are no other cases}
> selector:=old_setting; the_toks:=str_toks(b);
> end;
7557,7562c9096,9135
< begin r←link(cur_val); p←temp_head; link(p)←null;
< while r≠null do
< begin store_new_token(info(r)); r←link(r);
< end;
< the_toks←p;
< end
---
> begin p:=temp_head; link(p):=null;
> if cur_val_level=ident_val then store_new_token(cs_token_flag+cur_val)
> else if cur_val<>null then
> begin r:=link(cur_val); {do not copy the reference count}
> while r<>null do
> begin fast_store_new_token(info(r)); r:=link(r);
> end;
> end;
> the_toks:=p;
> end
>
> @ Here's part of the |expand| subroutine that we are now ready to complete:
>
> @p procedure ins_the_toks;
> begin link(garbage):=the_toks; ins_list(link(temp_head));
> end;
>
> @ The primitives \.{\\number}, \.{\\romannumeral}, \.{\\string}, \.{\\meaning},
> \.{\\fontname}, and \.{\\jobname} are defined as follows.
>
> @d number_code=0 {command code for \.{\\number}}
> @d roman_numeral_code=1 {command code for \.{\\romannumeral}}
> @d string_code=2 {command code for \.{\\string}}
> @d meaning_code=3 {command code for \.{\\meaning}}
> @d font_name_code=4 {command code for \.{\\fontname}}
> @d job_name_code=5 {command code for \.{\\jobname}}
>
> @<Put each...@>=
> primitive("number",convert,number_code);@/
> @!@:number_}{\.{\\number} primitive@>
> primitive("romannumeral",convert,roman_numeral_code);@/
> @!@:roman_numeral_}{\.{\\romannumeral} primitive@>
> primitive("string",convert,string_code);@/
> @!@:string_}{\.{\\string} primitive@>
> primitive("meaning",convert,meaning_code);@/
> @!@:meaning_}{\.{\\meaning} primitive@>
> primitive("fontname",convert,font_name_code);@/
> @!@:font_name_}{\.{\\fontname} primitive@>
> primitive("jobname",convert,job_name_code);@/
> @!@:job_name_}{\.{\\jobname} primitive@>
7564,7565c9137,9149
< @ Similarly, we have |num_toks|, which prepares the token list
< following `\.{\\number}':
---
> @ @<Cases of |print_cmd_chr|...@>=
> convert: case chr_code of
> number_code: print_esc("number");
> roman_numeral_code: print_esc("romannumeral");
> string_code: print_esc("string");
> meaning_code: print_esc("meaning");
> font_name_code: print_esc("fontname");
> othercases print_esc("jobname")
> endcases;
>
> @ The procedure |conv_toks| uses |str_toks| to insert the token list
> for |convert| functions into the scanner; `\.{\\outer}' control sequences
> are allowed to follow `\.{\\string}' and `\.{\\meaning}'.
7567c9151
< @p function num_toks:pointer;
---
> @p procedure conv_toks;
7569,7572c9153,9159
< begin old_setting←selector;
< scan_the(int_val,false); selector←new_string;
< if cur_val≥0 then print_int(cur_val)@+else print_roman_int(-cur_val);
< selector←old_setting; num_toks←str_toks;
---
> @!c:number_code..job_name_code; {desired type of conversion}
> @!save_scanner_status:small_number; {|scanner_status| upon entry}
> @!b:pool_pointer; {base of temporary string}
> begin c:=cur_chr; @<Scan the argument for command |c|@>;
> old_setting:=selector; selector:=new_string; b:=pool_ptr;
> @<Print the result of command |c|@>;
> selector:=old_setting; link(garbage):=str_toks(b); ins_list(link(temp_head));
7574a9162,9187
> @ @<Scan the argument for command |c|@>=
> case c of
> number_code,roman_numeral_code: scan_int;
> string_code, meaning_code: begin save_scanner_status:=scanner_status;
> scanner_status:=normal; get_token; scanner_status:=save_scanner_status;
> end;
> font_name_code: scan_font_ident;
> job_name_code: if job_name=0 then open_log_file;
> end {there are no other cases}
>
> @ @<Print the result of command |c|@>=
> case c of
> number_code: print_int(cur_val);
> roman_numeral_code: print_roman_int(cur_val);
> string_code:if cur_cs<>0 then sprint_cs(cur_cs)
> else print_char(cur_chr);
> meaning_code: print_meaning;
> font_name_code: begin print(font_name[cur_val]);
> if font_size[cur_val]<>font_dsize[cur_val] then
> begin print(" at "); print_scaled(font_size[cur_val]);
> print("pt");
> end;
> end;
> job_name_code: print(job_name);
> end {there are no other cases}
>
7577,7578c9190,9191
< list, and it also makes |cur_val| point to the reference count at the head
< of that list.
---
> list, and it also makes |def_ref| point to the reference count at the
> head of that list.
7584,7585c9197,9198
< \.{\\uppercase}, \.{\\message}, \.{\\errmessage}, \.{\\send}, or
< \.{\\xsend}. In the latter cases a left brace must be scanned next; this
---
> \.{\\uppercase}, \.{\\message}, \.{\\errmessage}, \.{\\write}, or
> \.{\\special}. In the latter cases a left brace must be scanned next; this
7588,7593c9201,9206
< simply be copied from the input using |get_token|. Otherwise all macros
< and occurrences of `\.{\\the}' and `\.{\\minus}' and `\.{\\number}' will
< be expanded, unless they are preceded by some control sequence like
< `\.{\\def}' whose command code is |def|. If both |macro_def| and |xpand|
< are true, the expansion applies only to the macro body (i.e., to the
< material following the first |left_brace| character).
---
> simply be copied from the input using |get_token|. Otherwise all expandable
> tokens will be expanded until unexpandable tokens are left, except that
> the results of expanding `\.{\\the}' are not expanded further.
> If both |macro_def| and |xpand| are true, the expansion applies
> only to the macro body (i.e., to the material following the first
> |left_brace| character).
7595c9208
< The value of |cs_ptr| when |scan_toks| begins should be the |eqtb|
---
> The value of |cur_cs| when |scan_toks| begins should be the |eqtb|
7599,7600d9211
< After the closing right brace, this routine will remove a space. % (rhymes)
<
7603,7604c9214
< var r: pointer; {reference count location}
< @!t:halfword; {token representing the highest parameter number}
---
> var t:halfword; {token representing the highest parameter number}
7610,7611c9220,9223
< begin scanner_status←defining; warning_index←cs_ptr; r←get_avail; info(r)←0;
< p←r; hash_brace←0;
---
> begin if macro_def then scanner_status:=defining
> @+else scanner_status:=absorbing;
> warning_index:=cur_cs; def_ref:=get_avail; token_ref_count(def_ref):=null;
> p:=def_ref; hash_brace:=0; t:=zero_token;
7615,7617c9227,9229
< found: scanner_status←normal; @<Scan an optional space@>;
< if hash_brace≠0 then store_new_token(hash_brace);
< cur_val←r; scan_toks←p;
---
> found: scanner_status:=normal;
> if hash_brace<>0 then store_new_token(hash_brace);
> scan_toks:=p;
7621,7629c9233,9240
< begin t←zero_token; {this represents |"0"|}
< loop@+ begin get_token; {set |cur_cmd|, |cur_chr|, |cur_tok|}
< if cur_cmd≤right_brace then goto done1;
< if cur_cmd=mac_param then
< @<If the next character is a parameter number, make |cur_tok|
< a |match| token; but if it is a left brace, store
< `|left_brace|, |end_match|' and |goto done|@>;
< store_new_token(cur_tok);
< end;
---
> begin loop begin get_token; {set |cur_cmd|, |cur_chr|, |cur_tok|}
> if cur_tok<right_brace_limit then goto done1;
> if cur_cmd=mac_param then
> @<If the next character is a parameter number, make |cur_tok|
> a |match| token; but if it is a left brace, store
> `|left_brace|, |end_match|', set |hash_brace|, and |goto done|@>;
> store_new_token(cur_tok);
> end;
7632c9243
< @<Express shock at the missing left brace; |goto found|@>;
---
> @<Express shock at the missing left brace; |goto found|@>;
7636,7637c9247,9248
< begin print_nl("! Missing { inserted"); incr(align_state);
< @.Missing {\{} inserted@>
---
> begin print_err("Missing { inserted"); incr(align_state);
> @.Missing \{ inserted@>
7639c9250
< ("which I'm going to interpret as `\def\a{}'."); error; goto found;
---
> ("which I'm going to interpret as `\def\a{}'."); error; goto found;
7643c9254
< begin s←match_token+cur_chr; get_token;
---
> begin s:=match_token+cur_chr; get_token;
7645,7647c9256,9259
< begin store_new_token(cur_tok); store_new_token(end_match_token);
< goto done;
< end;
---
> begin hash_brace:=cur_tok;
> store_new_token(cur_tok); store_new_token(end_match_token);
> goto done;
> end;
7649c9261
< begin print_nl("! You already have nine parameters");
---
> begin print_err("You already have nine parameters");
7651,7655c9263,9267
< help1("I'm going to ignore the # sign you just used."); error;
< end
< else begin incr(t);
< if cur_tok≠t then
< begin print_nl("! Parameters must be numbered consecutively");
---
> help1("I'm going to ignore the # sign you just used."); error;
> end
> else begin incr(t);
> if cur_tok<>t then
> begin print_err("Parameters must be numbered consecutively");
7657,7661c9269,9273
< help2("I've inserted the digit you should have used after the #.")@/
< ("Type `1' to delete what you did use."); back_error;
< end;
< cur_tok←s;
< end;
---
> help2("I've inserted the digit you should have used after the #.")@/
> ("Type `1' to delete what you did use."); back_error;
> end;
> cur_tok:=s;
> end;
7665,7685c9277,9303
< unbalance←1;
< loop@+ begin if xpand ∧(cur_cmd≠def) then
< @<Expand the next part of the input@>
< else get_token;
< if cur_cmd≤right_brace then
< if cur_cmd<right_brace then incr(unbalance)
< else begin decr(unbalance);
< if unbalance=0 then goto found;
< end
< else if cur_cmd=mac_param then @<Look for parameter number or \.{\#\#}@>;
< store_new_token(cur_tok);
< end
<
< @ @<Expand the next part of the input@>=
< begin loop begin get_nc_token;
< if cur_cmd=the then q←the_toks(cur_chr>0)
< else if cur_cmd=number then q←num_toks
< else goto done2;
< link(p)←link(temp_head); p←q;
< end;
< done2:
---
> unbalance:=1;
> loop@+ begin if xpand then @<Expand the next part of the input@>
> else get_token;
> if cur_tok<right_brace_limit then
> if cur_cmd<right_brace then incr(unbalance)
> else begin decr(unbalance);
> if unbalance=0 then goto found;
> end
> else if cur_cmd=mac_param then
> if macro_def then @<Look for parameter number or \.{\#\#}@>;
> store_new_token(cur_tok);
> end
>
> @ Here we insert an entire token list created by |the_toks| without
> expanding it further.
>
> @<Expand the next part of the input@>=
> begin loop begin get_next;
> if cur_cmd<=max_command then goto done2;
> if cur_cmd<>the then expand
> else begin q:=the_toks;
> if link(temp_head)<>null then
> begin link(p):=link(temp_head); p:=q;
> end;
> end;
> end;
> done2: x_token
7689,7692c9307,9311
< begin s←cur_tok; get_token;
< if cur_cmd≠mac_param then
< if (cur_chr<"1")∨(cur_chr>t-zero_token+"0")∨@|(cur_cmd≠other_char) then
< begin print_nl("! Illegal parameter number in definition of ");
---
> begin s:=cur_tok;
> if xpand then get_x_token else get_token;
> if cur_cmd<>mac_param then
> if (cur_tok<=zero_token)or(cur_tok>t) then
> begin print_err("Illegal parameter number in definition of ");
7694,7709c9313,9327
< sprint_cs(warning_index);
< help3("You meant to type ## instead of #, right?")@/
< ("Or maybe a } was forgotten somewhere earlier, and things")@/
< ("are all screwed up? I'm going to assume you meant ##.");
< back_error; cur_tok←s;
< end
< else cur_tok←out_param_token-"0"+cur_chr;
< end
< @* \[28] File names.
< Besides the fact that different operating systems treat files in different ways,
< we must cope with the fact that completely different naming conventions
< are used. The following programs show what is required for one particular
< operating system; similar routines for other systems are not difficult
< to devise.
< @^fingers@>
< @^system dependencies@>
---
> sprint_cs(warning_index);
> help3("You meant to type ## instead of #, right?")@/
> ("Or maybe a } was forgotten somewhere earlier, and things")@/
> ("are all screwed up? I'm going to assume that you meant ##.");
> back_error; cur_tok:=s;
> end
> else cur_tok:=out_param_token-"0"+cur_chr;
> end
>
> @ Another way to create a token list is via the \.{\\read} command. The
> sixteen files potentially usable for reading appear in the following
> global variables. The value of |read_open[n]| will be |closed| if
> stream number |n| has not been opened or if it has been fully read;
> |just_open| if an \.{\\openin} but not a \.{\\read} has been done;
> and |normal| if it is open and ready to read the next line.
7711,7723c9329,9330
< \TeX\ assumes that a file name has three parts: the name proper, its
< ``exten\-sion'', and a ``file area'' where it is found in an external file
< system. The extension of an input file or a send file is assumed to be
< `\.{.tex}' unless otherwise specified; it is `\.{.err}' on the error
< transcript file that records each run of \TeX; it is `\.{.tfm}' on the font
< metric files that describe characters in the fonts \TeX\ uses; it is
< `\.{.dvi}' on the output files that specify typesetting information; and it
< is `\.{.fmt}' on the format files written by \.{INITEX} to initialize \TeX.
< The file area can be arbitrary on input files, but it is usually the
< user's current area when a file is output. If an input file cannot be
< found on the specified area, \TeX\ will look for it on a special system
< area; this special area is intended for commonly used input files like
< \.{webhdr.tex}.
---
> @d closed=2 {not open, or at end of file}
> @d just_open=1 {newly opened, first line not yet read}
7725,7734c9332,9334
< Simple uses of \TeX\ refer only to file names that have no explicit extension
< or area. For example, one usually says `\.{\\input paper}' or
< `\.{\\font100=helvetica}' instead of `\.{\\input paper.new}' or
< `\.{\\font100=<csd.knuth>test}'. Simple file names are best, because they
< make the \TeX\ source files portable; whenever a file name consists entirely
< of letters and digits, it should be treated in the same way by all
< implementations of \TeX. However, users need the ability to refer to other
< files in their environment, especially when responding to error messages
< concerning unopenable files; therefore we want to let them use the syntax
< that appears in their favorite operating system.
---
> @<Glob...@>=
> @!read_file:array[0..15] of alpha_file; {used for \.{\\read}}
> @!read_open:array[0..16] of normal..closed; {state of |read_file[n]|}
7736,7748c9336,9337
< @ In order to isolate the system-dependent aspects of file names, the
< @^system dependencies@>
< system-independent parts of \TeX\ make use of three system-dependent
< procedures that are called |begin_name|, |more_name|, and |end_name|. In
< essence, if the user-specified characters of the file name are $c↓1\ldotsm c↓n$,
< the system-independent driver program does the operations
< $$|begin_name|;\,|more_name|(c↓1);\ldotss;|more_name|(c↓n);
< \,|end_name|.$$
< These three procedures communicate with each other via global variables.
< After\-wards the file name will appear in the string pool as three strings
< called |cur_name|\penalty10000\hskip-.05em,
< |cur_area|, and |cur_ext|; the latter two are null (i.e.,
< |""|), unless they were explicitly specified by the user.
---
> @ @<Set init...@>=
> for k:=0 to 16 do read_open[k]:=closed;
7750,7759c9339,9341
< Actually the situation is slightly more complicated, because \TeX\ needs
< to know when the file name ends. The |more_name| routine is a function
< (with side effects) that returns |true| on the calls |more_name|$(c↓1)$,
< $\ldotss$, |more_name|$(c↓{n-1})$. The final call |more_name|$(c↓n)$
< returns |false|; or, it returns |true| and the token following $c↓n$ is
< something like `\.{\\hbox}' (i.e., not a character). In other words,
< |more_name| is supposed to return |true| unless it is sure that the
< file name has been completely scanned; and |end_name| is supposed to be able
< to finish the assembly of |cur_name|, |cur_area|, and |cur_ext| regardless of
< whether $|more_name|(c↓n)$ returned |true| or |false|.
---
> @ The |read_toks| procedure constructs a token list like that for any
> macro definition, and makes |cur_val| point to it. Parameter |r| points
> to the control sequence that will receive this token list.
7761,7764c9343,9391
< @<Glob...@>=
< @!cur_name:str_number; {name of file just scanned}
< @!cur_area:str_number; {file area just scanned, or \.{""}}
< @!cur_ext:str_number; {file extension just scanned, or \.{""}}
---
> @p procedure read_toks(@!n:integer;@!r:pointer);
> label done;
> var p:pointer; {tail of the token list}
> @!q:pointer; {new node being added to the token list via |store_new_token|}
> @!s:integer; {saved value of |align_state|}
> @!m:small_number; {stream number}
> begin scanner_status:=defining; warning_index:=r;
> def_ref:=get_avail; token_ref_count(def_ref):=null;
> p:=def_ref; {the reference count}
> store_new_token(end_match_token);
> if (n<0)or(n>15) then m:=16@+else m:=n;
> s:=align_state; align_state:=1000000; {disable tab marks, etc.}
> repeat @<Input and store tokens from the next line of the file@>;
> until align_state=1000000;
> cur_val:=def_ref; scanner_status:=normal; align_state:=s;
> end;
>
> @ @<Input and store tokens from the next line of the file@>=
> begin_file_reading; name:=m+1;
> if read_open[m]=closed then @<Input for \.{\\read} from the terminal@>
> else if read_open[m]=just_open then @<Input the first line of |read_file[m]|@>
> else @<Input the next line of |read_file[m]|@>;
> limit:=last;
> if end_line_char_inactive then decr(limit)
> else buffer[limit]:=end_line_char;
> first:=limit+1; loc:=start; state:=new_line;@/
> loop@+ begin get_token;
> if cur_tok=0 then goto done;
> {|cur_cmd=cur_chr=0| will occur at the end of the line}
> if align_state<1000000 then {unmatched `\.\}' aborts the line}
> begin repeat get_token; until cur_tok=0;
> align_state:=1000000; goto done;
> end;
> store_new_token(cur_tok);
> end;
> done: end_file_reading
>
> @ Here we input on-line into the |buffer| array, prompting the user explicitly
> if |n>=0|. The value of |n| is set negative so that additional prompts
> will not be given in the case of multi-line input.
>
> @<Input for \.{\\read} from the terminal@>=
> if interaction>nonstop_mode then
> if n<0 then prompt_input("")
> else begin wake_up_terminal;
> print_ln; sprint_cs(r); prompt_input("="); n:=-1;
> end
> else fatal_error("*** (cannot \read from terminal in nonstop modes)")
> @.cannot \\read@>
7766,7771c9393,9394
< @ The file names we shall deal with have the following structure:
< If the name contains `\.>' or `\.:', the file area consists of all characters
< up to and including the final such character; otherwise the file area is null.
< If the remaining file name contains `\..', the file extension consists of all
< such characters from the first `\..' to the end, otherwise the file extension
< is null.
---
> @ The first line of a file must be treated specially, since |input_ln|
> must be told not to start with |get|.
7774,7775c9397,9416
< We can scan such file names easily by using two global variables that keep track
< of the occurrences of area and extension delimiters:
---
> @<Input the first line of |read_file[m]|@>=
> if input_ln(read_file[m],false) then read_open[m]:=normal
> else begin a_close(read_file[m]); read_open[m]:=closed;
> end
>
> @ An empty line is appended at the end of a |read_file|.
> @^empty line at end of file@>
>
> @<Input the next line of |read_file[m]|@>=
> begin if not input_ln(read_file[m],true) then
> begin a_close(read_file[m]); read_open[m]:=closed;
> if align_state<>1000000 then
> begin runaway;
> print_err("File ended within "); print_esc("read");
> @.File ended within \\read@>
> help1("This \read has unbalanced braces.");
> align_state:=1000000; error;
> end;
> end;
> end
7777,7778c9418,9890
< @<Glob...@>=
< @!area_delimiter:pool_pointer; {the most recent `\.>' or `\.:', if any}
---
> @* \[28] Conditional processing.
> We consider now the way \TeX\ handles various kinds of \.{\\if} commands.
>
> @d if_char_code=0 { `\.{\\if}' }
> @d if_cat_code=1 { `\.{\\ifcat}' }
> @d if_int_code=2 { `\.{\\ifnum}' }
> @d if_dim_code=3 { `\.{\\ifdim}' }
> @d if_odd_code=4 { `\.{\\ifodd}' }
> @d if_vmode_code=5 { `\.{\\ifvmode}' }
> @d if_hmode_code=6 { `\.{\\ifhmode}' }
> @d if_mmode_code=7 { `\.{\\ifmmode}' }
> @d if_inner_code=8 { `\.{\\ifinner}' }
> @d if_void_code=9 { `\.{\\ifvoid}' }
> @d if_hbox_code=10 { `\.{\\ifhbox}' }
> @d if_vbox_code=11 { `\.{\\ifvbox}' }
> @d ifx_code=12 { `\.{\\ifx}' }
> @d if_eof_code=13 { `\.{\\ifeof}' }
> @d if_true_code=14 { `\.{\\iftrue}' }
> @d if_false_code=15 { `\.{\\iffalse}' }
> @d if_case_code=16 { `\.{\\ifcase}' }
>
> @<Put each...@>=
> primitive("if",if_test,if_char_code);
> @!@:if_char_}{\.{\\if} primitive@>
> primitive("ifcat",if_test,if_cat_code);
> @!@:if_cat_code_}{\.{\\ifcat} primitive@>
> primitive("ifnum",if_test,if_int_code);
> @!@:if_int_}{\.{\\ifnum} primitive@>
> primitive("ifdim",if_test,if_dim_code);
> @!@:if_dim_}{\.{\\ifdim} primitive@>
> primitive("ifodd",if_test,if_odd_code);
> @!@:if_odd_}{\.{\\ifodd} primitive@>
> primitive("ifvmode",if_test,if_vmode_code);
> @!@:if_vmode_}{\.{\\ifvmode} primitive@>
> primitive("ifhmode",if_test,if_hmode_code);
> @!@:if_hmode_}{\.{\\ifhmode} primitive@>
> primitive("ifmmode",if_test,if_mmode_code);
> @!@:if_mmode_}{\.{\\ifmmode} primitive@>
> primitive("ifinner",if_test,if_inner_code);
> @!@:if_inner_}{\.{\\ifinner} primitive@>
> primitive("ifvoid",if_test,if_void_code);
> @!@:if_void_}{\.{\\ifvoid} primitive@>
> primitive("ifhbox",if_test,if_hbox_code);
> @!@:if_hbox_}{\.{\\ifhbox} primitive@>
> primitive("ifvbox",if_test,if_vbox_code);
> @!@:if_vbox_}{\.{\\ifvbox} primitive@>
> primitive("ifx",if_test,ifx_code);
> @!@:ifx_}{\.{\\ifx} primitive@>
> primitive("ifeof",if_test,if_eof_code);
> @!@:if_eof_}{\.{\\ifeof} primitive@>
> primitive("iftrue",if_test,if_true_code);
> @!@:if_true_}{\.{\\iftrue} primitive@>
> primitive("iffalse",if_test,if_false_code);
> @!@:if_false_}{\.{\\iffalse} primitive@>
> primitive("ifcase",if_test,if_case_code);
> @!@:if_case_}{\.{\\ifcase} primitive@>
>
> @ @<Cases of |print_cmd_chr|...@>=
> if_test: case chr_code of
> if_cat_code:print_esc("ifcat");
> if_int_code:print_esc("ifnum");
> if_dim_code:print_esc("ifdim");
> if_odd_code:print_esc("ifodd");
> if_vmode_code:print_esc("ifvmode");
> if_hmode_code:print_esc("ifhmode");
> if_mmode_code:print_esc("ifmmode");
> if_inner_code:print_esc("ifinner");
> if_void_code:print_esc("ifvoid");
> if_hbox_code:print_esc("ifhbox");
> if_vbox_code:print_esc("ifvbox");
> ifx_code:print_esc("ifx");
> if_eof_code:print_esc("ifeof");
> if_true_code:print_esc("iftrue");
> if_false_code:print_esc("iffalse");
> if_case_code:print_esc("ifcase");
> othercases print_esc("if")
> endcases;
>
> @ Conditions can be inside conditions, and this nesting has a stack
> that is independent of the |save_stack|.
>
> Four global variables represent the top of the condition stack:
> |cond_ptr| points to pushed-down entries, if any; |if_limit| specifies
> the largest code of a |fi_or_else| command that is syntactically legal;
> |cur_if| is the name of the current type of conditional; and |if_line|
> is the line number at which it began.
>
> If no conditions are currently in progress, the condition stack has the
> special state |cond_ptr=null|, |if_limit=normal|, |cur_if=0|, |if_line=0|.
> Otherwise |cond_ptr| points to a two-word node; the |type|, |subtype|, and
> |link| fields of the first word contain |if_limit|, |cur_if|, and
> |cond_ptr| at the next level, and the second word contains the
> corresponding |if_line|.
>
> @d if_node_size=2 {number of words in stack entry for conditionals}
> @d if_line_field(#)==mem[#+1].int
> @d if_code=1 {code for \.{\\if...} being evaluated}
> @d fi_code=2 {code for \.{\\fi}}
> @d else_code=3 {code for \.{\\else}}
> @d or_code=4 {code for \.{\\or}}
>
> @<Glob...@>=
> @!cond_ptr:pointer; {top of the condition stack}
> @!if_limit:normal..or_code; {upper bound on |fi_or_else| codes}
> @!cur_if:small_number; {type of conditional being worked on}
> @!if_line:integer; {line where that conditional began}
>
> @ @<Set init...@>=
> cond_ptr:=null; if_limit:=normal; cur_if:=0; if_line:=0;
>
> @ @<Put each...@>=
> primitive("fi",fi_or_else,fi_code);
> @!@:fi_}{\.{\\fi} primitive@>
> text(frozen_fi):="fi"; eqtb[frozen_fi]:=eqtb[cur_val];
> primitive("or",fi_or_else,or_code);
> @!@:or_}{\.{\\or} primitive@>
> primitive("else",fi_or_else,else_code);
> @!@:else_}{\.{\\else} primitive@>
>
> @ @<Cases of |print_cmd_chr|...@>=
> fi_or_else: if chr_code=fi_code then print_esc("fi")
> else if chr_code=or_code then print_esc("or")
> else print_esc("else");
>
> @ When we skip conditional text, we keep track of the line number
> where skipping began, for use in error messages.
>
> @<Glob...@>=
> @!skip_line:integer; {skipping began here}
>
> @ Here is a procedure that ignores text until coming to an \.{\\or},
> \.{\\else}, or \.{\\fi} at level zero of $\.{\\if}\ldots\.{\\fi}$
> nesting. After it has acted, |cur_chr| will indicate the token that
> was found, but |cur_tok| will not be set (because this makes the
> procedure run faster).
>
> @p procedure pass_text;
> label done;
> var l:integer; {level of $\.{\\if}\ldots\.{\\fi}$ nesting}
> @!save_scanner_status:small_number; {|scanner_status| upon entry}
> begin save_scanner_status:=scanner_status; scanner_status:=skipping; l:=0;
> skip_line:=line;
> loop@+ begin get_next;
> if cur_cmd=fi_or_else then
> begin if l=0 then goto done;
> if cur_chr=fi_code then decr(l);
> end
> else if cur_cmd=if_test then incr(l);
> end;
> done: scanner_status:=save_scanner_status;
> end;
>
> @ When we begin to process a new \.{\\if}, we set |if_limit:=if_code|; then
> if\/ \.{\\or} or \.{\\else} or \.{\\fi} occurs before the current \.{\\if}
> condition has been evaluated, \.{\\relax} will be inserted.
> For example, a sequence of commands like `\.{\\ifvoid1\\else...\\fi}'
> would otherwise require something after the `\.1'.
>
> @<Push the condition stack@>=
> begin p:=get_node(if_node_size); link(p):=cond_ptr; type(p):=if_limit;
> subtype(p):=cur_if; if_line_field(p):=if_line;
> cond_ptr:=p; cur_if:=cur_chr; if_limit:=if_code; if_line:=line;
> end
>
> @ @<Pop the condition stack@>=
> begin p:=cond_ptr; if_line:=if_line_field(p);
> cur_if:=subtype(p); if_limit:=type(p); cond_ptr:=link(p);
> free_node(p,if_node_size);
> end
>
> @ Here's a procedure that changes the |if_limit| code corresponding to
> a given value of |cond_ptr|.
>
> @p procedure change_if_limit(@!l:small_number;@!p:pointer);
> label exit;
> var q:pointer;
> begin if p=cond_ptr then if_limit:=l {that's the easy case}
> else begin q:=cond_ptr;
> loop@+ begin if q=null then confusion("if");
> @:this can't happen if}{\quad if@>
> if link(q)=p then
> begin type(q):=l; return;
> end;
> q:=link(q);
> end;
> end;
> exit:end;
>
> @ A condition is started when the |expand| procedure encounters
> an |if_test| command; in that case |expand| reduces to |conditional|,
> which is a recursive procedure.
> @^recursion@>
>
> @p procedure conditional;
> label exit,common_ending;
> var b:boolean; {is the condition true?}
> @!r:"<"..">"; {relation to be evaluated}
> @!m,@!n:integer; {to be tested against the second operand}
> @!p,@!q:pointer; {for traversing token lists in \.{\\ifx} tests}
> @!save_scanner_status:small_number; {|scanner_status| upon entry}
> @!save_cond_ptr:pointer; {|cond_ptr| corresponding to this conditional}
> @!this_if:small_number; {type of this conditional}
> begin @<Push the condition stack@>;@+save_cond_ptr:=cond_ptr;this_if:=cur_chr;@/
> @<Either process \.{\\ifcase} or set |b| to the value of a boolean condition@>;
> if tracing_commands>1 then @<Display the value of |b|@>;
> if b then
> begin change_if_limit(else_code,save_cond_ptr);
> return; {wait for \.{\\else} or \.{\\fi}}
> end;
> @<Skip to \.{\\else} or \.{\\fi}, then |goto common_ending|@>;
> common_ending: if cur_chr=fi_code then @<Pop the condition stack@>
> else if_limit:=fi_code; {wait for \.{\\fi}}
> exit:end;
>
> @ In a construction like `\.{\\if\\iftrue abc\\else d\\fi}', the first
> \.{\\else} that we come to after learning that the \.{\\if} is false is
> not the \.{\\else} we're looking for. Hence the following curious
> logic is needed.
>
> @ @<Skip to \.{\\else} or \.{\\fi}...@>=
> loop@+ begin pass_text;
> if cond_ptr=save_cond_ptr then
> begin if cur_chr<>or_code then goto common_ending;
> print_err("Extra "); print_esc("or");
> @.Extra \\or@>
> help1("I'm ignoring this; it doesn't match any \if.");
> error;
> end
> else if cur_chr=fi_code then @<Pop the condition stack@>;
> end
>
> @ @<Either process \.{\\ifcase} or set |b|...@>=
> case this_if of
> if_char_code, if_cat_code: @<Test if two characters match@>;
> if_int_code, if_dim_code: @<Test relation between integers or dimensions@>;
> if_odd_code: @<Test if an integer is odd@>;
> if_vmode_code: b:=(abs(mode)=vmode);
> if_hmode_code: b:=(abs(mode)=hmode);
> if_mmode_code: b:=(abs(mode)=mmode);
> if_inner_code: b:=(mode<0);
> if_void_code, if_hbox_code, if_vbox_code: @<Test box register status@>;
> ifx_code: @<Test if two tokens match@>;
> if_eof_code: begin scan_four_bit_int; b:=(read_open[cur_val]=closed);
> end;
> if_true_code: b:=true;
> if_false_code: b:=false;
> if_case_code: @<Select the appropriate case
> and |return| or |goto common_ending|@>;
> end {there are no other cases}
>
> @ @<Display the value of |b|@>=
> begin begin_diagnostic;
> if b then print("{true}")@+else print("{false}");
> end_diagnostic(false);
> end
>
> @ Here we use the fact that |"<"|, |"="|, and |">"| are consecutive ASCII
> codes.
> @^ASCII code@>
>
> @<Test relation between integers or dimensions@>=
> begin if this_if=if_int_code then scan_int@+else scan_normal_dimen;
> n:=cur_val; @<Get the next non-blank non-call...@>;
> if (cur_tok>=other_token+"<")and(cur_tok<=other_token+">") then
> r:=cur_tok-other_token
> else begin print_err("Missing = inserted for ");
> @.Missing = inserted@>
> print_cmd_chr(if_test,this_if);
> help1("I was expecting to see `<', `=', or `>'. Didn't.");
> back_error; r:="=";
> end;
> if this_if=if_int_code then scan_int@+else scan_normal_dimen;
> case r of
> "<": b:=(n<cur_val);
> "=": b:=(n=cur_val);
> ">": b:=(n>cur_val);
> end;
> end
>
> @ @<Test if an integer is odd@>=
> begin scan_int; b:=odd(cur_val);
> end
>
> @ @<Test box register status@>=
> begin scan_eight_bit_int; p:=box(cur_val);
> if this_if=if_void_code then b:=(p=null)
> else if p=null then b:=false
> else if this_if=if_hbox_code then b:=(type(p)=hlist_node)
> else b:=(type(p)=vlist_node);
> end
>
> @ An active character will be treated as category 13 following
> \.{\\if\\noexpand} or following \.{\\ifcat\\noexpand}. We use the fact that
> active characters have the smallest tokens, among all control sequences.
>
> @d get_x_token_or_active_char==@t@>@;
> begin get_x_token;
> if cur_cmd=relax then if cur_chr=no_expand_flag then
> begin cur_cmd:=active_char;
> cur_chr:=cur_tok-cs_token_flag-active_base;
> end;
> end
>
> @<Test if two characters match@>=
> begin get_x_token_or_active_char;
> if (cur_cmd>active_char)or(cur_chr>255) then {not a character}
> begin m:=relax; n:=256;
> end
> else begin m:=cur_cmd; n:=cur_chr;
> end;
> get_x_token_or_active_char;
> if (cur_cmd>active_char)or(cur_chr>255) then
> begin cur_cmd:=relax; cur_chr:=256;
> end;
> if this_if=if_char_code then b:=(n=cur_chr)@+else b:=(m=cur_cmd);
> end
>
> @ Note that `\.{\\ifx}' will declare two macros different if one is \\{long}
> or \\{outer} and the other isn't, even though the texts of the macros are
> the same.
>
> We need to reset |scanner_status|, since \.{\\outer} control sequences
> are allowed, but we might be scanning a macro definition or preamble.
>
> @<Test if two tokens match@>=
> begin save_scanner_status:=scanner_status; scanner_status:=normal;
> get_next; n:=cur_cs; p:=cur_cmd; q:=cur_chr;
> get_next; if cur_cmd<>p then b:=false
> else if cur_cmd<call then b:=(cur_chr=q)
> else @<Test if two macro texts match@>;
> scanner_status:=save_scanner_status;
> end
>
> @ Note also that `\.{\\ifx}' decides that macros \.{\\a} and \.{\\b} are
> different in examples like this:
> $$\vbox{\halign{\.{#}\hfil&\qquad\.{#}\hfil\cr
> {}\\def\\a\{\\c\}&
> {}\\def\\c\{\}\cr
> {}\\def\\b\{\\d\}&
> {}\\def\\d\{\}\cr}}$$
>
> @<Test if two macro texts match@>=
> begin p:=link(cur_chr); q:=link(equiv(n)); {omit reference counts}
> if p=q then b:=true
> else begin while (p<>null)and(q<>null) do
> if info(p)<>info(q) then p:=null
> else begin p:=link(p); q:=link(q);
> end;
> b:=((p=null)and(q=null));
> end;
> end
>
> @ @<Select the appropriate case and |return| or |goto common_ending|@>=
> begin scan_int; n:=cur_val; {|n| is the number of cases to pass}
> if tracing_commands>1 then
> begin begin_diagnostic; print("{case "); print_int(n); print_char("}");
> end_diagnostic(false);
> end;
> while n<>0 do
> begin pass_text;
> if cond_ptr=save_cond_ptr then
> if cur_chr=or_code then decr(n)
> else goto common_ending
> else if cur_chr=fi_code then @<Pop the condition stack@>;
> end;
> change_if_limit(or_code,save_cond_ptr);
> return; {wait for \.{\\or}, \.{\\else}, or \.{\\fi}}
> end
>
> @ The processing of conditionals is complete except for the following
> code, which is actually part of |expand|. It comes into play when
> \.{\\or}, \.{\\else}, or \.{\\fi} is scanned.
>
> @<Terminate the current conditional and skip to \.{\\fi}@>=
> if cur_chr>if_limit then
> if if_limit=if_code then insert_relax {condition not yet evaluated}
> else begin print_err("Extra "); print_cmd_chr(fi_or_else,cur_chr);
> @.Extra \\or@>
> @.Extra \\else@>
> @.Extra \\fi@>
> help1("I'm ignoring this; it doesn't match any \if.");
> error;
> end
> else begin while cur_chr<>fi_code do pass_text; {skip to \.{\\fi}}
> @<Pop the condition stack@>;
> end
>
> @* \[29] File names.
> It's time now to fret about file names. Besides the fact that different
> operating systems treat files in different ways, we must cope with the
> fact that completely different naming conventions are used by different
> groups of people. The following programs show what is required for one
> particular operating system; similar routines for other systems are not
> difficult to devise.
> @^fingers@>
> @^system dependencies@>
>
> \TeX\ assumes that a file name has three parts: the name proper; its
> ``extension''; and a ``file area'' where it is found in an external file
> system. The extension of an input file or a write file is assumed to be
> `\.{.tex}' unless otherwise specified; it is `\.{.log}' on the
> transcript file that records each run of \TeX; it is `\.{.tfm}' on the font
> metric files that describe characters in the fonts \TeX\ uses; it is
> `\.{.dvi}' on the output files that specify typesetting information; and it
> is `\.{.fmt}' on the format files written by \.{INITEX} to initialize \TeX.
> The file area can be arbitrary on input files, but files are usually
> output to the user's current area. If an input file cannot be
> found on the specified area, \TeX\ will look for it on a special system
> area; this special area is intended for commonly used input files like
> \.{webmac.tex}.
>
> Simple uses of \TeX\ refer only to file names that have no explicit
> extension or area. For example, a person usually says `\.{\\input} \.{paper}'
> or `\.{\\font\\tenrm} \.= \.{helvetica}' instead of `\.{\\input}
> \.{paper.new}' or `\.{\\font\\tenrm} \.= \.{<csd.knuth>test}'. Simple file
> names are best, because they make the \TeX\ source files portable;
> whenever a file name consists entirely of letters and digits, it should be
> treated in the same way by all implementations of \TeX. However, users
> need the ability to refer to other files in their environment, especially
> when responding to error messages concerning unopenable files; therefore
> we want to let them use the syntax that appears in their favorite
> operating system.
>
> The following procedures don't allow spaces to be part of
> file names; but some users seem to like names that are spaced-out.
> System-dependent changes to allow such things should probably
> be made with reluctance, and only when an entire file name that
> includes spaces is ``quoted'' somehow.
>
> @ In order to isolate the system-dependent aspects of file names, the
> @^system dependencies@>
> system-independent parts of \TeX\ are expressed in terms
> of three system-dependent
> procedures called |begin_name|, |more_name|, and |end_name|. In
> essence, if the user-specified characters of the file name are $c_1\ldots c_n$,
> the system-independent driver program does the operations
> $$|begin_name|;\,|more_name|(c_1);\,\ldots\,;\,|more_name|(c_n);
> \,|end_name|.$$
> These three procedures communicate with each other via global variables.
> Afterwards the file name will appear in the string pool as three strings
> called |cur_name|\penalty10000\hskip-.05em,
> |cur_area|, and |cur_ext|; the latter two are null (i.e.,
> |""|), unless they were explicitly specified by the user.
>
> Actually the situation is slightly more complicated, because \TeX\ needs
> to know when the file name ends. The |more_name| routine is a function
> (with side effects) that returns |true| on the calls |more_name|$(c_1)$,
> \dots, |more_name|$(c_{n-1})$. The final call |more_name|$(c_n)$
> returns |false|; or, it returns |true| and the token following $c_n$ is
> something like `\.{\\hbox}' (i.e., not a character). In other words,
> |more_name| is supposed to return |true| unless it is sure that the
> file name has been completely scanned; and |end_name| is supposed to be able
> to finish the assembly of |cur_name|, |cur_area|, and |cur_ext| regardless of
> whether $|more_name|(c_n)$ returned |true| or |false|.
>
> @<Glob...@>=
> @!cur_name:str_number; {name of file just scanned}
> @!cur_area:str_number; {file area just scanned, or \.{""}}
> @!cur_ext:str_number; {file extension just scanned, or \.{""}}
>
> @ The file names we shall deal with for illustrative purposes have the
> following structure: If the name contains `\.>' or `\.:', the file area
> consists of all characters up to and including the final such character;
> otherwise the file area is null. If the remaining file name contains
> `\..', the file extension consists of all such characters from the first
> remaining `\..' to the end, otherwise the file extension is null.
> @^system dependencies@>
>
> We can scan such file names easily by using two global variables that keep track
> of the occurrences of area and extension delimiters:
>
> @<Glob...@>=
> @!area_delimiter:pool_pointer; {the most recent `\.>' or `\.:', if any}
7782,7784c9894,9897
< system area called |TEX_area|. Font files whose areas are not given explicitly
< are assumed to appear in a standard system area called |TEX_font_area|.
< These system area names will, of course, vary from place to place.
---
> system area called |TEX_area|. Font metric files whose areas are not given
> explicitly are assumed to appear in a standard system area called
> |TEX_font_area|. These system area names will, of course, vary from place
> to place.
7787,7788c9900,9903
< @d TEX_area=="<TeX>"
< @d TEX_font_area=="<TeX.fonts>"
---
> @d TEX_area=="TeXinputs:"
> @.TeXinputs@>
> @d TEX_font_area=="TeXfonts:"
> @.TeXfonts@>
7794c9909
< begin area_delimiter←0; ext_delimiter←0;
---
> begin area_delimiter:=0; ext_delimiter:=0;
7797c9912,9915
< @ And here's the second.
---
> @ And here's the second. The string pool might change as the file name is
> being scanned, since a new \.{\\csname} might be entered; therefore we keep
> |area_delimiter| and |ext_delimiter| relative to the beginning of the current
> string, instead of assigning an absolute address like |pool_ptr| to them.
7800,7808c9918,9926
< @p function more_name(@!c:ascii_code):boolean;
< begin if c=" " then more_name←false
< else begin if (c=">")∨(c=":") then
< begin area_delimiter←pool_ptr; ext_delimiter←0;
< end
< else if (c=".")∧(ext_delimiter=0) then ext_delimiter←pool_ptr;
< str_room(1); append_char(c); {contribute |c| to the current string}
< more_name←true;
< end;
---
> @p function more_name(@!c:ASCII_code):boolean;
> begin if c=" " then more_name:=false
> else begin str_room(1); append_char(c); {contribute |c| to the current string}
> if (c=">")or(c=":") then
> begin area_delimiter:=cur_length; ext_delimiter:=0;
> end
> else if (c=".")and(ext_delimiter=0) then ext_delimiter:=cur_length;
> more_name:=true;
> end;
7815,7819c9933,9939
< begin if str_ptr+3>max_strings then overflow("number of strings",max_strings);
< if area_delimiter=0 then cur_area←""
< else begin cur_area←str_ptr; incr(str_ptr);
< str_start[str_ptr]←area_delimiter+1;
< end;
---
> begin if str_ptr+3>max_strings then
> overflow("number of strings",max_strings-init_str_ptr);
> @:TeX capacity exceeded number of strings}{\quad number of strings@>
> if area_delimiter=0 then cur_area:=""
> else begin cur_area:=str_ptr;
> str_start[str_ptr+1]:=str_start[str_ptr]+area_delimiter; incr(str_ptr);
> end;
7821,7825c9941,9946
< begin cur_ext←""; cur_name←make_string;
< end
< else begin cur_name←str_ptr; incr(str_ptr);
< str_start[str_ptr]←ext_delimiter; cur_ext←make_string;
< end;
---
> begin cur_ext:=""; cur_name:=make_string;
> end
> else begin cur_name:=str_ptr;
> str_start[str_ptr+1]:=str_start[str_ptr]+ext_delimiter-area_delimiter-1;
> incr(str_ptr); cur_ext:=make_string;
> end;
7835c9956
< begin print(a); print(n); print(e);
---
> begin slow_print(a); slow_print(n); slow_print(e);
7838,7839c9959,9962
< @ Another system-dependent routine is needed to convert three \TeX\ strings
< into the |name_of_file| value that is used to open files.
---
> @ Another system-dependent routine is needed to convert three internal
> \TeX\ strings
> into the |name_of_file| value that is used to open files. The present code
> allows both lowercase and uppercase letters in the file name.
7842,7845c9965,9967
< @d append_to_name(#)==begin c←#; incr(k);
< if (c≥"a")∧(c≤"z") then c←c-@'40; {convert to upper case}
< name_of_file[k]←xchr[c];
< end
---
> @d append_to_name(#)==begin c:=#; incr(k);
> if k<=file_name_size then name_of_file[k]:=xchr[c];
> end
7849,7858c9971,9978
< @!c: ascii_code; {character being packed}
< @!j:pool_pointer; {index into |string_pool|}
< begin if length(a)+length(n)+length(e)>file_name_size then
< overflow("file name size",file_name_size);
< k←0;
< for j←str_start[a] to str_start[a+1]-1 do append_to_name(str_pool[j]);
< for j←str_start[n] to str_start[n+1]-1 do append_to_name(str_pool[j]);
< for j←str_start[e] to str_start[e+1]-1 do append_to_name(str_pool[j]);
< name_length←k;
< for k←name_length+1 to file_name_size do name_of_file[k]←' ';
---
> @!c: ASCII_code; {character being packed}
> @!j:pool_pointer; {index into |str_pool|}
> begin k:=0;
> for j:=str_start[a] to str_start[a+1]-1 do append_to_name(so(str_pool[j]));
> for j:=str_start[n] to str_start[n+1]-1 do append_to_name(so(str_pool[j]));
> for j:=str_start[e] to str_start[e+1]-1 do append_to_name(so(str_pool[j]));
> if k<=file_name_size then name_length:=k@+else name_length:=file_name_size;
> for k:=name_length+1 to file_name_size do name_of_file[k]:=' ';
7867,7868c9987,9990
< @d format_default_length=22 {length of the |TEX_format_default| string}
< @d format_area_length=13 {length of its area part}
---
> @d format_default_length=20 {length of the |TEX_format_default| string}
> @d format_area_length=11 {length of its area part}
> @d format_ext_length=4 {length of its `\.{.fmt}' part}
> @d format_extension=".fmt" {the extension, as a \.{WEB} constant}
7874c9996,9999
< TEX_format_default←'<TeX.formats>BASIC.fmt';
---
> TEX_format_default:='TeXformats:plain.fmt';
> @.TeXformats@>
> @.plain@>
> @^system dependencies@>
7877c10002
< if format_default_length>file_name_size then bad←31;
---
> if format_default_length>file_name_size then bad:=31;
7881c10006,10007
< |buffer[a..b]|, followed by the last four characters of |format_default|.
---
> |buffer[a..b]|, followed by the last |format_ext_length| characters of
> |TEX_format_default|.
7891c10017
< @!c: ascii_code; {character being packed}
---
> @!c: ASCII_code; {character being packed}
7893,7900c10019,10027
< begin if n+b-a+5>file_name_size then b←a+file_name_size-n-5;
< k←0;
< for j←1 to n do append_to_name(xord[TEX_format_default[j]]);
< for j←a to b do append_to_name(buffer[j]);
< for j←format_default_length-3 to format_default_length do
< append_to_name(xord[TEX_format_default[j]]);
< name_length←k;
< for k←name_length+1 to file_name_size do name_of_file[k]←' ';
---
> begin if n+b-a+1+format_ext_length>file_name_size then
> b:=a+file_name_size-n-1-format_ext_length;
> k:=0;
> for j:=1 to n do append_to_name(xord[TEX_format_default[j]]);
> for j:=a to b do append_to_name(buffer[j]);
> for j:=format_default_length-format_ext_length+1 to format_default_length do
> append_to_name(xord[TEX_format_default[j]]);
> if k<=file_name_size then name_length:=k@+else name_length:=file_name_size;
> for k:=name_length+1 to file_name_size do name_of_file[k]:=' ';
7905,7906c10032,10035
< the preliminary initialization. The buffer contains the first line of input
< in |buffer[loc..(last-1)]|, where |loc<last| and |buffer[loc]≠" "|.
---
> the preliminary initialization, or when the user is substituting another
> format file by typing `\.\&' after the initial `\.{**}' prompt. The buffer
> contains the first line of input in |buffer[loc..(last-1)]|, where
> |loc<last| and |buffer[loc]<>" "|.
7911,7931c10040,10064
< var j:0..buf_size; {the first space after the file name}
< begin if buffer[loc]≠"\" then
< begin j←loc+1; buffer[last]←" ";
< while buffer[j]≠" " do incr(j);
< pack_buffered_name(0,loc,j-1); {try first without the system file area}
< if w_open_in(fmt_file) then
< begin loc←j; goto found;
< end;@/
< {now try the system format file area}
< pack_buffered_name(format_area_length,loc,j-1);
< if w_open_in(fmt_file) then
< begin loc←j; goto found;
< end;
< end;
< {now pull out all the stops: try for the system \.{BASIC} file}
< pack_buffered_name(format_default_length-4,1,0);
< if ¬ w_open_in(fmt_file) then
< begin write_ln(term_out,'I can''t find the BASIC format file!');
< open_fmt_file←false; return;
< end;
< found:open_fmt_file←true;
---
> var j:0..buf_size; {the first space after the format file name}
> begin j:=loc;
> if buffer[loc]="&" then
> begin incr(loc); j:=loc; buffer[last]:=" ";
> while buffer[j]<>" " do incr(j);
> pack_buffered_name(0,loc,j-1); {try first without the system file area}
> if w_open_in(fmt_file) then goto found;
> pack_buffered_name(format_area_length,loc,j-1);
> {now try the system format file area}
> if w_open_in(fmt_file) then goto found;
> wake_up_terminal;
> wterm_ln('Sorry, I can''t find that format;',' will try PLAIN.');
> @.Sorry, I can't find...@>
> update_terminal;
> end;
> {now pull out all the stops: try for the system \.{plain} file}
> pack_buffered_name(format_default_length-format_ext_length,1,0);
> if not w_open_in(fmt_file) then
> begin wake_up_terminal;
> wterm_ln('I can''t find the PLAIN format file!');
> @.I can't find PLAIN...@>
> @.plain@>
> open_fmt_file:=false; return;
> end;
> found:loc:=j; open_fmt_file:=true;
7937,7938c10070,10071
< ideally be changed to deduce the full name of file@@|f|, if it is
< possible to do this in a \PASCAL\ program.
---
> ideally be changed to deduce the full name of file~|f|, which is the file
> most recently opened, if it is possible to do this in a \PASCAL\ program.
7940a10074,10076
> This routine might be called after string memory has overflowed, hence
> we dare not use `|str_room|'.
>
7943,7945c10079,10084
< begin str_room(name_length);
< for k←1 to name_length do append_char(xord[name_of_file[k]]);
< make_name_string←make_string;
---
> begin if (pool_ptr+name_length>pool_size)or(str_ptr=max_strings)or
> (cur_length>0) then
> make_name_string:="?"
> else begin for k:=1 to name_length do append_char(xord[name_of_file[k]]);
> make_name_string:=make_string;
> end;
7948c10087
< begin a_make_name_string←make_name_string;
---
> begin a_make_name_string:=make_name_string;
7951c10090
< begin b_make_name_string←make_name_string;
---
> begin b_make_name_string:=make_name_string;
7954,7964c10093
< begin w_make_name_string←make_name_string;
< end;
<
< @ Similarly, the ideal |write_name_string| would write the full
< external name of |fmt_file|, assuming that |fmt_file| has been opened.
< The procedure shown here merely copies |name_of_file|. Output in this
< case goes to the user's terminal.
<
< @p procedure write_name_string;
< var k:1..file_name_size; {index into |name_of_file|}
< begin for k←1 to name_length do write(term_out,name_of_file[k]);
---
> begin w_make_name_string:=make_name_string;
7967,7970c10096,10099
< @ Now let's consider the routines by which \TeX\ deals with file names
< in a (hopefully) system-independent manner.
< First comes a procedure that looks for a file name in the input by
< calling |get_nc_token| for the information.
---
> @ Now let's consider the ``driver''
> routines by which \TeX\ deals with file names
> in a system-independent manner. First comes a procedure that looks for a
> file name in the input by calling |get_x_token| for the information.
7974c10103
< begin begin_name;
---
> begin name_in_progress:=true; begin_name;
7976,7982c10105,10111
< loop@+begin if (cur_cmd>other_char)∨(cur_chr>127) then {not a character}
< begin back_input; goto done;
< end;
< if ¬ more_name(cur_chr) then goto done;
< get_nc_token;
< end;
< done: end_name;
---
> loop@+begin if (cur_cmd>other_char)or(cur_chr>255) then {not a character}
> begin back_input; goto done;
> end;
> if not more_name(cur_chr) then goto done;
> get_x_token;
> end;
> done: end_name; name_in_progress:=false;
7985,7987c10114,10124
< @ The global variable |job_name| contains the file name that was first
< \.{\\input} by the user. This name is extended by `\.{err}' and `\.{dvi}'
< and `\.{fmt}' in order to make the names of \TeX's output files.
---
> @ The global variable |name_in_progress| is used to prevent recursive
> use of |scan_file_name|, since the |begin_name| and other procedures
> communicate via global variables. Recursion would arise only by
> devious tricks like `\.{\\input\\input f}'; such attempts at sabotage
> must be thwarted. Furthermore, |name_in_progress| prevents \.{\\input}
> @^recursion@>
> from being initiated when a font size specification is being scanned.
>
> Another global variable, |job_name|, contains the file name that was first
> \.{\\input} by the user. This name is extended by `\.{.log}' and `\.{.dvi}'
> and `\.{.fmt}' in the names of \TeX's output files.
7989a10127
> @!name_in_progress:boolean; {is a file name being scanned?}
7990a10129
> @!log_opened:boolean; {has the transcript file been opened?}
7993c10132,10133
< We have |job_name=0| if and only the `\.{err}' file has not been opened.
---
> We have |job_name=0| if and only if the `\.{log}' file has not been opened,
> except of course for a short time just after |job_name| has become nonzero.
7995c10135,10136
< @<Initialize the output...@>=job_name←0;
---
> @<Initialize the output...@>=
> job_name:=0; name_in_progress:=false; log_opened:=false;
7998c10139
< |job_name≠0|. It ignores and changes the current settings of |cur_area|
---
> |job_name<>0|. It ignores and changes the current settings of |cur_area|
8003,8006c10144,10147
< @p procedure pack_job_name(@!s:str_number); {|s = ".err"|, |".dvi"|, or
< |".fmt"|}
< begin cur_area←""; cur_ext←s;
< cur_name←job_name; pack_cur_name;
---
> @p procedure pack_job_name(@!s:str_number); {|s = ".log"|, |".dvi"|, or
> |format_extension|}
> begin cur_area:=""; cur_ext:=s;
> cur_name:=job_name; pack_cur_name;
8010,8011c10151,10152
< routine calls upon the user to supply another file name. Parameter@@|s|
< is used in the error message to identify the type of file; parameter@@|e|
---
> routine calls upon the user to supply another file name. Parameter~|s|
> is used in the error message to identify the type of file; parameter~|e|
8019c10160,10161
< begin if s="input file name" then print_nl("! I can't find file `")
---
> begin if interaction=scroll_mode then wake_up_terminal;
> if s="input file name" then print_err("I can't find file `")
8021c10163
< else print_nl("! I can't write on file `");
---
> else print_err("I can't write on file `");
8025a10168
> @.Please type...@>
8027c10170,10171
< fatal_error("*** (job aborted, file error in nonstop mode)");
---
> fatal_error("*** (job aborted, file error in nonstop mode)");
> @.job aborted, file error...@>
8029c10173
< if cur_ext="" then cur_ext←e;
---
> if cur_ext="" then cur_ext:=e;
8034,8039c10178,10183
< begin begin_name; k←first;
< while (buffer[k]=" ")∧(k<last) do incr(k);
< loop@+ begin if k=last then goto done;
< if ¬ more_name(buffer[k]) then goto done;
< incr(k);
< end;
---
> begin begin_name; k:=first;
> while (buffer[k]=" ")and(k<last) do incr(k);
> loop@+ begin if k=last then goto done;
> if not more_name(buffer[k]) then goto done;
> incr(k);
> end;
8043,8044c10187,10188
< @ Here's an example of how these conventions are used. We shall use the
< macro |ensure_dvi_open| when it is time to ship out a box of stuff.
---
> @ Here's an example of how these conventions are used. Whenever it is time to
> ship out a box of stuff, we shall use the macro |ensure_dvi_open|.
8047,8052c10191,10196
< begin if job_name=0 then open_err_file;
< pack_job_name(".dvi");
< while ¬ b_open_out(dvi_file) do
< prompt_file_name("file name for output",".dvi");
< output_file_name←b_make_name_string(dvi_file);
< end
---
> begin if job_name=0 then open_log_file;
> pack_job_name(".dvi");
> while not b_open_out(dvi_file) do
> prompt_file_name("file name for output",".dvi");
> output_file_name:=b_make_name_string(dvi_file);
> end
8056a10201
> @!log_name:str_number; {full name of the log file}
8058c10203
< @ @<Initialize the output...@>=output_file_name←0;
---
> @ @<Initialize the output...@>=output_file_name:=0;
8060c10205
< @ The |open_err_file| routine is used to open the transcript file and to help
---
> @ The |open_log_file| routine is used to open the transcript file and to help
8063c10208
< @p procedure open_err_file;
---
> @p procedure open_log_file;
8065a10211
> @!l:0..buf_size; {end of first input line}
8067,8072c10213,10219
< begin old_setting←selector; print_nl("");
< if job_name=0 then job_name←"texput";
< pack_job_name(".err");
< while ¬ a_open_out(err_file) do
< prompt_file_name("`err' file name for the transcript",".err");
< selector←err_only;
---
> begin old_setting:=selector;
> if job_name=0 then job_name:="texput";
> @.texput@>
> pack_job_name(".log");
> while not a_open_out(log_file) do @<Try to get a different log file name@>;
> log_name:=a_make_name_string(log_file);
> selector:=log_only; log_opened:=true;
8074,8075c10221,10226
< input_stack[input_ptr]←cur_input; {make sure bottom level is in memory}
< for k←1 to input_stack[0].limit_field do print(buffer[k-1]);
---
> input_stack[input_ptr]:=cur_input; {make sure bottom level is in memory}
> print_nl("**");
> @.**@>
> l:=input_stack[0].limit_field; {last position of first line}
> if buffer[l]=end_line_char then decr(l);
> for k:=1 to l do print(buffer[k]);
8077c10228
< selector←old_setting+2;
---
> selector:=old_setting+2; {|log_only| or |term_and_log|}
8079a10231,10249
> @ Sometimes |open_log_file| is called at awkward moments when \TeX\ is
> unable to print error messages or even to |show_context|.
> The |prompt_file_name| routine can result in a |fatal_error|, but the |error|
> routine will not be invoked because |log_opened| will be false.
>
> The normal idea of |batch_mode| is that nothing at all should be written
> on the terminal. However, in the unusual case that
> no log file could be opened, we make an exception and allow
> an explanatory message to be seen.
>
> Incidentally, the program always refers to the log file as a `\.{transcript
> file}', because some systems cannot use the extension `\.{.log}' for
> this file.
>
> @<Try to get a different log file name@>=
> begin selector:=term_only;
> prompt_file_name("transcript file name",".log");
> end
>
8081,8082c10251,10252
< begin write(err_file,banner);
< print(format_ident); print(" ");
---
> begin wlog(banner);
> slow_print(format_ident); print(" ");
8084,8085c10254,10255
< months←'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC';
< for k←3*month-2 to 3*month do write(err_file,months[k]);
---
> months:='JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC';
> for k:=3*month-2 to 3*month do wlog(months[k]);
8087,8089c10257
< print_int(time div 60); print_char(":");
< print_char("0"+((time mod 60) div 10));
< print_char("0"+(time mod 10)); print_ln;
---
> print_two(time div 60); print_char(":"); print_two(time mod 60);
8098c10266
< if cur_ext="" then cur_ext←".tex";
---
> if cur_ext="" then cur_ext:=".tex";
8100,8107c10268,10277
< loop@+ begin begin_file_reading; {set up |cur_file| and new level of input}
< if a_open_in(cur_file) then goto done;
< pack_file_name(cur_name,TEX_area,cur_ext);
< if a_open_in(cur_file) then goto done;
< end_file_reading; {remove the level that didn't work}
< prompt_file_name("input file name",".tex");
< end;
< done: name←a_make_name_string(cur_file); state←new_line;
---
> loop@+ begin begin_file_reading; {set up |cur_file| and new level of input}
> if a_open_in(cur_file) then goto done;
> if cur_area="" then
> begin pack_file_name(cur_name,TEX_area,cur_ext);
> if a_open_in(cur_file) then goto done;
> end;
> end_file_reading; {remove the level that didn't work}
> prompt_file_name("input file name",".tex");
> end;
> done: name:=a_make_name_string(cur_file);
8109,8112c10279,10288
< begin job_name←cur_name; open_err_file;
< end; {|open_err_file| doesn't |show_context|, so |limit|
< and |loc| needn't be set to meaningful values yet}
< print(" ("); print(name); update_terminal;
---
> begin job_name:=cur_name; open_log_file;
> end; {|open_log_file| doesn't |show_context|, so |limit|
> and |loc| needn't be set to meaningful values yet}
> if term_offset+length(name)>max_print_line-2 then print_ln
> else if (term_offset>0)or(file_offset>0) then print_char(" ");
> print_char("("); incr(open_parens); slow_print(name); update_terminal;
> state:=new_line;
> if name=str_ptr-1 then {we can conserve string pool space now}
> begin flush_string; name:=cur_name;
> end;
8116,8118c10292,10296
< @ Here we have to remember that the |input_ln| routine
< starts with a |get|, so we have to read the first character of the file
< before it is lost.
---
> @ Here we have to remember to tell the |input_ln| routine not to
> start with a |get|. If the file is empty, it is considered to
> contain a single blank line.
> @^system dependencies@>
> @^empty line at end of file@>
8121,8125c10299,10300
< begin if eoln(cur_file) then last←start
< else begin buffer[start]←xord[cur_file^]; first←start+1;
< if ¬ input_ln(cur_file) then confusion("input");
< @:confusion input}{\quad input@>
< end;
---
> begin line:=1;
> if input_ln(cur_file,false) then do_nothing;
8127c10302,10304
< buffer[limit]←carriage_return; first←limit+1; loc←start; line←1;
---
> if end_line_char_inactive then decr(limit)
> else buffer[limit]:=end_line_char;
> first:=limit+1; loc:=start;
8129c10306,10307
< @* \[29] Font metric data.
---
>
> @* \[30] Font metric data.
8131c10309
< \.{TFM} files; the `\.T' in `\.{TFM} stands for \TeX,
---
> \.{TFM} files; the `\.T' in `\.{TFM}' stands for \TeX,
8163c10341
< They are all nonnegative and less than $2^{15}$. We must have |bc-1≤ec≤255|,
---
> They are all nonnegative and less than $2^{15}$. We must have |bc-1<=ec<=255|,
8167,8170c10345
< and as few as 0 characters (if |bc=ec+1|). An exception to these rules is
< planned for oriental fonts, which will be identified by the condition |ec=256|;
< such fonts are not allowed except in extensions to \TeX82.
< @^oriental characters@>@^Chinese characters@>@^Japanese characters@>
---
> and as few as 0 characters (if |bc=ec+1|).
8206,8207c10381,10382
< scheme used (e.g., `\.{XEROX TEXT}' or `\.{TeX MATHSY}'), the next five
< give the font family name (e.g., `\.{HELVETICA}' or `\.{CMSY}'), and the
---
> scheme used (e.g., `\.{XEROX text}' or `\.{TeX math symbols}'), the next five
> give the font identifier (e.g., `\.{HELVETICA}' or `\.{CMSY}'), and the
8211c10386
< is not explicitly repeated in \.{DVI} format.
---
> is not explicitly repeated in \.{DVI}~format.
8226c10401
< the font, in units of points. This number must be at least 1.0; it is
---
> the font, in units of \TeX\ points. This number must be at least 1.0; it is
8231c10406
< and replace it by $\delta$, and to multiply the $x$ and@@$y$ coordinates
---
> and replace it by $\delta$, and to multiply the $x$ and~$y$ coordinates
8233,8235c10408,10411
< design size. {\sl All other dimensions in the\/\ \.{TFM} file are
< |fix_word| numbers in design-size units.} Thus, for example, the value
< of |param[6]|, one \.{em} or \.{\\quad}, is often the |fix_word| value
---
> design size. {\sl All other dimensions in the\/ \.{TFM} file are
> |fix_word|\kern-1pt\ numbers in design-size units}, with the exception of
> |param[1]| (which denotes the slant ratio). Thus, for example, the value
> of |param[6]|, which defines the \.{em} unit, is often the |fix_word| value
8242,8244c10418,10420
< @ Next comes the |char_info| array, which contains one |char_info_word|
< per character. Each |@!char_info_word| contains six fields packed into
< four bytes as follows.
---
> @ Next comes the |char_info| array, which contains one |@!char_info_word|
> per character. Each word in this part of the file contains six fields
> packed into four bytes as follows.
8248c10424
< (4@@bits)\par
---
> (4~bits)\par
8250c10426
< (2@@bits)\par
---
> (2~bits)\par
8261,8262c10437,10438
< The italic correction of a character has three different uses.
< (a)@@In ordinary text, the italic correction is added to the width only if
---
> The italic correction of a character has two different uses.
> (a)~In ordinary text, the italic correction is added to the width only if
8264,8269c10440,10441
< (b)@@In math formulas, the italic correction is always added to the width,
< unless the character has a subscript but no superscript.
< (c)@@In math formulas for which the character is a mathop in display style,
< a nonzero italic correction also affects the ``limit switch.'' For example,
< an integral sign $\int$ has a nonzero italic correction, but a summation
< sign $\sum$ does not.
---
> (b)~In math formulas, the italic correction is always added to the width,
> except with respect to the positioning of subscripts.
8280,8283c10452,10455
< \yskip\hang|tag=0| (|no_tag|) means that |remainder| is unused.\par
< \hang|tag=1| (|lig_tag|) means that this character has a ligature/kerning
< program starting at |lig_kern[remainder]|.\par
< \hang|tag=2| (|list_tag|) means that this character is part of a chain of
---
> \yskip\hangg|tag=0| (|no_tag|) means that |remainder| is unused.\par
> \hangg|tag=1| (|lig_tag|) means that this character has a ligature/kerning
> program starting at position |remainder| in the |lig_kern| array.\par
> \hangg|tag=2| (|list_tag|) means that this character is part of a chain of
8286c10458
< \hang|tag=3| (|ext_tag|) means that this character code represents an
---
> \hangg|tag=3| (|ext_tag|) means that this character code represents an
8305,8306c10477,10479
< \yskip\hang first byte: |stop_bit|, indicates the final program step
< if the byte is 128 or more.\par
---
> \yskip\hang first byte: |skip_byte|, indicates that this is the final program
> step if the byte is 128 or more, otherwise the next step is obtained by
> skipping this number of intervening steps.\par
8308,8310c10481,10483
< then perform the operation and stop, otherwise continue.''\par
< \hang third byte: |op_bit|, indicates a ligature step if less than@@128,
< a kern step otherwise.\par
---
> then perform the operation and stop, otherwise continue.''\par
> \hang third byte: |op_byte|, indicates a ligature step if less than~128,
> a kern step otherwise.\par
8313,8316c10486,10488
< In a ligature step the current character and |next_char| are replaced by
< the single character whose code is |remainder|. In a kern step, an
< additional space equal to |@!kern[remainder]| is inserted between the
< current character and |next_char|. (The value of |kern[remainder]| is
---
> In a kern step, an
> additional space equal to |kern[256*(op_byte-128)+remainder]| is inserted
> between the current character and |next_char|. This amount is
8318c10490
< by kerning, but it might be positive.)
---
> by kerning; but it might be positive.
8320,8323c10492,10525
< @d stop_flag=128+min_quarterword
< {value indicating `\.{STOP}' in a lig/kern program}
< @d kern_flag=128+min_quarterword {op code for a kern step}
< @d stop_bit(#)==#.b0
---
> There are eight kinds of ligature steps, having |op_byte| codes $4a+2b+c$ where
> $0\le a\le b+c$ and $0\le b,c\le1$. The character whose code is
> |remainder| is inserted between the current character and |next_char|;
> then the current character is deleted if $b=0$, and |next_char| is
> deleted if $c=0$; then we pass over $a$~characters to reach the next
> current character (which may have a ligature/kerning program of its own).
>
> If the very first instruction of the |lig_kern| array has |skip_byte=255|,
> the |next_char| byte is the so-called right boundary character of this font;
> the value of |next_char| need not lie between |bc| and~|ec|.
> If the very last instruction of the |lig_kern| array has |skip_byte=255|,
> there is a special ligature/kerning program for a left boundary character,
> beginning at location |256*op_byte+remainder|.
> The interpretation is that \TeX\ puts implicit boundary characters
> before and after each consecutive string of characters from the same font.
> These implicit characters do not appear in the output, but they can affect
> ligatures and kerning.
>
> If the very first instruction of a character's |lig_kern| program has
> |skip_byte>128|, the program actually begins in location
> |256*op_byte+remainder|. This feature allows access to large |lig_kern|
> arrays, because the first instruction must otherwise
> appear in a location |<=255|.
>
> Any instruction with |skip_byte>128| in the |lig_kern| array must satisfy
> the condition
> $$\hbox{|256*op_byte+remainder<nl|.}$$
> If such an instruction is encountered during
> normal program execution, it denotes an unconditional halt; no ligature
> or kerning command is performed.
>
> @d stop_flag==qi(128) {value indicating `\.{STOP}' in a lig/kern program}
> @d kern_flag==qi(128) {op code for a kern step}
> @d skip_byte(#)==#.b0
8325c10527
< @d op_bit(#)==#.b2
---
> @d op_byte(#)==#.b2
8337,8338c10539,10540
< $TR^kMR^kB$ from top to bottom, for some |k≥0|, unless $M$ is absent;
< in the latter case we can have $TR^kB$ for both even and odd values of@@|k|.
---
> $TR^kMR^kB$ from top to bottom, for some |k>=0|, unless $M$ is absent;
> in the latter case we can have $TR^kB$ for both even and odd values of~|k|.
8354c10556
< number; it is the only |fix_word| other than the design size itself that is
---
> number; it's the only |fix_word| other than the design size itself that is
8358c10560
< Note that character @'40 in the font need not have anything to do with
---
> Note that character |" "| in the font need not have anything to do with
8392,8394c10594,10597
< When the user defines \.{\\font 100}, say, \TeX\ assigns an
< internal number to the user's font 100. For example, if this internal number
< is 13, we will have |font_code[13]=100| and |font_number[100]=13|.
---
> When the user defines \.{\\font\\f}, say, \TeX\ assigns an internal number
> to the user's font~\.{\\f}. Adding this number to |font_id_base| gives the
> |eqtb| location of a ``frozen'' control sequence that will always select
> the font.
8397d10599
< @!user_font_code=0..bad_font_code; {font identification in \TeX\ input}
8398a10601
> @!font_index=0..font_mem_size; {index into |font_info|}
8401a10605,10607
> @d non_char==qi(256) {a |halfword| code that can't match a real character}
> @d non_address=0 {a spurious |bchar_label|}
>
8403,8405c10609,10611
< @!font_info:array[0..font_mem_size] of memory_word;
< {the big collection of font data}
< @!fmem_ptr:0..font_mem_size; {first unused word of |font_info|}
---
> @!font_info:array[font_index] of memory_word;
> {the big collection of font data}
> @!fmem_ptr:font_index; {first unused word of |font_info|}
8407,8410d10612
< @!font_code:array[internal_font_number] of user_font_code; {the first user
< font code corresponding to an internal font number}
< @!font_number:array[user_font_code] of internal_font_number; {the internal
< font number corresponding to a user's font code}
8413,8416c10615,10617
< @!font_scaled:array[internal_font_number] of boolean; {is the ``at'' size
< different from the design size?}
< @!font_params:array[internal_font_number] of halfword; {how many font
< parameters are present}
---
> @!font_dsize:array[internal_font_number] of scaled; {``design'' size}
> @!font_params:array[internal_font_number] of font_index; {how many font
> parameters are present}
8419,8426c10620,10638
< @!font_bc:array[internal_font_number] of eight_bits; {beginning (smallest)
< character code}
< @!font_ec:array[internal_font_number] of eight_bits; {ending (largest)
< character code}
< @!font_glue:array[internal_font_number] of pointer; {glue specification
< for interword space, |null| if not allocated}
< @!font_used:array[internal_font_number] of boolean; {has a character from
< this font actually appeared in the output?}
---
> @!font_bc:array[internal_font_number] of eight_bits;
> {beginning (smallest) character code}
> @!font_ec:array[internal_font_number] of eight_bits;
> {ending (largest) character code}
> @!font_glue:array[internal_font_number] of pointer;
> {glue specification for interword space, |null| if not allocated}
> @!font_used:array[internal_font_number] of boolean;
> {has a character from this font actually appeared in the output?}
> @!hyphen_char:array[internal_font_number] of integer;
> {current \.{\\hyphenchar} values}
> @!skew_char:array[internal_font_number] of integer;
> {current \.{\\skewchar} values}
> @!bchar_label:array[internal_font_number] of font_index;
> {start of |lig_kern| program for left boundary character,
> |non_address| if there is none}
> @!font_bchar:array[internal_font_number] of min_quarterword..non_char;
> {right boundary character, |non_char| if there is none}
> @!font_false_bchar:array[internal_font_number] of min_quarterword..non_char;
> {|font_bchar| if it doesn't exist in the font, otherwise |non_char|}
8432,8435c10644,10647
< part of this word (the |b0| field), |font_info[width_base[f]+w].sc|
< is the width of the character. (These formulas assume that |min_quarterword|
< has already been added to |c| and to |w|, since \TeX\ stores its
< quarterwords that way.)
---
> part of this word (the |b0| field), the width of the character is
> |font_info[width_base[f]+w].sc|. (These formulas assume that
> |min_quarterword| has already been added to |c| and to |w|, since \TeX\
> stores its quarterwords that way.)
8437c10649
< @<Globals...@>=
---
> @<Glob...@>=
8439c10651
< {base addresses for |char_info|}
---
> {base addresses for |char_info|}
8441c10653
< {base addresses for widths}
---
> {base addresses for widths}
8443c10655
< {base addresses for heights}
---
> {base addresses for heights}
8445c10657
< {base addresses for depths}
---
> {base addresses for depths}
8447c10659
< {base addresses for italic corrections}
---
> {base addresses for italic corrections}
8449c10661
< {base addresses for ligature/kerning programs}
---
> {base addresses for ligature/kerning programs}
8451c10663
< {base addresses for kerns}
---
> {base addresses for kerns}
8453c10665
< {base addresses for extensible recipes}
---
> {base addresses for extensible recipes}
8455c10667
< {base addresses for font parameters}
---
> {base addresses for font parameters}
8457,8458c10669,10670
< @ In order to cope more easily with erroneous situations, the undefined font
< is assumed to have seven valid parameters, all equal to zero.
---
> @ @<Set init...@>=
> for k:=font_base to font_max do font_used[k]:=false;
8460,8467c10672,10694
< @<Set init...@>=
< for k←0 to bad_font_code do font_number[k]←undefined_font;
< font_ptr←font_base; fmem_ptr←7; font_code[undefined_font]←bad_font_code;
< font_bc[undefined_font]←1; font_ec[undefined_font]←0;
< font_glue[undefined_font]←zero_glue; font_params[undefined_font]←7;
< param_base[undefined_font]←-1;
< for k←0 to 6 do font_info[k].sc←0;
< for k←font_base to font_max do font_used[k]←false;
---
> @ \TeX\ always knows at least one font, namely the null font. It has no
> characters, and its seven parameters are all equal to zero.
>
> @<Initialize table...@>=
> font_ptr:=null_font; fmem_ptr:=7;
> font_name[null_font]:="nullfont"; font_area[null_font]:="";
> hyphen_char[null_font]:="-"; skew_char[null_font]:=-1;
> bchar_label[null_font]:=non_address;
> font_bchar[null_font]:=non_char; font_false_bchar[null_font]:=non_char;
> font_bc[null_font]:=1; font_ec[null_font]:=0;
> font_size[null_font]:=0; font_dsize[null_font]:=0;
> char_base[null_font]:=0; width_base[null_font]:=0;
> height_base[null_font]:=0; depth_base[null_font]:=0;
> italic_base[null_font]:=0; lig_kern_base[null_font]:=0;
> kern_base[null_font]:=0; exten_base[null_font]:=0;
> font_glue[null_font]:=null; font_params[null_font]:=7;
> param_base[null_font]:=-1;
> for k:=0 to 6 do font_info[k].sc:=0;
>
> @ @<Put each...@>=
> primitive("nullfont",set_font,null_font);
> @!@:null_font_}{\.{\\nullfont} primitive@>
> text(frozen_null_font):="nullfont"; eqtb[frozen_null_font]:=eqtb[cur_val];
8475c10702
< the character's width, so that the long formula above is at least
---
> the character's width; hence the long formula above is at least
8493,8495c10720,10722
< Access to a character's |height|, |depth|, and |tag| fields is part of
< \TeX's inner loop, so we want these macros to produce code that is as fast
< as possible under the circumstances.
---
> Access to a character's |width|, |height|, |depth|, and |tag| fields is
> part of \TeX's inner loop, so we want these macros to produce code that is
> as fast as possible under the circumstances.
8503c10730
< @d char_italic_end(#)==qo(#.b2) div 4].sc
---
> @d char_italic_end(#)==(qo(#.b2)) div 4].sc
8506c10733
< @d char_height_end(#)==# div 16].sc
---
> @d char_height_end(#)==(#) div 16].sc
8508c10735
< @d char_depth_end(#)==# mod 16].sc
---
> @d char_depth_end(#)==(#) mod 16].sc
8510c10737
< @d char_tag(#)==(qo(#.b2) mod 4)
---
> @d char_tag(#)==((qo(#.b2)) mod 4)
8520,8521c10747,10748
< null_character.b0←min_quarterword; null_character.b1←min_quarterword;
< null_character.b2←min_quarterword; null_character.b3←min_quarterword;
---
> null_character.b0:=min_quarterword; null_character.b1:=min_quarterword;
> null_character.b2:=min_quarterword; null_character.b3:=min_quarterword;
8525c10752,10755
< kerning command |j|.
---
> kerning command~|j| in font~|f|. If |j| is the |char_info| for a character
> with a ligature/kern program, the first instruction of that program is either
> |i=font_info[lig_kern_start(f)(j)]| or |font_info[lig_kern_restart(f)(i)]|,
> depending on whether or not |skip_byte(i)<=stop_flag|.
8527,8528c10757,10761
< @d lig_kern_start(#)==lig_kern_base[#]+rem_byte {beginning of lig/kern program}
< @d char_kern_end(#)==rem_byte(#)].sc
---
> The constant |kern_base_offset| should be simplified, for \PASCAL\ compilers
> that do not do local optimization.
> @^system dependencies@>
>
> @d char_kern_end(#)==256*op_byte(#)+rem_byte(#)].sc
8529a10763,10766
> @d kern_base_offset==256*(128+min_quarterword)
> @d lig_kern_start(#)==lig_kern_base[#]+rem_byte {beginning of lig/kern program}
> @d lig_kern_restart_end(#)==256*op_byte(#)+rem_byte(#)+32768-kern_base_offset
> @d lig_kern_restart(#)==lig_kern_base[#]+lig_kern_restart_end
8550,8554c10787,10793
< is called |read_font_info|. It has four parameters: the user font code@@|u|,
< the file name and area strings |nom| and |aire|, and the ``at'' size@@|s|;
< if |s|@@is nonzero, |read_font_info| substitutes |s| for the design size.
< In the latter case, |s| must be positive and less than 2048 (i.e.,
< it is less than $2^{27}$ when considered as an integer).
---
> is called |read_font_info|. It has four parameters: the user font
> identifier~|u|, the file name and area strings |nom| and |aire|, and the
> ``at'' size~|s|. If |s|~is negative, it's the negative of a scale factor
> to be applied to the design size; |s=-1000| is the normal case.
> Otherwise |s| will be substituted for the design size; in this
> case, |s| must be positive and less than $2048\rm\,pt$
> (i.e., it must be less than $2^{27}$ when considered as an integer).
8556a10796
> It returns the value of the internal font number that was just loaded.
8558c10798
< information is stored.
---
> information is stored; |null_font| is returned in this case.
8563,8564c10803,10804
< @p procedure read_font_info(@!u:user_font_code;
< @!nom,@!aire:str_number; @!s:scaled); {input a \.{TFM} file}
---
> @p function read_font_info(@!u:pointer;@!nom,@!aire:str_number;
> @!s:scaled):internal_font_number; {input a \.{TFM} file}
8566c10806
< var k:0..font_mem_size; {index into |font_info|}
---
> var k:font_index; {index into |font_info|}
8569c10809
< {sizes of subfiles}
---
> {sizes of subfiles}
8570a10811
> @!g:internal_font_number; {the number to return}
8572a10814,10815
> @!bch_label:integer; {left boundary start location, or infinity}
> @!bchar:0..256; {right boundary character, or 256}
8575,8578c10818,10822
< {auxiliary quantities used in fixed-point multiplication}
< begin @<Read and check the font data; |abort| if the \.{TFM} file is
< malformed; if there's no room for this font, say so and |goto
< done|; otherwise |incr(font_ptr)| and |goto done|@>;
---
> {auxiliary quantities used in fixed-point multiplication}
> begin g:=null_font;@/
> @<Read and check the font data; |abort| if the \.{TFM} file is
> malformed; if there's no room for this font, say so and |goto
> done|; otherwise |incr(font_ptr)| and |goto done|@>;
8580c10824,10825
< done: b_close(tfm_file);
---
> done: if file_opened then b_close(tfm_file);
> read_font_info:=g;
8590,8594c10835,10842
< @d start_font_error_message==print_nl("! Font "); print_int(u);
< print_char("="); print_file_name(nom,aire,"");
< if s≠0 then
< begin print(" at "); print_scaled(s); print("pt");
< end
---
> @d start_font_error_message==print_err("Font "); sprint_cs(u);
> print_char("="); print_file_name(nom,aire,"");
> if s>=0 then
> begin print(" at "); print_scaled(s); print("pt");
> end
> else if s<>-1000 then
> begin print(" scaled "); print_int(-s);
> end
8605c10853
< ("e.g., type `I\font<same number>=<new name>'.");
---
> ("e.g., type `I\font<same font id>=<substitute font name>'.");
8621c10869
< file_opened←false;
---
> file_opened:=false;
8624,8625c10872,10873
< if not b_open_in(tfm_file) then goto bad_tfm;
< file_opened←true
---
> if not b_open_in(tfm_file) then abort;
> file_opened:=true
8631c10879
< for example by defining |fget| to be `\!|begin get(tfm_file);|
---
> for example by defining |fget| to be `\ignorespaces|begin get(tfm_file);|
8637,8646c10885,10894
< @d read_sixteen(#)==begin #←fbyte;
< if #>127 then abort;
< fget; #←#*@'400+fbyte;
< end
< @d store_four_quarters(#)==begin fget; a←fbyte; qw.b0←qi(a);
< fget; b←fbyte; qw.b1←qi(b);
< fget; c←fbyte; qw.b2←qi(c);
< fget; d←fbyte; qw.b3←qi(d);
< #←qw;
< end
---
> @d read_sixteen(#)==begin #:=fbyte;
> if #>127 then abort;
> fget; #:=#*@'400+fbyte;
> end
> @d store_four_quarters(#)==begin fget; a:=fbyte; qw.b0:=qi(a);
> fget; b:=fbyte; qw.b1:=qi(b);
> fget; c:=fbyte; qw.b2:=qi(c);
> fget; d:=fbyte; qw.b3:=qi(d);
> #:=qw;
> end
8653c10901,10904
< if (bc>ec+1)∨(ec>255) then abort;
---
> if (bc>ec+1)or(ec>255) then abort;
> if bc>255 then {|bc=256| and |ec=255|}
> begin bc:=1; ec:=0;
> end;
8662c10913,10914
< if lf≠6+lh+(ec-bc+1)+nw+nh+nd+ni+nl+nk+ne+np then abort;
---
> if lf<>6+lh+(ec-bc+1)+nw+nh+nd+ni+nl+nk+ne+np then abort;
> if (nw=0)or(nh=0)or(nd=0)or(ni=0) then abort;
8665c10917
< @ The preliminary settings of the index variables |char_base|,
---
> @ The preliminary settings of the index-offset variables |char_base|,
8672,8685c10924,10937
< lf←lf-6-lh; {|lf| words should be loaded into |font_info|}
< if np<7 then lf←lf+7-np; {at least seven parameters will appear}
< if (font_ptr=font_max)∨(fmem_ptr+lf>font_mem_size) then
< @<Apologize for not loading the font, |goto done|@>;
< f←font_ptr+1;
< char_base[f]←fmem_ptr-bc;
< width_base[f]←char_base[f]+ec+1;
< height_base[f]←width_base[f]+nw;
< depth_base[f]←height_base[f]+nh;
< italic_base[f]←depth_base[f]+nd;
< lig_kern_base[f]←italic_base[f]+ni;
< kern_base[f]←lig_kern_base[f]+nl;
< exten_base[f]←kern_base[f]+nk;
< param_base[f]←exten_base[f]+ne
---
> lf:=lf-6-lh; {|lf| words should be loaded into |font_info|}
> if np<7 then lf:=lf+7-np; {at least seven parameters will appear}
> if (font_ptr=font_max)or(fmem_ptr+lf>font_mem_size) then
> @<Apologize for not loading the font, |goto done|@>;
> f:=font_ptr+1;
> char_base[f]:=fmem_ptr-bc;
> width_base[f]:=char_base[f]+ec+1;
> height_base[f]:=width_base[f]+nw;
> depth_base[f]:=height_base[f]+nh;
> italic_base[f]:=depth_base[f]+nd;
> lig_kern_base[f]:=italic_base[f]+ni;
> kern_base[f]:=lig_kern_base[f]+nl-kern_base_offset;
> exten_base[f]:=kern_base[f]+kern_base_offset+nk;
> param_base[f]:=exten_base[f]+ne
8689c10941
< print(" not loaded: No more room.");
---
> print(" not loaded: Not enough room left");
8694c10946
< ("Or maybe try `I\font<same number>=<name of loaded font>'.");
---
> ("Or maybe try `I\font<same font id>=<name of loaded font>'.");
8704c10956
< fget; z←z*@'400+fbyte; fget; z←(z*@'20)+(fbyte div@'20);
---
> fget; z:=z*@'400+fbyte; fget; z:=(z*@'20)+(fbyte div@'20);
8707,8713c10959,10965
< begin fget;fget;fget;fget;decr(lh); {ignore the rest of the header}
< end;
< if s=0 then font_scaled[f]←false
< else if z=s then font_scaled[f]←false
< else begin font_scaled[f]←true; z←s;
< end;
< font_size[f]←z;
---
> begin fget;fget;fget;fget;decr(lh); {ignore the rest of the header}
> end;
> font_dsize[f]:=z;
> if s<>-1000 then
> if s>=0 then z:=s
> else z:=xn_over_d(z,-s,1000);
> font_size[f]:=z;
8717,8727c10969,10979
< for k←fmem_ptr to width_base[f]-1 do
< begin store_four_quarters(font_info[k].qqqq);
< if (a≥nw)∨(b div @'20≥nh)∨(b mod @'20≥nd)∨
< (c div 4≥ni) then abort;
< case c mod 4 of
< lig_tag: if d≥nl then abort;
< ext_tag: if d≥ne then abort;
< list_tag: @<Check for charlist cycle@>;
< othercases do_nothing {|no_tag|}
< endcases;
< end
---
> for k:=fmem_ptr to width_base[f]-1 do
> begin store_four_quarters(font_info[k].qqqq);
> if (a>=nw)or(b div @'20>=nh)or(b mod @'20>=nd)or
> (c div 4>=ni) then abort;
> case c mod 4 of
> lig_tag: if d>=nl then abort;
> ext_tag: if d>=ne then abort;
> list_tag: @<Check for charlist cycle@>;
> othercases do_nothing {|no_tag|}
> endcases;
> end
8734c10986
< @d check_byte_range(#)==begin if (#<bc)∨(#>ec) then abort@+end
---
> @d check_byte_range(#)==begin if (#<bc)or(#>ec) then abort@+end
8740,8744c10992,10996
< begin qw←char_info(f)(d);
< {N.B.: not |qi(d)|, since |char_base[f]| hasn't been adjusted yet}
< if char_tag(qw)≠list_tag then goto not_found;
< d←qo(rem_byte(qw)); {next character on the list}
< end;
---
> begin qw:=char_info(f)(d);
> {N.B.: not |qi(d)|, since |char_base[f]| hasn't been adjusted yet}
> if char_tag(qw)<>list_tag then goto not_found;
> d:=qo(rem_byte(qw)); {next character on the list}
> end;
8750c11002
< $$x=\left\{\vcenter{\halign{\lft{$#$,}\qquad&if \lft{$#$}\cr
---
> $$x=\left\{\vcenter{\halign{$#$,\hfil\qquad&if $#$\hfil\cr
8753c11005
< (No other choices of $a$ are allowed, since the magnitude of a number in
---
> (No other choices of |a| are allowed, since the magnitude of a number in
8755,8756c11007,11008
< quantity by the integer@@|z|, which is known to be less than $2^{27}$. Let
< $\alpha=16z$. If $|z|<2^{23}$, the individual multiplications $b\cdot z$,
---
> quantity by the integer~|z|, which is known to be less than $2^{27}$.
> If $|z|<2^{23}$, the individual multiplications $b\cdot z$,
8762c11014
< if $a=0$, or the same quantity minus $\alpha$ if $a=255$.
---
> if $a=0$, or the same quantity minus $\alpha=2^{4+e}z^\prime$ if $a=255$.
8766,8770c11018,11022
< @d store_scaled(#)==begin fget; a←fbyte; fget; b←fbyte;
< fget; c←fbyte; fget; d←fbyte;@/
< sw←(((((d*z)div@'400)+(c*z))div@'400)+(b*z))div beta;
< if a=0 then #←sw@+else if a=255 then #←sw-alpha@+else abort;
< end
---
> @d store_scaled(#)==begin fget; a:=fbyte; fget; b:=fbyte;
> fget; c:=fbyte; fget; d:=fbyte;@/
> sw:=(((((d*z)div@'400)+(c*z))div@'400)+(b*z))div beta;
> if a=0 then #:=sw@+else if a=255 then #:=sw-alpha@+else abort;
> end
8774,8779c11026,11031
< for k←width_base[f] to lig_kern_base[f]-1 do
< store_scaled(font_info[k].sc);
< if font_info[width_base[f]].sc≠0 then abort; {\\{width}[0] must be zero}
< if font_info[height_base[f]].sc≠0 then abort; {\\{height}[0] must be zero}
< if font_info[depth_base[f]].sc≠0 then abort; {\\{depth}[0] must be zero}
< if font_info[italic_base[f]].sc≠0 then abort; {\\{italic}[0] must be zero}
---
> for k:=width_base[f] to lig_kern_base[f]-1 do
> store_scaled(font_info[k].sc);
> if font_info[width_base[f]].sc<>0 then abort; {\\{width}[0] must be zero}
> if font_info[height_base[f]].sc<>0 then abort; {\\{height}[0] must be zero}
> if font_info[depth_base[f]].sc<>0 then abort; {\\{depth}[0] must be zero}
> if font_info[italic_base[f]].sc<>0 then abort; {\\{italic}[0] must be zero}
8783,8799c11035,11066
< begin alpha←16*z; beta←16;
< while z≥@'40000000 do
< begin z←z div 2; beta←beta div 2;
< end;
< end
<
< @ @<Read ligature/kern program@>=
< begin for k←lig_kern_base[f] to kern_base[f]-1 do
< begin store_four_quarters(font_info[k].qqqq);
< check_byte_range(b);
< if c<kern_flag then check_byte_range(d)
< else if d≥nk then abort;
< end;
< if (nl>0)∧(a<stop_flag) then abort; {check for stop bit on last command}
< for k←kern_base[f] to exten_base[f]-1 do
< store_scaled(font_info[k].sc);
< end
---
> begin alpha:=16;
> while z>=@'40000000 do
> begin z:=z div 2; alpha:=alpha+alpha;
> end;
> beta:=256 div alpha; alpha:=alpha*z;
> end
>
> @ @d check_existence(#)==@t@>@;@/
> begin check_byte_range(#);
> qw:=char_info(f)(#); {N.B.: not |qi(#)|}
> if not char_exists(qw) then abort;
> end
>
> @<Read ligature/kern program@>=
> bch_label:=@'77777; bchar:=256;
> if nl>0 then
> begin for k:=lig_kern_base[f] to kern_base[f]+kern_base_offset-1 do
> begin store_four_quarters(font_info[k].qqqq);
> if a>128 then
> begin if 256*c+d>=nl then abort;
> if a=255 then if k=lig_kern_base[f] then bchar:=b;
> end
> else begin if b<>bchar then check_existence(b);
> if c<128 then check_existence(d) {check ligature}
> else if 256*(c-128)+d>=nk then abort; {check kern}
> if a<128 then if k-lig_kern_base[f]+a+1>=nl then abort;
> end;
> end;
> if a=255 then bch_label:=256*c+d;
> end;
> for k:=kern_base[f]+kern_base_offset to exten_base[f]-1 do
> store_scaled(font_info[k].sc);
8802,8808c11069,11075
< for k←exten_base[f] to param_base[f]-1 do
< begin store_four_quarters(font_info[k].qqqq);
< if a≠0 then check_byte_range(a);
< if b≠0 then check_byte_range(b);
< if c≠0 then check_byte_range(c);
< check_byte_range(d);
< end
---
> for k:=exten_base[f] to param_base[f]-1 do
> begin store_four_quarters(font_info[k].qqqq);
> if a<>0 then check_existence(a);
> if b<>0 then check_existence(b);
> if c<>0 then check_existence(c);
> check_existence(d);
> end
8814,8821c11081,11088
< begin for k←1 to np do
< if k=1 then {the |slant| parameter is a pure number}
< begin fget; sw←fbyte; if sw>127 then sw←sw-256;
< fget; sw←sw*@'400+fbyte; fget; sw←sw*@'400+fbyte;
< fget; font_info[param_base[f]].sc←
< (sw*@'20)+(fbyte div@'20);
< end
< else store_scaled(font_info[param_base[f]+k-1].sc);
---
> begin for k:=1 to np do
> if k=1 then {the |slant| parameter is a pure number}
> begin fget; sw:=fbyte; if sw>127 then sw:=sw-256;
> fget; sw:=sw*@'400+fbyte; fget; sw:=sw*@'400+fbyte;
> fget; font_info[param_base[f]].sc:=
> (sw*@'20)+(fbyte div@'20);
> end
> else store_scaled(font_info[param_base[f]+k-1].sc);
8823c11090
< for k←np+1 to 7 do font_info[param_base[f]+k-1].sc←0;
---
> for k:=np+1 to 7 do font_info[param_base[f]+k-1].sc:=0;
8830,8831c11097,11098
< @d adjust(#)==#[f]←qo(#[f])
< {correct for the excess |min_quarterword| that was added}
---
> @d adjust(#)==#[f]:=qo(#[f])
> {correct for the excess |min_quarterword| that was added}
8834,8838c11101,11113
< font_code[f]←u; font_number[u]←f;
< if np≥7 then font_params[f]←np@+else font_params[f]←7;
< font_name[f]←nom;
< font_area[f]←aire;
< font_bc[f]←bc; font_ec[f]←ec; font_glue[f]←null;
---
> if np>=7 then font_params[f]:=np@+else font_params[f]:=7;
> hyphen_char[f]:=default_hyphen_char; skew_char[f]:=default_skew_char;
> if bch_label<nl then bchar_label[f]:=bch_label+lig_kern_base[f]
> else bchar_label[f]:=non_address;
> font_bchar[f]:=qi(bchar);
> font_false_bchar[f]:=qi(bchar);
> if bchar<=ec then if bchar>=bc then
> begin qw:=char_info(f)(bchar); {N.B.: not |qi(bchar)|}
> if char_exists(qw) then font_false_bchar[f]:=non_char;
> end;
> font_name[f]:=nom;
> font_area[f]:=aire;
> font_bc[f]:=bc; font_ec[f]:=ec; font_glue[f]:=null;
8842c11117
< fmem_ptr←fmem_ptr+lf; font_ptr←f; goto done
---
> fmem_ptr:=fmem_ptr+lf; font_ptr:=f; g:=f; goto done
8847,8848c11122,11123
< @<Declare procedures that scan restricted classes of integers@>=
< procedure scan_font_number;
---
> @<Declare procedures that scan font-related stuff@>=
> procedure scan_font_ident;
8850,8866c11125,11139
< begin scan_int;
< if (cur_val<0)∨(cur_val≥bad_font_code) then f←undefined_font
< else f←font_number[cur_val];
< if f=undefined_font then
< begin print_nl("! Undefined font code");
< @.Undefined font code@>
< help3("Watch out---you must define a font code before you")@/
< ("try to use the font, so you may have to start over.")@/
< ("(Chapter 27 of the manual explains how to survive this.)");
< int_error(cur_val);
< end;
< cur_val←f;
< end;
<
< @ The following routine is used to implement `\.{\\texinfo} |m| |n|'. If
< font |m| is undefined, no error message is needed since |scan_font_number|
< will have already issued one.
---
> @!m:halfword;
> begin @<Get the next non-blank non-call...@>;
> if cur_cmd=def_font then f:=cur_font
> else if cur_cmd=set_font then f:=cur_chr
> else if cur_cmd=def_family then
> begin m:=cur_chr; scan_four_bit_int; f:=equiv(m+cur_val);
> end
> else begin print_err("Missing font identifier");
> @.Missing font identifier@>
> help2("I was looking for a control sequence whose")@/
> ("current meaning has been defined by \font.");
> back_error; f:=null_font;
> end;
> cur_val:=f;
> end;
8867a11141
> @ The following routine is used to implement `\.{\\fontdimen} |n| |f|'.
8871,8873c11145,11147
< @<Declare procedures that scan restricted classes of integers@>=
< procedure scan_tex_info(@!writing:boolean);
< {sets |cur_val| to |font_info| location}
---
> @<Declare procedures that scan font-related stuff@>=
> procedure find_font_dimen(@!writing:boolean);
> {sets |cur_val| to |font_info| location}
8875,8889c11149,11162
< begin scan_font_number; f←cur_val; scan_int;
< if f=undefined_font then cur_val←fmem_ptr {a harmless location}
< else begin if cur_val≤0 then cur_val←fmem_ptr
< else begin if writing ∧(cur_val≤space_shrink_code)∧@|
< (cur_val≥space_code)∧(font_glue[f]≠null) then
< begin delete_glue_ref(font_glue[f]);
< font_glue[f]←null;
< end;
< if cur_val>font_params[f] then
< if f<font_ptr then cur_val←fmem_ptr
< else @<Increase the number of parameters in the last font@>
< else cur_val←cur_val+param_base[f];
< end;
< @<Issue an error message if |cur_val=fmem_ptr|@>;
< end;
---
> @!n:integer; {the parameter number}
> begin scan_int; n:=cur_val; scan_font_ident; f:=cur_val;
> if n<=0 then cur_val:=fmem_ptr
> else begin if writing and(n<=space_shrink_code)and@|
> (n>=space_code)and(font_glue[f]<>null) then
> begin delete_glue_ref(font_glue[f]);
> font_glue[f]:=null;
> end;
> if n>font_params[f] then
> if f<font_ptr then cur_val:=fmem_ptr
> else @<Increase the number of parameters in the last font@>
> else cur_val:=n+param_base[f];
> end;
> @<Issue an error message if |cur_val=fmem_ptr|@>;
8894,8900c11167,11174
< begin help2("To increase the number of font parameters, you must")@/
< ("use \texinfo immediately after the font code is defined.");
< print_nl("! Font "); print_int(font_code[f]);
< @.Font x has n texinfo...@>
< print(" has "); print_int(font_params[f]);
< print(" texinfo parameters"); error;
< end
---
> begin print_err("Font "); print_esc(font_id_text(f));
> print(" has only "); print_int(font_params[f]);
> print(" fontdimen parameters");
> @.Font x has only...@>
> help2("To increase the number of font parameters, you must")@/
> ("use \fontdimen immediately after the \font is loaded.");
> error;
> end
8903,8905c11177,11183
< repeat if fmem_ptr=font_mem_size then overflow("font memory",font_mem_size);
< font_info[fmem_ptr].sc←0; incr(fmem_ptr); incr(font_params[f]);
< until cur_val=font_params[f]
---
> begin repeat if fmem_ptr=font_mem_size then
> overflow("font memory",font_mem_size);
> @:TeX capacity exceeded font memory}{\quad font memory@>
> font_info[fmem_ptr].sc:=0; incr(fmem_ptr); incr(font_params[f]);
> until n=font_params[f];
> cur_val:=fmem_ptr-1; {this equals |param_base[f]+font_params[f]|}
> end
8909c11187
< that characters exist when it sees them. The following procedure
---
> that characters exist when it sees them. The following procedure
8913,8915c11191,11193
< begin if tracing_lost_chars≠0 then
< begin begin_diagnostic;
< print_nl("Missing character: There is no ");
---
> begin if tracing_lost_chars>0 then
> begin begin_diagnostic;
> print_nl("Missing character: There is no ");
8917,8919c11195,11197
< print_ascii(c); print(" in font ");
< print(font_name[f]); print_char("!"); end_diagnostic;
< end;
---
> print_ASCII(c); print(" in font ");
> slow_print(font_name[f]); print_char("!"); end_diagnostic(false);
> end;
8929,8933c11207,11211
< begin if (font_bc[f]≤c)∧(font_ec[f]≥c) then
< if char_exists(char_info(f)(qi(c))) then
< begin p←get_avail; font(p)←f; character(p)←qi(c);
< new_character←p; return;
< end;
---
> begin if font_bc[f]<=c then if font_ec[f]>=c then
> if char_exists(char_info(f)(qi(c))) then
> begin p:=get_avail; font(p):=f; character(p):=qi(c);
> new_character:=p; return;
> end;
8935c11213
< new_character←null;
---
> new_character:=null;
8937,8938c11215,11217
< @* \[30] Device-independent file format.
< The most important output pro\-duced by a run of \TeX\ is the ``device
---
>
> @* \[31] Device-independent file format.
> The most important output produced by a run of \TeX\ is the ``device
8941c11220
< David R. Fuchs in 1979. Almost any reasonable device can be driven by
---
> David R. Fuchs in 1979. Almost any reasonable typesetting device can be
8944c11223
< a program that takes \.{DVI} files as input, and dozens of such
---
> driven by a program that takes \.{DVI} files as input, and dozens of such
8959c11238,11239
< $-2^{15}$ and $2^{15}-1$.
---
> $-2^{15}$ and $2^{15}-1$. As in \.{TFM} files, numbers that occupy
> more than one byte position appear in BigEndian order.
8961,8969c11241,11252
< A \.{DVI} file consists of a sequence of one or more ``pages,'' followed by
< a ``postamble.'' A ``page'' consists of a |bop| command, followed by any number
< of other commands that tell where characters are to be placed on a physical
< page, followed by an |eop| command. The pages appear in the order that \TeX\
< generated them. If we ignore |nop| commands (which are allowed between
< any two commands in the file), each |eop| command is immediately followed by
< a |bop| command, or by a |pst| command; in the latter case, there are no
< more pages in the file, and the remaining bytes form the postamble.
< Further details about the postamble will be explained later.
---
> A \.{DVI} file consists of a ``preamble,'' followed by a sequence of one
> or more ``pages,'' followed by a ``postamble.'' The preamble is simply a
> |pre| command, with its parameters that define the dimensions used in the
> file; this must come first. Each ``page'' consists of a |bop| command,
> followed by any number of other commands that tell where characters are to
> be placed on a physical page, followed by an |eop| command. The pages
> appear in the order that \TeX\ generated them. If we ignore |nop| commands
> and \\{fnt\_def} commands (which are allowed between any two commands in
> the file), each |eop| command is immediately followed by a |bop| command,
> or by a |post| command; in the latter case, there are no more pages in the
> file, and the remaining bytes form the postamble. Further details about
> the postamble will be explained later.
8973c11256
< the first byte is number@@0, then comes number@@1, and so on. For example,
---
> the first byte is number~0, then comes number~1, and so on. For example,
8975,8980c11258,11264
< this makes it feasible to read the pages in backwards order, in case you
< are producing output on devices that stack their output face up. If the
< first page on a \.{DVI} file occupies bytes 0 to 99, and if the second
< page occupies bytes 100 to 299, then the |bop| that starts in byte 100
< points to 0 and the |bop| thats starts in byte 300 points to 100. (The
< first |bop|, i.e., the one that starts in byte 0, has a pointer of $-1$.)
---
> this makes it feasible to read the pages in backwards order, in case the
> results are being directed to a device that stacks its output face up.
> Suppose the preamble of a \.{DVI} file occupies bytes 0 to 99. Now if the
> first page occupies bytes 100 to 999, say, and if the second
> page occupies bytes 1000 to 1999, then the |bop| that starts in byte 1000
> points to 100 and the |bop| that starts in byte 2000 points to 1000. (The
> very first |bop|, i.e., the one starting in byte 100, has a pointer of~$-1$.)
8984,8985c11268,11269
< implicit instead of explicit; when a \.{DVI}-reading program reads the
< commands for a page, it keeps track of several quantities: (a)@@The current
---
> implicit instead of explicit. When a \.{DVI}-reading program reads the
> commands for a page, it keeps track of several quantities: (a)~The current
8987c11271
< by \\{fnt} and \\{fnt\_num} commands. (b)@@The current position on the page
---
> by \\{fnt} and \\{fnt\_num} commands. (b)~The current position on the page
8993c11277
< flipped; the Cartesian version of |(h,v)| would be |(h,-v)|. (c)@@The
---
> flipped; the Cartesian version of |(h,v)| would be |(h,-v)|. (c)~The
8995,8996c11279,11280
< where |w| and@@|x| are used for horizontal spacing and where |y| and@@|z|
< are used for vertical spacing. (d)@@There is a stack containing
---
> where |w| and~|x| are used for horizontal spacing and where |y| and~|z|
> are used for vertical spacing. (d)~There is a stack containing
8998c11282
< change the current level of operation. Note that the current font@@|f| is
---
> change the current level of operation. Note that the current font~|f| is
9004c11288
< there is a small unit of measurement such that increasing |h| by@@1 means
---
> there is a small unit of measurement such that increasing |h| by~1 means
9010,9012c11294,11296
< @ Here is list of all the commands that may appear in a \.{DVI} file. With
< each command we give its symbolic name (e.g., |bop|), its opcode byte
< (e.g., 129), and its parameters (if any). The parameters are followed
---
> @ Here is a list of all the commands that may appear in a \.{DVI} file. Each
> command is specified by its symbolic name (e.g., |bop|), its opcode byte
> (e.g., 139), and its parameters (if any). The parameters are followed
9016c11300
< \yskip\hang|set_char_0| 0. Typeset character number@@0 from font@@|f|
---
> \yskip\hang|set_char_0| 0. Typeset character number~0 from font~|f|
9022,9024c11306,11308
< \yskip\hang|set_char_1| through |set_char_127| (opcodes 1 to 127).
< Do the operations of |set_char_0|, but use the appropriate character number
< instead of char\-acter@@0.
---
> \yskip\hang\\{set\_char\_1} through \\{set\_char\_127} (opcodes 1 to 127).
> Do the operations of |set_char_0|; but use the character whose number
> matches the opcode, instead of character~0.
9027,9028c11311,11312
< number@@|c| is typeset. \TeX82 uses this command for characters in the
< range |128≤c<256|.
---
> number~|c| is typeset. \TeX82 uses this command for characters in the
> range |128<=c<256|.
9030,9031c11314,11315
< \yskip\hang|set2| 129 |c[2]|. Same as |set1|, except that@@|c| is two
< bytes long, so it is in the range |0≤c<65536|. \TeX82 never uses this
---
> \yskip\hang|@!set2| 129 |c[2]|. Same as |set1|, except that |c|~is two
> bytes long, so it is in the range |0<=c<65536|. \TeX82 never uses this
9036c11320
< \yskip\hang|set3| 130 |c[3]|. Same as |set1|, except that@@|c| is three
---
> \yskip\hang|@!set3| 130 |c[3]|. Same as |set1|, except that |c|~is three
9041c11325
< \yskip\hang|set4| 131 |c[4]|. Same as |set1|, except that@@|c| is four
---
> \yskip\hang|@!set4| 131 |c[4]|. Same as |set1|, except that |c|~is four
9045,9046c11329,11330
< of height@@|a| and width@@|b|, with its bottom left corner at |(h,v)|. Then
< set |h←h+b|. If either |a≤0| or |b≤0|, nothing should be typeset. Note
---
> of height~|a| and width~|b|, with its bottom left corner at |(h,v)|. Then
> set |h:=h+b|. If either |a<=0| or |b<=0|, nothing should be typeset. Note
9051c11335
< \yskip\hang|put1| 133 |c[1]|. Typeset character number@@|c| from font@@|f|
---
> \yskip\hang|@!put1| 133 |c[1]|. Typeset character number~|c| from font~|f|
9056c11340
< \yskip\hang|put2| 134 |c[2]|. Same as |set2|, except that |h| is not changed.
---
> \yskip\hang|@!put2| 134 |c[2]|. Same as |set2|, except that |h| is not changed.
9058c11342
< \yskip\hang|put3| 135 |c[3]|. Same as |set3|, except that |h| is not changed.
---
> \yskip\hang|@!put3| 135 |c[3]|. Same as |set3|, except that |h| is not changed.
9060c11344
< \yskip\hang|put4| 136 |c[4]|. Same as |set4|, except that |h| is not changed.
---
> \yskip\hang|@!put4| 136 |c[4]|. Same as |set4|, except that |h| is not changed.
9069,9071c11353,11355
< \yskip\hang|bop| 139 $c↓0[4]$ $c↓1[4]$ $\ldots$ $c↓9[4]$ $p[4]$. Beginning
< of a page: Set |(h,v,w,x,y,z)←(0,0,0,0,0,0)| and set the stack empty. Set
< the current font |f| to an undefined value. The ten $c↓i$ parameters hold
---
> \yskip\hang|bop| 139 $c_0[4]$ $c_1[4]$ $\ldots$ $c_9[4]$ $p[4]$. Beginning
> of a page: Set |(h,v,w,x,y,z):=(0,0,0,0,0,0)| and set the stack empty. Set
> the current font |f| to an undefined value. The ten $c_i$ parameters hold
9075c11359
< |p| points to the previous |bop| command in the file, where the first
---
> |p| points to the previous |bop| in the file; the first
9083c11367
< |h|@@coordinate; so it usually needs to be sorted into some order that is
---
> |h|~coordinate; so it usually needs to be sorted into some order that is
9095,9097c11379,11381
< \yskip\hang|right1| 143 |b[1]|. Set |h←h+b|, i.e., move right |b| units.
< The parameter is a signed number in two's complement notation, |-128≤b<128|;
< if |b<0|, the reference point actually moves left.
---
> \yskip\hang|right1| 143 |b[1]|. Set |h:=h+b|, i.e., move right |b| units.
> The parameter is a signed number in two's complement notation, |-128<=b<128|;
> if |b<0|, the reference point moves left.
9100c11384
< two-byte quantity in the range |-32768≤b<32768|.
---
> two-byte quantity in the range |-32768<=b<32768|.
9103c11387
< three-byte quantity in the range |@t$-2^{23}$@>≤b<@t$2^{23}$@>|.
---
> three-byte quantity in the range |@t$-2^{23}$@><=b<@t$2^{23}$@>|.
9106c11390
< four-byte quantity in the range |@t$-2^{31}$@>≤b<@t$2^{31}$@>|.
---
> four-byte quantity in the range |@t$-2^{31}$@><=b<@t$2^{31}$@>|.
9108c11392
< \yskip\hang|w0| 147. Set |h←h+w|; i.e., move right |w| units. With luck,
---
> \yskip\hang|w0| 147. Set |h:=h+w|; i.e., move right |w| units. With luck,
9113,9115c11397,11399
< \yskip\hang|w1| 148 |b[1]|. Set |w←b| and |h←h+b|. The value of |b| is a
< signed quantity in two's complement notation, |-128≤b<128|. This command
< changes the current |w|@@spacing and moves right by |b|.
---
> \yskip\hang|w1| 148 |b[1]|. Set |w:=b| and |h:=h+b|. The value of |b| is a
> signed quantity in two's complement notation, |-128<=b<128|. This command
> changes the current |w|~spacing and moves right by |b|.
9117,9118c11401,11402
< \yskip\hang|w2| 149 |b[2]|. Same as |w1|, but |b| is two bytes long,
< |-32768≤b<32768|.
---
> \yskip\hang|@!w2| 149 |b[2]|. Same as |w1|, but |b| is two bytes long,
> |-32768<=b<32768|.
9120,9121c11404,11405
< \yskip\hang|w3| 150 |b[3]|. Same as |w1|, but |b| is three bytes long,
< |@t$-2^{23}$@>≤b<@t$2^{23}$@>|.
---
> \yskip\hang|@!w3| 150 |b[3]|. Same as |w1|, but |b| is three bytes long,
> |@t$-2^{23}$@><=b<@t$2^{23}$@>|.
9123,9124c11407,11408
< \yskip\hang|w4| 151 |b[4]|. Same as |w1|, but |b| is four bytes long,
< |@t$-2^{31}$@>≤b<@t$2^{31}$@>|.
---
> \yskip\hang|@!w4| 151 |b[4]|. Same as |w1|, but |b| is four bytes long,
> |@t$-2^{31}$@><=b<@t$2^{31}$@>|.
9126c11410
< \yskip\hang|x0| 152. Set |h←h+x|; i.e., move right |x| units. The `|x|'
---
> \yskip\hang|x0| 152. Set |h:=h+x|; i.e., move right |x| units. The `|x|'
9130,9132c11414,11416
< \yskip\hang|x1| 153 |b[1]|. Set |x←b| and |h←h+b|. The value of |b| is a
< signed quantity in two's complement notation, |-128≤b<128|. This command
< changes the current |x|@@spacing and moves right by |b|.
---
> \yskip\hang|x1| 153 |b[1]|. Set |x:=b| and |h:=h+b|. The value of |b| is a
> signed quantity in two's complement notation, |-128<=b<128|. This command
> changes the current |x|~spacing and moves right by |b|.
9134,9135c11418,11419
< \yskip\hang|x2| 154 |b[2]|. Same as |x1|, but |b| is two bytes long,
< |-32768≤b<32768|.
---
> \yskip\hang|@!x2| 154 |b[2]|. Same as |x1|, but |b| is two bytes long,
> |-32768<=b<32768|.
9137,9138c11421,11422
< \yskip\hang|x3| 155 |b[3]|. Same as |x1|, but |b| is three bytes long,
< |@t$-2^{23}$@>≤b<@t$2^{23}$@>|.
---
> \yskip\hang|@!x3| 155 |b[3]|. Same as |x1|, but |b| is three bytes long,
> |@t$-2^{23}$@><=b<@t$2^{23}$@>|.
9140,9141c11424,11425
< \yskip\hang|x4| 156 |b[4]|. Same as |x1|, but |b| is four bytes long,
< |@t$-2^{31}$@>≤b<@t$2^{31}$@>|.
---
> \yskip\hang|@!x4| 156 |b[4]|. Same as |x1|, but |b| is four bytes long,
> |@t$-2^{31}$@><=b<@t$2^{31}$@>|.
9143,9145c11427,11429
< \yskip\hang|down1| 157 |a[1]|. Set |v←v+a|, i.e., move down |a| units.
< The parameter is a signed number in two's complement notation, |-128≤a<128|;
< if |a<0|, the reference point actually moves up.
---
> \yskip\hang|down1| 157 |a[1]|. Set |v:=v+a|, i.e., move down |a| units.
> The parameter is a signed number in two's complement notation, |-128<=a<128|;
> if |a<0|, the reference point moves up.
9147,9148c11431,11432
< \yskip\hang|down2| 158 |a[2]|. Same as |down1|, except that |a| is a
< two-byte quantity in the range |-32768≤a<32768|.
---
> \yskip\hang|@!down2| 158 |a[2]|. Same as |down1|, except that |a| is a
> two-byte quantity in the range |-32768<=a<32768|.
9150,9151c11434,11435
< \yskip\hang|down3| 159 |a[3]|. Same as |down1|, except that |a| is a
< three-byte quantity in the range |@t$-2^{23}$@>≤a<@t$2^{23}$@>|.
---
> \yskip\hang|@!down3| 159 |a[3]|. Same as |down1|, except that |a| is a
> three-byte quantity in the range |@t$-2^{23}$@><=a<@t$2^{23}$@>|.
9153,9154c11437,11438
< \yskip\hang|down4| 160 |a[4]|. Same as |down1|, except that |a| is a
< four-byte quantity in the range |@t$-2^{31}$@>≤a<@t$2^{31}$@>|.
---
> \yskip\hang|@!down4| 160 |a[4]|. Same as |down1|, except that |a| is a
> four-byte quantity in the range |@t$-2^{31}$@><=a<@t$2^{31}$@>|.
9156c11440
< \yskip\hang|y0| 161. Set |v←v+y|; i.e., move down |y| units. With luck,
---
> \yskip\hang|y0| 161. Set |v:=v+y|; i.e., move down |y| units. With luck,
9161,9163c11445,11447
< \yskip\hang|y1| 162 |a[1]|. Set |y←a| and |v←v+a|. The value of |a| is a
< signed quantity in two's complement notation, |-128≤a<128|. This command
< changes the current |y|@@spacing and moves down by |a|.
---
> \yskip\hang|y1| 162 |a[1]|. Set |y:=a| and |v:=v+a|. The value of |a| is a
> signed quantity in two's complement notation, |-128<=a<128|. This command
> changes the current |y|~spacing and moves down by |a|.
9165,9166c11449,11450
< \yskip\hang|y2| 163 |a[2]|. Same as |y1|, but |a| is two bytes long,
< |-32768≤a<32768|.
---
> \yskip\hang|@!y2| 163 |a[2]|. Same as |y1|, but |a| is two bytes long,
> |-32768<=a<32768|.
9168,9169c11452,11453
< \yskip\hang|y3| 164 |a[3]|. Same as |y1|, but |a| is three bytes long,
< |@t$-2^{23}$@>≤a<@t$2^{23}$@>|.
---
> \yskip\hang|@!y3| 164 |a[3]|. Same as |y1|, but |a| is three bytes long,
> |@t$-2^{23}$@><=a<@t$2^{23}$@>|.
9171,9172c11455,11456
< \yskip\hang|y4| 165 |a[4]|. Same as |y1|, but |a| is four bytes long,
< |@t$-2^{31}$@>≤a<@t$2^{31}$@>|.
---
> \yskip\hang|@!y4| 165 |a[4]|. Same as |y1|, but |a| is four bytes long,
> |@t$-2^{31}$@><=a<@t$2^{31}$@>|.
9174c11458
< \yskip\hang|z0| 166. Set |v←v+z|; i.e., move down |z| units. The `|z|' commands
---
> \yskip\hang|z0| 166. Set |v:=v+z|; i.e., move down |z| units. The `|z|' commands
9177,9179c11461,11463
< \yskip\hang|z1| 167 |a[1]|. Set |z←a| and |v←v+a|. The value of |a| is a
< signed quantity in two's complement notation, |-128≤a<128|. This command
< changes the current |z|@@spacing and moves down by |a|.
---
> \yskip\hang|z1| 167 |a[1]|. Set |z:=a| and |v:=v+a|. The value of |a| is a
> signed quantity in two's complement notation, |-128<=a<128|. This command
> changes the current |z|~spacing and moves down by |a|.
9181,9182c11465,11466
< \yskip\hang|z2| 168 |a[2]|. Same as |z1|, but |a| is two bytes long,
< |-32768≤a<32768|.
---
> \yskip\hang|@!z2| 168 |a[2]|. Same as |z1|, but |a| is two bytes long,
> |-32768<=a<32768|.
9184,9185c11468,11469
< \yskip\hang|z3| 169 |a[3]|. Same as |z1|, but |a| is three bytes long,
< |@t$-2^{23}$@>≤a<@t$2^{23}$@>|.
---
> \yskip\hang|@!z3| 169 |a[3]|. Same as |z1|, but |a| is three bytes long,
> |@t$-2^{23}$@><=a<@t$2^{23}$@>|.
9187,9188c11471,11472
< \yskip\hang|z4| 170 |a[4]|. Same as |z1|, but |a| is four bytes long,
< |@t$-2^{31}$@>≤a<@t$2^{31}$@>|.
---
> \yskip\hang|@!z4| 170 |a[4]|. Same as |z1|, but |a| is four bytes long,
> |@t$-2^{31}$@><=a<@t$2^{31}$@>|.
9190c11474,11475
< \yskip\hang|fnt_num_0| 171. Set |f←0|.
---
> \yskip\hang|fnt_num_0| 171. Set |f:=0|. Font 0 must previously have been
> defined by a \\{fnt\_def} instruction, as explained below.
9192,9193c11477,11478
< \yskip\hang|fnt_num_1| through |fnt_num_63| (opcodes 172 to 234). Set
< |f←1|, $\ldotss$, \hbox{|f←63|}, respectively.
---
> \yskip\hang\\{fnt\_num\_1} through \\{fnt\_num\_63} (opcodes 172 to 234). Set
> |f:=1|, \dots, \hbox{|f:=63|}, respectively.
9195,9196c11480,11481
< \yskip\hang|fnt1| 235 |n[1]|. Set |f←n|. \TeX82 uses this command for font
< numbers in the range |64≤n<256|.
---
> \yskip\hang|fnt1| 235 |k[1]|. Set |f:=k|. \TeX82 uses this command for font
> numbers in the range |64<=k<256|.
9198,9199c11483,11484
< \yskip\hang|fnt2| 236 |n[2]|. Same as |fnt1|, except that@@|n| is two
< bytes long, so it is in the range |0≤n<65536|. \TeX82 never generates this
---
> \yskip\hang|@!fnt2| 236 |k[2]|. Same as |fnt1|, except that |k|~is two
> bytes long, so it is in the range |0<=k<65536|. \TeX82 never generates this
9204c11489
< \yskip\hang|fnt3| 237 |n[3]|. Same as |fnt1|, except that@@|n| is three
---
> \yskip\hang|@!fnt3| 237 |k[3]|. Same as |fnt1|, except that |k|~is three
9207,9217c11492,11513
< \yskip\hang|fnt4| 238 |n[4]|. Same as |fnt1|, except that@@|n| is four
< bytes long; this is for the really big font numbers. The value $-1$
< is forbidden, so the legal values of@@|f| are $-2^{31}\L f<-1$ and
< $0\L f<2^{31}-1$.
<
< \yskip\hang|xxx| 239 |m[1]| |x[m]|. This command is undefined in
< general; it functions as an $(m+2)$-byte |nop| unless special \.{DVI}-reading
< programs are being used. \TeX82 generates this command when an \.{\\xsend}
< appears, setting |m| to the number of bytes being sent. It is recommended that
< |x| be a string having the form of a keyword followed by possible parameters
< relevant to that keyword.
---
> \yskip\hang|@!fnt4| 238 |k[4]|. Same as |fnt1|, except that |k|~is four
> bytes long; this is for the really big font numbers (and for the negative ones).
>
> \yskip\hang|xxx1| 239 |k[1]| |x[k]|. This command is undefined in
> general; it functions as a $(k+2)$-byte |nop| unless special \.{DVI}-reading
> programs are being used. \TeX82 generates |xxx1| when a short enough
> \.{\\special} appears, setting |k| to the number of bytes being sent. It
> is recommended that |x| be a string having the form of a keyword followed
> by possible parameters relevant to that keyword.
>
> \yskip\hang|@!xxx2| 240 |k[2]| |x[k]|. Like |xxx1|, but |0<=k<65536|.
>
> \yskip\hang|@!xxx3| 241 |k[3]| |x[k]|. Like |xxx1|, but |0<=k<@t$2^{24}$@>|.
>
> \yskip\hang|xxx4| 242 |k[4]| |x[k]|. Like |xxx1|, but |k| can be ridiculously
> large. \TeX82 uses |xxx4| when sending a string of length 256 or more.
>
> \yskip\hang|fnt_def1| 243 |k[1]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
> Define font |k|, where |0<=k<256|; font definitions will be explained shortly.
>
> \yskip\hang|@!fnt_def2| 244 |k[2]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
> Define font |k|, where |0<=k<65536|.
9219c11515,11516
< \yskip\hang|pst| 240. Beginning of the postamble, see below.
---
> \yskip\hang|@!fnt_def3| 245 |k[3]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
> Define font |k|, where |0<=k<@t$2^{24}$@>|.
9221c11518,11529
< \yskip\noindent Commands 241--255 are undefined at the present time.
---
> \yskip\hang|@!fnt_def4| 246 |k[4]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
> Define font |k|, where |@t$-2^{31}$@><=k<@t$2^{31}$@>|.
>
> \yskip\hang|pre| 247 |i[1]| |num[4]| |den[4]| |mag[4]| |k[1]| |x[k]|.
> Beginning of the preamble; this must come at the very beginning of the
> file. Parameters |i|, |num|, |den|, |mag|, |k|, and |x| are explained below.
>
> \yskip\hang|post| 248. Beginning of the postamble, see below.
>
> \yskip\hang|post_post| 249. Ending of the postamble, see below.
>
> \yskip\noindent Commands 250--255 are undefined at the present time.
9226d11533
< @d put1=133 {typeset a character}
9245,9246c11552,11619
< @d xxx=239 {extension to \.{DVI} primitives}
< @d pst=240 {postamble}
---
> @d xxx1=239 {extension to \.{DVI} primitives}
> @d xxx4=242 {potentially long extension to \.{DVI} primitives}
> @d fnt_def1=243 {define the meaning of a font number}
> @d pre=247 {preamble}
> @d post=248 {postamble beginning}
> @d post_post=249 {postamble ending}
>
> @ The preamble contains basic information about the file as a whole. As
> stated above, there are six parameters:
> $$\hbox{|@!i[1]| |@!num[4]| |@!den[4]| |@!mag[4]| |@!k[1]| |@!x[k]|.}$$
> The |i| byte identifies \.{DVI} format; currently this byte is always set
> to~2. (The value |i=3| is currently used for an extended format that
> allows a mixture of right-to-left and left-to-right typesetting.
> Some day we will set |i=4|, when \.{DVI} format makes another
> incompatible change---perhaps in the year 2048.)
>
> The next two parameters, |num| and |den|, are positive integers that define
> the units of measurement; they are the numerator and denominator of a
> fraction by which all dimensions in the \.{DVI} file could be multiplied
> in order to get lengths in units of $10^{-7}$ meters. Since $\rm 7227{pt} =
> 254{cm}$, and since \TeX\ works with scaled points where there are $2^{16}$
> sp in a point, \TeX\ sets
> $|num|/|den|=(254\cdot10^5)/(7227\cdot2^{16})=25400000/473628672$.
> @^sp@>
>
> The |mag| parameter is what \TeX\ calls \.{\\mag}, i.e., 1000 times the
> desired magnification. The actual fraction by which dimensions are
> multiplied is therefore $|mag|\cdot|num|/1000|den|$. Note that if a \TeX\
> source document does not call for any `\.{true}' dimensions, and if you
> change it only by specifying a different \.{\\mag} setting, the \.{DVI}
> file that \TeX\ creates will be completely unchanged except for the value
> of |mag| in the preamble and postamble. (Fancy \.{DVI}-reading programs allow
> users to override the |mag|~setting when a \.{DVI} file is being printed.)
>
> Finally, |k| and |x| allow the \.{DVI} writer to include a comment, which is not
> interpreted further. The length of comment |x| is |k|, where |0<=k<256|.
>
> @d id_byte=2 {identifies the kind of \.{DVI} files described here}
>
> @ Font definitions for a given font number |k| contain further parameters
> $$\hbox{|c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.}$$
> The four-byte value |c| is the check sum that \TeX\ found in the \.{TFM}
> file for this font; |c| should match the check sum of the font found by
> programs that read this \.{DVI} file.
> @^check sum@>
>
> Parameter |s| contains a fixed-point scale factor that is applied to
> the character widths in font |k|; font dimensions in \.{TFM} files and
> other font files are relative to this quantity, which is called the
> ``at size'' elsewhere in this documentation. The value of |s| is
> always positive and less than $2^{27}$. It is given in the same units
> as the other \.{DVI} dimensions, i.e., in sp when \TeX82 has made the
> file. Parameter |d| is similar to |s|; it is the ``design size,'' and
> (like~|s|) it is given in \.{DVI} units. Thus, font |k| is to be used
> at $|mag|\cdot s/1000d$ times its normal size.
>
> The remaining part of a font definition gives the external name of the font,
> which is an ASCII string of length |a+l|. The number |a| is the length
> of the ``area'' or directory, and |l| is the length of the font name itself;
> the standard local system font area is supposed to be used when |a=0|.
> The |n| field contains the area in its first |a| bytes.
>
> Font definitions must appear before the first use of a particular font number.
> Once font |k| is defined, it must not be defined again; however, we
> shall see below that font definitions appear in the postamble as well as
> in the pages, so in this sense each font number is defined exactly twice,
> if at all. Like |nop| commands, font definitions can
> appear before the first |bop|, or between an |eop| and a |bop|.
9251c11624
< generated by \MF\ by adhering to the following principles: (1)@@The \MF\
---
> generated by \MF\ by adhering to the following principles: (1)~The \MF\
9254c11627
< reference point, i.e., in row@@0 and column@@0 of the \MF\ raster. This
---
> reference point, i.e., in row~0 and column~0 of the \MF\ raster. This
9257c11630
< the \.{DVI} file. (2)@@A typeset rule of height $a>0$ and width $b>0$
---
> the \.{DVI} file. (2)~A typeset rule of height $a>0$ and width $b>0$
9260c11633
< |0≤x<@t$\alpha$@>b| and |0≤y<@t$\alpha$@>a|, where $\alpha$ is the number
---
> |0<=x<@t$\alpha$@>b| and |0<=y<@t$\alpha$@>a|, where $\alpha$ is the number
9266c11639
< @ The last page in a \.{DVI} file is followed by `|pst|'; this command
---
> @ The last page in a \.{DVI} file is followed by `|post|'; this command
9268,9288c11641,11649
< accumulated about the file. The postamble has the form
< $$\hbox{|p[4]| |n[4]| |d[4]| |m[4]| |l[4]| |u[4]| |s[2]| |t[2]|
< $\langle\,$font definitions$\,\rangle$
< $(-1)[4]$ |q[4]| |i[1]| 223's|[≥4]|}$$
< Here |p| is a pointer to the final |bop| in the file. The next two parameters,
< |n| and |d|, are positive integers that define the units of measurement;
< they are the numerator and denominator of a fraction by which all dimensions
< in the \.{DVI} file could be multiplied in order to get lengths in units
< of $10^{-7}$ meters. (Since there are 72.27 points per inch and 2.54 centimeters
< per inch, and since \TeX82 works with scaled points where there are $2^{16}$
< sp in a point, \TeX82 sets |n=25400000| and $d=7227\cdot2^{16}=473628672$.)
< @^sp@>
<
< The next parameter, |m|, is \TeX's \.{\\mag} parameter, i.e., 1000 times the
< desired magnification. The actual fraction by which dimensions are multiplied
< is therefore $mn/1000d$. Note that if a \TeX\ source document does not call
< for any `\.{true}' dimensions, and if you change it only by specifying a
< different \.{\\mag} setting, the \.{DVI} file that \TeX\ creates will be
< completely unchanged except for the value of |m| in the postamble. (Fancy
< \.{DVI}-reading programs allow users to override the |m|@@setting when a
< \.{DVI} file is being printed.)
---
> accumulated about the file, making it possible to print subsets of the data
> with reasonable efficiency. The postamble has the form
> $$\vbox{\halign{\hbox{#\hfil}\cr
> |post| |p[4]| |num[4]| |den[4]| |mag[4]| |l[4]| |u[4]| |s[2]| |t[2]|\cr
> $\langle\,$font definitions$\,\rangle$\cr
> |post_post| |q[4]| |i[1]| 223's$[{\G}4]$\cr}}$$
> Here |p| is a pointer to the final |bop| in the file. The next three
> parameters, |num|, |den|, and |mag|, are duplicates of the quantities that
> appeared in the preamble.
9293,9296c11654,11664
< position individual ``pages'' on large sheets of film or paper.
< Parameter |s| is the maximum stack depth (i.e., the excess of |push| commands
< over |pop| commands) needed to process this file. Then comes |t|, the total
< number of pages (|bop| commands) present.
---
> position individual ``pages'' on large sheets of film or paper; however,
> the standard convention for output on normal size paper is to position each
> page so that the upper left-hand corner is exactly one inch from the left
> and the top. Experience has shown that it is unwise to design \.{DVI}-to-printer
> software that attempts cleverly to center the output; a fixed position of
> the upper left corner is easiest for users to understand and to work with.
> Therefore |l| and~|u| are often ignored.
>
> Parameter |s| is the maximum stack depth (i.e., the largest excess of
> |push| commands over |pop| commands) needed to process this file. Then
> comes |t|, the total number of pages (|bop| commands) present.
9299,9327c11667,11675
< speci\-fi\-ca\-tions having the form
< \def\f{↓{\!f}}
< $$\hbox{|f[4]| $c\f[4]$ $s\f[4]$ $a\f[1]$ $l\f[1]$ $n\f[a\f+l\f]$.}$$
< The first parameter in a font definition is the font number, $f$; this
< must be different from $-1$ and distinct from the font numbers in other
< definitions. (Note that the font definitions are followed by the four-byte
< value $-1$, so it will be clear when the definitions have ended.) The
< next parameter, $c\f$, is the check sum that \TeX\ found in the \.{TFM}
< file for this font; it should match the check sum of the font found by
< @^check sum@>
< programs that read this \.{DVI} file.
< Parameter $s\f$ contains a fixed-point scale factor that is applied to the
< character widths in font |f|; font dimensions in \.{TFM} files and other font
< files are relative to this quantity, which is called the ``at size'' elsewhere
< in this documentation. The value of $s\f$ is always positive and less than
< $2^{27}$. It is given in the same units as the other dimensions of the
< file, i.e., in sp.
<
< The remaining part of a font definition gives the external name of the font,
< which is an ascii string of length $a\f+l\f$. The number $a\f$ is the length
< of the ``area'' or directory, and $l\f$ is the length of the font name itself;
< the standard local system font area is supposed to be used when $a\f=0$.
< The $n\f$ field contains the area in its first $a\f$ bytes.
<
< @ The last part of the postamble, following the phony font number
< $-1$, contains |q|, a pointer to the |pst| command that started the
< postamble. An identification byte, |i|, comes next; currently this byte
< is always set to@@2. (Some day we will set |i=3|, when \.{DVI} format
< makes another incompatible change---perhaps in 1992.)
---
> \\{fnt\_def} commands as described above, possibly interspersed with |nop|
> commands. Each font number that is used in the \.{DVI} file must be defined
> exactly twice: Once before it is first selected by a \\{fnt} command, and once
> in the postamble.
>
> @ The last part of the postamble, following the |post_post| byte that
> signifies the end of the font definitions, contains |q|, a pointer to the
> |post| command that started the postamble. An identification byte, |i|,
> comes next; this currently equals~2, as in the preamble.
9329c11677
< Following the |i| byte there are four or more bytes that are all equal to
---
> The |i| byte is followed by four or more bytes that are all equal to
9341,9345c11689,11693
< the \.{DVI} reader starts at the end and skips backwards over the 223's
< until finding the identification byte. Then it backs up four bytes, reads
< |q|, and goes to byte |q| of the file. This byte should, of course,
< contain the value 240 (|pst|); now the postamble can be read, so the
< \.{DVI} reader discovers all the information needed for typesetting the
---
> the \.{DVI} reader can start at the end and skip backwards over the 223's
> until finding the identification byte. Then it can back up four bytes, read
> |q|, and move to byte |q| of the file. This byte should, of course,
> contain the value 248 (|post|); now the postamble can be read, so the
> \.{DVI} reader can discover all the information needed for typesetting the
9348,9362c11696,11697
< desirable.
<
< The reason for reading the postamble first is that the \.{DVI} reader must
< know the widths of characters, in order to find out where things go on a page;
< and it needs to know the names of the fonts, so that it can get their widths
< from a \.{TFM} file or from some other kind of font-information file.
< The reason for writing the postamble last is that \TeX\ can't put out all
< the font names until it has finished generating the pages of the \.{DVI}
< file, since new fonts can occur anywhere in a \TeX\ job; and the alternative
< of sprinkling font definitions throughout a \.{DVI} file is unattractive,
< since that would make it necessary to read the whole file even when
< printing only one page. Furthermore, we wouldn't want to copy the
< information in the first part of a \.{DVI} file to the end of another file
< that begins with the postamble information, since the first part
< is typically quite long.
---
> desirable. This saves a lot of time, since \.{DVI} files used in production
> jobs tend to be large.
9370,9371c11705,11708
< \PASCAL, one can simply read them twice, first skipping to the postamble
< and then doing the pages.
---
> \PASCAL, one can simply read them from front to back, since the necessary
> header information is present in the preamble and in the font definitions.
> (The |l| and |u| and |s| and |t| parameters, which appear only in the
> postamble, are ``frills'' that are handy but not absolutely necessary.)
9373,9374c11710
< @d id_byte=2 {identifies the kind of \.{DVI} files described here}
< @* \[31] Shipping pages out.
---
> @* \[32] Shipping pages out.
9393a11730,11731
> The variable |dead_cycles| contains the number of times an output routine
> has been initiated since the last |ship_out|.
9406a11745
> @!dead_cycles:integer; {recent outputs that didn't ship anything out}
9410d11748
< @!hd:quarterword; {height and depth indices for a character}
9413c11751
< @!lq,@!lr,@!lx:integer; {quantities used in calculations for leaders}
---
> @!lq,@!lr:integer; {quantities used in calculations for leaders}
9416,9417c11754,11755
< total_pages←0; max_v←0; max_h←0; max_push←0; last_bop←-1;
< doing_leaders←false;
---
> total_pages:=0; max_v:=0; max_h:=0; max_push:=0; last_bop:=-1;
> doing_leaders:=false; dead_cycles:=0; cur_s:=-1;
9440c11778
< A byte is present in the buffer only if its number is |≥dvi_gone|.
---
> A byte is present in the buffer only if its number is |>=dvi_gone|.
9446a11785
> @^system dependencies@>
9454c11793
< output buffer has been fully emptied}
---
> output buffer has been fully emptied}
9461,9462c11800,11801
< half_buf←dvi_buf_size div 2; dvi_limit←dvi_buf_size; dvi_ptr←0;
< dvi_offset←0; dvi_gone←0;
---
> half_buf:=dvi_buf_size div 2; dvi_limit:=dvi_buf_size; dvi_ptr:=0;
> dvi_offset:=0; dvi_gone:=0;
9477c11816
< begin for k←a to b do write(dvi_file,dvi_buf[k]);
---
> begin for k:=a to b do write(dvi_file,dvi_buf[k]);
9483,9485c11822,11824
< @d dvi_out(#)==@+begin dvi_buf[dvi_ptr]←#; incr(dvi_ptr);
< if dvi_ptr=dvi_limit then dvi_swap;
< end
---
> @d dvi_out(#)==@+begin dvi_buf[dvi_ptr]:=#; incr(dvi_ptr);
> if dvi_ptr=dvi_limit then dvi_swap;
> end
9489,9494c11828,11833
< begin write_dvi(0,half_buf-1); dvi_limit←half_buf;
< dvi_offset←dvi_offset+dvi_buf_size; dvi_ptr←0;
< end
< else begin write_dvi(half_buf,dvi_buf_size-1); dvi_limit←dvi_buf_size;
< end;
< dvi_gone←dvi_gone+half_buf;
---
> begin write_dvi(0,half_buf-1); dvi_limit:=half_buf;
> dvi_offset:=dvi_offset+dvi_buf_size; dvi_ptr:=0;
> end
> else begin write_dvi(half_buf,dvi_buf_size-1); dvi_limit:=dvi_buf_size;
> end;
> dvi_gone:=dvi_gone+half_buf;
9498c11837
< will be a multiple of@@4.
---
> will be a multiple of~4.
9508,9514c11847,11853
< begin if x≥0 then dvi_out(x div @'100000000)
< else begin x:=x+@'10000000000;
< x:=x+@'10000000000;
< dvi_out((x div @'100000000) + 128);
< end;
< x←x mod @'100000000; dvi_out(x div @'200000);
< x←x mod @'200000; dvi_out(x div @'400);
---
> begin if x>=0 then dvi_out(x div @'100000000)
> else begin x:=x+@'10000000000;
> x:=x+@'10000000000;
> dvi_out((x div @'100000000) + 128);
> end;
> x:=x mod @'100000000; dvi_out(x div @'200000);
> x:=x mod @'200000; dvi_out(x div @'400);
9517a11857,11889
> @ A mild optimization of the output is performed by the |dvi_pop|
> routine, which issues a |pop| unless it is possible to cancel a
> `|push| |pop|' pair. The parameter to |dvi_pop| is the byte address
> following the old |push| that matches the new |pop|.
>
> @p procedure dvi_pop(@!l:integer);
> begin if (l=dvi_offset+dvi_ptr)and(dvi_ptr>0) then decr(dvi_ptr)
> else dvi_out(pop);
> end;
>
> @ Here's a procedure that outputs a font definition. Since \TeX82 uses at
> most 256 different fonts per job, |fnt_def1| is always used as the command code.
>
> @p procedure dvi_font_def(@!f:internal_font_number);
> var k:pool_pointer; {index into |str_pool|}
> begin dvi_out(fnt_def1);
> dvi_out(f-font_base-1);@/
> dvi_out(qo(font_check[f].b0));
> dvi_out(qo(font_check[f].b1));
> dvi_out(qo(font_check[f].b2));
> dvi_out(qo(font_check[f].b3));@/
> dvi_four(font_size[f]);
> dvi_four(font_dsize[f]);@/
> dvi_out(length(font_area[f]));
> dvi_out(length(font_name[f]));
> @<Output the font name whose internal number is |f|@>;
> end;
>
> @ @<Output the font name whose internal number is |f|@>=
> for k:=str_start[font_area[f]] to str_start[font_area[f]+1]-1 do
> dvi_out(so(str_pool[k]));
> for k:=str_start[font_name[f]] to str_start[font_name[f]+1]-1 do
> dvi_out(so(str_pool[k]))
9536,9539c11908,11911
< $$3↓z\,1↓y\,4↓d\,1↓y\,5↓y\,9↓d\,2↓d\,6↓d\,5↓y\,3↓z\,5↓y\,8↓d\,9↓d.$$
< There are three $y$-hits ($1↓y\ldotsm1↓y$ and $5↓y\ldotsm5↓y\ldotsm5↓y$) and
< one $z$-hit ($3↓z\ldotsm3↓z$); there are no $d$-hits, since the two appearances
< of $9↓d$ have $d$'s between them, but we don't count $d$-hits so it doesn't
---
> $$3_z\,1_y\,4_d\,1_y\,5_y\,9_d\,2_d\,6_d\,5_y\,3_z\,5_y\,8_d\,9_d.$$
> There are three $y$-hits ($1_y\ldots1_y$ and $5_y\ldots5_y\ldots5_y$) and
> one $z$-hit ($3_z\ldots3_z$); there are no $d$-hits, since the two appearances
> of $9_d$ have $d$'s between them, but we don't count $d$-hits so it doesn't
9547,9548c11919,11920
< sequence until one of the following things happens: (a)@@You see
< $\delta↓y$ or $\delta↓z$, and this was the first time you encountered a
---
> sequence until one of the following things happens: (a)~You see
> $\delta_y$ or $\delta_z$, and this was the first time you encountered a
9550c11922
< $\delta$; you have scored a hit. (b)@@You see $\delta↓d$, and no $y$
---
> $\delta$; you have scored a hit. (b)~You see $\delta_d$, and no $y$
9552c11924
< the previous $\delta↓d$ to $\delta↓y$ (this corresponds to changing a
---
> the previous $\delta_d$ to $\delta_y$ (this corresponds to changing a
9554,9556c11926,11928
< another hit. (c)@@You see $\delta↓d$, and a $y$ subscript has been seen
< but not a $z$. Change the previous $\delta↓d$ to $\delta↓z$ and assign
< $z$ to the new $\delta$. (d)@@You encounter both $y$ and $z$ subscripts
---
> another hit. (c)~You see $\delta_d$, and a $y$ subscript has been seen
> but not a $z$. Change the previous $\delta_d$ to $\delta_z$ and assign
> $z$ to the new $\delta$. (d)~You encounter both $y$ and $z$ subscripts
9561c11933
< The subscripts $3↓z\,1↓y\,4↓d\ldotsm$ in the example above were, in fact,
---
> The subscripts $3_z\,1_y\,4_d\ldots\,$ in the example above were, in fact,
9584c11956
< down_ptr←null; right_ptr←null;
---
> down_ptr:=null; right_ptr:=null;
9597,9598c11969,11970
< begin q←get_node(movement_node_size); {new node for the top of the stack}
< width(q)←w; location(q)←dvi_offset+dvi_ptr;
---
> begin q:=get_node(movement_node_size); {new node for the top of the stack}
> width(q):=w; location(q):=dvi_offset+dvi_ptr;
9600,9603c11972,11975
< begin link(q)←down_ptr; down_ptr←q;
< end
< else begin link(q)←right_ptr; right_ptr←q;
< end;
---
> begin link(q):=down_ptr; down_ptr:=q;
> end
> else begin link(q):=right_ptr; right_ptr:=q;
> end;
9605c11977
< to generate; |goto found| if node |p| is a ``hit''@>;
---
> to generate; |goto found| if node |p| is a ``hit''@>;
9608c11980
< appearance of@@|w|@>;
---
> appearance of~|w|@>;
9625c11997
< redefining hits so that $\delta↓y\ldotsm \delta↓y$ is a hit if all $y$'s between
---
> redefining hits so that $\delta_y\ldots \delta_y$ is a hit if all $y$'s between
9627c11999
< parenthesis level of the right-hand $\delta↓y$ is deeper than or equal to
---
> parenthesis level of the right-hand $\delta_y$ is deeper than or equal to
9631,9634c12003,12009
< $$2↓y\,7↓d\,1↓d\,(\,8↓z\,2↓y\,8↓z\,)\,1$$
< we cannot change the previous $1↓d$ to $1↓y$, since that would invalidate
< the $2↓y\ldotsm2↓y$ hit. But we can change it to $1↓z$, scoring a hit
< since the intervening $8↓z$'s are enclosed in parentheses.
---
> $$2_y\,7_d\,1_d\,(\,8_z\,2_y\,8_z\,)\,1$$
> we cannot change the previous $1_d$ to $1_y$, since that would invalidate
> the $2_y\ldots2_y$ hit. But we can change it to $1_z$, scoring a hit
> since the intervening $8_z$'s are enclosed in parentheses.
>
> The program below removes movement nodes that are introduced after a |push|,
> before it outputs the corresponding |pop|.
9649c12024
< info(q)←info(p);
---
> info(q):=info(p);
9651,9670c12026,12045
< begin dvi_out(o+y0-down1); {|y0| or |w0|}
< while link(q)≠p do
< begin q←link(q);
< case info(q) of
< yz_OK: info(q)←z_OK;
< y_OK: info(q)←d_fixed;
< othercases do_nothing
< endcases;
< end;
< end
< else begin dvi_out(o+z0-down1); {|z0| or |x0|}
< while link(q)≠p do
< begin q←link(q);
< case info(q) of
< yz_OK: info(q)←y_OK;
< z_OK: info(q)←d_fixed;
< othercases do_nothing
< endcases;
< end;
< end
---
> begin dvi_out(o+y0-down1); {|y0| or |w0|}
> while link(q)<>p do
> begin q:=link(q);
> case info(q) of
> yz_OK: info(q):=z_OK;
> y_OK: info(q):=d_fixed;
> othercases do_nothing
> endcases;
> end;
> end
> else begin dvi_out(o+z0-down1); {|z0| or |x0|}
> while link(q)<>p do
> begin q:=link(q);
> case info(q) of
> yz_OK: info(q):=y_OK;
> z_OK: info(q):=d_fixed;
> othercases do_nothing
> endcases;
> end;
> end
9673,9687c12048,12062
< info(q)←yz_OK;
< if abs(w)≥@'40000000 then
< begin dvi_out(o+3); {|down4| or |right4|}
< dvi_four(w); return;
< end;
< if abs(w)≥@'100000 then
< begin dvi_out(o+2); {|down3| or |right3|}
< if w<0 then w←w+@'100000000;
< dvi_out(w div @'200000); w←w mod @'200000; goto 2;
< end;
< if abs(w)≥@'200 then
< begin dvi_out(o+1); {|down2| or |right2|}
< if w<0 then w←w+@'200000;
< goto 2;
< end;
---
> info(q):=yz_OK;
> if abs(w)>=@'40000000 then
> begin dvi_out(o+3); {|down4| or |right4|}
> dvi_four(w); return;
> end;
> if abs(w)>=@'100000 then
> begin dvi_out(o+2); {|down3| or |right3|}
> if w<0 then w:=w+@'100000000;
> dvi_out(w div @'200000); w:=w mod @'200000; goto 2;
> end;
> if abs(w)>=@'200 then
> begin dvi_out(o+1); {|down2| or |right2|}
> if w<0 then w:=w+@'200000;
> goto 2;
> end;
9689c12064
< if w<0 then w←w+@'400;
---
> if w<0 then w:=w+@'400;
9698a12074
> @^inner loop@>
9705,9716c12081,12092
< p←link(q); mstate←none_seen;
< while p≠null do
< begin if width(p)=w then @<Consider a node with matching width;
< |goto found| if it's a hit@>
< else case mstate+info(p) of
< none_seen+y_here: mstate←y_seen;
< none_seen+z_here: mstate←z_seen;
< y_seen+z_here,z_seen+y_here: goto not_found;
< othercases do_nothing
< endcases;
< p←link(p);
< end;
---
> p:=link(q); mstate:=none_seen;
> while p<>null do
> begin if width(p)=w then @<Consider a node with matching width;
> |goto found| if it's a hit@>
> else case mstate+info(p) of
> none_seen+y_here: mstate:=y_seen;
> none_seen+z_here: mstate:=z_seen;
> y_seen+z_here,z_seen+y_here: goto not_found;
> othercases do_nothing
> endcases;
> p:=link(p);
> end;
9721c12097
< moving finger writes, $\ldotss\,$.''
---
> moving finger writes, $\ldots\,\,$.''
9725,9730c12101,12106
< none_seen+yz_OK,none_seen+y_OK,z_seen+yz_OK,z_seen+y_OK:@;@/
< if location(p)<dvi_gone then goto not_found
< else @<Change buffered instruction to |y| or |w| and |goto found|@>;
< none_seen+z_OK,y_seen+yz_OK,y_seen+z_OK:@;@/
< if location(p)<dvi_gone then goto not_found
< else @<Change buffered instruction to |z| or |x| and |goto found|@>;
---
> none_seen+yz_OK,none_seen+y_OK,z_seen+yz_OK,z_seen+y_OK:@t@>@;@/
> if location(p)<dvi_gone then goto not_found
> else @<Change buffered instruction to |y| or |w| and |goto found|@>;
> none_seen+z_OK,y_seen+yz_OK,y_seen+z_OK:@t@>@;@/
> if location(p)<dvi_gone then goto not_found
> else @<Change buffered instruction to |z| or |x| and |goto found|@>;
9736,9739c12112,12115
< begin k←location(p)-dvi_offset;
< if k<0 then k←k+dvi_buf_size;
< dvi_buf[k]←dvi_buf[k]+y1-down1;
< info(p)←y_here; goto found;
---
> begin k:=location(p)-dvi_offset;
> if k<0 then k:=k+dvi_buf_size;
> dvi_buf[k]:=dvi_buf[k]+y1-down1;
> info(p):=y_here; goto found;
9743,9746c12119,12122
< begin k←location(p)-dvi_offset;
< if k<0 then k←k+dvi_buf_size;
< dvi_buf[k]←dvi_buf[k]+z1-down1;
< info(p)←z_here; goto found;
---
> begin k:=location(p)-dvi_offset;
> if k<0 then k:=k+dvi_buf_size;
> dvi_buf[k]:=dvi_buf[k]+z1-down1;
> info(p):=z_here; goto found;
9756c12132
< {delete movement nodes with |location≥l|}
---
> {delete movement nodes with |location>=l|}
9759,9766c12135,12142
< begin while down_ptr≠null do
< begin if location(down_ptr)<l then goto done;
< p←down_ptr; down_ptr←link(p); free_node(p,movement_node_size);
< end;
< done: while right_ptr≠null do
< begin if location(right_ptr)<l then return;
< p←right_ptr; right_ptr←link(p); free_node(p,movement_node_size);
< end;
---
> begin while down_ptr<>null do
> begin if location(down_ptr)<l then goto done;
> p:=down_ptr; down_ptr:=link(p); free_node(p,movement_node_size);
> end;
> done: while right_ptr<>null do
> begin if location(right_ptr)<l then return;
> p:=right_ptr; right_ptr:=link(p); free_node(p,movement_node_size);
> end;
9777c12153
< Therefore \TeX\ maintains two pairs of global variables: |dvi_h| and |dvi_v|
---
> Therefore, \TeX\ maintains two pairs of global variables: |dvi_h| and |dvi_v|
9792,9797c12168,12173
< @d synch_h==if cur_h≠dvi_h then
< begin movement(cur_h-dvi_h,right1); dvi_h←cur_h;
< end
< @d synch_v==if cur_v≠dvi_v then
< begin movement(cur_v-dvi_v,down1); dvi_v←cur_v;
< end
---
> @d synch_h==if cur_h<>dvi_h then
> begin movement(cur_h-dvi_h,right1); dvi_h:=cur_h;
> end
> @d synch_v==if cur_v<>dvi_v then
> begin movement(cur_v-dvi_v,down1); dvi_v:=cur_v;
> end
9803c12179
< @!cur_s:integer; {current depth of output box nesting}
---
> @!cur_s:integer; {current depth of output box nesting, initially $-1$}
9806,9807c12182,12197
< dvi_h←0; dvi_v←0; cur_h←0; dvi_f←undefined_font;
< cur_s←-1; ensure_dvi_open;
---
> dvi_h:=0; dvi_v:=0; cur_h:=h_offset; dvi_f:=null_font;
> ensure_dvi_open;
> if total_pages=0 then
> begin dvi_out(pre); dvi_out(id_byte); {output the preamble}
> @^preamble of \.{DVI} file@>
> dvi_four(25400000); dvi_four(473628672); {conversion ratio for sp}
> prepare_mag; dvi_four(mag); {magnification factor is frozen}
> old_setting:=selector; selector:=new_string;
> print(" TeX output "); print_int(year); print_char(".");
> print_two(month); print_char("."); print_two(day);
> print_char(":"); print_two(time div 60);
> print_two(time mod 60);
> selector:=old_setting; dvi_out(cur_length);
> for s:=str_start[str_ptr] to pool_ptr-1 do dvi_out(so(str_pool[s]));
> pool_ptr:=str_start[str_ptr]; {flush the current string}
> end
9819c12209
< recursive}
---
> recursive}
9827c12217
< @d advance=13 {go to this label when advancing past glue or a rule}
---
> @d move_past=13 {go to this label when advancing past glue or a rule}
9833c12223
< label reswitch, advance, fin_rule, next_p;
---
> label reswitch, move_past, fin_rule, next_p;
9834a12225
> @!left_edge: scaled; {the left coordinate for this box}
9842a12234
> @!lx:scaled; {extra space between leader boxes}
9845,9846c12237,12242
< begin this_box←temp_ptr; g_order←glue_order(this_box);
< g_sign←glue_sign(this_box); p←list_ptr(this_box);
---
> @!glue_temp:real; {glue value before rounding}
> @!cur_glue:real; {glue seen so far}
> @!cur_g:scaled; {rounded equivalent of |cur_glue| times the glue ratio}
> begin cur_g:=0; cur_glue:=float_constant(0);
> this_box:=temp_ptr; g_order:=glue_order(this_box);
> g_sign:=glue_sign(this_box); p:=list_ptr(this_box);
9848,9852c12244,12251
< if cur_s>max_push then max_push←cur_s;
< save_loc←dvi_offset+dvi_ptr; base_line←cur_v;
< while p≠null do @<Output node |p| for |hlist_out| and move to the next node,
< maintaining the condition |cur_v=base_line|@>;
< prune_movements(save_loc); decr(cur_s);
---
> if cur_s>0 then dvi_out(push);
> if cur_s>max_push then max_push:=cur_s;
> save_loc:=dvi_offset+dvi_ptr; base_line:=cur_v; left_edge:=cur_h;
> while p<>null do @<Output node |p| for |hlist_out| and move to the next node,
> maintaining the condition |cur_v=base_line|@>;
> prune_movements(save_loc);
> if cur_s>0 then dvi_pop(save_loc);
> decr(cur_s);
9863,9875c12262,12273
< begin synch_h; synch_v;
< repeat f←font(p); c←character(p);
< if f≠dvi_f then @<Change font |dvi_f| to |f|@>;
< if c<128+min_quarterword then dvi_out(qo(c))
< else begin dvi_out(set1); dvi_out(qo(c));
< end;
< cur_h←cur_h+char_width(f)(char_info(f)(c));
< p←link(p);
< until not is_char_node(p);
< dvi_h←cur_h;
< end
< else if p≠null then @<Output the non-|char_node| |p| for |hlist_out|
< and move to the next node@>
---
> begin synch_h; synch_v;
> repeat f:=font(p); c:=character(p);
> if f<>dvi_f then @<Change font |dvi_f| to |f|@>;
> if c>=qi(128) then dvi_out(set1);
> dvi_out(qo(c));@/
> cur_h:=cur_h+char_width(f)(char_info(f)(c));
> p:=link(p);
> until not is_char_node(p);
> dvi_h:=cur_h;
> end
> else @<Output the non-|char_node| |p| for |hlist_out|
> and move to the next node@>
9878,9882c12276,12282
< begin if f≤64+font_base then dvi_out(f-font_base-1+fnt_num_0)
< else begin dvi_out(fnt1); dvi_out(f-font_base-1);
< end;
< dvi_f←f;
< font_used[f]←true;
---
> begin if not font_used[f] then
> begin dvi_font_def(f); font_used[f]:=true;
> end;
> if f<=64+font_base then dvi_out(f-font_base-1+fnt_num_0)
> else begin dvi_out(fnt1); dvi_out(f-font_base-1);
> end;
> dvi_f:=f;
9888,9890c12288,12290
< rule_node: begin rule_ht←height(p); rule_dp←depth(p); rule_wd←width(p);
< goto fin_rule;
< end;
---
> rule_node: begin rule_ht:=height(p); rule_dp:=depth(p); rule_wd:=width(p);
> goto fin_rule;
> end;
9893c12293
< kern_node,math_node:cur_h←cur_h+width(p);
---
> kern_node,math_node:cur_h:=cur_h+width(p);
9899,9900c12299,12300
< advance: cur_h←cur_h+rule_wd;
< next_p:p←link(p);
---
> move_past: cur_h:=cur_h+rule_wd;
> next_p:p:=link(p);
9904,9911c12304,12311
< if list_ptr(p)=null then cur_h←cur_h+width(p)
< else begin save_h←dvi_h; save_v←dvi_v; dvi_out(push);
< cur_v←base_line+shift_amount(p); {shift the box down}
< temp_ptr←p; edge←cur_h;
< if type(p)=vlist_node then vlist_out@+else hlist_out;
< dvi_out(pop); dvi_h←save_h; dvi_v←save_v;
< cur_h←edge+width(p); cur_v←base_line;
< end
---
> if list_ptr(p)=null then cur_h:=cur_h+width(p)
> else begin save_h:=dvi_h; save_v:=dvi_v;
> cur_v:=base_line+shift_amount(p); {shift the box down}
> temp_ptr:=p; edge:=cur_h;
> if type(p)=vlist_node then vlist_out@+else hlist_out;
> dvi_h:=save_h; dvi_v:=save_v;
> cur_h:=edge+width(p); cur_v:=base_line;
> end
9914,9937c12314,12351
< if is_running(rule_ht) then rule_ht←height(this_box);
< if is_running(rule_dp) then rule_dp←depth(this_box);
< rule_ht←rule_ht+rule_dp; {this is the rule thickness}
< if (rule_ht>0)∧(rule_wd>0) then {we don't output empty rules}
< begin synch_h; cur_v←base_line+rule_dp; synch_v;
< dvi_out(set_rule); dvi_four(rule_ht); dvi_four(rule_wd);
< cur_v←base_line; dvi_h←dvi_h+rule_wd;
< end
<
< @ @<Move right or output leaders@>=
< begin g←glue_ptr(p); rule_wd←width(g);
< if g_sign≠normal then
< begin if g_sign=stretching then
< begin if stretch_order(g)=g_order then
< rule_wd←rule_wd+round(glue_set(this_box)*stretch(g));
< end
< else begin if shrink_order(g)=g_order then
< rule_wd←rule_wd-round(glue_set(this_box)*shrink(g));
< end;
< end;
< if subtype(p)≥a_leaders then
< @<Output leaders in an hlist, |goto fin_rule| if a rule
< or to |next_p| if done@>;
< goto advance;
---
> if is_running(rule_ht) then rule_ht:=height(this_box);
> if is_running(rule_dp) then rule_dp:=depth(this_box);
> rule_ht:=rule_ht+rule_dp; {this is the rule thickness}
> if (rule_ht>0)and(rule_wd>0) then {we don't output empty rules}
> begin synch_h; cur_v:=base_line+rule_dp; synch_v;
> dvi_out(set_rule); dvi_four(rule_ht); dvi_four(rule_wd);
> cur_v:=base_line; dvi_h:=dvi_h+rule_wd;
> end
>
> @ @d billion==float_constant(1000000000)
> @d vet_glue(#)== glue_temp:=#;
> if glue_temp>billion then
> glue_temp:=billion
> else if glue_temp<-billion then
> glue_temp:=-billion
>
> @<Move right or output leaders@>=
> begin g:=glue_ptr(p); rule_wd:=width(g)-cur_g;
> if g_sign<>normal then
> begin if g_sign=stretching then
> begin if stretch_order(g)=g_order then
> begin cur_glue:=cur_glue+stretch(g);
> vet_glue(float(glue_set(this_box))*cur_glue);
> @^real multiplication@>
> cur_g:=round(glue_temp);
> end;
> end
> else if shrink_order(g)=g_order then
> begin cur_glue:=cur_glue-shrink(g);
> vet_glue(float(glue_set(this_box))*cur_glue);
> cur_g:=round(glue_temp);
> end;
> end;
> rule_wd:=rule_wd+cur_g;
> if subtype(p)>=a_leaders then
> @<Output leaders in an hlist, |goto fin_rule| if a rule
> or to |next_p| if done@>;
> goto move_past;
9941c12355
< begin leader_box←leader_ptr(p);
---
> begin leader_box:=leader_ptr(p);
9943,9955c12357,12370
< begin rule_ht←height(leader_box); rule_dp←depth(leader_box);
< goto fin_rule;
< end;
< leader_wd←width(leader_box);
< if (leader_wd>0)∧(rule_wd>0) then
< begin edge←cur_h+rule_wd;
< @<Let |cur_h| be the position of the first box, and set |leader_wd|
< to the spacing between corresponding parts of boxes@>;
< while cur_h+leader_wd≤edge do
< @<Output a leader box at |cur_h|,
< then advance |cur_h| by |leader_wd|@>;
< cur_h←edge; goto next_p;
< end;
---
> begin rule_ht:=height(leader_box); rule_dp:=depth(leader_box);
> goto fin_rule;
> end;
> leader_wd:=width(leader_box);
> if (leader_wd>0)and(rule_wd>0) then
> begin rule_wd:=rule_wd+10; {compensate for floating-point rounding}
> edge:=cur_h+rule_wd; lx:=0;
> @<Let |cur_h| be the position of the first box, and set |leader_wd+lx|
> to the spacing between corresponding parts of boxes@>;
> while cur_h+leader_wd<=edge do
> @<Output a leader box at |cur_h|,
> then advance |cur_h| by |leader_wd+lx|@>;
> cur_h:=edge-10; goto next_p;
> end;
9959,9963c12374,12380
< case of |a_leaders| (aligned leaders), we want to move |cur_h| to the
< smallest multiple of |leader_wd| that is not less than the current
< value of |cur_h|, namely $|leader_wd|\ast\lceil |cur_h|/|leader_wd|\rceil$.
< The program here should work in all cases even though \PASCAL\ does not define
< the |div| operation precisely, and even when |cur_h| is negative.
---
> case of |a_leaders| (aligned leaders), we want to move |cur_h| to
> |left_edge| plus the smallest multiple of |leader_wd| for which the result
> is not less than the current value of |cur_h|; i.e., |cur_h| should become
> $|left_edge|+|leader_wd|\times\lceil
> (|cur_h|-|left_edge|)/|leader_wd|\rceil$. The program here should work in
> all cases even though some implementations of \PASCAL\ give nonstandard
> results for the |div| operation when |cur_h| is less than |left_edge|.
9966,9967c12383,12384
< by half of the excess space not occupied by the leaders; and in the case of
< case of |x_leaders| (expanded leaders) we increase both |cur_h| and |leader_wd|
---
> by half of the excess space not occupied by the leaders; and in the
> case of |x_leaders| (expanded leaders) we increase |cur_h|
9974,9984c12391,12401
< begin save_h←cur_h; cur_h←leader_wd*(cur_h @!div leader_wd);
< if cur_h<save_h then cur_h←cur_h+leader_wd;
< end
< else begin lq←rule_wd div leader_wd; {the number of box copies}
< lr←rule_wd mod leader_wd; {the remaining space}
< if subtype(p)=c_leaders then cur_h←cur_h+(lr div 2)
< else begin lx←(2*lr+lq+1) div (2*lq+2); {round|(lr/(q+1))|}
< leader_wd←leader_wd+lx;
< cur_h←cur_h+((lr-(lq-1)*lx) div 2);
< end;
< end
---
> begin save_h:=cur_h;
> cur_h:=left_edge+leader_wd*((cur_h-left_edge)@!div leader_wd);
> if cur_h<save_h then cur_h:=cur_h+leader_wd;
> end
> else begin lq:=rule_wd div leader_wd; {the number of box copies}
> lr:=rule_wd mod leader_wd; {the remaining space}
> if subtype(p)=c_leaders then cur_h:=cur_h+(lr div 2)
> else begin lx:=lr div (lq+1);
> cur_h:=cur_h+((lr-(lq-1)*lx) div 2);
> end;
> end
9986,9987c12403,12404
< @ The `\\{synch}' operations here are intended to decrease the number
< of bytes needed to specify horizontal and vertical motion in the \.{DVI} output.
---
> @ The `\\{synch}' operations here are intended to decrease the number of
> bytes needed to specify horizontal and vertical motion in the \.{DVI} output.
9990,9992c12407,12409
< begin cur_v←base_line+shift_amount(leader_box); synch_v; save_v←dvi_v;@/
< synch_h; save_h←dvi_h; dvi_out(push); temp_ptr←leader_box;
< outer_doing_leaders←doing_leaders; doing_leaders←true;
---
> begin cur_v:=base_line+shift_amount(leader_box); synch_v; save_v:=dvi_v;@/
> synch_h; save_h:=dvi_h; temp_ptr:=leader_box;
> outer_doing_leaders:=doing_leaders; doing_leaders:=true;
9994,9996c12411,12413
< doing_leaders←outer_doing_leaders;
< dvi_out(pop); dvi_v←save_v; dvi_h←save_h; cur_v←save_v;
< cur_h←save_h+leader_wd;
---
> doing_leaders:=outer_doing_leaders;
> dvi_v:=save_v; dvi_h:=save_h; cur_v:=base_line;
> cur_h:=save_h+leader_wd+lx;
10002c12419
< label advance, fin_rule, next_p;
---
> label move_past, fin_rule, next_p;
10003a12421
> @!top_edge: scaled; {the top coordinate for this box}
10011a12430
> @!lx:scaled; {extra space between leader boxes}
10014,10015c12433,12438
< begin this_box←temp_ptr; g_order←glue_order(this_box);
< g_sign←glue_sign(this_box); p←list_ptr(this_box);
---
> @!glue_temp:real; {glue value before rounding}
> @!cur_glue:real; {glue seen so far}
> @!cur_g:scaled; {rounded equivalent of |cur_glue| times the glue ratio}
> begin cur_g:=0; cur_glue:=float_constant(0);
> this_box:=temp_ptr; g_order:=glue_order(this_box);
> g_sign:=glue_sign(this_box); p:=list_ptr(this_box);
10017,10021c12440,12448
< if cur_s>max_push then max_push←cur_s;
< save_loc←dvi_offset+dvi_ptr; left_edge←cur_h; cur_v←cur_v-height(this_box);
< while p≠null do @<Output node |p| for |vlist_out| and move to the next node,
< maintaining the condition |cur_h=left_edge|@>;
< prune_movements(save_loc); decr(cur_s);
---
> if cur_s>0 then dvi_out(push);
> if cur_s>max_push then max_push:=cur_s;
> save_loc:=dvi_offset+dvi_ptr; left_edge:=cur_h; cur_v:=cur_v-height(this_box);
> top_edge:=cur_v;
> while p<>null do @<Output node |p| for |vlist_out| and move to the next node,
> maintaining the condition |cur_h=left_edge|@>;
> prune_movements(save_loc);
> if cur_s>0 then dvi_pop(save_loc);
> decr(cur_s);
10026c12453
< @:confusion vlistout}{\quad vlistout@>
---
> @:this can't happen vlistout}{\quad vlistout@>
10028c12455
< next_p:p←link(p);
---
> next_p:p:=link(p);
10034,10036c12461,12463
< rule_node: begin rule_ht←height(p); rule_dp←depth(p); rule_wd←width(p);
< goto fin_rule;
< end;
---
> rule_node: begin rule_ht:=height(p); rule_dp:=depth(p); rule_wd:=width(p);
> goto fin_rule;
> end;
10039c12466
< kern_node:cur_v←cur_v+width(p);
---
> kern_node:cur_v:=cur_v+width(p);
10044c12471
< advance: cur_v←cur_v+rule_ht;
---
> move_past: cur_v:=cur_v+rule_ht;
10052,10060c12479,12487
< if list_ptr(p)=null then cur_v←cur_v+height(p)+depth(p)
< else begin cur_v←cur_v+height(p); synch_v;
< save_h←dvi_h; save_v←dvi_v; dvi_out(push);
< cur_h←left_edge+shift_amount(p); {shift the box right}
< temp_ptr←p;
< if type(p)=vlist_node then vlist_out@+else hlist_out;
< dvi_out(pop); dvi_h←save_h; dvi_v←save_v;
< cur_v←save_v+depth(p); cur_h←left_edge;
< end
---
> if list_ptr(p)=null then cur_v:=cur_v+height(p)+depth(p)
> else begin cur_v:=cur_v+height(p); synch_v;
> save_h:=dvi_h; save_v:=dvi_v;
> cur_h:=left_edge+shift_amount(p); {shift the box right}
> temp_ptr:=p;
> if type(p)=vlist_node then vlist_out@+else hlist_out;
> dvi_h:=save_h; dvi_v:=save_v;
> cur_v:=save_v+depth(p); cur_h:=left_edge;
> end
10063,10069c12490,12496
< if is_running(rule_wd) then rule_wd←width(this_box);
< rule_ht←rule_ht+rule_dp; {this is the rule thickness}
< cur_v←cur_v+rule_ht;
< if (rule_ht>0)∧(rule_wd>0) then {we don't output empty rules}
< begin synch_h; synch_v;
< dvi_out(put_rule); dvi_four(rule_ht); dvi_four(rule_wd);
< end;
---
> if is_running(rule_wd) then rule_wd:=width(this_box);
> rule_ht:=rule_ht+rule_dp; {this is the rule thickness}
> cur_v:=cur_v+rule_ht;
> if (rule_ht>0)and(rule_wd>0) then {we don't output empty rules}
> begin synch_h; synch_v;
> dvi_out(put_rule); dvi_four(rule_ht); dvi_four(rule_wd);
> end;
10073,10086c12500,12520
< begin g←glue_ptr(p); rule_ht←width(g);
< if g_sign≠normal then
< begin if g_sign=stretching then
< begin if stretch_order(g)=g_order then
< rule_ht←rule_ht+round(glue_set(this_box)*stretch(g));
< end
< else begin if shrink_order(g)=g_order then
< rule_ht←rule_ht-round(glue_set(this_box)*shrink(g));
< end;
< end;
< if subtype(p)≥a_leaders then
< @<Output leaders in a vlist, |goto fin_rule| if a rule
< or to |next_p| if done@>;
< goto advance;
---
> begin g:=glue_ptr(p); rule_ht:=width(g)-cur_g;
> if g_sign<>normal then
> begin if g_sign=stretching then
> begin if stretch_order(g)=g_order then
> begin cur_glue:=cur_glue+stretch(g);
> vet_glue(float(glue_set(this_box))*cur_glue);
> @^real multiplication@>
> cur_g:=round(glue_temp);
> end;
> end
> else if shrink_order(g)=g_order then
> begin cur_glue:=cur_glue-shrink(g);
> vet_glue(float(glue_set(this_box))*cur_glue);
> cur_g:=round(glue_temp);
> end;
> end;
> rule_ht:=rule_ht+cur_g;
> if subtype(p)>=a_leaders then
> @<Output leaders in a vlist, |goto fin_rule| if a rule
> or to |next_p| if done@>;
> goto move_past;
10090c12524
< begin leader_box←leader_ptr(p);
---
> begin leader_box:=leader_ptr(p);
10092,10104c12526,12539
< begin rule_wd←width(leader_box); rule_dp←0;
< goto fin_rule;
< end;
< leader_ht←height(leader_box)+depth(leader_box);
< if (leader_ht>0)∧(rule_ht>0) then
< begin edge←cur_v+rule_ht;
< @<Let |cur_v| be the position of the first box, and set |leader_ht|
< to the spacing between corresponding parts of boxes@>;
< while cur_v+leader_ht≤edge do
< @<Output a leader box at |cur_v|,
< then advance |cur_v| by |leader_ht|@>;
< cur_v←edge; goto next_p;
< end;
---
> begin rule_wd:=width(leader_box); rule_dp:=0;
> goto fin_rule;
> end;
> leader_ht:=height(leader_box)+depth(leader_box);
> if (leader_ht>0)and(rule_ht>0) then
> begin rule_ht:=rule_ht+10; {compensate for floating-point rounding}
> edge:=cur_v+rule_ht; lx:=0;
> @<Let |cur_v| be the position of the first box, and set |leader_ht+lx|
> to the spacing between corresponding parts of boxes@>;
> while cur_v+leader_ht<=edge do
> @<Output a leader box at |cur_v|,
> then advance |cur_v| by |leader_ht+lx|@>;
> cur_v:=edge-10; goto next_p;
> end;
10109,10119c12544,12554
< begin save_v←cur_v; cur_v←leader_ht*(cur_v @!div leader_ht);
< if cur_v<save_v then cur_v←cur_v+leader_ht;
< end
< else begin lq←rule_ht div leader_ht; {the number of box copies}
< lr←rule_ht mod leader_ht; {the remaining space}
< if subtype(p)=c_leaders then cur_v←cur_v+(lr div 2)
< else begin lx←(2*lr+lq+1) div (2*lq+2); {round|(lr/(q+1))|}
< leader_ht←leader_ht+lx;
< cur_v←cur_v+((lr-(lq-1)*lx) div 2);
< end;
< end
---
> begin save_v:=cur_v;
> cur_v:=top_edge+leader_ht*((cur_v-top_edge)@!div leader_ht);
> if cur_v<save_v then cur_v:=cur_v+leader_ht;
> end
> else begin lq:=rule_ht div leader_ht; {the number of box copies}
> lr:=rule_ht mod leader_ht; {the remaining space}
> if subtype(p)=c_leaders then cur_v:=cur_v+(lr div 2)
> else begin lx:=lr div (lq+1);
> cur_v:=cur_v+((lr-(lq-1)*lx) div 2);
> end;
> end
10125,10128c12560,12563
< begin cur_h←left_edge+shift_amount(leader_box); synch_h; save_h←dvi_h;@/
< cur_v←cur_v+height(leader_box); synch_v; save_v←dvi_v;
< dvi_out(push); temp_ptr←leader_box;
< outer_doing_leaders←doing_leaders; doing_leaders←true;
---
> begin cur_h:=left_edge+shift_amount(leader_box); synch_h; save_h:=dvi_h;@/
> cur_v:=cur_v+height(leader_box); synch_v; save_v:=dvi_v;
> temp_ptr:=leader_box;
> outer_doing_leaders:=doing_leaders; doing_leaders:=true;
10130,10132c12565,12567
< doing_leaders←outer_doing_leaders;
< dvi_out(pop); dvi_v←save_v; dvi_h←save_h; cur_h←save_h;
< cur_v←save_v-height(leader_box)+leader_ht;
---
> doing_leaders:=outer_doing_leaders;
> dvi_v:=save_v; dvi_h:=save_h; cur_h:=left_edge;
> cur_v:=save_v-height(leader_box)+leader_ht+lx;
10138a12574
> label done;
10140,10145c12576,12581
< @!k:0..9; {runs through ten count registers}
< begin if tracing_output=0 then
< begin if offset>max_print_line-9 then print_ln@+else print_char(" ");
< print_char("["); print_int(count(0)); update_terminal;
< end
< else begin print_nl(""); print_nl("Completed box being shipped out [");
---
> @!j,@!k:0..9; {indices to first ten count registers}
> @!s:pool_pointer; {index into |str_pool|}
> @!old_setting:0..max_selector; {saved |selector| setting}
> begin if tracing_output>0 then
> begin print_nl(""); print_ln;
> print("Completed box being shipped out");
10147,10153c12583,12596
< for k←0 to 9 do
< begin print_int(count(k));
< if k<9 then print_char(".");
< end;
< print_char("]");@/
< begin_diagnostic; show_box(p); end_diagnostic;
< end;
---
> end;
> if term_offset>max_print_line-9 then print_ln
> else if (term_offset>0)or(file_offset>0) then print_char(" ");
> print_char("["); j:=9;
> while (count(j)=0)and(j>0) do decr(j);
> for k:=0 to j do
> begin print_int(count(k));
> if k<j then print_char(".");
> end;
> update_terminal;
> if tracing_output>0 then
> begin print_char("]");
> begin_diagnostic; show_box(p); end_diagnostic(true);
> end;
10155c12598,12600
< if tracing_output=0 then print_char("]"); update_terminal; {progress report}
---
> if tracing_output<=0 then print_char("]");
> dead_cycles:=0;
> update_terminal; {progress report}
10160,10164c12605,12610
< stat if tracing_stats≠0 then
< begin print_nl("Memory usage before: ");
< print_int(var_used); print_char(",");
< print_int(dyn_used); print_char(";");
< end;
---
> @!stat if tracing_stats>1 then
> begin print_nl("Memory usage before: ");
> @.Memory usage...@>
> print_int(var_used); print_char("&");
> print_int(dyn_used); print_char(";");
> end;
10167,10173c12613,12618
< stat if tracing_stats≠0 then
< begin print(" after: ");
< print_int(var_used); print_char(",");
< print_int(dyn_used); print("; max so far: ");
< print_int(max_var_used); print_char(",");
< print_int(mem_end+1-hi_mem_base); print_ln;
< end;
---
> @!stat if tracing_stats>1 then
> begin print(" after: ");
> print_int(var_used); print_char("&");
> print_int(dyn_used); print("; still untouched: ");
> print_int(hi_mem_min-lo_mem_max-1); print_ln;
> end;
10177,10178c12622,12623
< if height(p)+depth(p)>max_v then max_v←height(p)+depth(p);
< if width(p)>max_h then max_h←width(p);
---
> @<Update the values of |max_h| and |max_v|; but if the page is too large,
> |goto done|@>;
10180c12625
< page_loc←dvi_offset+dvi_ptr;
---
> page_loc:=dvi_offset+dvi_ptr;
10182,10184c12627,12629
< for k←0 to 9 do dvi_four(count(k));
< dvi_four(last_bop); last_bop←page_loc;
< cur_v←height(p); temp_ptr←p;
---
> for k:=0 to 9 do dvi_four(count(k));
> dvi_four(last_bop); last_bop:=page_loc;
> cur_v:=height(p)+v_offset; temp_ptr:=p;
10186c12631,12657
< dvi_out(eop); incr(total_pages)
---
> dvi_out(eop); incr(total_pages); cur_s:=-1;
> done:
>
> @ Sometimes the user will generate a huge page because other error messages
> are being ignored. Such pages are not output to the \.{dvi} file, since they
> may confuse the printing software.
>
> @<Update the values of |max_h| and |max_v|; but if the page is too large...@>=
> if (height(p)>max_dimen)or@|(depth(p)>max_dimen)or@|
> (height(p)+depth(p)+v_offset>max_dimen)or@|
> (width(p)+h_offset>max_dimen) then
> begin print_err("Huge page cannot be shipped out");
> @.Huge page...@>
> help2("The page just created is more than 18 feet tall or")@/
> ("more than 18 feet wide, so I suspect something went wrong.");
> error;
> if tracing_output<=0 then
> begin begin_diagnostic;
> print_nl("The following box has been deleted:");
> @.The following...deleted@>
> show_box(p);
> end_diagnostic(true);
> end;
> goto done;
> end;
> if height(p)+depth(p)+v_offset>max_v then max_v:=height(p)+depth(p)+v_offset;
> if width(p)+h_offset>max_h then max_h:=width(p)+h_offset
10189a12661,12662
> If |total_pages>=65536|, the \.{DVI} file will lie. And if
> |max_push>=65536|, the user deserves whatever chaos might ensue.
10194,10212c12667,12695
< if total_pages=0 then print_nl("No output file.")
< else begin dvi_out(pst); {beginning of the postamble}
< dvi_four(last_bop); last_bop←dvi_offset+dvi_ptr-5; {|pst| location}
< dvi_four(25400000); dvi_four(473628672); {conversion ratio for sp}
< prepare_mag; dvi_four(mag); {magnification factor}
< dvi_four(max_v); dvi_four(max_h);@/
< dvi_out(max_push div 256); dvi_out(max_push mod 256);@/
< dvi_out(total_pages div 256); dvi_out(total_pages mod 256);@/
< @<Output the font definitions for all fonts that were used@>;
< dvi_four(-1); dvi_four(last_bop); dvi_out(id_byte);
< k←4+((dvi_buf_size-dvi_ptr) mod 4); {the number of 223's}
< while k>0 do
< begin dvi_out(223); decr(k);
< end;
< @<Empty the last bytes out of |dvi_buf|@>;
< print_nl("Output written on "); print(output_file_name);
< print(" ("); print_int(total_pages); print(" pages, ");
< print_int(dvi_offset+dvi_ptr); print(" bytes)."); b_close(dvi_file);
< end
---
> while cur_s>-1 do
> begin if cur_s>0 then dvi_out(pop)
> else begin dvi_out(eop); incr(total_pages);
> end;
> decr(cur_s);
> end;
> if total_pages=0 then print_nl("No pages of output.")
> @.No pages of output@>
> else begin dvi_out(post); {beginning of the postamble}
> dvi_four(last_bop); last_bop:=dvi_offset+dvi_ptr-5; {|post| location}
> dvi_four(25400000); dvi_four(473628672); {conversion ratio for sp}
> prepare_mag; dvi_four(mag); {magnification factor}
> dvi_four(max_v); dvi_four(max_h);@/
> dvi_out(max_push div 256); dvi_out(max_push mod 256);@/
> dvi_out((total_pages div 256) mod 256); dvi_out(total_pages mod 256);@/
> @<Output the font definitions for all fonts that were used@>;
> dvi_out(post_post); dvi_four(last_bop); dvi_out(id_byte);@/
> k:=4+((dvi_buf_size-dvi_ptr) mod 4); {the number of 223's}
> while k>0 do
> begin dvi_out(223); decr(k);
> end;
> @<Empty the last bytes out of |dvi_buf|@>;
> print_nl("Output written on "); slow_print(output_file_name);
> @.Output written on x@>
> print(" ("); print_int(total_pages); print(" page");
> if total_pages<>1 then print_char("s");
> print(", "); print_int(dvi_offset+dvi_ptr); print(" bytes).");
> b_close(dvi_file);
> end
10216,10234c12699,12703
< begin if font_used[font_ptr] then
< begin dvi_four(font_ptr-font_base-1);
< dvi_out(qo(font_check[font_ptr].b0));
< dvi_out(qo(font_check[font_ptr].b1));
< dvi_out(qo(font_check[font_ptr].b2));
< dvi_out(qo(font_check[font_ptr].b3));
< dvi_four(font_size[font_ptr]);
< dvi_out(length(font_area[font_ptr]));
< dvi_out(length(font_name[font_ptr]));
< @<Output the font name whose internal number is |font_ptr|@>;
< end;
< decr(font_ptr);
< end
< @ @<Output the font name whose internal number is |font_ptr|@>=
< for k←str_start[font_area[font_ptr]] to str_start[font_area[font_ptr]+1]-1 do
< dvi_out(str_pool[k]);
< for k←str_start[font_name[font_ptr]] to str_start[font_name[font_ptr]+1]-1 do
< dvi_out(str_pool[k])
< @* \[32] Packaging.
---
> begin if font_used[font_ptr] then dvi_font_def(font_ptr);
> decr(font_ptr);
> end
>
> @* \[33] Packaging.
10245c12714
< inside the new box, but some items may stick out if negative glue is used,
---
> inside the new box; but some items may stick out if negative glue is used,
10251,10252c12720,12721
< a width; and pa\-ram\-eter |m| is either `|exactly|' or `|additional|'. Thus,
< |hpack(p,w,exactly)| pro\-duces a box whose width is exactly |w|, while
---
> a width; and parameter |m| is either `|exactly|' or `|additional|'. Thus,
> |hpack(p,w,exactly)| produces a box whose width is exactly |w|, while
10267c12736
< like `\.{\\hbox} \.{to} \.{300pt}', `\.{\\hbox} \.{expand} \.{10pt}'; note
---
> like `\.{\\hbox} \.{to} \.{300pt}', `\.{\\hbox} \.{spread} \.{10pt}'; note
10269c12738
< `\.{\\hbox} \.{expand} \.{0pt}'. The |scan_spec| subroutine scans such
---
> `\.{\\hbox} \.{spread} \.{0pt}'. The |scan_spec| subroutine scans such
10274c12743
< |save_ptr←save_ptr-2;|\cr
---
> |save_ptr:=save_ptr-2;|\cr
10275a12745,12747
> Special care is necessary to ensure that the special |save_stack| codes
> are placed just below the new group code, because scanning can change
> |save_stack| when \.{\\csname} appears.
10277c12749,12750
< @p procedure scan_spec; {scans a box specification and left brace}
---
> @p procedure scan_spec(@!c:group_code;@!three_codes:boolean);
> {scans a box specification and left brace}
10279,10285c12752,12767
< begin if scan_keyword("to") then saved(0)←exactly
< else if scan_keyword("expand") then saved(0)←additional
< else begin saved(0)←additional; saved(1)←0;
< goto found;
< end;
< scan_dimen(false,false,false); saved(1)←cur_val;
< found: save_ptr←save_ptr+2; scan_left_brace;
---
> var @!s:integer; {temporarily saved value}
> @!spec_code:exactly..additional;
> begin if three_codes then s:=saved(0);
> if scan_keyword("to") then spec_code:=exactly
> @.to@>
> else if scan_keyword("spread") then spec_code:=additional
> @.spread@>
> else begin spec_code:=additional; cur_val:=0;
> goto found;
> end;
> scan_normal_dimen;
> found: if three_codes then
> begin saved(0):=s; incr(save_ptr);
> end;
> saved(0):=spec_code; saved(1):=cur_val; save_ptr:=save_ptr+2;
> new_save_level(c); scan_left_brace;
10302c12784,12785
< glue of each kind is present.
---
> glue of each kind is present. A global variable |last_badness| is used
> to implement \.{\\badness}.
10306c12789,12795
< {glue found by |hpack| or |vpack|}
---
> {glue found by |hpack| or |vpack|}
> @!last_badness:integer; {badness of the most recently packaged box}
>
> @ If the global variable |adjust_tail| is non-null, the |hpack| routine
> also removes all occurrences of |ins_node|, |mark_node|, and |adjust_node|
> items and appends the resulting material onto the list that ends at
> location |adjust_tail|.
10308,10315c12797,12798
< @ Here now is |hpack| itself, which contains only one possible surprise:
< Be\-sides making a list into a box, |hpack| also removes all occurrences of
< |ins_node|, |mark_node|, and |adjust_node| items; it puts the resulting
< material into a list that starts at location |adjustments=link(adjust_head)|.
< These adjustments will be put into the enclosing vertical list, if |hpack|
< is being called to make a line of a paragraph; otherwise such nodes cannot
< be present in a horizontal list, since they are syntactically forbidden in
< restricted horizontal mode.
---
> @< Glob...@>=
> @!adjust_tail:pointer; {tail of adjustment list}
10317c12800,12802
< @d adjustments==link(adjust_head)
---
> @ @<Set init...@>=adjust_tail:=null; last_badness:=0;
>
> @ Here now is |hpack|, which contains few if any surprises.
10329,10339c12814,12823
< @!hd:quarterword; {height and depth indices for a character}
< @!t:pointer; {tail of the adjustment list}
< @!b:integer; {badness of the new box}
< begin r←get_node(box_node_size); type(r)←hlist_node;
< subtype(r)←min_quarterword; shift_amount(r)←0;
< q←r+list_offset; link(q)←p;@/
< t←adjust_head; h←0; @<Clear dimensions to zero@>;
< while p≠null do @<Examine node |p| in the hlist, taking account of its effect
< on the dimensions of the new box, or moving it to the adjustment list;
< then advance |p| to the next node@>;
< link(t)←null; height(r)←h; depth(r)←d;@/
---
> @!hd:eight_bits; {height and depth indices for a character}
> begin last_badness:=0; r:=get_node(box_node_size); type(r):=hlist_node;
> subtype(r):=min_quarterword; shift_amount(r):=0;
> q:=r+list_offset; link(q):=p;@/
> h:=0; @<Clear dimensions to zero@>;
> while p<>null do @<Examine node |p| in the hlist, taking account of its effect
> on the dimensions of the new box, or moving it to the adjustment list;
> then advance |p| to the next node@>;
> if adjust_tail<>null then link(adjust_tail):=null;
> height(r):=h; depth(r):=d;@/
10341c12825
< then |return| or |goto common_ending|@>;
---
> then |return| or |goto common_ending|@>;
10343,10344c12827,12828
< for an overfull or underfull hbox@>;
< exit: hpack←r;
---
> for an overfull or underfull hbox@>;
> exit: hpack:=r;
10348,10351c12832,12836
< d←0; x←0;
< for o←normal to filll do
< begin total_stretch[o]←0; total_shrink[o]←0;
< end
---
> d:=0; x:=0;
> total_stretch[normal]:=0; total_shrink[normal]:=0;
> total_stretch[fil]:=0; total_shrink[fil]:=0;
> total_stretch[fill]:=0; total_shrink[fill]:=0;
> total_stretch[filll]:=0; total_shrink[filll]:=0
10353a12839
> @^inner loop@>
10355,10372c12841,12858
< @<Incorporate character dimensions into the dimensions of
< the hbox that will contain@@it, then move to the next node@>;
< if p≠null then
< begin case type(p) of
< hlist_node,vlist_node,rule_node,unset_node:
< @<Incorporate box dimensions into the dimensions of
< the hbox that will contain@@it@>;
< ins_node,mark_node,adjust_node:
< @<Transfer node |p| to the adjustment list@>;
< whatsit_node:@<Incorporate a whatsit node into an hbox@>;
< glue_node:@<Incorporate glue into the totals@>;
< kern_node,math_node: x←x+width(p);
< ligature_node: @<Make node |p| look like a |char_node|
< and |goto reswitch|@>;
< othercases do_nothing
< endcases;@/
< p←link(p);
< end;
---
> @<Incorporate character dimensions into the dimensions of
> the hbox that will contain~it, then move to the next node@>;
> if p<>null then
> begin case type(p) of
> hlist_node,vlist_node,rule_node,unset_node:
> @<Incorporate box dimensions into the dimensions of
> the hbox that will contain~it@>;
> ins_node,mark_node,adjust_node: if adjust_tail<>null then
> @<Transfer node |p| to the adjustment list@>;
> whatsit_node:@<Incorporate a whatsit node into an hbox@>;
> glue_node:@<Incorporate glue into the horizontal totals@>;
> kern_node,math_node: x:=x+width(p);
> ligature_node: @<Make node |p| look like a |char_node|
> and |goto reswitch|@>;
> othercases do_nothing
> endcases;@/
> p:=link(p);
> end;
10377,10378c12863,12864
< begin mem[lig_trick]←mem[lig_char(p)]; link(lig_trick)←link(p);
< p←lig_trick; goto reswitch;
---
> begin mem[lig_trick]:=mem[lig_char(p)]; link(lig_trick):=link(p);
> p:=lig_trick; goto reswitch;
10381,10385c12867,12875
< @ @<Incorporate box dimensions into the dimensions of the hbox...@>=
< begin x←x+width(p);
< if type(p)≥rule_node then s←0 @+else s←shift_amount(p);
< if height(p)-s>h then h←height(p)-s;
< if depth(p)+s>d then d←depth(p)+s;
---
> @ The code here implicitly uses the fact that running dimensions are
> indicated by |null_flag|, which will be ignored in the calculations
> because it is a highly negative number.
>
> @<Incorporate box dimensions into the dimensions of the hbox...@>=
> begin x:=x+width(p);
> if type(p)>=rule_node then s:=0 @+else s:=shift_amount(p);
> if height(p)-s>h then h:=height(p)-s;
> if depth(p)+s>d then d:=depth(p)+s;
10394,10398c12884,12888
< begin f←font(p); i←char_info(f)(character(p)); hd←height_depth(i);
< x←x+char_width(f)(i);@/
< s←char_height(f)(hd);@+if s>h then h←s;
< s←char_depth(f)(hd);@+if s>d then d←s;
< p←link(p);
---
> begin f:=font(p); i:=char_info(f)(character(p)); hd:=height_depth(i);
> x:=x+char_width(f)(i);@/
> s:=char_height(f)(hd);@+if s>h then h:=s;
> s:=char_depth(f)(hd);@+if s>d then d:=s;
> p:=link(p);
10405a12896
> @^inner loop@>
10408c12899
< begin while link(q)≠p do q←link(q);
---
> begin while link(q)<>p do q:=link(q);
10410,10422c12901,12918
< begin link(t)←adjust_ptr(p);
< while link(t)≠null do t←link(t);
< p←link(p); free_node(link(q),small_node_size);
< end
< else begin link(t)←p; t←p; p←link(p);
< end;
< link(q)←p; p←q;
< end
<
< @ @<Incorporate glue into the totals@>=
< begin g←glue_ptr(p); x←x+width(g);@/
< o←stretch_order(g); total_stretch[o]←total_stretch[o]+stretch(g);
< o←shrink_order(g); total_shrink[o]←total_shrink[o]+shrink(g);
---
> begin link(adjust_tail):=adjust_ptr(p);
> while link(adjust_tail)<>null do adjust_tail:=link(adjust_tail);
> p:=link(p); free_node(link(q),small_node_size);
> end
> else begin link(adjust_tail):=p; adjust_tail:=p; p:=link(p);
> end;
> link(q):=p; p:=q;
> end
>
> @ @<Incorporate glue into the horizontal totals@>=
> begin g:=glue_ptr(p); x:=x+width(g);@/
> o:=stretch_order(g); total_stretch[o]:=total_stretch[o]+stretch(g);
> o:=shrink_order(g); total_shrink[o]:=total_shrink[o]+shrink(g);
> if subtype(p)>=a_leaders then
> begin g:=leader_ptr(p);
> if height(g)>h then h:=height(g);
> if depth(g)>d then d:=depth(g);
> end;
10429,10430c12925,12926
< if m=additional then w←x+w;
< width(r)←w; x←w-x; {now |x| is the excess to be made up}
---
> if m=additional then w:=x+w;
> width(r):=w; x:=w-x; {now |x| is the excess to be made up}
10432,10434c12928,12931
< begin glue_sign(r)←normal; glue_order(r)←normal; glue_set(r)←0.0;
< return;
< end
---
> begin glue_sign(r):=normal; glue_order(r):=normal;
> set_glue_ratio_zero(glue_set(r));
> return;
> end
10436c12933
< or \hbox{|goto common_ending|}@>
---
> or \hbox{|goto common_ending|}@>
10438c12935
< or \hbox{|goto common_ending|}@>
---
> or \hbox{|goto common_ending|}@>
10442,10447c12939,12947
< glue_order(r)←o; glue_sign(r)←stretching;
< if total_stretch[o]=0 then glue_set(r)←0.0 {there's nothing to stretch}
< else glue_set(r)←x/total_stretch[o];
< if (hbadness<inf_bad)∧(o=normal)∧(list_ptr(r)≠null) then
< @<Report an underfull hbox and |goto common_ending|, if this box
< is sufficiently bad@>;
---
> glue_order(r):=o; glue_sign(r):=stretching;
> if total_stretch[o]<>0 then glue_set(r):=unfloat(x/total_stretch[o])
> @^real division@>
> else begin glue_sign(r):=normal;
> set_glue_ratio_zero(glue_set(r)); {there's nothing to stretch}
> end;
> if o=normal then if list_ptr(r)<>null then
> @<Report an underfull hbox and |goto common_ending|, if this box
> is sufficiently bad@>;
10452,10455c12952,12955
< if total_stretch[filll]≠0 then o←filll
< else if total_stretch[fill]≠0 then o←fill
< else if total_stretch[fil]≠0 then o←fil
< else o←normal
---
> if total_stretch[filll]<>0 then o:=filll
> else if total_stretch[fill]<>0 then o:=fill
> else if total_stretch[fil]<>0 then o:=fil
> else o:=normal
10458,10464c12958,12966
< begin b←badness(x,total_stretch[normal]);
< if b>hbadness then
< begin print_ln;
< if b>100 then print_nl("Underfull")@+else print_nl("Loose");
< print(" \hbox (badness "); print_int(b);
< goto common_ending;
< end;
---
> begin last_badness:=badness(x,total_stretch[normal]);
> if last_badness>hbadness then
> begin print_ln;
> if last_badness>100 then print_nl("Underfull")@+else print_nl("Loose");
> print(" \hbox (badness "); print_int(last_badness);
> @.Underfull \\hbox...@>
> @.Loose \\hbox...@>
> goto common_ending;
> end;
10468,10469c12970,12972
< box originated, we use a global variable |par_begin_line| that is
< set nonzero only when |hpack| is being called by the paragraph builder.
---
> box originated, we use a global variable |pack_begin_line| that is
> set nonzero only when |hpack| is being called by the paragraph builder
> or the alignment finishing routine.
10472c12975,12976
< @!par_begin_line:integer; {source file line where the current paragraph began}
---
> @!pack_begin_line:integer; {source file line where the current paragraph
> or alignment began; a negative value denotes alignment}
10475c12979
< par_begin_line←0;
---
> pack_begin_line:=0;
10479,10485c12983,12991
< else begin if par_begin_line≠0 then
< begin print(") in paragraph at lines "); print_int(par_begin_line);
< print("--");
< end
< else print(") detected at line ");
< print_int(line);
< end;
---
> else begin if pack_begin_line<>0 then
> begin if pack_begin_line>0 then print(") in paragraph at lines ")
> else print(") in alignment at lines ");
> print_int(abs(pack_begin_line));
> print("--");
> end
> else print(") detected at line ");
> print_int(line);
> end;
10487,10488c12993,12994
< font_in_short_display←undefined_font; short_display(list_ptr(r)); print_ln;@/
< begin_diagnostic; show_box(r); end_diagnostic
---
> font_in_short_display:=null_font; short_display(list_ptr(r)); print_ln;@/
> begin_diagnostic; show_box(r); end_diagnostic(true)
10492,10502c12998,13012
< glue_order(r)←o; glue_sign(r)←shrinking;
< if total_shrink[o]=0 then glue_set(r)←0.0 {there's nothing to shrink}
< else glue_set(r)←-x/total_shrink[o];
< if (total_shrink[o]<-x)∧(o=normal)∧(list_ptr(r)≠null) then
< begin glue_set(r)←1.0; {this is the maximum shrinkage}
< @<Report an overfull hbox and |goto common_ending|, if this box
< is sufficiently bad@>;
< end
< else if (hbadness<100)∧(o=normal)∧(list_ptr(r)≠null) then
< @<Report a tight hbox and |goto common_ending|, if this box
< is sufficiently bad@>;
---
> glue_order(r):=o; glue_sign(r):=shrinking;
> if total_shrink[o]<>0 then glue_set(r):=unfloat((-x)/total_shrink[o])
> @^real division@>
> else begin glue_sign(r):=normal;
> set_glue_ratio_zero(glue_set(r)); {there's nothing to shrink}
> end;
> if (total_shrink[o]<-x)and(o=normal)and(list_ptr(r)<>null) then
> begin last_badness:=1000000;
> set_glue_ratio_one(glue_set(r)); {use the maximum shrinkage}
> @<Report an overfull hbox and |goto common_ending|, if this box
> is sufficiently bad@>;
> end
> else if o=normal then if list_ptr(r)<>null then
> @<Report a tight hbox and |goto common_ending|, if this box
> is sufficiently bad@>;
10507,10510c13017,13020
< if total_shrink[filll]≠0 then o←filll
< else if total_shrink[fill]≠0 then o←fill
< else if total_shrink[fil]≠0 then o←fil
< else o←normal
---
> if total_shrink[filll]<>0 then o:=filll
> else if total_shrink[fill]<>0 then o:=fill
> else if total_shrink[fil]<>0 then o:=fil
> else o:=normal
10513,10522c13023,13033
< if -x-total_shrink[normal]>hfuzz then
< begin if overfull_rule>0 then
< begin while link(q)≠null do q←link(q);
< link(q)←new_rule;
< width(link(q))←overfull_rule;
< end;
< print_ln; print_nl("Overfull \hbox (");
< print_scaled(-x-total_shrink[normal]); print("pt too wide");
< goto common_ending;
< end
---
> if (-x-total_shrink[normal]>hfuzz)or(hbadness<100) then
> begin if (overfull_rule>0)and(-x-total_shrink[normal]>hfuzz) then
> begin while link(q)<>null do q:=link(q);
> link(q):=new_rule;
> width(link(q)):=overfull_rule;
> end;
> print_ln; print_nl("Overfull \hbox (");
> @.Overfull \\hbox...@>
> print_scaled(-x-total_shrink[normal]); print("pt too wide");
> goto common_ending;
> end
10525,10529c13036,13041
< begin b←badness(-x,total_shrink[normal]);
< if b>hbadness then
< begin print_ln; print_nl("Tight \hbox (badness "); print_int(b);
< goto common_ending;
< end;
---
> begin last_badness:=badness(-x,total_shrink[normal]);
> if last_badness>hbadness then
> begin print_ln; print_nl("Tight \hbox (badness "); print_int(last_badness);
> @.Tight \\hbox...@>
> goto common_ending;
> end;
10542c13054
< pointer;
---
> pointer;
10549,10556c13061,13067
< @!b:integer; {badness of the new box}
< begin r←get_node(box_node_size); type(r)←vlist_node;
< subtype(r)←min_quarterword; shift_amount(r)←0;
< list_ptr(r)←p;@/
< w←0; @<Clear dimensions to zero@>;
< while p≠null do @<Examine node |p| in the vlist, taking account of its effect
< on the dimensions of the new box; then advance |p| to the next node@>;
< width(r)←w;
---
> begin last_badness:=0; r:=get_node(box_node_size); type(r):=vlist_node;
> subtype(r):=min_quarterword; shift_amount(r):=0;
> list_ptr(r):=p;@/
> w:=0; @<Clear dimensions to zero@>;
> while p<>null do @<Examine node |p| in the vlist, taking account of its effect
> on the dimensions of the new box; then advance |p| to the next node@>;
> width(r):=w;
10558,10560c13069,13071
< begin x←x+d-l; depth(r)←l;
< end
< else depth(r)←d;
---
> begin x:=x+d-l; depth(r):=l;
> end
> else depth(r):=d;
10562c13073
< then |return| or |goto common_ending|@>;
---
> then |return| or |goto common_ending|@>;
10564,10565c13075,13076
< for an overfull or underfull vbox@>;
< exit: vpackage←r;
---
> for an overfull or underfull vbox@>;
> exit: vpackage:=r;
10570,10583c13081,13092
< @:confusion vpack}{\quad vpack@>
< else case type(p) of
< hlist_node,vlist_node,rule_node,unset_node:
< @<Incorporate box dimensions into the dimensions of
< the vbox that will contain@@it@>;
< whatsit_node:@<Incorporate a whatsit node into a vbox@>;
< glue_node: begin x←x+d; d←0;
< @<Incorporate glue into the totals@>;
< end;
< kern_node: begin x←x+d+width(p); d←0;
< end;
< othercases do_nothing
< endcases;
< p←link(p);
---
> @:this can't happen vpack}{\quad vpack@>
> else case type(p) of
> hlist_node,vlist_node,rule_node,unset_node:
> @<Incorporate box dimensions into the dimensions of
> the vbox that will contain~it@>;
> whatsit_node:@<Incorporate a whatsit node into a vbox@>;
> glue_node: @<Incorporate glue into the vertical totals@>;
> kern_node: begin x:=x+d+width(p); d:=0;
> end;
> othercases do_nothing
> endcases;
> p:=link(p);
10587,10589c13096,13109
< begin x←x+d+height(p); d←depth(p);
< if type(p)≥rule_node then s←0 @+else s←shift_amount(p);
< if width(p)+s>w then w←width(p)+s;
---
> begin x:=x+d+height(p); d:=depth(p);
> if type(p)>=rule_node then s:=0 @+else s:=shift_amount(p);
> if width(p)+s>w then w:=width(p)+s;
> end
>
> @ @<Incorporate glue into the vertical totals@>=
> begin x:=x+d; d:=0;@/
> g:=glue_ptr(p); x:=x+width(g);@/
> o:=stretch_order(g); total_stretch[o]:=total_stretch[o]+stretch(g);
> o:=shrink_order(g); total_shrink[o]:=total_shrink[o]+shrink(g);
> if subtype(p)>=a_leaders then
> begin g:=leader_ptr(p);
> if width(g)>w then w:=width(g);
> end;
10596,10597c13116,13117
< if m=additional then h←x+h;
< height(r)←h; x←h-x; {now |x| is the excess to be made up}
---
> if m=additional then h:=x+h;
> height(r):=h; x:=h-x; {now |x| is the excess to be made up}
10599,10601c13119,13122
< begin glue_sign(r)←normal; glue_order(r)←normal; glue_set(r)←0.0;
< return;
< end
---
> begin glue_sign(r):=normal; glue_order(r):=normal;
> set_glue_ratio_zero(glue_set(r));
> return;
> end
10603c13124
< or \hbox{|goto common_ending|}@>
---
> or \hbox{|goto common_ending|}@>
10605c13126
< or \hbox{|goto common_ending|}@>
---
> or \hbox{|goto common_ending|}@>
10609,10614c13130,13138
< glue_order(r)←o; glue_sign(r)←stretching;
< if total_stretch[o]=0 then glue_set(r)←0.0 {there's nothing to stretch}
< else glue_set(r)←x/total_stretch[o];
< if (vbadness<inf_bad)∧(o=normal)∧(list_ptr(r)≠null) then
< @<Report an underfull vbox and |goto common_ending|, if this box
< is sufficiently bad@>;
---
> glue_order(r):=o; glue_sign(r):=stretching;
> if total_stretch[o]<>0 then glue_set(r):=unfloat(x/total_stretch[o])
> @^real division@>
> else begin glue_sign(r):=normal;
> set_glue_ratio_zero(glue_set(r)); {there's nothing to stretch}
> end;
> if o=normal then if list_ptr(r)<>null then
> @<Report an underfull vbox and |goto common_ending|, if this box
> is sufficiently bad@>;
10619,10625c13143,13151
< begin b←badness(x,total_stretch[normal]);
< if b>vbadness then
< begin print_ln;
< if b>100 then print_nl("Underfull")@+else print_nl("Loose");
< print(" \vbox (badness "); print_int(b);
< goto common_ending;
< end;
---
> begin last_badness:=badness(x,total_stretch[normal]);
> if last_badness>vbadness then
> begin print_ln;
> if last_badness>100 then print_nl("Underfull")@+else print_nl("Loose");
> print(" \vbox (badness "); print_int(last_badness);
> @.Underfull \\vbox...@>
> @.Loose \\vbox...@>
> goto common_ending;
> end;
10630,10633c13156,13165
< else begin print(") detected at line "); print_int(line);
< print_ln;@/
< end;
< begin_diagnostic; show_box(r); end_diagnostic
---
> else begin if pack_begin_line<>0 then {it's actually negative}
> begin print(") in alignment at lines ");
> print_int(abs(pack_begin_line));
> print("--");
> end
> else print(") detected at line ");
> print_int(line);
> print_ln;@/
> end;
> begin_diagnostic; show_box(r); end_diagnostic(true)
10637,10647c13169,13183
< glue_order(r)←o; glue_sign(r)←shrinking;
< if total_shrink[o]=0 then glue_set(r)←0.0 {there's nothing to shrink}
< else glue_set(r)←-x/total_shrink[o];
< if (total_shrink[o]<-x)∧(o=normal)∧(list_ptr(r)≠null) then
< begin glue_set(r)←1.0; {this is the maximum shrinkage}
< @<Report an overfull vbox and |goto common_ending|, if this box
< is sufficiently bad@>;
< end
< else if (vbadness<100)∧(o=normal)∧(list_ptr(r)≠null) then
< @<Report a tight vbox and |goto common_ending|, if this box
< is sufficiently bad@>;
---
> glue_order(r):=o; glue_sign(r):=shrinking;
> if total_shrink[o]<>0 then glue_set(r):=unfloat((-x)/total_shrink[o])
> @^real division@>
> else begin glue_sign(r):=normal;
> set_glue_ratio_zero(glue_set(r)); {there's nothing to shrink}
> end;
> if (total_shrink[o]<-x)and(o=normal)and(list_ptr(r)<>null) then
> begin last_badness:=1000000;
> set_glue_ratio_one(glue_set(r)); {use the maximum shrinkage}
> @<Report an overfull vbox and |goto common_ending|, if this box
> is sufficiently bad@>;
> end
> else if o=normal then if list_ptr(r)<>null then
> @<Report a tight vbox and |goto common_ending|, if this box
> is sufficiently bad@>;
10652,10656c13188,13193
< if -x-total_shrink[normal]>vfuzz then
< begin print_ln; print_nl("Overfull \vbox (");
< print_scaled(-x-total_shrink[normal]); print("pt too high");
< goto common_ending;
< end
---
> if (-x-total_shrink[normal]>vfuzz)or(vbadness<100) then
> begin print_ln; print_nl("Overfull \vbox (");
> @.Overfull \\vbox...@>
> print_scaled(-x-total_shrink[normal]); print("pt too high");
> goto common_ending;
> end
10659,10663c13196,13201
< begin b←badness(-x,total_shrink[normal]);
< if b>vbadness then
< begin print_ln; print_nl("Tight \vbox (badness "); print_int(b);
< goto common_ending;
< end;
---
> begin last_badness:=badness(-x,total_shrink[normal]);
> if last_badness>vbadness then
> begin print_ln; print_nl("Tight \vbox (badness "); print_int(last_badness);
> @.Tight \\vbox...@>
> goto common_ending;
> end;
10671,10680c13209,13218
< @!p:pointer; {a new glue specification}
< begin if prev_depth≠ignore_depth then
< begin d←width(baseline_skip)-prev_depth-height(b);
< if d<line_skip_limit then p←new_param_glue(line_skip_code)
< else begin p←new_skip_param(baseline_skip_code);
< width(temp_ptr)←d; {|temp_ptr=glue_ptr(p)|}
< end;
< link(tail)←p; tail←p;
< end;
< link(tail)←b; tail←b; prev_depth←depth(b);
---
> @!p:pointer; {a new glue node}
> begin if prev_depth>ignore_depth then
> begin d:=width(baseline_skip)-prev_depth-height(b);
> if d<line_skip_limit then p:=new_param_glue(line_skip_code)
> else begin p:=new_skip_param(baseline_skip_code);
> width(temp_ptr):=d; {|temp_ptr=glue_ptr(p)|}
> end;
> link(tail):=p; tail:=p;
> end;
> link(tail):=b; tail:=b; prev_depth:=depth(b);
10682c13220,13221
< @* \[33] Data structures for math mode.
---
>
> @* \[34] Data structures for math mode.
10697c13236
< classi\-fied as a relation, a binary operator, an open parenthesis, etc.,
---
> classified as a relation, a binary operator, an open parenthesis, etc.,
10715c13254
< nodes, math nodes, ligature nodes, mark nodes, insert nodes, adjust nodes,
---
> nodes, math nodes, ligature nodes,
10721c13260
< second, third, and fourth words are called the noad's |operand|, |subscr|,
---
> second, third, and fourth words are called the noad's |nucleus|, |subscr|,
10724c13263
< Consider, for example, the simple formula `\.{\$x\UA2\$}', which would be
---
> Consider, for example, the simple formula `\.{\$x\^2\$}', which would be
10726c13265
< The |operand| of this noad is a representation of `\.x', the |subscr| is
---
> The |nucleus| of this noad is a representation of `\.x', the |subscr| is
10729c13268
< The |operand|, |subscr|, and |supscr| fields are further broken into
---
> The |nucleus|, |subscr|, and |supscr| fields are further broken into
10737a13277,13282
> \yskip\hang|math_type(q)=math_text_char| is similar, but the character is
> unsubscripted and unsuperscripted and it is followed immediately by another
> character from the same font. (This |math_type| setting appears only
> briefly during the processing; it is used to suppress unwanted italic
> corrections.)
>
10751c13296
< is not the same as |math_type(q)=empty|; for example, `\.{\$P\DA\{\}\$}'
---
> is not the same as |math_type(q)=empty|; for example, `\.{\$P\_\{\}\$}'
10757c13302
< since a halfword is being used for the |math_type| although only two
---
> since a halfword is being used for the |math_type| although only three
10764c13309
< @d operand(#)==#+1 {the |operand| field of a noad}
---
> @d nucleus(#)==#+1 {the |nucleus| field of a noad}
10769d13313
< @d empty=0 {|math_type| when the attribute is absent}
10772a13317
> @d math_text_char=4 {|math_type| when italic correction is dubious}
10774,10775c13319,13320
< @ Each portion of a formula is classified as Ord, Op, Bin, Rel, Open,
< Close, Punct, or Inner, for purposes of spacing and line breaking. An
---
> @ Each portion of a formula is classified as Ord, Op, Bin, Rel, Ope,
> Clo, Pun, or Inn, for purposes of spacing and line breaking. An
10779c13324
< |rel_noad| whose |operand| field is a representation of an equals sign
---
> |rel_noad| whose |nucleus| field is a representation of an equals sign
10788c13333
< A noad of type |ord_noad|, |op_noad|, $\ldotss$, |inner_noad| usually
---
> A noad of type |ord_noad|, |op_noad|, \dots, |inner_noad| usually
10790,10791c13335,13336
< have |subtype=switched|, if \.{\\limitswitch} has been applied to this
< operator.
---
> have |subtype=limits| or |no_limits|, if the normal positioning of
> limits has been overridden for this operator.
10793c13338
< @d ord_noad=unset_node+2 {|type| of a noad classified Ord}
---
> @d ord_noad=unset_node+3 {|type| of a noad classified Ord}
10797,10801c13342,13347
< @d open_noad=ord_noad+4 {|type| of a noad classified Open}
< @d close_noad=ord_noad+5 {|type| of a noad classified Close}
< @d punct_noad=ord_noad+6 {|type| of a noad classified Punct}
< @d inner_noad=ord_noad+7 {|type| of a noad classified Inner}
< @d switched=1 {|subtype| of a limit-switched |op_noad|}
---
> @d open_noad=ord_noad+4 {|type| of a noad classified Ope}
> @d close_noad=ord_noad+5 {|type| of a noad classified Clo}
> @d punct_noad=ord_noad+6 {|type| of a noad classified Pun}
> @d inner_noad=ord_noad+7 {|type| of a noad classified Inn}
> @d limits=1 {|subtype| of |op_noad| whose scripts are to be above, below}
> @d no_limits=2 {|subtype| of |op_noad| whose scripts are to be normal}
10812c13358,13359
< starting characters, as explained in the manual.
---
> starting characters, as explained in Chapter~17 of {\sl The \TeX book}.
> @:TeXbook}{\sl The \TeX book@>
10816c13363
< |numerator| fields instead of |operand|, |subscr|, and |supscr|. The
---
> |numerator| fields instead of |nucleus|, |subscr|, and |supscr|. The
10825c13372,13373
< \.{\\atop}, \.{\\above}, \.{\\xoverx}, \.{\\xatopx}, and \.{\\xabovex}.
---
> \.{\\atop}, \.{\\above}, \.{\\overwithdelims}, \.{\\atopwithdelims}, and
> \.{\\abovewithdelims}.
10844,10847c13392
< of delimiter fields; we can use the fact that a null delimiter is the same
< as an empty word of character information.
<
< @d null_delimiter==null_character
---
> of delimiter fields.
10850a13396
> @!null_delimiter:four_quarters;
10853c13399,13401
< empty_field.rh←empty; empty_field.lh←null;
---
> empty_field.rh:=empty; empty_field.lh:=null;@/
> null_delimiter.b0:=0; null_delimiter.b1:=min_quarterword;@/
> null_delimiter.b2:=0; null_delimiter.b3:=min_quarterword;
10855c13403
< @ The |new_noad| function creates an |inner_noad| that is completely null.
---
> @ The |new_noad| function creates an |ord_noad| that is completely null.
10859,10864c13407,13412
< begin p←get_node(noad_size);
< type(p)←inner_noad; subtype(p)←normal;
< mem[operand(p)].hh←empty_field;
< mem[subscr(p)].hh←empty_field;
< mem[supscr(p)].hh←empty_field;
< new_noad←p;
---
> begin p:=get_node(noad_size);
> type(p):=ord_noad; subtype(p):=normal;
> mem[nucleus(p)].hh:=empty_field;
> mem[subscr(p)].hh:=empty_field;
> mem[supscr(p)].hh:=empty_field;
> new_noad:=p;
10868,10869c13416,13417
< operand underlined; an |over_noad| has it overlined. An |accent_noad| places
< an accent over its operand; the accent character appears as
---
> nucleus underlined; an |over_noad| has it overlined. An |accent_noad| places
> an accent over its nucleus; the accent character appears as
10871,10872c13419,13420
< centers its operand vertically with respect to the axis of the formula;
< we always have |math_type(operand(p))=sub_box| in this case.
---
> centers its nucleus vertically with respect to the axis of the formula;
> in such noads we always have |math_type(nucleus(p))=sub_box|.
10875c13423
< \TeX's \.{\\left} and \.{\\right}. The |operand| of such noads is
---
> \TeX's \.{\\left} and \.{\\right}. The |nucleus| of such noads is
10892c13440,13441
< @d delimiter==operand {|delimiter| field in left and right noads}
---
> @d delimiter==nucleus {|delimiter| field in left and right noads}
> @d scripts_allowed(#)==(type(#)>=ord_noad)and(type(#)<left_noad)
10896c13445
< data structure to record such instructions; it is two words long, so it
---
> data structure to record such instructions; it is three words long, so it
10899c13448,13449
< second word of a |style_node| is not used.
---
> second and third words of a |style_node| are not used, but they are
> present because a |choice_node| is converted to a |style_node|.
10902,10903c13452,13456
< |display_style|, $\ldotss$, |script_script_style|, and adds@@1 to get the
< ``cramped'' versions of these styles.
---
> |display_style|, \dots, |script_script_style|, and adds~1 to get the
> ``cramped'' versions of these styles. This gives a numerical order that
> is backwards from the convention of Appendix~G in {\sl The \TeX book\/};
> i.e., a smaller style has a larger numerical value.
> @:TeXbook}{\sl The \TeX book@>
10905a13459
> @d style_node_size=3 {number of words in a style node}
10914,10916c13468,13489
< begin p←get_node(small_node_size); type(p)←style_node;
< subtype(p)←s; width(p)←0; {the |width| is not used}
< new_style←p;
---
> begin p:=get_node(style_node_size); type(p):=style_node;
> subtype(p):=s; width(p):=0; depth(p):=0; {the |width| and |depth| are not used}
> new_style:=p;
> end;
>
> @ Finally, the \.{\\mathchoice} primitive creates a |choice_node|, which
> has special subfields |display_mlist|, |text_mlist|, |script_mlist|,
> and |script_script_mlist| pointing to the mlists for each style.
>
> @d choice_node=unset_node+2 {|type| of a choice node}
> @d display_mlist(#)==info(#+1) {mlist to be used in display style}
> @d text_mlist(#)==link(#+1) {mlist to be used in text style}
> @d script_mlist(#)==info(#+2) {mlist to be used in script style}
> @d script_script_mlist(#)==link(#+2) {mlist to be used in scriptscript style}
>
> @p function new_choice:pointer; {create a choice node}
> var p:pointer; {the new node}
> begin p:=get_node(style_node_size); type(p):=choice_node;
> subtype(p):=0; {the |subtype| is not used}
> display_mlist(p):=null; text_mlist(p):=null; script_mlist(p):=null;
> script_script_mlist(p):=null;
> new_choice:=p;
10920c13493
< that displays the things that can only be present in mlists; this
---
> that displays the things that can only be present in mlists; this
10927,10928c13500,13501
< subsidiary to the |operand| field of some noad; the dot is replaced by
< `\.[' or `\.(' or `\./' or `\.\\' if |p| is descended from the |subscr|
---
> subsidiary to the |nucleus| field of some noad; the dot is replaced by
> `\.\_' or `\.\^' or `\./' or `\.\\' if |p| is descended from the |subscr|
10930,10932c13503,13505
< the current string would be `\.{.(.[/}' if |p| points to the |ord_noad| for
< |x| in the (ridiculous) formula `\.{\$\\sqrt\{a\UA\{\{b\DA\{c\\over x+y\}
< \}\}\}\$}'.
---
> the current string would be `\.{.\^.\_/}' if |p| points to the |ord_noad| for
> |x| in the (ridiculous) formula
> `\.{\$\\sqrt\{a\^\{\\mathinner\{b\_\{c\\over x+y\}\}\}\}\$}'.
10936,10938c13509,13512
< ord_noad,op_noad,bin_noad,rel_noad,open_noad,close_noad,punct_noad,
< radical_noad,over_noad,under_noad,vcenter_noad,accent_noad,
< left_noad,right_noad:@<Display normal noad |p|@>;
---
> choice_node:@<Display choice node |p|@>;
> ord_noad,op_noad,bin_noad,rel_noad,open_noad,close_noad,punct_noad,inner_noad,
> radical_noad,over_noad,under_noad,vcenter_noad,accent_noad,
> left_noad,right_noad:@<Display normal noad |p|@>;
10946c13520
< print_ascii(qo(character(p)));
---
> print_ASCII(qo(character(p)));
10949c13523
< procedure print_delimiter(@!p:pointer); {prints a delimiter as 24-bit octal}
---
> procedure print_delimiter(@!p:pointer); {prints a delimiter as 24-bit hex value}
10951,10952c13525,13526
< begin a←small_fam(p)*256+qo(small_char(p));
< a←a*@'10000+large_fam(p)*256+qo(large_char(p));
---
> begin a:=small_fam(p)*256+qo(small_char(p));
> a:=a*@"1000+large_fam(p)*256+qo(large_char(p));
10954c13528
< else print_octal(a);
---
> else print_hex(a);
10966,10982c13540,13558
< procedure print_subsidiary_data(@!p:pointer;@!c:ascii_code);
< {display a noad field}
< begin if cur_length<depth_threshold then
< begin append_char(c); {include |c| in the recursion history}
< temp_ptr←p; {prepare for |show_info| if recursion is needed}
< case math_type(p) of
< math_char: begin print_ln; print_current_string; print_fam_and_char(p);
< end;
< sub_box: show_info; {recursive call}
< sub_mlist: if info(p)=null then
< begin print_ln; print_current_string; print("{}");
< end
< else show_info; {recursive call}
< othercases do_nothing {|empty|}
< endcases;@/
< flush_char; {remove |c| from the recursion history}
< end;
---
> procedure print_subsidiary_data(@!p:pointer;@!c:ASCII_code);
> {display a noad field}
> begin if cur_length>=depth_threshold then
> begin if math_type(p)<>empty then print(" []");
> end
> else begin append_char(c); {include |c| in the recursion history}
> temp_ptr:=p; {prepare for |show_info| if recursion is needed}
> case math_type(p) of
> math_char: begin print_ln; print_current_string; print_fam_and_char(p);
> end;
> sub_box: show_info; {recursive call}
> sub_mlist: if info(p)=null then
> begin print_ln; print_current_string; print("{}");
> end
> else show_info; {recursive call}
> othercases do_nothing {|empty|}
> endcases;@/
> flush_char; {remove |c| from the recursion history}
> end;
11009a13586,13593
> @ @<Display choice node |p|@>=
> begin print_esc("mathchoice");
> append_char("D"); show_node_list(display_mlist(p)); flush_char;
> append_char("T"); show_node_list(text_mlist(p)); flush_char;
> append_char("S"); show_node_list(script_mlist(p)); flush_char;
> append_char("s"); show_node_list(script_script_mlist(p)); flush_char;
> end
>
11018a13603
> inner_noad: print_esc("mathinner");
11023c13608
< end;
---
> end;
11025,11034c13610,13621
< end;
< left_noad: begin print_esc("left"); print_delimiter(operand(p));
< end;
< right_noad: begin print_esc("right"); print_delimiter(operand(p));
< end;
< end;
< if subtype(p)≠normal then print_esc("limitswitch");
< if type(p)<left_noad then print_subsidiary_data(operand(p),".");
< print_subsidiary_data(supscr(p),"(");
< print_subsidiary_data(subscr(p),"[");
---
> end;
> left_noad: begin print_esc("left"); print_delimiter(delimiter(p));
> end;
> right_noad: begin print_esc("right"); print_delimiter(delimiter(p));
> end;
> end;
> if subtype(p)<>normal then
> if subtype(p)=limits then print_esc("limits")
> else print_esc("nolimits");
> if type(p)<left_noad then print_subsidiary_data(nucleus(p),".");
> print_subsidiary_data(supscr(p),"^");
> print_subsidiary_data(subscr(p),"_");
11038c13625
< begin print_esc("xabovex"); print(" thickness ");
---
> begin print_esc("fraction, thickness ");
11041,11052c13628,13639
< if (small_fam(left_delimiter(p))≠0)∨@+
< (small_char(left_delimiter(p))≠min_quarterword)∨@|
< (large_fam(left_delimiter(p))≠0)∨@|
< (large_char(left_delimiter(p))≠min_quarterword) then
< begin print(", left-delimiter "); print_delimiter(left_delimiter(p));
< end;
< if (small_fam(right_delimiter(p))≠0)∨@|
< (small_char(right_delimiter(p))≠min_quarterword)∨@|
< (large_fam(right_delimiter(p))≠0)∨@|
< (large_char(right_delimiter(p))≠min_quarterword) then
< begin print(", right-delimiter "); print_delimiter(right_delimiter(p));
< end;
---
> if (small_fam(left_delimiter(p))<>0)or@+
> (small_char(left_delimiter(p))<>min_quarterword)or@|
> (large_fam(left_delimiter(p))<>0)or@|
> (large_char(left_delimiter(p))<>min_quarterword) then
> begin print(", left-delimiter "); print_delimiter(left_delimiter(p));
> end;
> if (small_fam(right_delimiter(p))<>0)or@|
> (small_char(right_delimiter(p))<>min_quarterword)or@|
> (large_fam(right_delimiter(p))<>0)or@|
> (large_char(right_delimiter(p))<>min_quarterword) then
> begin print(", right-delimiter "); print_delimiter(right_delimiter(p));
> end;
11056c13643,13675
< @* \[34] Subroutines for math mode.
---
>
> @ That which can be displayed can also be destroyed.
>
> @<Cases of |flush_node_list| that arise...@>=
> style_node: begin free_node(p,style_node_size); goto done;
> end;
> choice_node:begin flush_node_list(display_mlist(p));
> flush_node_list(text_mlist(p));
> flush_node_list(script_mlist(p));
> flush_node_list(script_script_mlist(p));
> free_node(p,style_node_size); goto done;
> end;
> ord_noad,op_noad,bin_noad,rel_noad,open_noad,close_noad,punct_noad,inner_noad,
> radical_noad,over_noad,under_noad,vcenter_noad,accent_noad:@t@>@;@/
> begin if math_type(nucleus(p))>=sub_box then
> flush_node_list(info(nucleus(p)));
> if math_type(supscr(p))>=sub_box then
> flush_node_list(info(supscr(p)));
> if math_type(subscr(p))>=sub_box then
> flush_node_list(info(subscr(p)));
> if type(p)=radical_noad then free_node(p,radical_noad_size)
> else if type(p)=accent_noad then free_node(p,accent_noad_size)
> else free_node(p,noad_size);
> goto done;
> end;
> left_noad,right_noad: begin free_node(p,noad_size); goto done;
> end;
> fraction_noad: begin flush_node_list(info(numerator(p)));
> flush_node_list(info(denominator(p)));
> free_node(p,fraction_noad_size); goto done;
> end;
>
> @* \[35] Subroutines for math mode.
11072c13691
< begin if s=0 then print_esc("textfont")
---
> begin if s=text_size then print_esc("textfont")
11077,11080c13696,13699
< @ Before an mlist is created, \TeX\ makes sure that
< the fonts in family@@2 have enough parameters to be math-symbol
< fonts, and that the text font in family@@3 has enough parameters to be a
< math-extension font. The math-symbol parameters are referred to by using the
---
> @ Before an mlist is converted to an hlist, \TeX\ makes sure that
> the fonts in family~2 have enough parameters to be math-symbol
> fonts, and that the fonts in family~3 have enough parameters to be
> math-extension fonts. The math-symbol parameters are referred to by using the
11102,11103c13721,13723
< @d delim1==mathsy(20) {size of \.{\\xatopx} delimiters in display styles}
< @d delim2==mathsy(21) {size of \.{\\xatopx} delimiters in non-displays}
---
> @d delim1==mathsy(20) {size of \.{\\atopwithdelims} delimiters
> in display styles}
> @d delim2==mathsy(21) {size of \.{\\atopwithdelims} delimiters in non-displays}
11123c13743
< an overlined operand (|und_style|), for a subscript or a superscript
---
> an overlined nucleus (|cramped_style|), for a subscript or a superscript
11127c13747
< @d und_style(#)==2*(# div 2)+cramped {cramp the style}
---
> @d cramped_style(#)==2*(# div 2)+cramped {cramp the style}
11137,11139c13757,13759
< begin if cur_style<script_style then cur_size←text_size
< else cur_size←16*((cur_style-text_style) div 2);
< cur_mu←x_over_n(math_quad(cur_style),18);
---
> begin if cur_style<script_style then cur_size:=text_size
> else cur_size:=16*((cur_style-text_style) div 2);
> cur_mu:=x_over_n(math_quad(cur_size),18);
11147c13767
< {construct the bar for a fraction}
---
> {construct the bar for a fraction}
11149c13769
< begin p←new_rule; height(p)←t; depth(p)←0; fraction_rule←p;
---
> begin p:=new_rule; height(p):=t; depth(p):=0; fraction_rule:=p;
11158,11159c13778,13779
< begin p←new_kern(k); link(p)←b; q←fraction_rule(t); link(q)←p;
< p←new_kern(t); link(p)←q; overbar←vpack(p,natural);
---
> begin p:=new_kern(k); link(p):=b; q:=fraction_rule(t); link(q):=p;
> p:=new_kern(t); link(p):=q; overbar:=vpack(p,natural);
11189d13808
< @!p: pointer; {character nodes constructed}
11192,11206c13811,13825
< begin f←undefined_font; w←0; large_attempt←false;
< z←small_fam(d); x←small_char(d);
< loop@+ begin @<Look at the variants of |(z,x)|; set |f| and |c| whenever
< a better character is found; |goto found| as soon as a
< large enough variant is encountered@>;
< if large_attempt then goto found; {there were none large enough}
< large_attempt←true; z←large_fam(d); x←large_char(d);
< end;
< found: if f≠undefined_font then
< @<Make variable |b| point to a box for |(f,c)|@>
< else begin b←new_null_box;
< width(b)←null_delimiter_space; {use this width if no delimiter was found}
< end;
< shift_amount(b)←half(height(b)-depth(b)) - axis_height(s);
< var_delimiter←b;
---
> begin f:=null_font; w:=0; large_attempt:=false;
> z:=small_fam(d); x:=small_char(d);
> loop@+ begin @<Look at the variants of |(z,x)|; set |f| and |c| whenever
> a better character is found; |goto found| as soon as a
> large enough variant is encountered@>;
> if large_attempt then goto found; {there were none large enough}
> large_attempt:=true; z:=large_fam(d); x:=large_char(d);
> end;
> found: if f<>null_font then
> @<Make variable |b| point to a box for |(f,c)|@>
> else begin b:=new_null_box;
> width(b):=null_delimiter_space; {use this width if no delimiter was found}
> end;
> shift_amount(b):=half(height(b)-depth(b)) - axis_height(s);
> var_delimiter:=b;
11214,11223c13833,13842
< if (z≠0)∨(x≠min_quarterword) then
< begin z←z+s+16;
< repeat z←z-16; g←fam_fnt(z);
< if g≠undefined_font then
< @<Look at the list of characters starting with |x| in
< font |g|; set |f| and |c| whenever
< a better character is found; |goto found| as soon as a
< large enough variant is encountered@>;
< until z<16;
< end
---
> if (z<>0)or(x<>min_quarterword) then
> begin z:=z+s+16;
> repeat z:=z-16; g:=fam_fnt(z);
> if g<>null_font then
> @<Look at the list of characters starting with |x| in
> font |g|; set |f| and |c| whenever
> a better character is found; |goto found| as soon as a
> large enough variant is encountered@>;
> until z<16;
> end
11226,11242c13845,13880
< begin y←x;
< continue: if (qo(y)≥font_bc[g])∧(qo(y)≤font_ec[g]) then
< begin q←char_info(g)(y);
< if char_exists(q) then
< begin if char_tag(q)=ext_tag then goto found;
< hd←height_depth(q);
< u←char_height(g)(hd)+char_depth(g)(hd);
< if u>w then
< begin f←g; c←y; w←u;
< if u≥v then goto found;
< end;
< if char_tag(q)=list_tag then
< begin y←rem_byte(q); goto continue;
< end;
< end;
< end;
< end
---
> begin y:=x;
> if (qo(y)>=font_bc[g])and(qo(y)<=font_ec[g]) then
> begin continue: q:=char_info(g)(y);
> if char_exists(q) then
> begin if char_tag(q)=ext_tag then
> begin f:=g; c:=y; goto found;
> end;
> hd:=height_depth(q);
> u:=char_height(g)(hd)+char_depth(g)(hd);
> if u>w then
> begin f:=g; c:=y; w:=u;
> if u>=v then goto found;
> end;
> if char_tag(q)=list_tag then
> begin y:=rem_byte(q); goto continue;
> end;
> end;
> end;
> end
>
> @ Here is a subroutine that creates a new box, whose list contains a
> single character, and whose width includes the italic correction for
> that character. The height or depth of the box will be negative, if
> the height or depth of the character is negative; thus, this routine
> may deliver a slightly different result than |hpack| would produce.
>
> @<Declare subprocedures for |var_delimiter|@>=
> function char_box(@!f:internal_font_number;@!c:quarterword):pointer;
> var q:four_quarters;
> @!hd:eight_bits; {|height_depth| byte}
> @!b,@!p:pointer; {the new box and its character node}
> begin q:=char_info(f)(c); hd:=height_depth(q);
> b:=new_null_box; width(b):=char_width(f)(q)+char_italic(f)(q);
> height(b):=char_height(f)(hd); depth(b):=char_depth(f)(hd);
> p:=get_avail; character(p):=c; font(p):=f; list_ptr(b):=p; char_box:=b;
> end;
11249,11252c13887,13889
< @<Construct an extensible character for |(f,c)| in box |b|@>
< else begin p←get_avail; font(p)←f; character(p)←c; list_ptr(b)←p;
< b←hpack(p,natural);
< end
---
> @<Construct an extensible character in a new box |b|,
> using recipe |rem_byte(q)| and font |f|@>
> else b:=char_box(f,c)
11260c13897
< @!c:quarterword);
---
> @!c:quarterword);
11262,11264c13899,13900
< begin p←get_avail; font(p)←f; character(p)←c; p←hpack(p,natural);
< link(p)←list_ptr(b); list_ptr(b)←p;
< height(b)←height(p);
---
> begin p:=char_box(f,c); link(p):=list_ptr(b); list_ptr(b):=p;
> height(b):=height(p);
11274,11275c13910,13911
< begin q←char_info(f)(c); hd←height_depth(q);
< height_plus_depth←char_height(f)(hd)+char_depth(f)(hd);
---
> begin q:=char_info(f)(c); hd:=height_depth(q);
> height_plus_depth:=char_height(f)(hd)+char_depth(f)(hd);
11279,11281c13915,13917
< begin b←new_null_box;
< type(b)←vlist_node;
< r←font_info[exten_base[f]+rem_byte(q)].qqqq;@/
---
> begin b:=new_null_box;
> type(b):=vlist_node;
> r:=font_info[exten_base[f]+rem_byte(q)].qqqq;@/
11283,11295c13919,13931
< number of extension steps, |n|; also set |width(b)|@>;
< c←ext_bot(r);
< if c≠min_quarterword then stack_into_box(b,f,c);
< c←ext_rep(r);
< for m←1 to n do stack_into_box(b,f,c);
< c←ext_mid(r);
< if c≠min_quarterword then
< begin stack_into_box(b,f,c); c←ext_rep(r);
< for m←1 to n do stack_into_box(b,f,c);
< end;
< c←ext_top(r);
< if c≠min_quarterword then stack_into_box(b,f,c);
< depth(b)←w-height(b);
---
> number of extension steps, |n|; also set |width(b)|@>;
> c:=ext_bot(r);
> if c<>min_quarterword then stack_into_box(b,f,c);
> c:=ext_rep(r);
> for m:=1 to n do stack_into_box(b,f,c);
> c:=ext_mid(r);
> if c<>min_quarterword then
> begin stack_into_box(b,f,c); c:=ext_rep(r);
> for m:=1 to n do stack_into_box(b,f,c);
> end;
> c:=ext_top(r);
> if c<>min_quarterword then stack_into_box(b,f,c);
> depth(b):=w-height(b);
11299c13935
< mod\-ule. If this module does not have positive height plus depth,
---
> module. If this module does not have positive height plus depth,
11304,11309c13940,13945
< c←ext_rep(r); u←height_plus_depth(f,c);
< w←0; width(b)←char_width(f)(char_info(f)(c));@/
< c←ext_bot(r);@+if c≠min_quarterword then w←w+height_plus_depth(f,c);
< c←ext_mid(r);@+if c≠min_quarterword then w←w+height_plus_depth(f,c);
< c←ext_top(r);@+if c≠min_quarterword then w←w+height_plus_depth(f,c);
< n←0;
---
> c:=ext_rep(r); u:=height_plus_depth(f,c);
> w:=0; q:=char_info(f)(c); width(b):=char_width(f)(q)+char_italic(f)(q);@/
> c:=ext_bot(r);@+if c<>min_quarterword then w:=w+height_plus_depth(f,c);
> c:=ext_mid(r);@+if c<>min_quarterword then w:=w+height_plus_depth(f,c);
> c:=ext_top(r);@+if c<>min_quarterword then w:=w+height_plus_depth(f,c);
> n:=0;
11311,11313c13947,13949
< begin w←w+u; incr(n);
< if ext_mid(r)≠min_quarterword then w←w+u;
< end
---
> begin w:=w+u; incr(n);
> if ext_mid(r)<>min_quarterword then w:=w+u;
> end
11317,11318c13953,13954
< their limits above and below. It takes a given hlist box |b| and
< changes it so that the new box is centered in a box of width |w|.
---
> their limits above and below. It takes a given box~|b| and
> changes it so that the new box is centered in a box of width~|w|.
11323a13960,13963
> The given box might contain a single character whose italic correction
> has been added to the width of the box; in this case a compensating
> kern is inserted.
>
11326,11334c13966,13982
< begin if (width(b)≠w)∧(list_ptr(b)≠null) then
< begin p←list_ptr(b); free_node(b,box_node_size);
< b←new_glue(ss_glue); link(b)←p;
< while link(p)≠null do p←link(p);
< link(p)←new_glue(ss_glue);
< rebox←hpack(b,w,exactly);
< end
< else begin width(b)←w; rebox←b;
< end;
---
> @!f:internal_font_number; {font in a one-character box}
> @!v:scaled; {width of a character without italic correction}
> begin if (width(b)<>w)and(list_ptr(b)<>null) then
> begin if type(b)=vlist_node then b:=hpack(b,natural);
> p:=list_ptr(b);
> if (is_char_node(p))and(link(p)=null) then
> begin f:=font(p); v:=char_width(f)(char_info(f)(character(p)));
> if v<>width(b) then link(p):=new_kern(width(b)-v);
> end;
> free_node(b,box_node_size);
> b:=new_glue(ss_glue); link(b):=p;
> while link(p)<>null do p:=link(p);
> link(p):=new_glue(ss_glue);
> rebox:=hpack(b,w,exactly);
> end
> else begin width(b):=w; rebox:=b;
> end;
11339a13988,13989
> @d mu_mult(#)==nx_plus_y(n,#,xn_over_d(#,f,@'200000))
>
11344,11353c13994,14006
< begin n←x_over_n(m,@'200000); f←remainder;@/
< p←get_node(glue_spec_size);
< width(p)←nx_plus_y(n,width(g),f); {convert \.{mu} to \.{pt}}
< stretch_order(p)←stretch_order(g);
< if stretch_order(p)=normal then stretch(p)←nx_plus_y(n,stretch(g),f)
< else stretch(p)←stretch(g);
< shrink_order(p)←shrink_order(g);
< if shrink_order(p)=normal then shrink(p)←nx_plus_y(n,shrink(g),f)
< else shrink(p)←shrink(g);
< math_glue←p;
---
> begin n:=x_over_n(m,@'200000); f:=remainder;@/
> if f<0 then
> begin decr(n); f:=f+@'200000;
> end;
> p:=get_node(glue_spec_size);
> width(p):=mu_mult(width(g)); {convert \.{mu} to \.{pt}}
> stretch_order(p):=stretch_order(g);
> if stretch_order(p)=normal then stretch(p):=mu_mult(stretch(g))
> else stretch(p):=stretch(g);
> shrink_order(p):=shrink_order(g);
> if shrink_order(p)=normal then shrink(p):=mu_mult(shrink(g))
> else shrink(p):=shrink(g);
> math_glue:=p;
11363,11376c14016,14041
< begin n←x_over_n(m,@'200000); f←remainder;@/
< width(p)←nx_plus_y(n,width(p),f); subtype(p)←normal;
< end;
< end;
< @* \[35] Typesetting math formulas.
< \TeX's major routine for dealing with formulas is called |mlist_to_hlist|.
< After a formula has been scanned and represented as an mlist, this routine
< converts it to an hlist that can be placed into a box or incorporated into
< the text of a paragraph. There are three implicit parameters, passed in
< global variables: |cur_mlist| points to the first node or noad in the
< given mlist (and it might be |null|); |cur_style| is a style code; and
< |mlist_penalties| is |true| if penalty nodes for potential line breaks are
< to be inserted into the resulting hlist. After |mlist_to_hlist| has
< acted, |link(temp_head)| points to the translated hlist.
---
> begin n:=x_over_n(m,@'200000); f:=remainder;@/
> if f<0 then
> begin decr(n); f:=f+@'200000;
> end;
> width(p):=mu_mult(width(p)); subtype(p):=explicit;
> end;
> end;
>
> @ Sometimes it is necessary to destroy an mlist. The following
> subroutine empties the current list, assuming that |abs(mode)=mmode|.
>
> @p procedure flush_math;
> begin flush_node_list(link(head)); flush_node_list(incompleat_noad);
> link(head):=null; tail:=head; incompleat_noad:=null;
> end;
>
> @* \[36] Typesetting math formulas.
> \TeX's most important routine for dealing with formulas is called
> |mlist_to_hlist|. After a formula has been scanned and represented as an
> mlist, this routine converts it to an hlist that can be placed into a box
> or incorporated into the text of a paragraph. There are three implicit
> parameters, passed in global variables: |cur_mlist| points to the first
> node or noad in the given mlist (and it might be |null|); |cur_style| is a
> style code; and |mlist_penalties| is |true| if penalty nodes for potential
> line breaks are to be inserted into the resulting hlist. After
> |mlist_to_hlist| has acted, |link(temp_head)| points to the translated hlist.
11393c14058,14061
< |mlist_to_hlist|. The box returned by |clean_box| is ``clean'' in the
---
> |mlist_to_hlist|.
> @^recursion@>
>
> The box returned by |clean_box| is ``clean'' in the
11396c14064
< @p procedure mlist_to_hlist; forward;@t\2@>@/
---
> @p procedure@?mlist_to_hlist; forward;@t\2@>@/
11398c14066
< label found,exit;
---
> label found;
11400a14069,14070
> @!x:pointer; {box to be returned}
> @!r:pointer; {temporary pointer}
11402,11413c14072,14078
< math_char: begin cur_mlist←new_noad; mem[operand(cur_mlist)]←mem[p];
< type(cur_mlist)←ord_noad;
< end;
< sub_box: begin q←info(p);
< if shift_amount(q)=0 then {already clean}
< begin clean_box←q; return;
< end
< else goto found;
< end;
< sub_mlist: cur_mlist←info(p);
< othercases begin q←null; goto found;
< end
---
> math_char: begin cur_mlist:=new_noad; mem[nucleus(cur_mlist)]:=mem[p];
> end;
> sub_box: begin q:=info(p); goto found;
> end;
> sub_mlist: cur_mlist:=info(p);
> othercases begin q:=new_null_box; goto found;
> end
11415,11417c14080,14082
< save_style←cur_style; cur_style←s; mlist_penalties←false;
< mlist_to_hlist; q←link(temp_head); {recursive call}
< cur_style←save_style; {restore the style}
---
> save_style:=cur_style; cur_style:=s; mlist_penalties:=false;@/
> mlist_to_hlist; q:=link(temp_head); {recursive call}
> cur_style:=save_style; {restore the style}
11419,11420c14084,14102
< found: clean_box←hpack(q,natural);
< exit:end;
---
> found: if is_char_node(q)or(q=null) then x:=hpack(q,natural)
> else if (link(q)=null)and(type(q)<=vlist_node)and(shift_amount(q)=0) then
> x:=q {it's already clean}
> else x:=hpack(q,natural);
> @<Simplify a trivial box@>;
> clean_box:=x;
> end;
>
> @ Here we save memory space in a common case.
>
> @<Simplify a trivial box@>=
> q:=list_ptr(x);
> if is_char_node(q) then
> begin r:=link(q);
> if r<>null then if link(r)=null then if not is_char_node(r) then
> if type(r)=kern_node then {unneeded italic correction}
> begin free_node(r,small_node_size); link(q):=null;
> end;
> end
11430,11440c14112,14122
< begin cur_c←character(a); cur_f←fam_fnt(fam(a)+cur_size);
< if cur_f=undefined_font then
< @<Complain about an undefined family and set |cur_i| null@>
< else begin if (qo(cur_c)≥font_bc[cur_f])∧(qo(cur_c)≤font_ec[cur_f]) then
< cur_i←char_info(cur_f)(cur_c)
< else cur_i←null_character;
< if not(char_exists(cur_i)) then
< begin char_warning(cur_f,cur_c);
< math_type(a)←empty;
< end;
< end;
---
> begin cur_c:=character(a); cur_f:=fam_fnt(fam(a)+cur_size);
> if cur_f=null_font then
> @<Complain about an undefined family and set |cur_i| null@>
> else begin if (qo(cur_c)>=font_bc[cur_f])and(qo(cur_c)<=font_ec[cur_f]) then
> cur_i:=char_info(cur_f)(cur_c)
> else cur_i:=null_character;
> if not(char_exists(cur_i)) then
> begin char_warning(cur_f,qo(cur_c));
> math_type(a):=empty;
> end;
> end;
11444,11452c14126,14133
< begin print_nl("! "); print_size(cur_size); print(" ");
< print_int(fam(a)); print(" is undefined");
< @:text_font_}{\.{\\textfont x is undefined}@>
< @:script_font_}{\.{\\scriptfont x is undefined}@>
< @:script_script_font_}{\.{\\scriptscriptfont x is undefined}@>
< help3("You have to define families outside of a math")@/
< ("subformula that uses them. Proceed, and I'll")@/
< ("ignore the nonexistent font you referred to.");
< error; cur_i←null_character; math_type(a)←empty;
---
> begin print_err(""); print_size(cur_size); print_char(" ");
> print_int(fam(a)); print(" is undefined (character ");
> print_ASCII(qo(cur_c)); print_char(")");
> help4("Somewhere in the math formula just ended, you used the")@/
> ("stated character from an undefined font family. For example,")@/
> ("plain TeX doesn't allow \it or \sl in subscripts. Proceed,")@/
> ("and I'll try to forget that I needed that character.");
> error; cur_i:=null_character; math_type(a):=empty;
11461c14142
< or a lig/kern instruction}
---
> or a lig/kern instruction}
11473c14154,14155
< field, an integer field that replaces the |operand| or |thickness|.
---
> field, an integer field that replaces the |nucleus| or |thickness|.
> @^recursion@>
11476c14158
< penal\-ties between nodes.
---
> penalties between nodes.
11478c14160
< @d new_hlist(#)==mem[operand(#)].int {the translation of an mlist}
---
> @d new_hlist(#)==mem[nucleus(#)].int {the translation of an mlist}
11491c14173
< done;
---
> done;
11500c14182
< @!p,@!v,@!x,@!y,@!z: pointer; {temporary registers for list construction}
---
> @!p,@!x,@!y,@!z: pointer; {temporary registers for list construction}
11505,11507c14187,14189
< begin mlist←cur_mlist; penalties←mlist_penalties;
< style←cur_style; {tuck global parameters away}
< q←mlist; r←null; r_type←op_noad; max_h←0; max_d←0;
---
> begin mlist:=cur_mlist; penalties:=mlist_penalties;
> style:=cur_style; {tuck global parameters away as local variables}
> q:=mlist; r:=null; r_type:=op_noad; max_h:=0; max_d:=0;
11509,11511c14191,14194
< while q≠null do @<Process node-or-noad |q| as much as possible in preparation
< for the second pass of |mlist_to_hlist|, then move to the next
< item in the mlist@>;
---
> while q<>null do @<Process node-or-noad |q| as much as possible in preparation
> for the second pass of |mlist_to_hlist|, then move to the next
> item in the mlist@>;
> @<Convert \(a)a final |bin_noad| to an |ord_noad|@>;
11513c14196
< proper spacing and penalties@>;
---
> proper spacing and penalties@>;
11516c14199
< @ We use the fact that no character nodes appear in an mlist, hence
---
> @ We use the fact that no character nodes appear in an mlist, hence
11521,11526c14204,14209
< if a noad has been fully processed, |goto check_dimensions| if it
< has been translated into |new_hlist(q)|, or |goto done_with_node|
< if a node has been fully processed@>;
< check_dimensions: z←hpack(new_hlist(q),natural);
< if height(z)>max_h then max_h←height(z);
< if depth(z)>max_d then max_d←depth(z);
---
> if a noad has been fully processed, |goto check_dimensions| if it
> has been translated into |new_hlist(q)|, or |goto done_with_node|
> if a node has been fully processed@>;
> check_dimensions: z:=hpack(new_hlist(q),natural);
> if height(z)>max_h then max_h:=height(z);
> if depth(z)>max_d then max_d:=depth(z);
11528,11529c14211,14212
< done_with_noad: r←q; r_type←type(r);
< done_with_node: q←link(q);
---
> done_with_noad: r:=q; r_type:=type(r);
> done_with_node: q:=link(q);
11537c14220
< reswitch: delta←0;
---
> reswitch: delta:=0;
11540,11544c14223,14227
< bin_noad,op_noad,rel_noad,open_noad,punct_noad,left_noad:
< begin type(q)←ord_noad; goto reswitch;
< end;
< othercases do_nothing
< endcases;
---
> bin_noad,op_noad,rel_noad,open_noad,punct_noad,left_noad:
> begin type(q):=ord_noad; goto reswitch;
> end;
> othercases do_nothing
> endcases;
11546,11548c14229,14231
< if r_type=bin_noad then type(r)←ord_noad;
< if type(q)=right_noad then goto done_with_noad;
< end;
---
> @<Convert \(a)a final |bin_noad| to an |ord_noad|@>;
> if type(q)=right_noad then goto done_with_noad;
> end;
11551c14234
< |goto done_with_node|@>@;
---
> |goto done_with_node|@>@;
11553,11555c14236,14241
< @:confusion mlist1}{\quad mlist1@>
< endcases;
< @<Convert \(o)|operand(q)| to an hlist and attach the sub/superscripts@>
---
> @:this can't happen mlist1}{\quad mlist1@>
> endcases;@/
> @<Convert \(n)|nucleus(q)| to an hlist and attach the sub/superscripts@>
>
> @ @<Convert \(a)a final |bin_noad| to an |ord_noad|@>=
> if r_type=bin_noad then type(r):=ord_noad
11558,11565c14244,14254
< style_node: begin cur_style←subtype(q);
< @<Set up the values of |cur_size| and |cur_mu|, based on |cur_style|@>;
< goto done_with_node;
< end;
< whatsit_node,penalty_node,disc_node: goto done_with_node;
< rule_node: begin if height(q)>max_h then max_h←height(q);
< if depth(q)>max_d then max_d←depth(q); goto done_with_node;
< end;
---
> style_node: begin cur_style:=subtype(q);
> @<Set up the values of |cur_size| and |cur_mu|, based on |cur_style|@>;
> goto done_with_node;
> end;
> choice_node: @<Change this node to a style node followed by the correct choice,
> then |goto done_with_node|@>;
> ins_node,mark_node,adjust_node,
> whatsit_node,penalty_node,disc_node: goto done_with_node;
> rule_node: begin if height(q)>max_h then max_h:=height(q);
> if depth(q)>max_d then max_d:=depth(q); goto done_with_node;
> end;
11567,11568c14256,14257
< goto done_with_node;
< end;
---
> goto done_with_node;
> end;
11570c14259,14281
< end;
---
> end;
>
> @ @d choose_mlist(#)==begin p:=#(q); #(q):=null;@+end
>
> @<Change this node to a style node...@>=
> begin case cur_style div 2 of
> 0: choose_mlist(display_mlist); {|display_style=0|}
> 1: choose_mlist(text_mlist); {|text_style=2|}
> 2: choose_mlist(script_mlist); {|script_style=4|}
> 3: choose_mlist(script_script_mlist); {|script_script_style=6|}
> end; {there are no other cases}
> flush_node_list(display_mlist(q));
> flush_node_list(text_mlist(q));
> flush_node_list(script_mlist(q));
> flush_node_list(script_script_mlist(q));@/
> type(q):=style_node; subtype(q):=cur_style; width(q):=0; depth(q):=0;
> if p<>null then
> begin z:=link(q); link(q):=p;
> while link(p)<>null do p:=link(p);
> link(p):=z;
> end;
> goto done_with_node;
> end
11576c14287
< (`\.{\\mskip}') is converted to normal glue by multiplying the dimensions
---
> (`\.{\\muskip}') is converted to normal glue by multiplying the dimensions
11577a14289
> @!@:non_script_}{\.{\\nonscript} primitive@>
11581,11589c14293,14302
< begin x←glue_ptr(q);
< y←math_glue(x,cur_mu); delete_glue_ref(x); glue_ptr(q)←y;
< end
< else if (cur_size>text_size)∧(subtype(q)=cond_math_glue) then
< begin p←link(q);
< if p≠null then if (type(p)=glue_node)∨(type(p)=kern_node) then
< begin link(q)←link(p); link(p)←null; flush_node_list(p);
< end;
< end
---
> begin x:=glue_ptr(q);
> y:=math_glue(x,cur_mu); delete_glue_ref(x); glue_ptr(q):=y;
> subtype(q):=normal;
> end
> else if (cur_size<>text_size)and(subtype(q)=cond_math_glue) then
> begin p:=link(q);
> if p<>null then if (type(p)=glue_node)or(type(p)=kern_node) then
> begin link(q):=link(p); link(p):=null; flush_node_list(p);
> end;
> end
11594,11597c14307,14310
< end;
< op_noad: begin delta←make_op(q);
< if subtype(q)=switched then goto check_dimensions;
< end;
---
> end;
> op_noad: begin delta:=make_op(q);
> if subtype(q)=limits then goto check_dimensions;
> end;
11607c14320,14321
< by procedures like |make_fraction|, |make_radical|, etc. To illustrate
---
> by procedures with names
> like |make_fraction|, |make_radical|, etc. To illustrate
11613,11615c14327,14330
< begin info(operand(q))←@|overbar(clean_box(operand(q),und_style(cur_style)),@|
< 3*default_rule_thickness,default_rule_thickness);
< math_type(operand(q))←sub_box;
---
> begin info(nucleus(q)):=@|
> overbar(clean_box(nucleus(q),cramped_style(cur_style)),@|
> 3*default_rule_thickness,default_rule_thickness);
> math_type(nucleus(q)):=sub_box;
11622,11628c14337,14343
< begin x←clean_box(operand(q),cur_style);
< p←new_kern(3*default_rule_thickness); link(x)←p;
< link(p)←fraction_rule(default_rule_thickness);
< y←vpack(x,natural);
< delta←height(y)+depth(y)+default_rule_thickness;
< height(y)←height(x); depth(y)←delta-height(y);
< info(operand(q))←y; math_type(operand(q))←sub_box;
---
> begin x:=clean_box(nucleus(q),cur_style);
> p:=new_kern(3*default_rule_thickness); link(x):=p;
> link(p):=fraction_rule(default_rule_thickness);
> y:=vpack(x,natural);
> delta:=height(y)+depth(y)+default_rule_thickness;
> height(y):=height(x); depth(y):=delta-height(y);
> info(nucleus(q)):=y; math_type(nucleus(q)):=sub_box;
11635,11640c14350,14355
< begin v←info(operand(q));
< if type(v)≠vlist_node then confusion("vcenter");
< @:confusion vcenter}{\quad vcenter@>
< delta←height(v)+depth(v);
< height(v)←axis_height(cur_size)+half(delta);
< depth(v)←height(v)-delta;
---
> begin v:=info(nucleus(q));
> if type(v)<>vlist_node then confusion("vcenter");
> @:this can't happen vcenter}{\quad vcenter@>
> delta:=height(v)+depth(v);
> height(v):=axis_height(cur_size)+half(delta);
> depth(v):=delta-height(v);
11645c14360
< between a square root sign and the rule above its operand by assuming that the
---
> between a square root sign and the rule above its nucleus by assuming that the
11649c14364
< of the operand plus a certain minimum clearance@@|clr|. The symbol will be
---
> of the nucleus plus a certain minimum clearance~|clr|. The symbol will be
11656,11668c14371,14382
< begin x←clean_box(operand(q),und_style(cur_style));
< if cur_style<text_style then
< clr←default_rule_thickness+(math_x_height(cur_size) div 4)
< else begin clr←default_rule_thickness; clr←clr + (clr div 4);
< end;
< y←var_delimiter(left_delimiter(q),cur_size,height(x)+depth(x)+clr+
< default_rule_thickness);
< if height(y)≤0 then height(y)←default_rule_thickness;
< delta←depth(y)-(height(x)+depth(x)+clr);
< if delta>0 then clr←clr+half(delta); {increase the actual clearance}
< shift_amount(y)←-(height(x)+clr);
< link(y)←overbar(x,clr,height(y));
< info(operand(q))←hpack(y,natural); math_type(operand(q))←sub_box;
---
> begin x:=clean_box(nucleus(q),cramped_style(cur_style));
> if cur_style<text_style then {display style}
> clr:=default_rule_thickness+(abs(math_x_height(cur_size)) div 4)
> else begin clr:=default_rule_thickness; clr:=clr + (abs(clr) div 4);
> end;
> y:=var_delimiter(left_delimiter(q),cur_size,height(x)+depth(x)+clr+
> default_rule_thickness);
> delta:=depth(y)-(height(x)+depth(x)+clr);
> if delta>0 then clr:=clr+half(delta); {increase the actual clearance}
> shift_amount(y):=-(height(x)+clr);
> link(y):=overbar(x,clr,height(y));
> info(nucleus(q)):=hpack(y,natural); math_type(nucleus(q)):=sub_box;
11677c14391
< label done;
---
> label done,done1;
11679c14393,14400
< @!delta:scaled; {amount to raise the accent}
---
> @!a:integer; {address of lig/kern instruction}
> @!c:quarterword; {accent character}
> @!f:internal_font_number; {its font}
> @!i:four_quarters; {its |char_info|}
> @!s:scaled; {amount to skew the accent to the right}
> @!h:scaled; {height of character being accented}
> @!delta:scaled; {space to remove between accent and accentee}
> @!w:scaled; {width of the accentee, not including sub/superscripts}
11682,11693c14403,14424
< begin x←clean_box(operand(q),und_style(cur_style));
< @<Switch to a larger accent if available and appropriate@>;
< delta←height(x)-x_height(cur_f);
< if delta<0 then delta←0;
< y←hpack(new_character(cur_f,cur_c),natural);
< shift_amount(y)←half(width(x)-width(y));
< width(y)←0; p←new_kern(delta-height(x)); link(p)←x; link(y)←p;
< y←vpack(y,natural); width(y)←width(x);
< info(operand(q))←y;
< math_type(operand(q))←sub_box;
< end;
< end;
---
> begin i:=cur_i; c:=cur_c; f:=cur_f;@/
> @<Compute the amount of skew@>;
> x:=clean_box(nucleus(q),cramped_style(cur_style)); w:=width(x); h:=height(x);
> @<Switch to a larger accent if available and appropriate@>;
> if h<x_height(f) then delta:=h@+else delta:=x_height(f);
> if (math_type(supscr(q))<>empty)or(math_type(subscr(q))<>empty) then
> if math_type(nucleus(q))=math_char then
> @<Swap the subscript and superscript into box |x|@>;
> y:=char_box(f,c);
> shift_amount(y):=s+half(w-width(y));
> width(y):=0; p:=new_kern(-delta); link(p):=x; link(y):=p;
> y:=vpack(y,natural); width(y):=width(x);
> if height(y)<h then @<Make the height of box |y| equal to |h|@>;
> info(nucleus(q)):=y;
> math_type(nucleus(q)):=sub_box;
> end;
> end;
>
> @ @<Make the height of box |y|...@>=
> begin p:=new_kern(h-height(y)); link(p):=list_ptr(y); list_ptr(y):=p;
> height(y):=h;
> end
11696,11701c14427,14433
< loop@+ begin if char_tag(cur_i)≠list_tag then goto done;
< y←rem_byte(cur_i);
< cur_i←char_info(cur_f)(y);
< if char_width(cur_f)(cur_i)>width(x) then goto done;
< cur_c←y;
< end;
---
> loop@+ begin if char_tag(i)<>list_tag then goto done;
> y:=rem_byte(i);
> i:=char_info(f)(y);
> if not char_exists(i) then goto done;
> if char_width(f)(i)>w then goto done;
> c:=y;
> end;
11703a14436,14470
> @ @<Compute the amount of skew@>=
> s:=0;
> if math_type(nucleus(q))=math_char then
> begin fetch(nucleus(q));
> if char_tag(cur_i)=lig_tag then
> begin a:=lig_kern_start(cur_f)(cur_i);
> cur_i:=font_info[a].qqqq;
> if skip_byte(cur_i)>stop_flag then
> begin a:=lig_kern_restart(cur_f)(cur_i);
> cur_i:=font_info[a].qqqq;
> end;
> loop@+ begin if qo(next_char(cur_i))=skew_char[cur_f] then
> begin if op_byte(cur_i)>=kern_flag then
> if skip_byte(cur_i)<=stop_flag then s:=char_kern(cur_f)(cur_i);
> goto done1;
> end;
> if skip_byte(cur_i)>=stop_flag then goto done1;
> a:=a+qo(skip_byte(cur_i))+1;
> cur_i:=font_info[a].qqqq;
> end;
> end;
> end;
> done1:
>
> @ @<Swap the subscript and superscript into box |x|@>=
> begin flush_node_list(x); x:=new_noad;
> mem[nucleus(x)]:=mem[nucleus(q)];
> mem[supscr(x)]:=mem[supscr(q)];
> mem[subscr(x)]:=mem[subscr(q)];@/
> mem[supscr(q)].hh:=empty_field;
> mem[subscr(q)].hh:=empty_field;@/
> math_type(nucleus(q)):=sub_mlist; info(nucleus(q)):=x;
> x:=clean_box(nucleus(q),cur_style); delta:=delta+height(x)-h; h:=height(x);
> end
>
11711,11714c14478,14482
< {dimensions for box calculations}
< begin @<Create equal-width boxes |x| and |z| for the numerator and denominator,
< and compute the default amounts |shift_up| and |shift_down| by which they
< are displaced from the baseline@>;
---
> {dimensions for box calculations}
> begin if thickness(q)=default_code then thickness(q):=default_rule_thickness;
> @<Create equal-width boxes |x| and |z| for the numerator and denominator,
> and compute the default amounts |shift_up| and |shift_down| by which they
> are displaced from the baseline@>;
11716c14484
< of no fraction line@>
---
> of no fraction line@>
11719c14487
< |shift_down|@>;
---
> |shift_down|@>;
11721c14489
< point to it@>;
---
> point to it@>;
11725,11735c14493,14503
< x←clean_box(numerator(q),num_style(cur_style));
< z←clean_box(denominator(q),denom_style(cur_style));
< if width(x)<width(z) then x←rebox(x,width(z))
< else z←rebox(z,width(x));
< if cur_style<text_style then
< begin shift_up←num1(cur_size); shift_down←denom1(cur_size);
< end
< else begin shift_down←denom2(cur_size);
< if thickness(q)≠0 then shift_up←num2(cur_size)
< else shift_up←num3(cur_size);
< end
---
> x:=clean_box(numerator(q),num_style(cur_style));
> z:=clean_box(denominator(q),denom_style(cur_style));
> if width(x)<width(z) then x:=rebox(x,width(z))
> else z:=rebox(z,width(x));
> if cur_style<text_style then {display style}
> begin shift_up:=num1(cur_size); shift_down:=denom1(cur_size);
> end
> else begin shift_down:=denom2(cur_size);
> if thickness(q)<>0 then shift_up:=num2(cur_size)
> else shift_up:=num3(cur_size);
> end
11742,11744c14510,14512
< begin if cur_style<text_style then clr←7*default_rule_thickness
< else clr←3*default_rule_thickness;
< delta←half(clr-((shift_up-depth(x))-(height(z)-shift_down)));
---
> begin if cur_style<text_style then clr:=7*default_rule_thickness
> else clr:=3*default_rule_thickness;
> delta:=half(clr-((shift_up-depth(x))-(height(z)-shift_down)));
11746,11748c14514,14516
< begin shift_up←shift_up+delta;
< shift_down←shift_down-delta;
< end;
---
> begin shift_up:=shift_up+delta;
> shift_down:=shift_down+delta;
> end;
11755,11762c14523,14529
< begin if thickness(q)=default_code then thickness(q)←default_rule_thickness;
< if cur_style<text_style then clr←3*thickness(q)
< else clr←thickness(q);
< delta←half(thickness(q));
< delta1←clr-((shift_up-depth(x))-(axis_height(cur_size)+delta));
< delta2←clr-((axis_height(cur_size)-delta)-(height(z)-shift_down));
< if delta1>0 then shift_up←shift_up+delta1;
< if delta2>0 then shift_down←shift_down+delta2;
---
> begin if cur_style<text_style then clr:=3*thickness(q)
> else clr:=thickness(q);
> delta:=half(thickness(q));
> delta1:=clr-((shift_up-depth(x))-(axis_height(cur_size)+delta));
> delta2:=clr-((axis_height(cur_size)-delta)-(height(z)-shift_down));
> if delta1>0 then shift_up:=shift_up+delta1;
> if delta2>0 then shift_down:=shift_down+delta2;
11766,11768c14533,14535
< v←new_null_box; type(v)←vlist_node;
< height(v)←shift_up+height(x); depth(v)←depth(z)+shift_down;
< width(v)←width(x); {this also equals |width(z)|}
---
> v:=new_null_box; type(v):=vlist_node;
> height(v):=shift_up+height(x); depth(v):=depth(z)+shift_down;
> width(v):=width(x); {this also equals |width(z)|}
11770,11779c14537,14546
< begin p←new_kern((shift_up-depth(x))-(height(z)-shift_down));
< link(p)←z;
< end
< else begin y←fraction_rule(thickness(q));@/
< p←new_kern((axis_height(cur_size)-delta)-@|(height(z)-shift_down));@/
< link(y)←p;@/
< p←new_kern((shift_up-depth(x))-(axis_height(cur_size)+delta));
< link(p)←y;
< end;
< link(x)←p; list_ptr(v)←x
---
> begin p:=new_kern((shift_up-depth(x))-(height(z)-shift_down));
> link(p):=z;
> end
> else begin y:=fraction_rule(thickness(q));@/
> p:=new_kern((axis_height(cur_size)-delta)-@|(height(z)-shift_down));@/
> link(y):=p; link(p):=z;@/
> p:=new_kern((shift_up-depth(x))-(axis_height(cur_size)+delta));
> link(p):=y;
> end;
> link(x):=p; list_ptr(v):=x
11782,11795c14549,14559
< if cur_style<text_style then delta←delim1(cur_size)
< else delta←delim2(cur_size);
< x←var_delimiter(left_delimiter(q), cur_size, delta); link(x)←v;@/
< z←var_delimiter(right_delimiter(q), cur_size, delta); link(v)←z;@/
< new_hlist(q)←hpack(x,natural)
<
< @ An |op_noad| is a bit confusing because its |operand| is really an
< ``operator.'' We shall occasionally call the operator an operand, since
< that is where the information appears in the data structure. If such an
< operand is a single character, it is to be centered vertically with
< respect to the axis, after first being enlarged (via a character list in
< the font) if we are in display style. The normal convention for placing
< displayed limits is to put them to the right only when the character has a
< nonzero italic correction.
---
> if cur_style<text_style then delta:=delim1(cur_size)
> else delta:=delim2(cur_size);
> x:=var_delimiter(left_delimiter(q), cur_size, delta); link(x):=v;@/
> z:=var_delimiter(right_delimiter(q), cur_size, delta); link(v):=z;@/
> new_hlist(q):=hpack(x,natural)
>
> @ If the nucleus of an |op_noad| is a single character, it is to be
> centered vertically with respect to the axis, after first being enlarged
> (via a character list in the font) if we are in display style. The normal
> convention for placing displayed limits is to put them above and below the
> operator in display style.
11797,11798c14561,14562
< The italic correction is removed from the character unless the limits are
< being placed at the right and there is no subscript. The |make_op|
---
> The italic correction is removed from the character if there is a subscript
> and the limits are not being displayed. The |make_op|
11802,11803c14566,14567
< After |make_op| has acted, |subtype(q)| will be |switched| if and only if
< the limits have been set above and below the operand. In that case,
---
> After |make_op| has acted, |subtype(q)| will be |limits| if and only if
> the limits have been set above and below the operator. In that case,
11809a14574
> @!c:quarterword;@+@!i:four_quarters; {registers for character examination}
11811,11832c14576,14596
< begin if math_type(operand(q))=math_char then
< begin fetch(operand(q));
< if (cur_style<text_style)∧(char_tag(cur_i)=list_tag) then {make it larger}
< begin cur_c←rem_byte(cur_i); character(operand(q))←cur_c;
< cur_i←char_info(cur_f)(cur_c);
< end;
< delta←char_italic(cur_f)(cur_i); x←clean_box(operand(q),cur_style);
< width(x)←width(x)-delta; {remove italic correction}
< shift_amount(x)←half(height(x)-depth(x)) - axis_height(cur_size);
< {center vertically}
< math_type(operand(q))←sub_box; info(operand(q))←x;
< end
< else delta←0;
< if cur_style<text_style then {display styles}
< if ((delta=0)∧(subtype(q)=normal))∨@|
< ((delta≠0)∧(subtype(q)=switched)) then subtype(q)←switched
< else subtype(q)←normal
< else subtype(q)←normal;
< if subtype(q)=switched then
< @<Construct a box with limits above and below it, skewed by |delta|@>
< else if (delta≠0)∧(math_type(subscr(q))=empty) then width(x)←width(x)+delta;
< make_op←delta;
---
> begin if (subtype(q)=normal)and(cur_style<text_style) then
> subtype(q):=limits;
> if math_type(nucleus(q))=math_char then
> begin fetch(nucleus(q));
> if (cur_style<text_style)and(char_tag(cur_i)=list_tag) then {make it larger}
> begin c:=rem_byte(cur_i); i:=char_info(cur_f)(c);
> if char_exists(i) then
> begin cur_c:=c; cur_i:=i; character(nucleus(q)):=c;
> end;
> end;
> delta:=char_italic(cur_f)(cur_i); x:=clean_box(nucleus(q),cur_style);
> if (math_type(subscr(q))<>empty)and(subtype(q)<>limits) then
> width(x):=width(x)-delta; {remove italic correction}
> shift_amount(x):=half(height(x)-depth(x)) - axis_height(cur_size);
> {center vertically}
> math_type(nucleus(q)):=sub_box; info(nucleus(q)):=x;
> end
> else delta:=0;
> if subtype(q)=limits then
> @<Construct a box with limits above and below it, skewed by |delta|@>;
> make_op:=delta;
11839,11847c14603,14611
< begin x←clean_box(supscr(q),sup_style(cur_style));
< y←clean_box(operand(q),cur_style);
< z←clean_box(subscr(q),sub_style(cur_style));
< v←new_null_box; type(v)←vlist_node; width(v)←width(y);
< if width(x)>width(v) then width(v)←width(x);
< if width(z)>width(v) then width(v)←width(z);
< x←rebox(x,width(v)); y←rebox(y,width(v)); z←rebox(z,width(v));@/
< shift_amount(x)←half(delta); shift_amount(z)←-shift_amount(x);
< height(v)←height(y); depth(v)←depth(y);
---
> begin x:=clean_box(supscr(q),sup_style(cur_style));
> y:=clean_box(nucleus(q),cur_style);
> z:=clean_box(subscr(q),sub_style(cur_style));
> v:=new_null_box; type(v):=vlist_node; width(v):=width(y);
> if width(x)>width(v) then width(v):=width(x);
> if width(z)>width(v) then width(v):=width(z);
> x:=rebox(x,width(v)); y:=rebox(y,width(v)); z:=rebox(z,width(v));@/
> shift_amount(x):=half(delta); shift_amount(z):=-shift_amount(x);
> height(v):=height(y); depth(v):=depth(y);
11849,11850c14613,14614
< account for their presence@>;
< new_hlist(q)←v;
---
> account for their presence@>;
> new_hlist(q):=v;
11860,11867c14624,14631
< begin free_node(x,box_node_size); list_ptr(v)←y;
< end
< else begin shift_up←big_op_spacing3-depth(x);
< if shift_up<big_op_spacing1 then shift_up←big_op_spacing1;
< p←new_kern(shift_up); link(p)←y; link(x)←p;@/
< p←new_kern(big_op_spacing5); link(p)←x; list_ptr(v)←p;
< height(v)←height(v)+big_op_spacing5+height(x)+depth(x)+shift_up;
< end;
---
> begin free_node(x,box_node_size); list_ptr(v):=y;
> end
> else begin shift_up:=big_op_spacing3-depth(x);
> if shift_up<big_op_spacing1 then shift_up:=big_op_spacing1;
> p:=new_kern(shift_up); link(p):=y; link(x):=p;@/
> p:=new_kern(big_op_spacing5); link(p):=x; list_ptr(v):=p;
> height(v):=height(v)+big_op_spacing5+height(x)+depth(x)+shift_up;
> end;
11869,11874c14633,14638
< else begin shift_down←big_op_spacing4-height(z);
< if shift_down<big_op_spacing2 then shift_down←big_op_spacing2;
< p←new_kern(shift_down); link(y)←p; link(p)←z;@/
< p←new_kern(big_op_spacing5); link(z)←p;
< depth(v)←depth(v)+big_op_spacing5+height(z)+depth(z)+shift_down;
< end
---
> else begin shift_down:=big_op_spacing4-height(z);
> if shift_down<big_op_spacing2 then shift_down:=big_op_spacing2;
> p:=new_kern(shift_down); link(y):=p; link(p):=z;@/
> p:=new_kern(big_op_spacing5); link(z):=p;
> depth(v):=depth(v)+big_op_spacing5+height(z)+depth(z)+shift_down;
> end
11879a14644,14649
> The |math_type| is converted to |math_text_char| here if we would not want to
> apply an italic correction to the current character unless it belongs
> to a math font (i.e., a font with |space=0|).
>
> No boundary characters enter into these ligatures.
>
11882c14652
< label restart;
---
> label restart,exit;
11884,11907c14654,14684
< @!p:pointer; {temporary register for list manipulation}
< begin restart:@;@/
< if (math_type(subscr(q))=empty)∧(math_type(supscr(q))=empty)∧@|
< (math_type(operand(q))=math_char) then
< begin p←link(q);
< if p≠null then if (type(p)≥ord_noad)∧(type(p)≤punct_noad) then
< if math_type(operand(p))=math_char then
< if fam(operand(p))=fam(operand(q)) then
< begin fetch(operand(q));
< if char_tag(cur_i)=lig_tag then
< begin a←lig_kern_start(cur_f)(cur_i);
< cur_c←character(operand(p));
< repeat cur_i←font_info[a].qqqq;@/
< @<If instruction |cur_i| is a kern with |cur_c|,
< attach the kern after |q|;
< or if it is a ligature with |cur_c|, combine
< noads |q| and |p| and |goto restart|@>;
< incr(a);
< until stop_bit(cur_i)≥stop_flag;
< end;
< end;
< end;
< end;
<
---
> @!p,@!r:pointer; {temporary registers for list manipulation}
> begin restart:@t@>@;@/
> if math_type(subscr(q))=empty then if math_type(supscr(q))=empty then
> if math_type(nucleus(q))=math_char then
> begin p:=link(q);
> if p<>null then if (type(p)>=ord_noad)and(type(p)<=punct_noad) then
> if math_type(nucleus(p))=math_char then
> if fam(nucleus(p))=fam(nucleus(q)) then
> begin math_type(nucleus(q)):=math_text_char;
> fetch(nucleus(q));
> if char_tag(cur_i)=lig_tag then
> begin a:=lig_kern_start(cur_f)(cur_i);
> cur_c:=character(nucleus(p));
> cur_i:=font_info[a].qqqq;
> if skip_byte(cur_i)>stop_flag then
> begin a:=lig_kern_restart(cur_f)(cur_i);
> cur_i:=font_info[a].qqqq;
> end;
> loop@+ begin @<If instruction |cur_i| is a kern with |cur_c|, attach
> the kern after~|q|; or if it is a ligature with |cur_c|, combine
> noads |q| and~|p| appropriately; then |return| if the cursor has
> moved past a noad, or |goto restart|@>;
> if skip_byte(cur_i)>=stop_flag then return;
> a:=a+qo(skip_byte(cur_i))+1;
> cur_i:=font_info[a].qqqq;
> end;
> end;
> end;
> end;
> exit:end;
>
11909c14686,14688
< is replaced by an |ord_noad|. Presumably a font designer will define such
---
> is replaced by an |ord_noad|, when the two noads collapse into one.
> But we could make a parenthesis (say) change shape when it follows
> certain letters. Presumably a font designer will define such
11911a14691,14692
> \chardef\?='174 % vertical line to indicate character retention
>
11913,11922c14694,14718
< if next_char(cur_i)=cur_c then
< if op_bit(cur_i)≥kern_flag then
< begin p←new_kern(char_kern(cur_f)(cur_i));
< link(p)←link(q); link(q)←p;
< end
< else begin link(q)←link(p); character(operand(q))←rem_byte(cur_i);@/
< mem[subscr(q)]←mem[subscr(p)];
< mem[supscr(q)]←mem[supscr(p)];
< free_node(p,noad_size); goto restart;
< end
---
> if next_char(cur_i)=cur_c then if skip_byte(cur_i)<=stop_flag then
> if op_byte(cur_i)>=kern_flag then
> begin p:=new_kern(char_kern(cur_f)(cur_i));
> link(p):=link(q); link(q):=p; return;
> end
> else begin check_interrupt; {allow a way out of infinite ligature loop}
> case op_byte(cur_i) of
> qi(1),qi(5): character(nucleus(q)):=rem_byte(cur_i); {\.{=:\?}, \.{=:\?>}}
> qi(2),qi(6): character(nucleus(p)):=rem_byte(cur_i); {\.{\?=:}, \.{\?=:>}}
> qi(3),qi(7),qi(11):begin r:=new_noad; {\.{\?=:\?}, \.{\?=:\?>}, \.{\?=:\?>>}}
> character(nucleus(r)):=rem_byte(cur_i);
> fam(nucleus(r)):=fam(nucleus(q));@/
> link(q):=r; link(r):=p;
> if op_byte(cur_i)<qi(11) then math_type(nucleus(r)):=math_char
> else math_type(nucleus(r)):=math_text_char; {prevent combination}
> end;
> othercases begin link(q):=link(p);
> character(nucleus(q)):=rem_byte(cur_i); {\.{=:}}
> mem[subscr(q)]:=mem[subscr(p)]; mem[supscr(q)]:=mem[supscr(p)];@/
> free_node(p,noad_size);
> end
> endcases;
> if op_byte(cur_i)>qi(3) then return;
> math_type(nucleus(q)):=math_char; goto restart;
> end
11926c14722
< |done_with_node|. Thus, |q|@@points to a noad whose operand may need to be
---
> |done_with_node|. Thus, |q|~points to a noad whose nucleus may need to be
11930c14726
< If |operand(q)| is not a |math_char|, the variable |delta| is the amount
---
> If |nucleus(q)| is not a |math_char|, the variable |delta| is the amount
11936,11947c14732,14745
< @<Convert \(o)|operand(q)| to an hlist and attach the sub/superscripts@>=
< case math_type(operand(q)) of
< math_char: @<Create a character node |p| for |operand(q)|, possibly followed
< by a kern node for the italic correction, and set |delta| to the
< italic correction if a subscript is present@>;
< empty: p←null;
< sub_box: p←info(operand(q));
< sub_mlist: begin cur_mlist←info(operand(q)); save_style←cur_style;
< mlist_penalties←false; mlist_to_hlist; {recursive call}
< cur_style←save_style; @<Set up the values...@>;
< p←hpack(link(temp_head),natural);
< end;
---
> @<Convert \(n)|nucleus(q)| to an hlist and attach the sub/superscripts@>=
> case math_type(nucleus(q)) of
> math_char, math_text_char:
> @<Create a character node |p| for |nucleus(q)|, possibly followed
> by a kern node for the italic correction, and set |delta| to the
> italic correction if a subscript is present@>;
> empty: p:=null;
> sub_box: p:=info(nucleus(q));
> sub_mlist: begin cur_mlist:=info(nucleus(q)); save_style:=cur_style;
> mlist_penalties:=false; mlist_to_hlist; {recursive call}
> @^recursion@>
> cur_style:=save_style; @<Set up the values...@>;
> p:=hpack(link(temp_head),natural);
> end;
11949c14747
< @:confusion mlist2}{\quad mlist2@>
---
> @:this can't happen mlist2}{\quad mlist2@>
11951,11953c14749,14751
< new_hlist(q)←p;
< if (math_type(subscr(q))=empty)∧(math_type(supscr(q))=empty) then
< goto check_dimensions;
---
> new_hlist(q):=p;
> if (math_type(subscr(q))=empty)and(math_type(supscr(q))=empty) then
> goto check_dimensions;
11956,11957c14754,14755
< @ @<Create a character node |p| for |operand(q)|...@>=
< begin fetch(operand(q));
---
> @ @<Create a character node |p| for |nucleus(q)|...@>=
> begin fetch(nucleus(q));
11959,11964c14757,14764
< begin delta←char_italic(cur_f)(cur_i); p←new_character(cur_f,cur_c);
< if (math_type(subscr(q))=empty)∧(delta≠0) then
< begin link(p)←new_kern(delta); delta←0;
< end;
< end
< else p←null;
---
> begin delta:=char_italic(cur_f)(cur_i); p:=new_character(cur_f,qo(cur_c));
> if (math_type(nucleus(q))=math_text_char)and(space(cur_f)<>0) then
> delta:=0; {no italic correction in mid-word of text font}
> if (math_type(subscr(q))=empty)and(delta<>0) then
> begin link(p):=new_kern(delta); delta:=0;
> end;
> end
> else p:=null;
11969c14769
< given that subscript and superscript aren't both empty. The superscript
---
> given that the subscript and superscript aren't both empty. The superscript
11973c14773
< baseline of subscripts and superscripts based on the given operand.
---
> baseline of subscripts and superscripts based on the given nucleus.
11980c14780
< begin p←new_hlist(q);
---
> begin p:=new_hlist(q);
11982,11989c14782,14789
< begin shift_up←0; shift_down←0;
< end
< else begin z←hpack(p,natural);
< if cur_style<script_style then t←script_size@+else t←script_script_size;
< shift_up←height(z)-sup_drop(t);
< shift_down←depth(z)+sub_drop(t);
< free_node(z,box_node_size);
< end;
---
> begin shift_up:=0; shift_down:=0;
> end
> else begin z:=hpack(p,natural);
> if cur_style<script_style then t:=script_size@+else t:=script_script_size;
> shift_up:=height(z)-sup_drop(t);
> shift_down:=depth(z)+sub_drop(t);
> free_node(z,box_node_size);
> end;
11991,12001c14791,14801
< @<Construct a subscript box |x| when there is no superscript@>
< else begin @<Construct a superscript box |x|@>;
< if math_type(subscr(q))=empty then shift_amount(x)←-shift_up
< else @<Construct a sub/superscript combination box |x|, with the
< superscript offset by |delta|@>;
< end;
< if new_hlist(q)=null then new_hlist(q)←x
< else begin p←new_hlist(q);
< while link(p)≠null do p←link(p);
< link(p)←x;
< end;
---
> @<Construct a subscript box |x| when there is no superscript@>
> else begin @<Construct a superscript box |x|@>;
> if math_type(subscr(q))=empty then shift_amount(x):=-shift_up
> else @<Construct a sub/superscript combination box |x|, with the
> superscript offset by |delta|@>;
> end;
> if new_hlist(q)=null then new_hlist(q):=x
> else begin p:=new_hlist(q);
> while link(p)<>null do p:=link(p);
> link(p):=x;
> end;
12008,12013c14808,14813
< begin x←clean_box(subscr(q),sub_style(cur_style));
< width(x)←width(x)+script_space;
< if shift_down<sub1(cur_size) then shift_down←sub1(cur_size);
< clr←height(x)-((math_x_height(cur_size)*4) div 5);
< if shift_down<clr then shift_down←clr;
< shift_amount(x)←shift_down;
---
> begin x:=clean_box(subscr(q),sub_style(cur_style));
> width(x):=width(x)+script_space;
> if shift_down<sub1(cur_size) then shift_down:=sub1(cur_size);
> clr:=height(x)-(abs(math_x_height(cur_size)*4) div 5);
> if shift_down<clr then shift_down:=clr;
> shift_amount(x):=shift_down;
12020,12027c14820,14827
< begin x←clean_box(supscr(q),sup_style(cur_style));
< width(x)←width(x)+script_space;
< if odd(cur_style) then clr←sup3(cur_size)
< else if cur_style<text_style then clr←sup1(cur_size)
< else clr←sup2(cur_size);
< if shift_up<clr then shift_up←clr;
< clr←depth(x)+(math_x_height(cur_size) div 4);
< if shift_up<clr then shift_up←clr;
---
> begin x:=clean_box(supscr(q),sup_style(cur_style));
> width(x):=width(x)+script_space;
> if odd(cur_style) then clr:=sup3(cur_size)
> else if cur_style<text_style then clr:=sup1(cur_size)
> else clr:=sup2(cur_size);
> if shift_up<clr then shift_up:=clr;
> clr:=depth(x)+(abs(math_x_height(cur_size)) div 4);
> if shift_up<clr then shift_up:=clr;
12031c14831
< at least four times |default_rule_thickness| away from the superscript.
---
> separated from the superscript by at least four times |default_rule_thickness|.
12037,12041c14837,14841
< begin y←clean_box(subscr(q),sub_style(cur_style));
< width(y)←width(y)+script_space;
< if shift_down<sub2(cur_size) then shift_down←sub2(cur_size);
< clr←4*default_rule_thickness-
< ((shift_up-depth(x))-(height(y)-shift_down));
---
> begin y:=clean_box(subscr(q),sub_style(cur_style));
> width(y):=width(y)+script_space;
> if shift_down<sub2(cur_size) then shift_down:=sub2(cur_size);
> clr:=4*default_rule_thickness-
> ((shift_up-depth(x))-(height(y)-shift_down));
12043,12052c14843,14852
< begin shift_down←shift_down+clr;
< clr←(4*math_x_height(cur_size) div 5)-(shift_up-depth(x));
< if clr>0 then
< begin shift_up←shift_up+clr;
< shift_down←shift_down-clr;
< end;
< end;
< shift_amount(x)←delta; {superscript is |delta| to the right of the subscript}
< p←new_kern((shift_up-depth(x))-(height(y)-shift_down)); link(x)←p; link(p)←y;
< x←vpack(x,natural); shift_amount(x)←shift_down;
---
> begin shift_down:=shift_down+clr;
> clr:=(abs(math_x_height(cur_size)*4) div 5)-(shift_up-depth(x));
> if clr>0 then
> begin shift_up:=shift_up+clr;
> shift_down:=shift_down-clr;
> end;
> end;
> shift_amount(x):=delta; {superscript is |delta| to the right of the subscript}
> p:=new_kern((shift_up-depth(x))-(height(y)-shift_down)); link(x):=p; link(p):=y;
> x:=vpack(x,natural); shift_amount(x):=shift_down;
12054c14854
<
---
>
12062c14862
< p←temp_head; link(p)←null; q←mlist; r_type←0; cur_style←style;
---
> p:=temp_head; link(p):=null; q:=mlist; r_type:=0; cur_style:=style;
12064,12074c14864,14874
< while q≠null do
< begin @<If node |q| is a style node, change the style and |goto delete_q|;
< otherwise if it is not a noad, put it into the hlist,
< advance |q|, and |goto done|; otherwise set |s| to the size
< of noad |q|, set |t| to the associated type (|ord_noad..
< inner_noad|), and set |pen| to the associated penalty@>;
< @<Append inter-element spacing based on |r_type| and |t|@>;
< @<Append any |new_hlist| entries for |q|, and any appropriate penalties@>;
< r_type←t;
< delete_q: r←q; q←link(q); free_node(r,s);
< done: end
---
> while q<>null do
> begin @<If node |q| is a style node, change the style and |goto delete_q|;
> otherwise if it is not a noad, put it into the hlist,
> advance |q|, and |goto done|; otherwise set |s| to the size
> of noad |q|, set |t| to the associated type (|ord_noad..
> inner_noad|), and set |pen| to the associated penalty@>;
> @<Append inter-element spacing based on |r_type| and |t|@>;
> @<Append any |new_hlist| entries for |q|, and any appropriate penalties@>;
> r_type:=t;
> delete_q: r:=q; q:=link(q); free_node(r,s);
> done: end
12076,12077c14876,14877
< @ Before we do the big |case| switch in the second pass, we set the default
< values so that most of the branches are short.
---
> @ Just before doing the big |case| switch in the second pass, the program
> sets up default values so that most of the branches are short.
12080c14880
< t←inner_noad; s←noad_size; pen←inf_penalty;
---
> t:=ord_noad; s:=noad_size; pen:=inf_penalty;
12082,12091c14882,14892
< ord_noad,op_noad,open_noad,close_noad,punct_noad: t←type(q);
< bin_noad: begin t←bin_noad; pen←bin_op_penalty;
< end;
< rel_noad: begin t←rel_noad; pen←rel_penalty;
< end;
< inner_noad,vcenter_noad,over_noad,under_noad: do_nothing;
< radical_noad: s←radical_noad_size;
< accent_noad: s←accent_noad_size;
< fraction_noad: s←fraction_noad_size;
< left_noad,right_noad: t←make_left_right(q,style,max_d,max_h);
---
> op_noad,open_noad,close_noad,punct_noad,inner_noad: t:=type(q);
> bin_noad: begin t:=bin_noad; pen:=bin_op_penalty;
> end;
> rel_noad: begin t:=rel_noad; pen:=rel_penalty;
> end;
> ord_noad,vcenter_noad,over_noad,under_noad: do_nothing;
> radical_noad: s:=radical_noad_size;
> accent_noad: s:=accent_noad_size;
> fraction_noad: begin t:=inner_noad; s:=fraction_noad_size;
> end;
> left_noad,right_noad: t:=make_left_right(q,style,max_d,max_h);
12093,12096c14894,14897
< whatsit_node,penalty_node,rule_node,disc_node,
< glue_node,kern_node: begin@t@>@;@/
< link(p)←q; q←link(q); link(p)←null; goto done;
< end;
---
> whatsit_node,penalty_node,rule_node,disc_node,adjust_node,ins_node,mark_node,
> glue_node,kern_node:@t@>@;@/
> begin link(p):=q; p:=q; q:=link(q); link(p):=null; goto done;
> end;
12098c14899
< @:confusion mlist3}{\quad mlist3@>
---
> @:this can't happen mlist3}{\quad mlist3@>
12101,12104c14902,14905
< @ The |make_left_right| function constructs a delimiter of the required size
< and returns the value |open_noad| or |close_noad|. The |right_noad| and
< |left_noad| will both be based on the original |style|, so they will
< have consistent sizes.
---
> @ The |make_left_right| function constructs a left or right delimiter of
> the required size and returns the value |open_noad| or |close_noad|. The
> |right_noad| and |left_noad| will both be based on the original |style|,
> so they will have consistent sizes.
12110c14911
< @!max_d,@!max_h:scaled):small_number;
---
> @!max_d,@!max_h:scaled):small_number;
12112,12121c14913,14922
< begin if style<script_style then cur_size←text_size
< else cur_size←16*((style-text_style) div 2);
< delta2←max_d+axis_height(cur_size);
< delta1←max_h+max_d-delta2;
< if delta2>delta1 then delta1←delta2; {|delta1| is max distance from axis}
< delta←(delimiter_factor*delta1) div 500;
< delta2←delta1+delta1-delimiter_limit;
< if delta<delta2 then delta←delta2;
< new_hlist(q)←var_delimiter(delimiter(q),cur_size,delta);
< make_left_right←type(q)-(left_noad-open_noad); {|open_noad| or |close_noad|}
---
> begin if style<script_style then cur_size:=text_size
> else cur_size:=16*((style-text_style) div 2);
> delta2:=max_d+axis_height(cur_size);
> delta1:=max_h+max_d-delta2;
> if delta2>delta1 then delta1:=delta2; {|delta1| is max distance from axis}
> delta:=(delta1 div 500)*delimiter_factor;
> delta2:=delta1+delta1-delimiter_shortfall;
> if delta<delta2 then delta:=delta2;
> new_hlist(q):=var_delimiter(delimiter(q),cur_size,delta);
> make_left_right:=type(q)-(left_noad-open_noad); {|open_noad| or |close_noad|}
12125c14926
< begin cur_style←subtype(q); s←small_node_size;
---
> begin cur_style:=subtype(q); s:=style_node_size;
12135,12138c14936,14941
< \.1 means a conditional thin space (\.{\\nonscript\\mskip\\the\\thinmskip});\cr
< \.2 means a thin space (\.{\\mskip\\the\\thinmskip});\cr
< \.3 means a conditional medium space (\.{\\nonscript\\mskip\\the\\medmskip});\cr
< \.4 means a thick space (\.{\\mskip\\the\\thickmskip});\cr
---
> \.1 means a conditional thin space (\.{\\nonscript\\mskip\\thinmuskip});\cr
> \.2 means a thin space (\.{\\mskip\\thinmuskip});\cr
> \.3 means a conditional medium space
> (\.{\\nonscript\\mskip\\medmuskip});\cr
> \.4 means a conditional thick space
> (\.{\\nonscript\\mskip\\thickmuskip});\cr
12140,12141c14943,14945
< This is all pretty cryptic, but the \TeX\ manual explains what is supposed to
< happen, and the string makes it happen.
---
> This is all pretty cryptic, but {\sl The \TeX book\/} explains what is
> supposed to happen, and the string makes it happen.
> @:TeXbook}{\sl The \TeX book@>
12153,12154c14957,14958
< "0234000022*4000033**3**344*0400400*000000234000011*4111102340000"
< @t\hskip-35pt@>
---
> "0234000122*4000133**3**344*0400400*000000234000111*1111112341011"
> @t$ \hskip-35pt$@>
12160c14964
< magic_offset←str_start[math_spacing]-9*ord_noad
---
> magic_offset:=str_start[math_spacing]-9*ord_noad
12164,12178c14968,14982
< begin case str_pool[r_type*8+t+magic_offset] of
< "0": x←0;
< "1": if cur_style<script_style then x←thin_mskip_code@+else x←0;
< "2": x←thin_mskip_code;
< "3": if cur_style<script_style then x←med_mskip_code@+else x←0;
< "4": x←thick_mskip_code;
< othercases confusion("mlist4")
< @:confusion mlist4}{\quad mlist4@>
< endcases;
< if x≠0 then
< begin y←math_glue(glue_par(x),cur_mu);
< z←new_glue(y); glue_ref_count(y)←null; link(p)←z; p←z;@/
< subtype(z)←x+1; {store a symbolic subtype}
< end;
< end
---
> begin case so(str_pool[r_type*8+t+magic_offset]) of
> "0": x:=0;
> "1": if cur_style<script_style then x:=thin_mu_skip_code@+else x:=0;
> "2": x:=thin_mu_skip_code;
> "3": if cur_style<script_style then x:=med_mu_skip_code@+else x:=0;
> "4": if cur_style<script_style then x:=thick_mu_skip_code@+else x:=0;
> othercases confusion("mlist4")
> @:this can't happen mlist4}{\quad mlist4@>
> endcases;
> if x<>0 then
> begin y:=math_glue(glue_par(x),cur_mu);
> z:=new_glue(y); glue_ref_count(y):=null; link(p):=z; p:=z;@/
> subtype(z):=x+1; {store a symbolic subtype}
> end;
> end
12185,12196c14989,15001
< if new_hlist(q)≠null then
< begin link(p)←new_hlist(q);
< repeat p←link(p);
< until link(p)=null;
< end;
< if (pen<inf_penalty)∧ penalties ∧(link(q)≠null) then
< begin r_type←type(link(q));
< if (r_type≠penalty_node)∧(r_type≠rel_noad) then
< begin z←new_penalty(pen); link(p)←z; p←z;
< end;
< end
< @* \[36] Alignment.
---
> if new_hlist(q)<>null then
> begin link(p):=new_hlist(q);
> repeat p:=link(p);
> until link(p)=null;
> end;
> if penalties then if link(q)<>null then if pen<inf_penalty then
> begin r_type:=type(link(q));
> if r_type<>penalty_node then if r_type<>rel_noad then
> begin z:=new_penalty(pen); link(p):=z; p:=z;
> end;
> end
>
> @* \[37] Alignment.
12198c15003,15005
< they cut across so many of the control structures of \TeX. There\-fore the
---
> they cut across so many of the control structures of \TeX.
>
> Therefore the
12220,12221c15027,15028
< places the 300pt dimension onto |save_stack|, and the code |align_group|
< is placed above it. This will make it possible to complete the alignment
---
> places the 300pt dimension onto the |save_stack|, and an |align_group|
> code is placed above it. This will make it possible to complete the alignment
12247c15054
< token list `\.{u1}', i.e., the template preceding the `\.\#' for column@@1.
---
> token list `\.{u1}', i.e., the template preceding the `\.\#' for column~1.
12258c15065
< alignrecord for column@@1; in general, the alignrecords will record the
---
> alignrecord for column~1; in general, the alignrecords will record the
12261c15068
< (3) Since `\.{\\omit}' folows the `\.\&', the templates for column@@2
---
> (3) Since `\.{\\omit}' follows the `\.\&', the templates for column~2
12265c15072
< is remembered in the |width| field of the alignrecord for column@@2.
---
> is remembered in the |width| field of the alignrecord for column~2.
12268c15075
< mecha\-nism that worked for column@@1; this unset box contains `\.{u3\\vrule
---
> mechanism that worked for column~1; this unset box contains `\.{u3\\vrule
12281c15088
< {}\\unsetbox for 1 column: u3\vrule v3\cr
---
> {}\\unsetbox for 1 column: u3\\vrule v3\cr
12299c15106
< The natural width of the unset box that spans columns 1@@and@@2 is stored
---
> The natural width of the unset box that spans columns 1~and~2 is stored
12301c15108
< alignrecord for column@@1 now points to the new span node, and the |info|
---
> alignrecord for column~1 now points to the new span node, and the |info|
12330,12331c15137,15138
< @d u_part(#)==mem[#+height_offset].int {pointer to \<u↓j> token list}
< @d v_part(#)==mem[#+depth_offset].int {pointer to \<v↓j> token list}
---
> @d u_part(#)==mem[#+height_offset].int {pointer to \<u_j> token list}
> @d v_part(#)==mem[#+depth_offset].int {pointer to \<v_j> token list}
12339,12341c15146,15152
< spanned columns; and the |align_state| variable, which indicates the nesting
< of braces so that \.{\\cr} and \.{\\span} and tab marks are properly
< intercepted.
---
> spanned columns; a |cur_loop| pointer, indicating the tabskip glue before
> an alignrecord that should be copied next if the current list is extended;
> and the |align_state| variable, which indicates the nesting of braces so
> that \.{\\cr} and \.{\\span} and tab marks are properly intercepted.
> There also are pointers |cur_head| and |cur_tail| to the head and tail
> of a list of adjustments being moved out from horizontal mode to
> vertical~mode.
12343,12344c15154,15155
< The current values of these four quantities appear in global variables;
< when they have to be pushed down, they are stored in 3-word nodes, and
---
> The current values of these seven quantities appear in global variables;
> when they have to be pushed down, they are stored in 5-word nodes, and
12348c15159
< @d align_stack_node_size=3 {number of |mem| words to save alignment states}
---
> @d align_stack_node_size=5 {number of |mem| words to save alignment states}
12352a15164
> @!cur_loop:pointer; {place to copy when extending a periodic preamble}
12353a15166
> @!cur_head,@!cur_tail:pointer; {adjustment list pointers}
12358c15171,15172
< align_ptr←null; cur_align←null; cur_span←null;
---
> align_ptr:=null; cur_align:=null; cur_span:=null; cur_loop:=null;
> cur_head:=null; cur_tail:=null;
12365,12368c15179,15185
< begin p←get_node(align_stack_node_size);
< link(p)←align_ptr; info(p)←cur_align;
< llink(p)←preamble; rlink(p)←cur_span;
< mem[p+2].int←align_state; align_ptr←p;
---
> begin p:=get_node(align_stack_node_size);
> link(p):=align_ptr; info(p):=cur_align;
> llink(p):=preamble; rlink(p):=cur_span;
> mem[p+2].int:=cur_loop; mem[p+3].int:=align_state;
> info(p+4):=cur_head; link(p+4):=cur_tail;
> align_ptr:=p;
> cur_head:=get_avail;
12373,12375c15190,15195
< begin p←align_ptr; align_state←mem[p+2].int;
< cur_span←rlink(p); preamble←llink(p);
< cur_align←info(p); align_ptr←link(p);
---
> begin free_avail(cur_head);
> p:=align_ptr;
> cur_tail:=link(p+4); cur_head:=info(p+4);
> align_state:=mem[p+3].int; cur_loop:=mem[p+2].int;
> cur_span:=rlink(p); preamble:=llink(p);
> cur_align:=info(p); align_ptr:=link(p);
12399c15219
< procedure@?off_save; forward;@t\2@>@/
---
> procedure@?normal_paragraph; forward;@t\2@>@/
12404,12405c15224,15225
< begin save_cs_ptr←cs_ptr; {\.{\\halign} or \.{\\valign}, usually}
< push_alignment; align_state←-1000000; {enter a new alignment level}
---
> begin save_cs_ptr:=cur_cs; {\.{\\halign} or \.{\\valign}, usually}
> push_alignment; align_state:=-1000000; {enter a new alignment level}
12409c15229
< scan_spec; new_save_level(align_group);
---
> scan_spec(align_group,false);@/
12410a15231,15232
> new_save_level(align_group);
> if every_cr<>null then begin_token_list(every_cr,every_cr_text);
12421,12425c15243,15245
< begin mode←-vmode; prev_depth←nest[nest_ptr-2].aux_field;
< end
< else begin if mode>0 then mode←-mode;
< if mode=-hmode then space_factor←1000;
< end
---
> begin mode:=-vmode; prev_depth:=nest[nest_ptr-2].aux_field.sc;
> end
> else if mode>0 then negate(mode)
12428,12430c15248
< no other pieces of mlists present. Incomplete mlists need to be
< deleted; and we must convert them to hlists first, since the
< |flush_node_list| procedure doesn't know about noads.
---
> no other pieces of mlists present.
12433,12445c15251,15258
< if (mode=mmode)∧((tail≠head)∨(incompleat_noad≠null)) then
< begin print_nl("! Improper \halign");
< @.Improper \\halign@>
< help3("Displays can use special alignments (like \eqalignno)")@/
< ("only if nothing but the alignment itself is between $$'s.")@/
< ("So I've deleted the formulas that preceded this alignment.");
< error;@/
< cur_style←display_style; mlist_penalties←false;
< cur_mlist←link(head); mlist_to_hlist; flush_node_list(link(temp_head));@/
< cur_style←display_style; cur_mlist←incompleat_noad;
< mlist_to_hlist; {|mlist_penalties=true|}
< flush_node_list(link(temp_head));
< end
---
> if (mode=mmode)and((tail<>head)or(incompleat_noad<>null)) then
> begin print_err("Improper "); print_esc("halign"); print(" inside $$'s");
> @.Improper \\halign...@>
> help3("Displays can use special alignments (like \eqalignno)")@/
> ("only if nothing but the alignment itself is between $$'s.")@/
> ("So I've deleted the formulas that preceded this alignment.");
> error; flush_math;
> end
12448,12457c15261,15270
< preamble←null; cur_align←align_head; scanner_status←aligning;
< warning_index←save_cs_ptr;
< {at this point, |cur_cmd=left_brace| and |align_state=-999999|}
< loop@+ begin @<Append the current tabskip glue to the preamble list@>;
< if cur_cmd=car_ret then goto done; {\.{\\cr} ends the preamble}
< @<Scan preamble text until |cur_cmd| is |tab_mark| or |car_ret|,
< looking for changes in the tabskip glue; append an
< alignrecord to the preamble list@>;
< end;
< done: scanner_status←normal
---
> preamble:=null; cur_align:=align_head; cur_loop:=null; scanner_status:=aligning;
> warning_index:=save_cs_ptr; align_state:=-1000000;
> {at this point, |cur_cmd=left_brace|}
> loop@+ begin @<Append the current tabskip glue to the preamble list@>;
> if cur_cmd=car_ret then goto done; {\.{\\cr} ends the preamble}
> @<Scan preamble text until |cur_cmd| is |tab_mark| or |car_ret|,
> looking for changes in the tabskip glue; append an
> alignrecord to the preamble list@>;
> end;
> done: scanner_status:=normal
12460,12461c15273,15274
< link(cur_align)←new_param_glue(tab_skip_code);
< cur_align←link(cur_align)
---
> link(cur_align):=new_param_glue(tab_skip_code);
> cur_align:=link(cur_align)
12464,12469c15277,15282
< @<Scan the template \<u↓j>, putting the resulting token list in |hold_head|@>;
< link(cur_align)←new_null_box; cur_align←link(cur_align); {a new alignrecord}
< info(cur_align)←end_span; width(cur_align)←null_flag;
< u_part(cur_align)←link(hold_head);
< @<Scan the template \<v↓j>, putting the resulting token list in |hold_head|@>;
< v_part(cur_align)←link(hold_head)
---
> @<Scan the template \<u_j>, putting the resulting token list in |hold_head|@>;
> link(cur_align):=new_null_box; cur_align:=link(cur_align); {a new alignrecord}
> info(cur_align):=end_span; width(cur_align):=null_flag;
> u_part(cur_align):=link(hold_head);
> @<Scan the template \<v_j>, putting the resulting token list in |hold_head|@>;
> v_part(cur_align):=link(hold_head)
12472c15285
< and with |span_code| as the operand modifier. This makes \TeX\ interpret it
---
> and with |span_code| as the command modifier. This makes \TeX\ interpret it
12475c15288,15289
< It also turns out to be useful to give a special |cr_code| to `\.{\\cr}'.
---
> It also turns out to be useful to give a special |cr_code| to `\.{\\cr}',
> and an even larger |cr_cr_code| to `\.{\\crcr}'.
12477,12478c15291,15300
< @d span_code=128 {distinct from any character}
< @d cr_code=129 {distinct from |span_code| and from any character}
---
> The end of a template is represented by two ``frozen'' control sequences
> called \.{\\endtemplate}. The first has the command code |end_template|, which
> is |>outer_call|, so it will not easily disappear in the presence of errors.
> The |get_x_token| routine converts the first into the second, which has |endv|
> as its command code.
>
> @d span_code=256 {distinct from any character}
> @d cr_code=257 {distinct from |span_code| and from any character}
> @d cr_cr_code=cr_code+1 {this distinguishes \.{\\crcr} from \.{\\cr}}
> @d end_template_token==cs_token_flag+frozen_end_template
12481c15303
< primitive("span",tab_mark,span_code);
---
> primitive("span",tab_mark,span_code);@/
12484a15307,15314
> text(frozen_cr):="cr"; eqtb[frozen_cr]:=eqtb[cur_val];@/
> primitive("crcr",car_ret,cr_cr_code);
> @!@:cr_cr_}{\.{\\crcr} primitive@>
> text(frozen_end_template):="endtemplate"; text(frozen_endv):="endtemplate";
> eq_type(frozen_endv):=endv; equiv(frozen_endv):=null_list;
> eq_level(frozen_endv):=level_one;@/
> eqtb[frozen_end_template]:=eqtb[frozen_endv];
> eq_type(frozen_end_template):=end_template;
12486c15316,15322
< @ The preamble is copied directly, except that \.{\\tabskip} causes a change
---
> @ @<Cases of |print_cmd_chr|...@>=
> tab_mark: if chr_code=span_code then print_esc("span")
> else chr_cmd("alignment tab character ");
> car_ret: if chr_code=cr_code then print_esc("cr")
> else print_esc("crcr");
>
> @ The preamble is copied directly, except that \.{\\tabskip} causes a change
12488c15324
< follow it.
---
> follow it. An appearance of \.{\\span} also causes such an expansion.
12496,12509c15332,15348
< label reswitch;
< begin reswitch: get_token;
< if (cur_cmd=assign_glue)∧(cur_chr=tab_skip_code) then
< begin scan_optional_equals; scan_glue(false);
< eq_define(glue_base+tab_skip_code,glue_ref,cur_val);
< goto reswitch;
< end;
< if (cur_chr=span_code)∧(cur_cmd=tab_mark) then
< begin print_nl("! Illegal preamble");
< @.Illegal preamble@>
< help2("You mustn't say \span in an alignment until after the \cr")@/
< ("that ends the preamble. But proceed; I'll ignore this \span.");@/
< error; goto reswitch;
< end;
---
> label restart;
> begin restart: get_token;
> while (cur_chr=span_code)and(cur_cmd=tab_mark) do
> begin get_token; {this token will be expanded once}
> if cur_cmd>max_command then
> begin expand; get_token;
> end;
> end;
> if cur_cmd=endv then
> fatal_error("(interwoven alignment preambles are not allowed)");
> @.interwoven alignment preambles...@>
> if (cur_cmd=assign_glue)and(cur_chr=glue_base+tab_skip_code) then
> begin scan_optional_equals; scan_glue(glue_val);
> if global_defs>0 then geq_define(glue_base+tab_skip_code,glue_ref,cur_val)
> else eq_define(glue_base+tab_skip_code,glue_ref,cur_val);
> goto restart;
> end;
12514,12529c15353,15370
< @<Scan the template \<u↓j>...@>=
< p←hold_head; link(p)←null;
< loop@+ begin get_preamble_token;
< if cur_cmd=mac_param then goto done1;
< if (cur_cmd≤car_ret)∧(cur_cmd≥tab_mark) then
< begin print_nl("! Missing # inserted in alignment preamble");
< @.Missing {\#} inserted...@>
< help3("There should be exactly one # between &'s, when an")@/
< ("\halign or \valign is being set up. In this case you had")@/
< ("none, so I've put one in; maybe that will work.");
< back_error; goto done1;
< end;
< if (cur_cmd≠spacer)∨(p≠hold_head) then
< begin link(p)←get_avail; p←link(p); info(p)←cur_tok;
< end;
< end;
---
> @<Scan the template \<u_j>...@>=
> p:=hold_head; link(p):=null;
> loop@+ begin get_preamble_token;
> if cur_cmd=mac_param then goto done1;
> if (cur_cmd<=car_ret)and(cur_cmd>=tab_mark)and(align_state=-1000000) then
> if (p=hold_head)and(cur_loop=null)and(cur_cmd=tab_mark)
> then cur_loop:=cur_align
> else begin print_err("Missing # inserted in alignment preamble");
> @.Missing \# inserted...@>
> help3("There should be exactly one # between &'s, when an")@/
> ("\halign or \valign is being set up. In this case you had")@/
> ("none, so I've put one in; maybe that will work.");
> back_error; goto done1;
> end
> else if (cur_cmd<>spacer)or(p<>hold_head) then
> begin link(p):=get_avail; p:=link(p); info(p):=cur_tok;
> end;
> end;
12532,12548c15373,15389
< @ @<Scan the template \<v↓j>...@>=
< p←hold_head; link(p)←null;
< loop@+ begin continue: get_preamble_token;
< if (cur_cmd≤car_ret)∧(cur_cmd≥tab_mark)∧(align_state=-1000000) then
< goto done2;
< if cur_cmd=mac_param then
< begin print_nl("! Only one # is allowed per tab");
< @.Only one {\#} is allowed...@>
< help3("There should be exactly one # between &'s, when an")@/
< ("\halign or \valign is being set up. In this case you had")@/
< ("more than one, so I'm ignoring all but the first.");
< goto continue;
< end;
< link(p)←get_avail; p←link(p); info(p)←cur_tok;
< end;
< done2: link(p)←get_avail; p←link(p);
< info(p)←endv_token {put |endv| at the end}
---
> @ @<Scan the template \<v_j>...@>=
> p:=hold_head; link(p):=null;
> loop@+ begin continue: get_preamble_token;
> if (cur_cmd<=car_ret)and(cur_cmd>=tab_mark)and(align_state=-1000000) then
> goto done2;
> if cur_cmd=mac_param then
> begin print_err("Only one # is allowed per tab");
> @.Only one \# is allowed...@>
> help3("There should be exactly one # between &'s, when an")@/
> ("\halign or \valign is being set up. In this case you had")@/
> ("more than one, so I'm ignoring all but the first.");
> error; goto continue;
> end;
> link(p):=get_avail; p:=link(p); info(p):=cur_tok;
> end;
> done2: link(p):=get_avail; p:=link(p);
> info(p):=end_template_token {put \.{\\endtemplate} at the end}
12562c15403,15404
< begin @<Get the next non-blank non-call token@>;
---
> label restart;
> begin restart: align_state:=1000000; @<Get the next non-blank non-call token@>;
12564,12565c15406,15408
< begin scan_left_brace; new_save_level(no_align_group);
< end
---
> begin scan_left_brace; new_save_level(no_align_group);
> if mode=-vmode then normal_paragraph;
> end
12567,12569c15410,15414
< else begin init_row; {start a new row}
< init_col; {start a new column and replace what we peeked at}
< end;
---
> else if (cur_cmd=car_ret)and(cur_chr=cr_cr_code) then
> goto restart {ignore \.{\\crcr}}
> else begin init_row; {start a new row}
> init_col; {start a new column and replace what we peeked at}
> end;
12574a15420,15421
> The |space_factor| and |prev_depth| are not used on this semantic level,
> but we clear them to zero just to be tidy.
12578c15425,15426
< begin push_nest; mode←(-hmode-vmode)-mode;
---
> begin push_nest; mode:=(-hmode-vmode)-mode;
> if mode=-hmode then space_factor:=0 @+else prev_depth:=0;
12580,12581c15428,15429
< subtype(tail)←tab_skip_code+1;@/
< cur_align←link(preamble); init_span(cur_align);
---
> subtype(tail):=tab_skip_code+1;@/
> cur_align:=link(preamble); cur_tail:=cur_head; init_span(cur_align);
12591,12593c15439,15442
< if mode=-vmode then prev_depth←ignore_depth
< else space_factor←1000;
< cur_span←p;
---
> if mode=-hmode then space_factor:=1000
> else begin prev_depth:=ignore_depth; normal_paragraph;
> end;
> cur_span:=p;
12597,12599c15446,15450
< the current token should be put back into the input until the \<u↓j> template
< has been scanned. We remain in the same mode, and start the template if
< it is called for.
---
> the current token should be put back into the input until the \<u_j>
> template has been scanned. (Note that |cur_cmd| might be |tab_mark| or
> |car_ret|.) We also assume that |align_state| is approximately 1000000 at
> this time. We remain in the same mode, and start the template if it is
> called for.
12602,12606c15453,15456
< begin extra_info(cur_align)←cur_cmd;
< if cur_cmd=omit then align_state←0
< else begin back_input; begin_token_list(u_part(cur_align),u_template);
< align_state←1000000;
< end;
---
> begin extra_info(cur_align):=cur_cmd;
> if cur_cmd=omit then align_state:=0
> else begin back_input; begin_token_list(u_part(cur_align),u_template);
> end; {now |align_state=1000000|}
12609c15459
< @ The scanner sets |align_state| to zero when the \<u↓j> template ends. When
---
> @ The scanner sets |align_state| to zero when the \<u_j> template ends. When
12611,12616c15461,15472
< the scanner activates the following code, which fires up the \<v↓j> template.
< We need to remember the |cur_chr|, which is either |cr_code|, |span_code|,
< or a character code, depending on how the column text has ended.
<
< @<Insert the \(v)\<v↓j>...@>=
< begin cur_cmd←extra_info(cur_align); extra_info(cur_align)←cur_chr;
---
> the scanner activates the following code, which fires up the \<v_j> template.
> We need to remember the |cur_chr|, which is either |cr_cr_code|, |cr_code|,
> |span_code|, or a character code, depending on how the column text has ended.
>
> This part of the program had better not be activated when the preamble
> to another alignment is being scanned, or when no alignment preamble is active.
>
> @<Insert the \(v)\<v_j>...@>=
> begin if (scanner_status=aligning) or (cur_align=null) then
> fatal_error("(interwoven alignment preambles are not allowed)");
> @.interwoven alignment preambles...@>
> cur_cmd:=extra_info(cur_align); extra_info(cur_align):=cur_chr;
12619c15475
< align_state←1000000; goto restart;
---
> align_state:=1000000; goto restart;
12623c15479
< list that contains |endv| only.
---
> list that contains the special control sequence \.{\\endtemplate} only.
12626c15482
< info(omit_template)←endv_token; {|link(omit_template)=null|}
---
> info(omit_template):=end_template_token; {|link(omit_template)=null|}
12628c15484
< @ When the |endv| token at the end of a \<v↓j> template comes through the
---
> @ When the |endv| command at the end of a \<v_j> template comes through the
12636c15492
< @!q:pointer; {runs through spanned alignrecords and span nodes}
---
> @!q,@!r:pointer; {temporary pointers for list manipulation}
12642,12644c15498,15504
< begin if (cur_align=null)∨(link(cur_align)=null) then confusion("endv");
< @:confusion endv}{\quad endv@>
< p←link(link(cur_align));
---
> begin if cur_align=null then confusion("endv");
> q:=link(cur_align);@+if q=null then confusion("endv");
> @:this can't happen endv}{\quad endv@>
> if align_state<500000 then
> fatal_error("(interwoven alignment preambles are not allowed)");
> @.interwoven alignment preambles...@>
> p:=link(q);
12646,12657c15506,15517
< if extra_info(cur_align)≠span_code then
< begin @<Package an unset box for the current column and
< record its width@>;
< @<Copy the tabskip glue between columns@>;
< if extra_info(cur_align)=cr_code then
< @<Package any omitted columns as dummies,
< then |return| with |fin_col=true|@>;
< init_span(p);
< end;
< @<Get the next non-blank non-call token@>;
< cur_align←p;
< init_col; fin_col←false;
---
> if extra_info(cur_align)<>span_code then
> begin unsave; new_save_level(align_group);@/
> @<Package an unset box for the current column and record its width@>;
> @<Copy the tabskip glue between columns@>;
> if extra_info(cur_align)>=cr_code then
> begin fin_col:=true; return;
> end;
> init_span(p);
> end;
> align_state:=1000000; @<Get the next non-blank non-call token@>;
> cur_align:=p;
> init_col; fin_col:=false;
12661,12662c15521,15523
< if (p=null)∧(extra_info(cur_align)≠cr_code) then
< begin print_nl("! Extra alignment tab has been changed to \cr");
---
> if (p=null)and(extra_info(cur_align)<cr_code) then
> if cur_loop<>null then @<Lengthen the preamble periodically@>
> else begin print_err("Extra alignment tab has been changed to ");
12664,12668c15525,15550
< help3("You have given more \span or & marks than there were")@/
< ("in the preamble to the \halign or \valign now in progress.")@/
< ("So I'll assume that you meant to type \cr instead.");
< extra_info(cur_align)←cr_code; error;
< end
---
> print_esc("cr");
> help3("You have given more \span or & marks than there were")@/
> ("in the preamble to the \halign or \valign now in progress.")@/
> ("So I'll assume that you meant to type \cr instead.");
> extra_info(cur_align):=cr_code; error;
> end
>
> @ @<Lengthen the preamble...@>=
> begin link(q):=new_null_box; p:=link(q); {a new alignrecord}
> info(p):=end_span; width(p):=null_flag; cur_loop:=link(cur_loop);
> @<Copy the templates from node |cur_loop| into node |p|@>;
> cur_loop:=link(cur_loop);
> link(p):=new_glue(glue_ptr(cur_loop));
> end
>
> @ @<Copy the templates from node |cur_loop| into node |p|@>=
> q:=hold_head; r:=u_part(cur_loop);
> while r<>null do
> begin link(q):=get_avail; q:=link(q); info(q):=info(r); r:=link(r);
> end;
> link(q):=null; u_part(p):=link(hold_head);
> q:=hold_head; r:=v_part(cur_loop);
> while r<>null do
> begin link(q):=get_avail; q:=link(q); info(q):=info(r); r:=link(r);
> end;
> link(q):=null; v_part(p):=link(hold_head)
12672,12684c15554
< subtype(tail)←tab_skip_code+1
<
< @ @<Package any omitted columns...@>=
< begin cur_align←p;
< while cur_align≠null do
< begin tail_append(new_null_box);
< type(tail)←unset_node;
< if width(cur_align)<0 then width(cur_align)←0;
< @<Copy the tabskip glue...@>;
< cur_align←link(link(cur_align));
< end;
< fin_col←true; return;
< end
---
> subtype(tail):=tab_skip_code+1
12688,12695c15558,15566
< begin u←hpack(head,natural); w←width(u);
< end
< else begin u←vpackage(head,natural,0); w←height(u);
< end;
< n←min_quarterword; {this represents a span count of 1}
< if cur_span≠cur_align then @<Update width entry for spanned columns@>
< else if w>width(cur_align) then width(cur_align)←w;
< type(u)←unset_node; span_count(u)←n;@/
---
> begin adjust_tail:=cur_tail; u:=hpack(link(head),natural); w:=width(u);
> cur_tail:=adjust_tail; adjust_tail:=null;
> end
> else begin u:=vpackage(link(head),natural,0); w:=height(u);
> end;
> n:=min_quarterword; {this represents a span count of 1}
> if cur_span<>cur_align then @<Update width entry for spanned columns@>
> else if w>width(cur_align) then width(cur_align):=w;
> type(u):=unset_node; span_count(u):=n;@/
12697c15568
< glue_order(u)←o; glue_stretch(u)←total_stretch[o];@/
---
> glue_order(u):=o; glue_stretch(u):=total_stretch[o];@/
12699,12700c15570,15571
< glue_sign(u)←o; glue_shrink(u)←total_shrink[o];@/
< pop_nest; link(tail)←u; tail←u;
---
> glue_sign(u):=o; glue_shrink(u):=total_shrink[o];@/
> pop_nest; link(tail):=u; tail:=u;
12703c15574
< @ A span node is a 2-word record contining |width|, |info|, and |link|
---
> @ A span node is a 2-word record containing |width|, |info|, and |link|
12717c15588
< link(end_span)←max_quarterword+1; info(end_span)←null;
---
> link(end_span):=max_quarterword+1; info(end_span):=null;
12720,12721c15591,15592
< q←cur_span;
< repeat incr(n); q←link(link(q));
---
> begin q:=cur_span;
> repeat incr(n); q:=link(link(q));
12724,12725c15595,15597
< @:confusion 256 spans}{\quad 256 spans@>
< q←cur_span; while link(info(q))<n do q←info(q);
---
> @^system dependencies@>
> @:this can't happen 256 spans}{\quad 256 spans@>
> q:=cur_span; while link(info(q))<n do q:=info(q);
12727,12730c15599,15603
< begin s←get_node(span_node_size); info(s)←info(q); link(s)←n;
< info(q)←s; width(s)←w;
< end
< else if width(info(q))<w then width(info(q))←w
---
> begin s:=get_node(span_node_size); info(s):=info(q); link(s):=n;
> info(q):=s; width(s):=w;
> end
> else if width(info(q))<w then width(info(q)):=w;
> end
12740,12745c15613,15623
< begin p←hpack(link(head),natural); pop_nest; append_to_vlist(p);
< end
< else begin p←vpack(link(head),natural); pop_nest;
< link(tail)←p; tail←p; space_factor←1000;
< end;
< type(p)←unset_node; glue_stretch(p)←0;
---
> begin p:=hpack(link(head),natural);
> pop_nest; append_to_vlist(p);
> if cur_head<>cur_tail then
> begin link(tail):=link(cur_head); tail:=cur_tail;
> end;
> end
> else begin p:=vpack(link(head),natural); pop_nest;
> link(tail):=p; tail:=p; space_factor:=1000;
> end;
> type(p):=unset_node; glue_stretch(p):=0;
> if every_cr<>null then begin_token_list(every_cr,every_cr_text);
12747c15625
< end;
---
> end; {note that |glue_shrink(p)=0| since |glue_shrink==shift_amount|}
12757,12758c15635,15637
< var @!p,@!q,@!r,@!s,@!u: pointer; {registers for the list operations}
< @!t:scaled; {width of column plus tabskip}
---
> var @!p,@!q,@!r,@!s,@!u,@!v: pointer; {registers for the list operations}
> @!t,@!w:scaled; {width of column}
> @!o:scaled; {shift offset for unset boxes}
12760,12762c15639,15647
< begin if cur_group≠align_group then confusion("align");
< @:confusion align}{\quad align@>
< unsave;@/
---
> @!rule_save:scaled; {temporary storage for |overfull_rule|}
> @!aux_save:memory_word; {temporary storage for |aux|}
> begin if cur_group<>align_group then confusion("align1");
> @:this can't happen align}{\quad align@>
> unsave; {that |align_group| was for individual entries}
> if cur_group<>align_group then confusion("align0");
> unsave; {that |align_group| was for the whole alignment}
> if nest[nest_ptr-1].mode_field=mmode then o:=display_indent
> else o:=0;
12764c15649
< changing the alignrecords to dummy unset boxes@>;
---
> changing the alignrecords to dummy unset boxes@>;
12766c15651
< and let |p| point to this prototype box@>;
---
> and let |p| point to this prototype box@>;
12771c15656
< @<Declare the procedure called |align_peek|@>
---
> @t\4@>@<Declare the procedure called |align_peek|@>
12774,12779c15659,15664
< widths. Let $w↓{ij}$ be the maximum of the natural widths of all entries
< that span columns $i$ through $j$, inclusive. The alignrecord for column@@$i$
< contains $w↓{ii}$ in its |width| field, and there is also a linked list of
< the nonzero $w↓{ij}$ for increasing $j$, accessible via the |info| field;
< these span nodes contain the value $j-i-1+|min_quarterword|$ in their
< |link| fields. The values of $w↓{ii}$ were initialized to |null_flag|, which
---
> widths. Let $w_{ij}$ be the maximum of the natural widths of all entries
> that span columns $i$ through $j$, inclusive. The alignrecord for column~$i$
> contains $w_{ii}$ in its |width| field, and there is also a linked list of
> the nonzero $w_{ij}$ for increasing $j$, accessible via the |info| field;
> these span nodes contain the value $j-i+|min_quarterword|$ in their
> |link| fields. The values of $w_{ii}$ were initialized to |null_flag|, which
12783,12793c15668,15679
< $$w↓j=\max↓{1\L i\L j}\bigglp(w↓{ij}-\sum↓{i\L k<j}(t↓k+w↓k)\biggrp,$$
< where $t↓k$ is the natural width of the tabskip glue between columns
< $k$ and@@$k+1$. However, if $w↓{ij}=-\infty$ for all |i| in the range
< |1≤i≤j| (i.e., if every entry that involved column@@|j| also involved
< column@@|j+1|), we let $w↓j=0$.
<
< \TeX\ computes these values by using the following scheme: First $w↓1=w↓{11}$.
< Then replace $w↓{2j}$ by $\max(w↓{2j},w↓{1j}-t↓1-w↓1)$, for all $j>1$.
< Then $w↓2=w↓{22}$. Then replace $w↓{3j}$ by $\max(w↓{3j},w↓{2j}-t↓2-w↓2)$
< for all $j>2$; and so on. If any $w↓j$ turns out to be $-\infty$, its
< value is changed to zero.
---
> $$w_j=\max_{1\L i\L j}\biggl( w_{ij}-\sum_{i\L k<j}(t_k+w_k)\biggr),$$
> where $t_k$ is the natural width of the tabskip glue between columns
> $k$ and~$k+1$. However, if $w_{ij}=-\infty$ for all |i| in the range
> |1<=i<=j| (i.e., if every entry that involved column~|j| also involved
> column~|j+1|), we let $w_j=0$, and we zero out the tabskip glue after
> column~|j|.
>
> \TeX\ computes these values by using the following scheme: First $w_1=w_{11}$.
> Then replace $w_{2j}$ by $\max(w_{2j},w_{1j}-t_1-w_1)$, for all $j>1$.
> Then $w_2=w_{22}$. Then replace $w_{3j}$ by $\max(w_{3j},w_{2j}-t_2-w_2)$
> for all $j>2$; and so on. If any $w_j$ turns out to be $-\infty$, its
> value is changed to zero and so is the next tabskip.
12796c15682
< q←link(preamble);
---
> q:=link(preamble);
12798,12804c15684,15692
< p←link(link(q));
< if width(q)=null_flag then width(q)←0;
< if (p≠null)∧(info(q)≠end_span) then
< @<Merge the widths in the span nodes of |q| with those of |p|,
< destroying the span nodes of |q|@>;
< type(q)←unset_node; span_count(q)←min_quarterword; height(q)←width(q);
< depth(q)←0; glue_order(q)←normal; glue_sign(q)←normal; q←p;
---
> p:=link(link(q));
> if width(q)=null_flag then
> @<Nullify |width(q)| and the tabskip glue following this column@>;
> if info(q)<>end_span then
> @<Merge the widths in the span nodes of |q| with those of |p|,
> destroying the span nodes of |q|@>;
> type(q):=unset_node; span_count(q):=min_quarterword; height(q):=0;
> depth(q):=0; glue_order(q):=normal; glue_sign(q):=normal;
> glue_stretch(q):=0; glue_shrink(q):=0; q:=p;
12806a15695,15702
> @ @<Nullify |width(q)| and the tabskip glue following this column@>=
> begin width(q):=0; r:=link(q); s:=glue_ptr(r);
> if s<>zero_glue then
> begin add_glue_ref(zero_glue); delete_glue_ref(s);
> glue_ptr(r):=zero_glue;
> end;
> end
>
12815,12817c15711,15713
< begin t←width(q)+width(glue_ptr(link(q)));
< r←info(q); s←end_span; info(s)←p; n←min_quarterword+1;
< repeat width(r)←width(r)-t; u←info(r);
---
> begin t:=width(q)+width(glue_ptr(link(q)));
> r:=info(q); s:=end_span; info(s):=p; n:=min_quarterword+1;
> repeat width(r):=width(r)-t; u:=info(r);
12819,12820c15715,15716
< begin s←info(s); n←link(info(s))+1;
< end;
---
> begin s:=info(s); n:=link(info(s))+1;
> end;
12822,12827c15718,15723
< begin info(r)←info(s); info(s)←r; decr(link(r)); s←r;
< end
< else begin if width(r)>width(info(s)) then width(info(s))←width(r);
< free_node(r,span_node_size);
< end;
< r←u;
---
> begin info(r):=info(s); info(s):=r; decr(link(r)); s:=r;
> end
> else begin if width(r)>width(info(s)) then width(info(s)):=width(r);
> free_node(r,span_node_size);
> end;
> r:=u;
12832,12837c15728,15731
< boxes and tabskip glue, where the box heights and widths are both equal
< to the final column sizes. This list is both an hlist and a vlist, and
< both |hpack| and |vpack| will set its glue in the same way; but we should
< choose the correct alternative, because it is important to produce the
< correct error messages when an alignment is overfull or underfull.
< The following program changes the tabskip amounts to equivalent kerns.
---
> boxes and tabskip glue, where the box widths are equal to the final
> column sizes. In case of \.{\\valign}, we change the widths to heights,
> so that a correct error message will be produced if the alignment is
> overfull or underfull.
12840,12853c15734,15748
< save_ptr←save_ptr-2;
< if mode=-hmode then
< p←hpack(preamble,saved(1),saved(0))
< else p←vpack(preamble,saved(1),saved(0));
< q←p+list_offset;
< repeat q←link(q); r←glue_ptr(q); type(q)←kern_node; subtype(q)←normal;
< if glue_sign(p)=normal then width(q)←width(r)
< else if glue_sign(p)=stretching then
< if stretch_order(r)≠glue_order(p) then width(q)←width(r)
< else width(q)←width(q)+round(glue_set(p)*stretch(r))
< else if shrink_order(r)≠glue_order(p) then width(q)←width(r)
< else width(q)←width(q)-round(glue_set(p)*shrink(r));
< delete_glue_ref(r); q←link(q);
< until q=null
---
> save_ptr:=save_ptr-2; pack_begin_line:=-mode_line;
> if mode=-vmode then
> begin rule_save:=overfull_rule;
> overfull_rule:=0; {prevent rule from being packaged}
> p:=hpack(preamble,saved(1),saved(0)); overfull_rule:=rule_save;
> end
> else begin q:=link(preamble);
> repeat height(q):=width(q); width(q):=0; q:=link(link(q));
> until q=null;
> p:=vpack(preamble,saved(1),saved(0));
> q:=link(preamble);
> repeat width(q):=height(q); height(q):=0; q:=link(link(q));
> until q=null;
> end;
> pack_begin_line:=0
12856,12861c15751,15773
< q←link(head);
< while q≠null do
< begin if type(q)=unset_node then
< @<Set the unset box |q| and the unset boxes in it@>;
< q←link(q);
< end
---
> q:=link(head); s:=head;
> while q<>null do
> begin if not is_char_node(q) then
> if type(q)=unset_node then
> @<Set the unset box |q| and the unset boxes in it@>
> else if type(q)=rule_node then
> @<Make the running dimensions in rule |q| extend to the
> boundaries of the alignment@>;
> s:=q; q:=link(q);
> end
>
> @ @<Make the running dimensions in rule |q| extend...@>=
> begin if is_running(width(q)) then width(q):=width(p);
> if is_running(height(q)) then height(q):=height(p);
> if is_running(depth(q)) then depth(q):=depth(p);
> if o<>0 then
> begin r:=link(q); link(q):=null; q:=hpack(q,natural);
> shift_amount(q):=o; link(q):=r; link(s):=q;
> end;
> end
>
> @ The unset box |q| represents a row that contains one or more unset boxes,
> depending on how soon \.{\\cr} occurred in that row.
12863c15775
< @ @<Set the unset box |q| and the unset boxes in it@>=
---
> @<Set the unset box |q| and the unset boxes in it@>=
12865,12871c15777,15783
< begin type(q)←hlist_node; width(q)←width(p);
< end
< else begin type(q)←vlist_node; height(q)←height(p);
< end;
< glue_order(q)←glue_order(p); glue_sign(q)←glue_sign(p);
< glue_set(q)←glue_set(p); shift_amount(q)←0;@/
< r←link(list_ptr(q)); s←link(list_ptr(p));
---
> begin type(q):=hlist_node; width(q):=width(p);
> end
> else begin type(q):=vlist_node; height(q):=height(p);
> end;
> glue_order(q):=glue_order(p); glue_sign(q):=glue_sign(p);
> glue_set(q):=glue_set(p); shift_amount(q):=o;
> r:=link(list_ptr(q)); s:=link(list_ptr(p));
12873c15785
< r←link(link(r)); s←link(link(s));
---
> r:=link(link(r)); s:=link(link(s));
12877,12878c15789,15795
< @ @<Set the glue in node |r|...@>=
< n←span_count(r); t←width(s);
---
> @ A box made from spanned columns will be followed by tabskip glue nodes and
> by empty boxes as if there were no spanning. This permits perfect alignment
> of subsequent entries, and it prevents values that depend on floating point
> arithmetic from entering into the dimensions of any boxes.
>
> @<Set the glue in node |r|...@>=
> n:=span_count(r); t:=width(s); w:=t; u:=hold_head;
12880,12882c15797,15800
< begin decr(n); s←link(s); t←t+width(s);
< s←link(s); t←t+width(s);
< end;
---
> begin decr(n);
> @<Append tabskip glue and an empty box to list |u|,
> and update |s| and |t| as the prototype nodes are passed@>;
> end;
12884,12886c15802,15826
< @<Make the unset node |r| into an |hlist_node| of width |t|@>
< else @<Make the unset node |r| into a |vlist_node| of height |t|@>;
< shift_amount(r)←0;
---
> @<Make the unset node |r| into an |hlist_node| of width |w|,
> setting the glue as if the width were |t|@>
> else @<Make the unset node |r| into a |vlist_node| of height |w|,
> setting the glue as if the height were |t|@>;
> shift_amount(r):=0;
> if u<>hold_head then {append blank boxes to account for spanned nodes}
> begin link(u):=link(r); link(r):=link(hold_head); r:=u;
> end
>
> @ @<Append tabskip glue and an empty box to list |u|...@>=
> s:=link(s); v:=glue_ptr(s); link(u):=new_glue(v); u:=link(u);
> subtype(u):=tab_skip_code+1; t:=t+width(v);
> if glue_sign(p)=stretching then
> begin if stretch_order(v)=glue_order(p) then
> t:=t+round(float(glue_set(p))*stretch(v));
> @^real multiplication@>
> end
> else if glue_sign(p)=shrinking then
> begin if shrink_order(v)=glue_order(p) then
> t:=t-round(float(glue_set(p))*shrink(v));
> end;
> s:=link(s); link(u):=new_null_box; u:=link(u); t:=t+width(s);
> if mode=-vmode then width(u):=width(s)@+else
> begin type(u):=vlist_node; height(u):=width(s);
> end
12888,12889c15828,15829
< @ @<Make the unset node |r| into an |hlist_node| of width |t|@>=
< begin height(r)←height(q); depth(r)←depth(q);
---
> @ @<Make the unset node |r| into an |hlist_node| of width |w|...@>=
> begin height(r):=height(q); depth(r):=depth(q);
12891,12893c15831,15833
< begin glue_sign(r)←normal; glue_order(r)←normal;
< glue_set(r)←0.0;
< end
---
> begin glue_sign(r):=normal; glue_order(r):=normal;
> set_glue_ratio_zero(glue_set(r));
> end
12895,12903c15835,15846
< begin glue_sign(r)←stretching;
< if glue_stretch(r)=0 then glue_set(r)←0.0
< else glue_set(r)←(t-width(r))/glue_stretch(r);
< end
< else begin glue_order(r)←glue_sign(r); glue_sign(r)←shrinking;
< if glue_shrink(r)=0 then glue_set(r)←0.0
< else glue_set(r)←(width(r)-t)/glue_shrink(r);
< end;
< width(r)←t; type(r)←hlist_node;
---
> begin glue_sign(r):=stretching;
> if glue_stretch(r)=0 then set_glue_ratio_zero(glue_set(r))
> else glue_set(r):=unfloat((t-width(r))/glue_stretch(r));
> @^real division@>
> end
> else begin glue_order(r):=glue_sign(r); glue_sign(r):=shrinking;
> if glue_shrink(r)=0 then set_glue_ratio_zero(glue_set(r))
> else if (glue_order(r)=normal)and(width(r)-t>glue_shrink(r)) then
> set_glue_ratio_one(glue_set(r))
> else glue_set(r):=unfloat((width(r)-t)/glue_shrink(r));
> end;
> width(r):=w; type(r):=hlist_node;
12906,12907c15849,15850
< @ @<Make the unset node |r| into a |vlist_node| of height |t|@>=
< begin width(r)←width(q);
---
> @ @<Make the unset node |r| into a |vlist_node| of height |w|...@>=
> begin width(r):=width(q);
12909,12911c15852,15854
< begin glue_sign(r)←normal; glue_order(r)←normal;
< glue_set(r)←0.0;
< end
---
> begin glue_sign(r):=normal; glue_order(r):=normal;
> set_glue_ratio_zero(glue_set(r));
> end
12913,12921c15856,15867
< begin glue_sign(r)←stretching;
< if glue_stretch(r)=0 then glue_set(r)←0.0
< else glue_set(r)←(t-height(r))/glue_stretch(r);
< end
< else begin glue_order(r)←glue_sign(r); glue_sign(r)←shrinking;
< if glue_shrink(r)=0 then glue_set(r)←0.0
< else glue_set(r)←(height(r)-t)/glue_shrink(r);
< end;
< height(r)←t; type(r)←vlist_node;
---
> begin glue_sign(r):=stretching;
> if glue_stretch(r)=0 then set_glue_ratio_zero(glue_set(r))
> else glue_set(r):=unfloat((t-height(r))/glue_stretch(r));
> @^real division@>
> end
> else begin glue_order(r):=glue_sign(r); glue_sign(r):=shrinking;
> if glue_shrink(r)=0 then set_glue_ratio_zero(glue_set(r))
> else if (glue_order(r)=normal)and(height(r)-t>glue_shrink(r)) then
> set_glue_ratio_one(glue_set(r))
> else glue_set(r):=unfloat((height(r)-t)/glue_shrink(r));
> end;
> height(r):=w; type(r):=vlist_node;
12927c15873,15878
< another routine will take care of inserting glue before and after the display.)
---
> we will need to insert glue before and after the display; that part of the
> program will be deferred until we're more familiar with such operations.)
>
> In restricted horizontal mode, the |clang| part of |aux| is undefined;
> an over-cautious \PASCAL\ runtime system may complain about this.
> @^dirty \PASCAL@>
12930c15881
< t←aux; p←link(head); q←tail; pop_nest;
---
> aux_save:=aux; p:=link(head); q:=tail; pop_nest;
12932,12936c15883,15888
< else begin aux←t; link(tail)←p;
< if q≠null then tail←q;
< if mode=vmode then build_page;
< end
< @* \[37] Breaking paragraphs into lines.
---
> else begin aux:=aux_save; link(tail):=p;
> if p<>null then tail:=q;
> if mode=vmode then build_page;
> end
>
> @* \[38] Breaking paragraphs into lines.
12957c15909
< new ideas to the algorithm of 1980: memory space requirements are considerably
---
> new ideas to the algorithm of 1980: Memory space requirements are considerably
12970c15922
< starts at |link(head)|, and it is nonempty. The value of |already| in the
---
> starts at |link(head)|, and it is nonempty. The value of |prev_graf| in the
12973c15925
< are in use; |already| is zero unless this paragraph is being continued
---
> is in use; |prev_graf| is zero unless this paragraph is being continued
12979c15931
< value of |already|. Furthermore, the global variable |just_box| will
---
> value of |prev_graf|. Furthermore, the global variable |just_box| will
12982c15934
< |disp_skip| or |disp_a_skip| before a displayed formula.
---
> |above_display_skip| or |above_display_short_skip| before a displayed formula.
12993,12996c15945,15948
< procedure line_break(@!final_widow_penalty:integer);
< label done,done1,done2,done3,done4;
< var@?@<Local variables for line breaking@>@;
< begin par_begin_line←mode_line; {this is for over/underfull box messages}
---
> procedure line_break(@!final_widow_penalty:integer);
> label done,done1,done2,done3,done4,done5,continue;
> var @<Local variables for line breaking@>@;
> begin pack_begin_line:=mode_line; {this is for over/underfull box messages}
13002c15954
< par_begin_line←0;
---
> pack_begin_line:=0;
13013c15965,15966
< same number of words in |mem|.
---
> same number of |mem|~words.
> @^data structure assumptions@>
13015,13016c15968,15969
< @<Get ready...@>=
< link(temp_head)←link(head);
---
> @<Get ready to start...@>=
> link(temp_head):=link(head);
13018,13023c15971,15978
< else if (type(tail)≠glue_node)∨(subtype(tail)≥a_leaders) then
< tail_append(new_penalty(inf_penalty))
< else begin type(tail)←penalty_node; delete_glue_ref(glue_ptr(tail));
< penalty(tail)←inf_penalty;
< end;
< link(tail)←new_param_glue(par_fill_skip_code);
---
> else if type(tail)<>glue_node then tail_append(new_penalty(inf_penalty))
> else begin type(tail):=penalty_node; delete_glue_ref(glue_ptr(tail));
> flush_node_list(leader_ptr(tail)); penalty(tail):=inf_penalty;
> end;
> link(tail):=new_param_glue(par_fill_skip_code);
> init_cur_lang:=prev_graf mod @'200000;
> init_l_hyf:=prev_graf div @'20000000;
> init_r_hyf:=(prev_graf div @'200000) mod @'100;
13035,13041c15990,15996
< @d tight_fit=0 {fitness classification for lines shrinking 0.5 to 1.0 of their
< shrinkability}
< @d loose_fit=2 {fitness classification for lines stretching 0.5 to 1.0 of their
< stretchability}
< @d very_loose_fit=3 {fitness classification for lines stretching more than
< their stretchability}
< @d decent_fit=1 {fitness classification for all other lines}
---
> @d tight_fit=3 {fitness classification for lines shrinking 0.5 to 1.0 of their
> shrinkability}
> @d loose_fit=1 {fitness classification for lines stretching 0.5 to 1.0 of their
> stretchability}
> @d very_loose_fit=0 {fitness classification for lines stretching more than
> their stretchability}
> @d decent_fit=2 {fitness classification for all other lines}
13073c16028
< \yskip\hang|type| is either |hyphenated| or |unhyphenated|, de\-pending on
---
> \yskip\hang|type| is either |hyphenated| or |unhyphenated|, depending on
13086c16041
< @d fitness==subtype {|tight_fit..very_loose_fit| on final line for this break}
---
> @d fitness==subtype {|very_loose_fit..tight_fit| on final line for this break}
13095,13096c16050,16051
< type(last_active)←hyphenated; line_number(last_active)←max_halfword;
< subtype(last_active)←0; {the |subtype| is never examined by the algorithm}
---
> type(last_active):=hyphenated; line_number(last_active):=max_halfword;
> subtype(last_active):=0; {the |subtype| is never examined by the algorithm}
13098c16053
< @ The passive node for a given breakpoint contains only three fields:
---
> @ The passive node for a given breakpoint contains only four fields:
13108a16064,16067
> \yskip\hang|serial| is equal to |n| if this passive node is the |n|th
> one created during the current pass. (This field is used only when
> printing out detailed statistics about the line-breaking calculations.)
>
13111c16070,16072
< recently created passive node.
---
> recently created passive node. Another global variable, |printed_node|,
> is used to help print out the paragraph when detailed information about
> the line-breaking computation is being displayed.
13114,13115c16075,16077
< @d cur_break==mark_ptr {in passive node, points to position of this breakpoint}
< @d prev_break==info {points to passive node that should precede this one}
---
> @d cur_break==rlink {in passive node, points to position of this breakpoint}
> @d prev_break==llink {points to passive node that should precede this one}
> @d serial==info {serial number for symbolic identification}
13118a16081,16082
> @!printed_node:pointer; {most recent node that has been printed}
> @!pass_number:halfword; {the number of passive nodes allocated on this pass}
13122c16086
< active nodes, and they have |type=delta|. If |p| and |r| are active nodes
---
> active nodes, and they have |type=delta_node|. If |p| and |r| are active nodes
13128c16092
< starts after |r| is obtained by adding the amounts in node@@|q|. A delta node
---
> starts after |r| is obtained by adding the amounts in node~|q|. A delta node
13146,13149c16110,16114
< When we pass a delta node we want to do operations like `\!|for k←1 to 6 do
< cur_active_width[k]←cur_active_width[k]+mem[q+k].sc|', and we want to
< do this without the overhead of |for| loops. The |do_all_six| macro
< makes such six-tuples convenient.
---
> When we pass a delta node we want to do operations like
> $$\hbox{\ignorespaces|for
> k:=1 to 6 do cur_active_width[k]:=cur_active_width[k]+mem[q+k].sc|};$$ and we
> want to do this without the overhead of |for| loops. The |do_all_six|
> macro makes such six-tuples convenient.
13153c16118
< @<Glo...@>=
---
> @<Glob...@>=
13155c16120
< {distance from first active node to@@|cur_p|}
---
> {distance from first active node to~|cur_p|}
13162,13164c16127,16129
< breakpoint@@$p$ in the paragraph, we define two quantities $\alpha(p)$ and
< $\beta(p)$ such that the length of material in a line from breakpoint@@$p$
< to breakpoint@@$q$ is $\gamma+\beta(q)-\alpha(p)$, for some fixed $\gamma$.
---
> breakpoint~|p| in the paragraph, we define two quantities $\alpha(p)$ and
> $\beta(p)$ such that the length of material in a line from breakpoint~|p|
> to breakpoint~|q| is $\gamma+\beta(q)-\alpha(p)$, for some fixed $\gamma$.
13166,13167c16131,16132
< the beginning of the paragraph to a point ``after'' a break at $p$ and to a
< point ``before'' a break at $q$; and $\gamma$ is the width of an empty line,
---
> the beginning of the paragraph to a point ``after'' a break at |p| and to a
> point ``before'' a break at |q|; and $\gamma$ is the width of an empty line,
13171,13177c16136,16142
< boxes and glue skips; let the boxes have widths $x↓1\ldotsm x↓n$ and
< let the skips have widths $y↓1\ldotsm y↓n$, so that the paragraph can be
< represented by $x↓1y↓1\ldotsm x↓ny↓n$. Let $p↓i$ be the legal breakpoint
< at $y↓i$; then $\alpha(p↓i)=x↓1+y↓1+\cdots+x↓i+y↓i$, and $\beta(p↓i)=
< x↓1+y↓1+\cdots+x↓i$. To check this, note that the length of material from
< $p↓2$ to $p↓5$, say, is $\gamma+x↓3+y↓3+x↓4+y↓4+x↓5=\gamma+\beta(p↓5)
< -\alpha(p↓2)$.
---
> boxes and glue skips; let the boxes have widths $x_1\ldots x_n$ and
> let the skips have widths $y_1\ldots y_n$, so that the paragraph can be
> represented by $x_1y_1\ldots x_ny_n$. Let $p_i$ be the legal breakpoint
> at $y_i$; then $\alpha(p_i)=x_1+y_1+\cdots+x_i+y_i$, and $\beta(p_i)=
> x_1+y_1+\cdots+x_i$. To check this, note that the length of material from
> $p_2$ to $p_5$, say, is $\gamma+x_3+y_3+x_4+y_4+x_5=\gamma+\beta(p_5)
> -\alpha(p_2)$.
13181c16146
< and $\beta(p)$ for each $p$, we would need multiple precision arithmetic, and
---
> and $\beta(p)$ for each |p|, we would need multiple precision arithmetic, and
13185,13189c16150,16154
< $a↓1\,\delta↓1\,a↓2\,\delta↓2\,a↓3$, where the $a$'s are active breakpoints
< and the $\delta$'s are delta nodes. Then $\delta↓1=\alpha(a↓1)-\alpha(a↓2)$
< and $\delta↓2=\alpha(a↓2)-\alpha(a↓3)$. If the line breaking algorithm is
< currently positioned at some other breakpoint $p$, the |active_width| array
< contains the value $\gamma+\beta(p)-\alpha(a↓1)$. If we are scanning through
---
> $a_1\,\delta_1\,a_2\,\delta_2\,a_3$, where the |a|'s are active breakpoints
> and the $\delta$'s are delta nodes. Then $\delta_1=\alpha(a_1)-\alpha(a_2)$
> and $\delta_2=\alpha(a_2)-\alpha(a_3)$. If the line breaking algorithm is
> currently positioned at some other breakpoint |p|, the |active_width| array
> contains the value $\gamma+\beta(p)-\alpha(a_1)$. If we are scanning through
13191,13195c16156,16160
< $a↓2$ to@@$p$, say, the |cur_active_width| array will contain the value
< $\gamma+\beta(p)-\alpha(a↓2)$. Thus, when we move from $a↓2$ to $a↓3$,
< we want to add $\alpha(a↓2)-\alpha(a↓3)$ to |cur_active_width|; and this
< is just $\delta↓2$, which appears in the active list between $a↓2$ and
< $a↓3$. The |background| array contains $\gamma$. The |break_width| array
---
> $a_2$ to~|p|, say, the |cur_active_width| array will contain the value
> $\gamma+\beta(p)-\alpha(a_2)$. Thus, when we move from $a_2$ to $a_3$,
> we want to add $\alpha(a_2)-\alpha(a_3)$ to |cur_active_width|; and this
> is just $\delta_2$, which appears in the active list between $a_2$ and
> $a_3$. The |background| array contains $\gamma$. The |break_width| array
13206,13208c16171,16173
< @d check_shrinkage(#)==if (shrink_order(#)≠normal)∧(shrink(#)≠0) then
< begin #←finite_shrink(#);
< end
---
> @d check_shrinkage(#)==if (shrink_order(#)<>normal)and(shrink(#)<>0) then
> begin #:=finite_shrink(#);
> end
13217,13223c16182,16183
< begin no_shrink_error_yet←false;
< help5("The paragraph just ended includes some glue that has")@/
< ("infinite shrinkability, e.g., `\hskip 0pt minus 1fil'.")@/
< ("Such glue doesn't belong there---it allows a paragraph")@/
< ("of any length to fit on one line. But it's safe to proceed,")@/
< ("since the offensive shrinkability has been made finite.");
< print_nl("! Infinite glue shrinkage found in a paragraph"); error;
---
> begin no_shrink_error_yet:=false;
> print_err("Infinite glue shrinkage found in a paragraph");
13225,13227c16185,16193
< end;
< q←new_spec(p); shrink_order(q)←normal;
< delete_glue_ref(p); finite_shrink←q;
---
> help5("The paragraph just ended includes some glue that has")@/
> ("infinite shrinkability, e.g., `\hskip 0pt minus 1fil'.")@/
> ("Such glue doesn't belong there---it allows a paragraph")@/
> ("of any length to fit on one line. But it's safe to proceed,")@/
> ("since the offensive shrinkability has been made finite.");
> error;
> end;
> q:=new_spec(p); shrink_order(q):=normal;
> delete_glue_ref(p); finite_shrink:=q;
13230,13231c16196,16197
< @ @<Get ready...@>=
< no_shrink_error_yet←true;@/
---
> @ @<Get ready to start...@>=
> no_shrink_error_yet:=true;@/
13233,13237c16199,16203
< q←left_skip; r←right_skip; background[1]←width(q)+width(r);@/
< background[2]←0; background[3]←0; background[4]←0; background[5]←0;@/
< background[2+stretch_order(q)]←stretch(q);@/
< background[2+stretch_order(r)]←@|background[2+stretch_order(r)]+stretch(r);@/
< background[6]←shrink(q)+shrink(r);
---
> q:=left_skip; r:=right_skip; background[1]:=width(q)+width(r);@/
> background[2]:=0; background[3]:=0; background[4]:=0; background[5]:=0;@/
> background[2+stretch_order(q)]:=stretch(q);@/
> background[2+stretch_order(r)]:=@|background[2+stretch_order(r)]+stretch(r);@/
> background[6]:=shrink(q)+shrink(r);
13244c16210
< of individual lines: breakpoints are feasible if there is a way to reach
---
> of individual lines: Breakpoints are feasible if there is a way to reach
13250c16216
< |badness| function specified above never returns a value greater than@@10000.
---
> |badness| function specified above never returns a value greater than~10000.
13252c16218
< Two passes might be made through the paragraph in an attempt to find at
---
> Up to three passes might be made through the paragraph in an attempt to find at
13254c16220,16221
< |threshold=pretolerance| and |second_pass=false|. If this pass fails to find a
---
> |threshold=pretolerance| and |second_pass=final_pass=false|.
> If this pass fails to find a
13256a16224,16225
> If that fails too, we add |emergency_stretch| to the background
> stretchability and set |final_pass=true|.
13260a16230
> @!final_pass:boolean; {is this our final attempt to break this paragraph?}
13266c16236
< nodes to@@|cur_p|. If feasible breaks are possible, new break nodes are
---
> nodes to~|cur_p|. If feasible breaks are possible, new break nodes are
13275,13276c16245,16246
< de\-pending on whether or not the current break is at a |disc_node|. The
< end of a para\-graph is also regarded as `|hyphenated|'; this case is
---
> depending on whether or not the current break is at a |disc_node|. The
> end of a paragraph is also regarded as `|hyphenated|'; this case is
13279c16249
< @d copy_to_cur_active(#)==cur_active_width[#]←active_width[#]
---
> @d copy_to_cur_active(#)==cur_active_width[#]:=active_width[#]
13284c16254
< label exit,done,continue,deactivate;
---
> label exit,done,done1,continue,deactivate;
13291c16261
< no_break_yet←true; prev_r←active; old_l←0;
---
> no_break_yet:=true; prev_r:=active; old_l:=0;
13293,13304c16263,16276
< loop@+ begin continue: r←link(prev_r);
< @<If node |r| is of type |delta_node|, update |cur_active_width|,
< set |prev_r| and |prev_prev_r|, then |goto continue|@>;
< @<If a line number class has ended, create new active nodes for
< the best feasible breaks in that class; then |return|
< if |r=last_active|, otherwise compute the new |line_width|@>;
< @<Consider the demerits for a line from |r| to |cur_p|;
< deactivate node |r| if it should no longer be active;
< then |goto continue| if a line from |r| to |cur_p| is infeasible,
< otherwise record a new feasible break@>;
< end;
< exit:end;
---
> loop@+ begin continue: r:=link(prev_r);
> @<If node |r| is of type |delta_node|, update |cur_active_width|,
> set |prev_r| and |prev_prev_r|, then |goto continue|@>;
> @<If a line number class has ended, create new active nodes for
> the best feasible breaks in that class; then |return|
> if |r=last_active|, otherwise compute the new |line_width|@>;
> @<Consider the demerits for a line from |r| to |cur_p|;
> deactivate node |r| if it should no longer be active;
> then |goto continue| if a line from |r| to |cur_p| is infeasible,
> otherwise record a new feasible break@>;
> end;
> exit: @!stat @<Update the value of |printed_node| for
> symbolic displays@>@+tats@;
> end;
13310,13311c16282,16283
< @!v:pointer; {points to a glue specification}
< @!t:quarterword; {replacement count, if |cur_p| is a discretionary node}
---
> @!v:pointer; {points to a glue specification or a node ahead of |cur_p|}
> @!t:integer; {node count, if |cur_p| is a discretionary node}
13316c16288
< @!fit_class:tight_fit..very_loose_fit; {possible fitness class of test line}
---
> @!fit_class:very_loose_fit..tight_fit; {possible fitness class of test line}
13318a16291,16293
> @!artificial_demerits:boolean; {has |d| been forced to zero?}
> @!save_link:pointer; {temporarily holds value of |link(cur_p)|}
> @!shortfall:scaled; {used in badness calculations}
13321,13323c16296,16298
< if abs(pi)≥inf_penalty then
< if pi>0 then return {this breakpoint is inhibited by infinite penalty}
< else pi←eject_penalty {this breakpoint will be forced}
---
> if abs(pi)>=inf_penalty then
> if pi>0 then return {this breakpoint is inhibited by infinite penalty}
> else pi:=eject_penalty {this breakpoint will be forced}
13325c16300
< @ The following code uses the fact that |type(last_active)≠delta_node|.
---
> @ The following code uses the fact that |type(last_active)<>delta_node|.
13328c16303
< cur_active_width[#]←cur_active_width[#]+mem[r+#].sc
---
> cur_active_width[#]:=cur_active_width[#]+mem[r+#].sc
13330a16306
> @^inner loop@>
13332,13334c16308,16310
< begin do_all_six(update_width);
< prev_prev_r←prev_r; prev_r←r; goto continue;
< end
---
> begin do_all_six(update_width);
> prev_prev_r:=prev_r; prev_r:=r; goto continue;
> end
13341c16317
< points to the passive node for the break before@@|cur_p| that achieves such
---
> points to the passive node for the break before~|cur_p| that achieves such
13351,13365c16327,16341
< @!minimal_demerits:array[tight_fit..very_loose_fit] of scaled; {best total
< demerits known for current line class and position, given the fitness}
< @!minimum_demerits:scaled; {best total demerits known for current line class
< and position}
< @!best_place:array[tight_fit..very_loose_fit] of pointer; {how to achieve
< |minimal_demerits|}
< @!best_pl_line:array[tight_fit..very_loose_fit] of halfword; {corresponding
< line number}
<
< @ @<Get ready...@>=
< minimum_demerits←awful_bad;
< minimal_demerits[tight_fit]←awful_bad;
< minimal_demerits[decent_fit]←awful_bad;
< minimal_demerits[loose_fit]←awful_bad;
< minimal_demerits[very_loose_fit]←awful_bad;
---
> @!minimal_demerits:array[very_loose_fit..tight_fit] of integer; {best total
> demerits known for current line class and position, given the fitness}
> @!minimum_demerits:integer; {best total demerits known for current line class
> and position}
> @!best_place:array[very_loose_fit..tight_fit] of pointer; {how to achieve
> |minimal_demerits|}
> @!best_pl_line:array[very_loose_fit..tight_fit] of halfword; {corresponding
> line number}
>
> @ @<Get ready to start...@>=
> minimum_demerits:=awful_bad;
> minimal_demerits[tight_fit]:=awful_bad;
> minimal_demerits[decent_fit]:=awful_bad;
> minimal_demerits[loose_fit]:=awful_bad;
> minimal_demerits[very_loose_fit]:=awful_bad;
13375c16351
< begin l←line_number(r);
---
> begin l:=line_number(r);
13377,13384c16353,16360
< begin {now we are no longer in the inner loop}
< if (minimum_demerits<awful_bad)∧@|
< ((old_l≠easy_line)∨(r=last_active)) then
< @<Create new active nodes for the best feasible breaks
< just found@>;
< if r=last_active then return;
< @<Compute the new line width@>;
< end;
---
> begin {now we are no longer in the inner loop}
> if (minimum_demerits<awful_bad)and@|
> ((old_l<>easy_line)or(r=last_active)) then
> @<Create new active nodes for the best feasible breaks
> just found@>;
> if r=last_active then return;
> @<Compute the new line width@>;
> end;
13387,13388c16363,16365
< @ It is not necessary to create new active nodes having |minimal_demerits
< >minimum_demerits+abs(adj_demerits)|, since such active nodes will never
---
> @ It is not necessary to create new active nodes having |minimal_demerits|
> greater than
> |minimum_demerits+abs(adj_demerits)|, since such active nodes will never
13395,13402c16372,16381
< minimum_demerits←minimum_demerits+abs(adj_demerits);
< for fit_class←tight_fit to very_loose_fit do
< begin if minimal_demerits[fit_class]≤minimum_demerits then
< @<Insert a new active node
< from |best_place[fit_class]| to |cur_p|@>;
< minimal_demerits[fit_class]←awful_bad;
< end;
< minimum_demerits←awful_bad;
---
> if abs(adj_demerits)>=awful_bad-minimum_demerits then
> minimum_demerits:=awful_bad-1
> else minimum_demerits:=minimum_demerits+abs(adj_demerits);
> for fit_class:=very_loose_fit to tight_fit do
> begin if minimal_demerits[fit_class]<=minimum_demerits then
> @<Insert a new active node
> from |best_place[fit_class]| to |cur_p|@>;
> minimal_demerits[fit_class]:=awful_bad;
> end;
> minimum_demerits:=awful_bad;
13408c16387
< want to insert `$\delta\,|cur_p|\,\delta^\prime$' before $a$, where
---
> want to insert `$\delta\,|cur_p|\,\delta^\prime$' before |a|, where
13410c16389
< in the notation explained above. The |cur_active_width| array now hold
---
> in the notation explained above. The |cur_active_width| array now holds
13417c16396
< (which is normally zero) minus the width of nodes following@@|cur_p| that are
---
> (which is normally zero) minus the width of nodes following~|cur_p| that are
13423c16402,16404
< @d set_break_width_to_background(#)==break_width[#]←background[#]
---
> Kern nodes do not disappear at a line break unless they are |explicit|.
>
> @d set_break_width_to_background(#)==break_width[#]:=background[#]
13426,13440c16407,16422
< begin no_break_yet←false; do_all_six(set_break_width_to_background);
< if (break_type=unhyphenated)∨(cur_p=null) then
< begin s←cur_p;
< while s≠null do
< begin if is_char_node(s) then goto done;
< case type(s) of
< glue_node:@<Subtract glue from |break_width|@>;
< penalty_node: do_nothing;
< math_node,kern_node: break_width[1]←break_width[1]-width(s);
< othercases goto done
< endcases;@/
< s←link(s);
< end;
< end
< else @<Compute the discretionary |break_width| values@>;
---
> begin no_break_yet:=false; do_all_six(set_break_width_to_background);
> s:=cur_p;
> if break_type>unhyphenated then if cur_p<>null then
> @<Compute the discretionary |break_width| values@>;
> while s<>null do
> begin if is_char_node(s) then goto done;
> case type(s) of
> glue_node:@<Subtract glue from |break_width|@>;
> penalty_node: do_nothing;
> math_node: break_width[1]:=break_width[1]-width(s);
> kern_node: if subtype(s)<>explicit then goto done
> else break_width[1]:=break_width[1]-width(s);
> othercases goto done
> endcases;@/
> s:=link(s);
> end;
13444,13446c16426,16428
< begin v←glue_ptr(s); break_width[1]←break_width[1]-width(v);
< break_width[2+stretch_order(v)]←break_width[2+stretch_order(v)]-stretch(v);
< break_width[6]←break_width[6]-shrink(v);
---
> begin v:=glue_ptr(s); break_width[1]:=break_width[1]-width(v);
> break_width[2+stretch_order(v)]:=break_width[2+stretch_order(v)]-stretch(v);
> break_width[6]:=break_width[6]-shrink(v);
13451,13452c16433,16434
< Suppose that the pre-break text at |cur_p| has length $l↓0$, the post-break
< text has length $l↓1$, and the replacement text has length $l$. Suppose
---
> Suppose that the pre-break text at |cur_p| has length $l_0$, the post-break
> text has length $l_1$, and the replacement text has length |l|. Suppose
13455,13456c16437,16441
< where $\beta(q)=\beta(|cur_p|)-l↓0+l$. The actual length will be the background
< plus $l↓1$, so the length from |cur_p| to |cur_p| should be $\gamma+l↓0+l↓1-l$.
---
> where $\beta(q)=\beta(|cur_p|)-l_0+l$. The actual length will be the background
> plus $l_1$, so the length from |cur_p| to |cur_p| should be $\gamma+l_0+l_1-l$.
> If the post-break text of the discretionary is empty, a break may also
> discard~|q|; in that unusual case we subtract the length of~|q| and any
> other nodes that will be discarded after the discretionary break.
13458c16443
< The value of $l↓0$ need not be computed, since |line_break| will put
---
> The value of $l_0$ need not be computed, since |line_break| will put
13465c16450
< begin t←replace_count(cur_p); s←cur_p;
---
> begin t:=replace_count(cur_p); v:=cur_p; s:=post_break(cur_p);
13467,13475c16452,16461
< begin decr(t); s←link(s);
< @<Subtract the width of node |s| from |break_width|@>;
< end;
< s←post_break(cur_p);
< while s≠null do
< begin @<Add the width of node |s| to |break_width|@>;
< s←link(s);
< end;
< break_width[1]←break_width[1]+disc_width;
---
> begin decr(t); v:=link(v);
> @<Subtract the width of node |v| from |break_width|@>;
> end;
> while s<>null do
> begin @<Add the width of node |s| to |break_width|@>;
> s:=link(s);
> end;
> break_width[1]:=break_width[1]+disc_width;
> if post_break(cur_p)=null then s:=link(v);
> {nodes may be discardable after the break}
13479c16465
< only character nodes, kern nodes, and ligature nodes.
---
> only character nodes, kern nodes, ligature nodes, and box or rule nodes.
13481,13494c16467,16481
< @<Subtract the width of node |s|...@>=
< if is_char_node(s) then
< begin f←font(s);
< break_width[1]←break_width[1]-char_width(f)(char_info(f)(character(s)));
< end
< else case type(s) of
< ligature_node: begin f←font(lig_char(s));@/
< break_width[1]←@|break_width[1]-
< char_width(f)(char_info(f)(character(lig_char(s))));
< end;
< kern_node: break_width[1]←break_width[1]-width(s);
< othercases confusion("disc1")
< @:confusion disc1}{\quad disc1@>
< endcases
---
> @<Subtract the width of node |v|...@>=
> if is_char_node(v) then
> begin f:=font(v);
> break_width[1]:=break_width[1]-char_width(f)(char_info(f)(character(v)));
> end
> else case type(v) of
> ligature_node: begin f:=font(lig_char(v));@/
> break_width[1]:=@|break_width[1]-
> char_width(f)(char_info(f)(character(lig_char(v))));
> end;
> hlist_node,vlist_node,rule_node,kern_node:
> break_width[1]:=break_width[1]-width(v);
> othercases confusion("disc1")
> @:this can't happen disc1}{\quad disc1@>
> endcases
13498,13509c16485,16497
< begin f←font(s);
< break_width[1]←@|break_width[1]+char_width(f)(char_info(f)(character(s)));
< end
< else case type(s) of
< ligature_node: begin f←font(lig_char(s));
< break_width[1]←break_width[1]+
< char_width(f)(char_info(f)(character(lig_char(s))));
< end;
< kern_node: break_width[1]←break_width[1]+width(s);
< othercases confusion("disc2")
< @:confusion disc2}{\quad disc2@>
< endcases
---
> begin f:=font(s);
> break_width[1]:=@|break_width[1]+char_width(f)(char_info(f)(character(s)));
> end
> else case type(s) of
> ligature_node: begin f:=font(lig_char(s));
> break_width[1]:=break_width[1]+
> char_width(f)(char_info(f)(character(lig_char(s))));
> end;
> hlist_node,vlist_node,rule_node,kern_node:
> break_width[1]:=break_width[1]+width(s);
> othercases confusion("disc2")
> @:this can't happen disc2}{\quad disc2@>
> endcases
13511c16499
< @ We use the fact that |type(active)≠delta_node|.
---
> @ We use the fact that |type(active)<>delta_node|.
13514,13516c16502,16504
< mem[prev_r+#].sc←@|@t\hskip10pt@>mem[prev_r+#].sc
< -cur_active_width[#]+break_width[#]
< @d store_break_width(#)==active_width[#]←break_width[#]
---
> mem[prev_r+#].sc:=@|@t\hskip10pt@>mem[prev_r+#].sc
> -cur_active_width[#]+break_width[#]
> @d store_break_width(#)==active_width[#]:=break_width[#]
13518c16506
< mem[q+#].sc←break_width[#]-cur_active_width[#]
---
> mem[q+#].sc:=break_width[#]-cur_active_width[#]
13522,13523c16510,16511
< begin εo_all_six(convert_to_break_width);
< end
---
> begin do_all_six(convert_to_break_width);
> end
13525,13531c16513,16519
< begin do_all_six(store_break_width);
< end
< else begin q←get_node(delta_node_size); link(q)←r; type(q)←delta_node;
< subtype(q)←0; {the |subtype| is not used}
< do_all_six(new_delta_to_break_width);
< link(prev_r)←q; prev_prev_r←prev_r; prev_r←q;
< end
---
> begin do_all_six(store_break_width);
> end
> else begin q:=get_node(delta_node_size); link(q):=r; type(q):=delta_node;@/
> subtype(q):=0; {the |subtype| is not used}
> do_all_six(new_delta_to_break_width);
> link(prev_r):=q; prev_prev_r:=prev_r; prev_r:=q;
> end
13534c16522
< least one active node before |r|, so |type(prev_r)≠delta_node|.
---
> least one active node before |r|, so |type(prev_r)<>delta_node|.
13536,13537c16524,16525
< @d new_delta_from_break_width(#)==@|mem[q+#].sc←
< cur_active_width[#]-break_width[#]
---
> @d new_delta_from_break_width(#)==@|mem[q+#].sc:=
> cur_active_width[#]-break_width[#]
13540,13545c16528,16533
< if r≠last_active then
< begin q←get_node(delta_node_size); link(q)←r; type(q)←delta_node;
< subtype(q)←0; {the |subtype| is not used}
< do_all_six(new_delta_from_break_width);
< link(prev_r)←q; prev_prev_r←prev_r; prev_r←q;
< end
---
> if r<>last_active then
> begin q:=get_node(delta_node_size); link(q):=r; type(q):=delta_node;@/
> subtype(q):=0; {the |subtype| is not used}
> do_all_six(new_delta_from_break_width);
> link(prev_r):=q; prev_prev_r:=prev_r; prev_r:=q;
> end
13551,13558c16539,16562
< begin q←get_node(passive_node_size);
< link(q)←passive; passive←q; cur_break(q)←cur_p;
< prev_break(q)←best_place[fit_class];@/
< q←get_node(active_node_size); break_node(q)←passive;
< line_number(q)←best_pl_line[fit_class]+1;
< fitness(q)←fit_class; type(q)←break_type;
< total_demerits(q)←minimal_demerits[fit_class];
< link(q)←r; link(prev_r)←q; prev_r←q;
---
> begin q:=get_node(passive_node_size);
> link(q):=passive; passive:=q; cur_break(q):=cur_p;
> @!stat incr(pass_number); serial(q):=pass_number;@+tats@;@/
> prev_break(q):=best_place[fit_class];@/
> q:=get_node(active_node_size); break_node(q):=passive;
> line_number(q):=best_pl_line[fit_class]+1;
> fitness(q):=fit_class; type(q):=break_type;
> total_demerits(q):=minimal_demerits[fit_class];
> link(q):=r; link(prev_r):=q; prev_r:=q;
> @!stat if tracing_paragraphs>0 then
> @<Print a symbolic description of the new break node@>;
> tats@;@/
> end
>
> @ @<Print a symbolic description of the new break node@>=
> begin print_nl("@@@@"); print_int(serial(passive));
> @.\AT!\AT!@>
> print(": line "); print_int(line_number(q)-1);
> print_char("."); print_int(fit_class);
> if break_type=hyphenated then print_char("-");
> print(" t="); print_int(total_demerits(q));
> print(" -> @@@@");
> if prev_break(passive)=null then print_char("0")
> else print_int(serial(prev_break(passive)));
13568,13574c16572,16578
< |n=hang_after|; if |n≥0|, hanging indentation takes place on lines |n+1|,
< |n+2|, $\ldotss$, otherwise it takes place on lines 1, $\ldotss$, $\leftv
< n\rightv$. When hanging indentation is active, the left margin is
< |hanging_indent|, if |hanging_indent≥0|, else it is 0; the line length is
< $|hsize|-\leftv|hanging_indent|\rightv$. The normal setting is
< |par_shape_ptr=null|, |hang_after=0|, and |hanging_indent=0|.
< Note that if |hanging_indent=0|, the value of |hang_after| is irrelevant.
---
> |n=hang_after|; if |n>=0|, hanging indentation takes place on lines |n+1|,
> |n+2|, \dots, otherwise it takes place on lines 1, \dots, $\vert
> n\vert$. When hanging indentation is active, the left margin is
> |hang_indent|, if |hang_indent>=0|, else it is 0; the line length is
> $|hsize|-\vert|hang_indent|\vert$. The normal setting is
> |par_shape_ptr=null|, |hang_after=1|, and |hang_indent=0|.
> Note that if |hang_indent=0|, the value of |hang_after| is irrelevant.
13580,13582c16584,16586
< the same width}
< @!first_width:scaled; {the width of all lines |≤last_special_line|, if
< no \.{\\parshape} has been specified}
---
> the same width}
> @!first_width:scaled; {the width of all lines |<=last_special_line|, if
> no \.{\\parshape} has been specified}
13590c16594
< @<Get ready...@>=
---
> @<Get ready to start...@>=
13592,13602c16596,16606
< if hanging_indent=0 then
< begin last_special_line←0; first_width←hsize;
< second_width←first_width;
< end
< else @<Set line length parameters in preparation for hanging indentation@>
< else begin last_special_line←info(par_shape_ptr)-1;
< second_width←mem[par_shape_ptr+2*(last_special_line+1)].sc;
< second_indent←mem[par_shape_ptr+2*last_special_line+1].sc;
< end;
< if looseness=0 then easy_line←last_special_line
< else easy_line←max_halfword
---
> if hang_indent=0 then
> begin last_special_line:=0; second_width:=hsize;
> second_indent:=0;
> end
> else @<Set line length parameters in preparation for hanging indentation@>
> else begin last_special_line:=info(par_shape_ptr)-1;
> second_width:=mem[par_shape_ptr+2*(last_special_line+1)].sc;
> second_indent:=mem[par_shape_ptr+2*last_special_line+1].sc;
> end;
> if looseness=0 then easy_line:=last_special_line
> else easy_line:=max_halfword
13605c16609
< begin last_special_line←abs(hang_after);
---
> begin last_special_line:=abs(hang_after);
13607,13616c16611,16620
< begin first_width←hsize-abs(hanging_indent);
< if hanging_indent≥0 then first_indent←hanging_indent
< else first_indent←0;
< second_width←hsize; second_indent←0;
< end
< else begin first_width←hsize; first_indent←0;
< second_width←hsize-abs(hanging_indent);
< if hanging_indent≥0 then second_indent←hanging_indent
< else second_indent←0;
< end;
---
> begin first_width:=hsize-abs(hang_indent);
> if hang_indent>=0 then first_indent:=hang_indent
> else first_indent:=0;
> second_width:=hsize; second_indent:=0;
> end
> else begin first_width:=hsize; first_indent:=0;
> second_width:=hsize-abs(hang_indent);
> if hang_indent>=0 then second_indent:=hang_indent
> else second_indent:=0;
> end;
13620,13621c16624,16625
< active node@@|r| whose |line_number| field contains |l|. Thus we want to
< compute the length of the $l\,$th line of the current paragraph. Furthermore
---
> active node~|r| whose |line_number| field contains |l|. Thus we want to
> compute the length of the $l\mskip1mu$th line of the current paragraph. Furthermore,
13623c16627
< equivalent to@@|l|.
---
> equivalent to~|l|.
13627,13633c16631,16637
< begin line_width←second_width; old_l←max_halfword-1;
< end
< else begin old_l←l;
< if l>last_special_line then line_width←second_width
< else if par_shape_ptr=null then line_width←first_width
< else line_width←mem[par_shape_ptr+2*l@,].sc;
< end
---
> begin line_width:=second_width; old_l:=max_halfword-1;
> end
> else begin old_l:=l;
> if l>last_special_line then line_width:=second_width
> else if par_shape_ptr=null then line_width:=first_width
> else line_width:=mem[par_shape_ptr+2*l@,].sc;
> end
13642c16646
< We also deactivate node@@|r| when a break at@@|cur_p| is forced, since future
---
> We also deactivate node~|r| when a break at~|cur_p| is forced, since future
13646,13648c16650,16655
< begin if cur_active_width[1]<line_width then
< @<Set the value of |b| to the badness for stretching the line,
< and compute the corresponding |fit_class|@>
---
> begin artificial_demerits:=false;@/
> @^inner loop@>
> shortfall:=line_width-cur_active_width[1]; {we're this much too short}
> if shortfall>0 then
> @<Set the value of |b| to the badness for stretching the line,
> and compute the corresponding |fit_class|@>
13650,13657c16657,16664
< and compute the corresponding |fit_class|@>;
< if (b>inf_bad)∨(pi=eject_penalty) then
< @<Prepare to deactivate node@@|r|, and |goto deactivate| unless
< there is a reason to consider lines of text from |r| to |cur_p|@>
< else begin prev_r←r;
< if b>threshold then goto continue;
< node_r_stays_active←true;
< end;
---
> and compute the corresponding |fit_class|@>;
> if (b>inf_bad)or(pi=eject_penalty) then
> @<Prepare to deactivate node~|r|, and |goto deactivate| unless
> there is a reason to consider lines of text from |r| to |cur_p|@>
> else begin prev_r:=r;
> if b>threshold then goto continue;
> node_r_stays_active:=true;
> end;
13663c16670
< @ When a line must stretch, the available stretchability appears in the
---
> @ When a line must stretch, the available stretchability can be found in the
13665a16673,16678
> The present section is part of \TeX's inner loop, and it is most often performed
> when the badness is infinite; therefore it is worth while to make a quick
> test for large width excess and small stretchability, before calling the
> |badness| subroutine.
> @^inner loop@>
>
13667,13676c16680,16693
< if (cur_active_width[3]≠0)∨(cur_active_width[4]≠0)∨@|
< (cur_active_width[5]≠0) then
< begin b←0; fit_class←decent_fit; {infinite stretch}
< end
< else begin b←badness(line_width-cur_active_width[1],cur_active_width[2]);
< if b>12 then
< if b>99 then fit_class←very_loose_fit
< else fit_class←loose_fit
< else fit_class←decent_fit;
< end
---
> if (cur_active_width[3]<>0)or(cur_active_width[4]<>0)or@|
> (cur_active_width[5]<>0) then
> begin b:=0; fit_class:=decent_fit; {infinite stretch}
> end
> else begin if shortfall>7230584 then if cur_active_width[2]<1663497 then
> begin b:=inf_bad; fit_class:=very_loose_fit; goto done1;
> end;
> b:=badness(shortfall,cur_active_width[2]);
> if b>12 then
> if b>99 then fit_class:=very_loose_fit
> else fit_class:=loose_fit
> else fit_class:=decent_fit;
> done1:
> end
13682,13685c16699,16701
< begin if cur_active_width[1]-line_width>cur_active_width[6] then
< b←inf_bad+1
< else b←badness(cur_active_width[1]-line_width,cur_active_width[6]);
< if b>12 then fit_class←tight_fit@+else fit_class←decent_fit;
---
> begin if -shortfall>cur_active_width[6] then b:=inf_bad+1
> else b:=badness(-shortfall,cur_active_width[6]);
> if b>12 then fit_class:=tight_fit@+else fit_class:=decent_fit;
13688c16704
< @ During the second pass, we dare not lose all active nodes, lest we lose
---
> @ During the final pass, we dare not lose all active nodes, lest we lose
13697,13700c16713,16717
< @<Prepare to deactivate node@@|r|, and |goto deactivate| unless...@>=
< begin if second_pass ∧ (minimum_demerits=awful_bad) ∧@|
< (link(r)=last_active) ∧
< (prev_r=active) then b←0 {set badness zero, this break is forced}
---
> @<Prepare to deactivate node~|r|, and |goto deactivate| unless...@>=
> begin if final_pass and (minimum_demerits=awful_bad) and@|
> (link(r)=last_active) and
> (prev_r=active) then
> artificial_demerits:=true {set demerits zero, this break is forced}
13702c16719
< node_r_stays_active←false;
---
> node_r_stays_active:=false;
13706c16723
< feasible, its badness is@@|b|, and its fitness classification is |fit_class|.
---
> feasible, its badness is~|b|, and its fitness classification is |fit_class|.
13713,13732c16730,16799
< @<Compute the fewest total demerits, |d|,
< from the beginning to |cur_p| via@@|r|@>;
< if d≤minimal_demerits[fit_class] then
< begin minimal_demerits[fit_class]←d;
< best_place[fit_class]←break_node(r); best_pl_line[fit_class]←l;
< if d<minimum_demerits then minimum_demerits←d;
< end
<
< @ @<Compute the fewest total demerits...@>=
< if pi≥0 then
< begin d←(line_penalty+b+pi); d←d*d;
< end
< else begin d←line_penalty+b; d←d*d;
< if pi>eject_penalty then d←d-pi*pi;
< end;
< d←d+total_demerits(r);
< if (break_type=hyphenated)∧(type(r)=hyphenated) then
< if cur_p≠null then d←d+double_hyphen_demerits
< else d←d+final_hyphen_demerits;
< if abs(fit_class-fitness(r))>1 then d←d+adj_demerits
---
> if artificial_demerits then d:=0
> else @<Compute the demerits, |d|, from |r| to |cur_p|@>;
> @!stat if tracing_paragraphs>0 then
> @<Print a symbolic description of this feasible break@>;
> tats@;@/
> d:=d+total_demerits(r); {this is the minimum total demerits
> from the beginning to |cur_p| via |r|}
> if d<=minimal_demerits[fit_class] then
> begin minimal_demerits[fit_class]:=d;
> best_place[fit_class]:=break_node(r); best_pl_line[fit_class]:=l;
> if d<minimum_demerits then minimum_demerits:=d;
> end
>
> @ @<Print a symbolic description of this feasible break@>=
> begin if printed_node<>cur_p then
> @<Print the list between |printed_node| and |cur_p|,
> then set |printed_node:=cur_p|@>;
> print_nl("@@");
> @.\AT!@>
> if cur_p=null then print_esc("par")
> else if type(cur_p)<>glue_node then
> begin if type(cur_p)=penalty_node then print_esc("penalty")
> else if type(cur_p)=disc_node then print_esc("discretionary")
> else if type(cur_p)=kern_node then print_esc("kern")
> else print_esc("math");
> end;
> print(" via @@@@");
> if break_node(r)=null then print_char("0")
> else print_int(serial(break_node(r)));
> print(" b=");
> if b>inf_bad then print_char("*")@+else print_int(b);
> @.*\relax@>
> print(" p="); print_int(pi); print(" d=");
> if artificial_demerits then print_char("*")@+else print_int(d);
> end
>
> @ @<Print the list between |printed_node| and |cur_p|...@>=
> begin print_nl("");
> if cur_p=null then short_display(link(printed_node))
> else begin save_link:=link(cur_p);
> link(cur_p):=null; print_nl(""); short_display(link(printed_node));
> link(cur_p):=save_link;
> end;
> printed_node:=cur_p;
> end
>
> @ When the data for a discretionary break is being displayed, we will have
> printed the |pre_break| and |post_break| lists; we want to skip over the
> third list, so that the discretionary data will not appear twice. The
> following code is performed at the very end of |try_break|.
>
> @<Update the value of |printed_node|...@>=
> if cur_p=printed_node then if cur_p<>null then if type(cur_p)=disc_node then
> begin t:=replace_count(cur_p);
> while t>0 do
> begin decr(t); printed_node:=link(printed_node);
> end;
> end
>
> @ @<Compute the demerits, |d|, from |r| to |cur_p|@>=
> begin d:=line_penalty+b;
> if abs(d)>=10000 then d:=100000000@+else d:=d*d;
> if pi<>0 then
> if pi>0 then d:=d+pi*pi
> else if pi>eject_penalty then d:=d-pi*pi;
> if (break_type=hyphenated)and(type(r)=hyphenated) then
> if cur_p<>null then d:=d+double_hyphen_demerits
> else d:=d+final_hyphen_demerits;
> if abs(fit_class-fitness(r))>1 then d:=d+adj_demerits;
> end
13738c16805
< to@@|cur_p|.
---
> to~|cur_p|.
13740,13742c16807,16809
< @d combine_two_deltas(#)==@|mem[prev_r+#].sc←mem[prev_r+#].sc+mem[r+#].sc
< @d downdate_width(#)==@|cur_active_width[#]←cur_active_width[#]-
< mem[prev_r+#].sc
---
> @d combine_two_deltas(#)==@|mem[prev_r+#].sc:=mem[prev_r+#].sc+mem[r+#].sc
> @d downdate_width(#)==@|cur_active_width[#]:=cur_active_width[#]-
> mem[prev_r+#].sc
13745c16812
< link(prev_r)←link(r); free_node(r,active_node_size);
---
> link(prev_r):=link(r); free_node(r,active_node_size);
13747c16814
< node has been deleted@>
---
> node has been deleted@>
13749,13760c16816,16827
< begin r←link(prev_r);
< if r=last_active then
< begin do_all_six(downdate_width);
< link(prev_prev_r)←last_active;
< free_node(prev_r,delta_node_size); prev_r←prev_prev_r;
< end
< else if type(r)=delta_node then
< begin do_all_six(update_width);
< do_all_six(combine_two_deltas);
< link(prev_r)←link(r); free_node(r,delta_node_size);
< end;
< end
---
> begin r:=link(prev_r);
> if r=last_active then
> begin do_all_six(downdate_width);
> link(prev_prev_r):=last_active;
> free_node(prev_r,delta_node_size); prev_r:=prev_prev_r;
> end
> else if type(r)=delta_node then
> begin do_all_six(update_width);
> do_all_six(combine_two_deltas);
> link(prev_r):=link(r); free_node(r,delta_node_size);
> end;
> end
13762c16829
< @ The following code uses the fact that |type(last_active)≠delta_node|. If the
---
> @ The following code uses the fact that |type(last_active)<>delta_node|. If the
13767c16834
< @d update_active(#)==active_width[#]←active_width[#]+mem[r+#].sc
---
> @d update_active(#)==active_width[#]:=active_width[#]+mem[r+#].sc
13770c16837
< begin r←link(active);
---
> begin r:=link(active);
13772,13775c16839,16842
< begin do_all_six(update_active);
< do_all_six(copy_to_cur_active);
< link(active)←link(r); free_node(r,delta_node_size);
< end;
---
> begin do_all_six(update_active);
> do_all_six(copy_to_cur_active);
> link(active):=link(r); free_node(r,delta_node_size);
> end;
13777c16844,16845
< @* \[38] Breaking paragraphs into lines, continued.
---
>
> @* \[39] Breaking paragraphs into lines, continued.
13782c16850
< The main loop of |line_break| traverses the hlist of the given paragraph,
---
> The main loop of |line_break| traverses the given hlist,
13789c16857
< local variable, |prev_p|, is usually one step behind |cur_p|, but the real
---
> variable, |prev_p|, is usually one step behind |cur_p|, but the real
13792c16860
< point to a glue node, penalty node, kern node, or math node.
---
> point to a glue node, penalty node, explicit kern node, or math node.
13800c16868
< @!q,@!r,@!s:pointer; {miscellaneous nodes of temporary interest}
---
> @!q,@!r,@!s,@!prev_s:pointer; {miscellaneous nodes of temporary interest}
13803,13804c16871,16872
< @ The `\!|loop|\unskip' in the following code is performed at most
< twice per call of |line_break|, since it is actually a pass over the
---
> @ The `\ignorespaces|loop|\unskip' in the following code is performed at most
> thrice per call of |line_break|, since it is actually a pass over the
13808,13826c16876,16912
< threshold←pretolerance; second_pass←false;
< loop@+ begin @<Create an active breakpoint representing the beginning of
< the paragraph@>;
< cur_p←link(temp_head); auto_breaking←true;@/
< prev_p←cur_p; {glue at beginning is not a legal breakpoint}
< while (cur_p≠null)∧(link(active)≠last_active) do
< @<Call |try_break| if |cur_p| is a legal breakpoint;
< on the second pass, also try to hyphenate the next
< word, if |cur_p| is a glue node;
< then advance |cur_p| to the next node of the paragraph
< that could possibly be a legal breakpoint@>;
< if cur_p=null then
< @<Try the final line break at the end of the paragraph,
< and |goto done| if the desired breakpoints have been found@>;
< @<Clean up the memory by removing the break nodes@>;
< threshold←tolerance; second_pass←true; {if at first you don't
< succeed, $\ldotss$}
< end;
< done:
---
> threshold:=pretolerance;
> if threshold>=0 then
> begin @!stat if tracing_paragraphs>0 then
> begin begin_diagnostic; print_nl("@@firstpass");@+end;@;@+tats@;@/
> second_pass:=false; final_pass:=false;
> end
> else begin threshold:=tolerance; second_pass:=true;
> final_pass:=(emergency_stretch<=0);
> @!stat if tracing_paragraphs>0 then begin_diagnostic;@+tats@;
> end;
> loop@+ begin if threshold>inf_bad then threshold:=inf_bad;
> if second_pass then @<Initialize for hyphenating a paragraph@>;
> @<Create an active breakpoint representing the beginning of the paragraph@>;
> cur_p:=link(temp_head); auto_breaking:=true;@/
> prev_p:=cur_p; {glue at beginning is not a legal breakpoint}
> while (cur_p<>null)and(link(active)<>last_active) do
> @<Call |try_break| if |cur_p| is a legal breakpoint;
> on the second pass, also try to hyphenate the next
> word, if |cur_p| is a glue node;
> then advance |cur_p| to the next node of the paragraph
> that could possibly be a legal breakpoint@>;
> if cur_p=null then
> @<Try the final line break at the end of the paragraph,
> and |goto done| if the desired breakpoints have been found@>;
> @<Clean up the memory by removing the break nodes@>;
> if not second_pass then
> begin@!stat if tracing_paragraphs>0 then print_nl("@@secondpass");@;@+tats@/
> threshold:=tolerance; second_pass:=true; final_pass:=(emergency_stretch<=0);
> end {if at first you don't succeed, \dots}
> else begin @!stat if tracing_paragraphs>0 then
> print_nl("@@emergencypass");@;@+tats@/
> background[2]:=background[2]+emergency_stretch; final_pass:=true;
> end;
> end;
> done: @!stat if tracing_paragraphs>0 then
> begin end_diagnostic(true); normalize_selector;
> end;@+tats@/
13829c16915
< corresponding passive node.
---
> corresponding passive node.
13831c16917
< @d store_background(#)==active_width[#]←background[#]
---
> @d store_background(#)==active_width[#]:=background[#]
13834,13837c16920,16923
< q←get_node(active_node_size);
< type(q)←unhyphenated; fitness(q)←decent_fit;
< link(q)←last_active; break_node(q)←null;
< line_number(q)←already+1; total_demerits(q)←0; link(active)←q;
---
> q:=get_node(active_node_size);
> type(q):=unhyphenated; fitness(q):=decent_fit;
> link(q):=last_active; break_node(q):=null;
> line_number(q):=prev_graf+1; total_demerits(q):=0; link(active):=q;
13839c16925,16926
< passive←null
---
> passive:=null; printed_node:=temp_head; pass_number:=0;
> font_in_short_display:=null_font
13842,13854c16929,16941
< q←link(active);
< while q≠last_active do
< begin cur_p←link(q);
< if type(q)=delta_node then free_node(q,delta_node_size)
< else free_node(q,active_node_size);
< q←cur_p;
< end;
< q←passive;
< while q≠null do
< begin cur_p←link(q);
< free_node(q,passive_node_size);
< q←cur_p;
< end
---
> q:=link(active);
> while q<>last_active do
> begin cur_p:=link(q);
> if type(q)=delta_node then free_node(q,delta_node_size)
> else free_node(q,active_node_size);
> q:=cur_p;
> end;
> q:=passive;
> while q<>null do
> begin cur_p:=link(q);
> free_node(q,passive_node_size);
> q:=cur_p;
> end
13863,13867c16950,16953
< @d kern_break==begin@t@>@;@/
< if not is_char_node(link(cur_p)) ∧ auto_breaking then
< if type(link(cur_p))=glue_node then try_break(0,unhyphenated);
< act_width←act_width+width(cur_p);
< end
---
> @d kern_break==begin if not is_char_node(link(cur_p)) and auto_breaking then
> if type(link(cur_p))=glue_node then try_break(0,unhyphenated);
> act_width:=act_width+width(cur_p);
> end
13870,13871c16956,16958
< begin while is_char_node(cur_p) do
< @<Advance \(c)|cur_p| to the node following the present character@>;
---
> begin if is_char_node(cur_p) then
> @<Advance \(c)|cur_p| to the node following the present
> string of characters@>;
13873,13886c16960,16974
< hlist_node,vlist_node,rule_node: act_width←act_width+width(cur_p);
< whatsit_node: @<Advance \(p)past a whatsit node in the |line_break| loop@>;
< glue_node: begin @<If node |cur_p| is a legal breakpoint, call |try_break|@>;
< @<Update the active widths by including the glue in |glue_ptr(cur_p)|@>;
< if second_pass ∧ auto_breaking then
< @<Try to hyphenate the following word@>;
< end;
< kern_node: kern_break;
< ligature_node: begin f←font(lig_char(cur_p));
< act_width←act_width+char_width(f)(char_info(f)(character(lig_char(cur_p))));
< end;
< disc_node: @<Try to break after a discretionary fragment@>;
< math_node: begin auto_breaking←(subtype(cur_p)=after); kern_break;
< end;
---
> hlist_node,vlist_node,rule_node: act_width:=act_width+width(cur_p);
> whatsit_node: @<Advance \(p)past a whatsit node in the \(l)|line_break| loop@>;
> glue_node: begin @<If node |cur_p| is a legal breakpoint, call |try_break|;
> then update the active widths by including the glue in |glue_ptr(cur_p)|@>;
> if second_pass and auto_breaking then
> @<Try to hyphenate the following word@>;
> end;
> kern_node: if subtype(cur_p)=explicit then kern_break
> else act_width:=act_width+width(cur_p);
> ligature_node: begin f:=font(lig_char(cur_p));
> act_width:=act_width+char_width(f)(char_info(f)(character(lig_char(cur_p))));
> end;
> disc_node: @<Try to break after a discretionary fragment, then |goto done5|@>;
> math_node: begin auto_breaking:=(subtype(cur_p)=after); kern_break;
> end;
13890c16978
< @:confusion paragraph}{\quad paragraph@>
---
> @:this can't happen paragraph}{\quad paragraph@>
13892,13893c16980,16981
< prev_p←cur_p; cur_p←link(cur_p);
< end
---
> prev_p:=cur_p; cur_p:=link(cur_p);
> done5:end
13899a16988
> @^inner loop@>
13901,13904c16990,16995
< @<Advance \(c)|cur_p| to the node following the present character@>=
< begin f←font(cur_p);
< act_width←act_width+char_width(f)(char_info(f)(character(cur_p)));
< cur_p←link(cur_p);
---
> @<Advance \(c)|cur_p| to the node following the present string...@>=
> begin prev_p:=cur_p;
> repeat f:=font(cur_p);
> act_width:=act_width+char_width(f)(char_info(f)(character(cur_p)));
> cur_p:=link(cur_p);
> until not is_char_node(cur_p);
13912,13922c17003,17012
< begin if is_char_node(prev_p) then try_break(0,unhyphenated)
< else if precedes_break(prev_p) then try_break(0,unhyphenated);
< end
<
< @ @<Update the active widths by including the glue in |glue_ptr(cur_p)|@>=
< begin check_shrinkage(glue_ptr(cur_p)); q←glue_ptr(cur_p);
< act_width←act_width+width(q);@|
< active_width[2+stretch_order(q)]←@|
< active_width[2+stretch_order(q)]+stretch(q);@/
< active_width[6]←active_width[6]+shrink(q);
< end
---
> begin if is_char_node(prev_p) then try_break(0,unhyphenated)
> else if precedes_break(prev_p) then try_break(0,unhyphenated)
> else if (type(prev_p)=kern_node)and(subtype(prev_p)<>explicit) then
> try_break(0,unhyphenated);
> end;
> check_shrinkage(glue_ptr(cur_p)); q:=glue_ptr(cur_p);
> act_width:=act_width+width(q);@|
> active_width[2+stretch_order(q)]:=@|
> active_width[2+stretch_order(q)]+stretch(q);@/
> active_width[6]:=active_width[6]+shrink(q)
13925c17015
< only character nodes, kern nodes, and ligature nodes.
---
> only character nodes, kern nodes, box nodes, rule nodes, and ligature nodes.
13927,13928c17017,17018
< @<Try to break after a discretionary fragment@>=
< begin s←pre_break(cur_p);
---
> @<Try to break after a discretionary fragment...@>=
> begin s:=pre_break(cur_p); disc_width:=0;
13930,13937c17020,17032
< else begin disc_width←0;
< repeat @<Add the width of node |s| to |disc_width|@>;
< s←link(s);
< until s=null;
< act_width←act_width+disc_width;
< try_break(hyphen_penalty,hyphenated);
< act_width←act_width-disc_width;
< end;
---
> else begin repeat @<Add the width of node |s| to |disc_width|@>;
> s:=link(s);
> until s=null;
> act_width:=act_width+disc_width;
> try_break(hyphen_penalty,hyphenated);
> act_width:=act_width-disc_width;
> end;
> r:=replace_count(cur_p); s:=link(cur_p);
> while r>0 do
> begin @<Add the width of node |s| to |act_width|@>;
> decr(r); s:=link(s);
> end;
> prev_p:=cur_p; cur_p:=s; goto done5;
13942,13953c17037,17065
< begin f←font(s);
< disc_width←disc_width+char_width(f)(char_info(f)(character(s)));
< end
< else case type(s) of
< ligature_node: begin f←font(lig_char(s));
< disc_width←disc_width+
< char_width(f)(char_info(f)(character(lig_char(s))));
< end;
< kern_node: disc_width←disc_width+width(s);
< othercases confusion("disc3")
< @:confusion disc3}{\quad disc3@>
< endcases
---
> begin f:=font(s);
> disc_width:=disc_width+char_width(f)(char_info(f)(character(s)));
> end
> else case type(s) of
> ligature_node: begin f:=font(lig_char(s));
> disc_width:=disc_width+
> char_width(f)(char_info(f)(character(lig_char(s))));
> end;
> hlist_node,vlist_node,rule_node,kern_node:
> disc_width:=disc_width+width(s);
> othercases confusion("disc3")
> @:this can't happen disc3}{\quad disc3@>
> endcases
>
> @ @<Add the width of node |s| to |act_width|@>=
> if is_char_node(s) then
> begin f:=font(s);
> act_width:=act_width+char_width(f)(char_info(f)(character(s)));
> end
> else case type(s) of
> ligature_node: begin f:=font(lig_char(s));
> act_width:=act_width+
> char_width(f)(char_info(f)(character(lig_char(s))));
> end;
> hlist_node,vlist_node,rule_node,kern_node:
> act_width:=act_width+width(s);
> othercases confusion("disc4")
> @:this can't happen disc4}{\quad disc4@>
> endcases
13958c17070
< correct ``looseness.'' On the second pass, there will be at least one active
---
> correct ``looseness.'' On the final pass, there will be at least one active
13970c17082
< and the optimum |best_line|}
---
> and the optimum |best_line|}
13972c17084
< the optimum |best_line|}
---
> the optimum |best_line|}
13976,13981c17088,17093
< if link(active)≠last_active then
< begin @<Find an active node with fewest demerits@>;
< if looseness=0 then goto done;
< @<Find the best active node for the desired looseness@>;
< if (actual_looseness=looseness)∨ second_pass then goto done;
< end;
---
> if link(active)<>last_active then
> begin @<Find an active node with fewest demerits@>;
> if looseness=0 then goto done;
> @<Find the best active node for the desired looseness@>;
> if (actual_looseness=looseness)or final_pass then goto done;
> end;
13985,13989c17097,17101
< r←link(active); fewest_demerits←awful_bad;
< repeat if type(r)≠delta_node then if total_demerits(r)<fewest_demerits then
< begin fewest_demerits←total_demerits(r); best_bet←r;
< end;
< r←link(r);
---
> r:=link(active); fewest_demerits:=awful_bad;
> repeat if type(r)<>delta_node then if total_demerits(r)<fewest_demerits then
> begin fewest_demerits:=total_demerits(r); best_bet:=r;
> end;
> r:=link(r);
13991c17103
< best_line←line_number(best_bet)
---
> best_line:=line_number(best_bet)
13999,14012c17111,17124
< begin r←link(active); actual_looseness←0;
< repeat if type(r)≠delta_node then
< begin line_diff←line_number(cur_p)-best_line;
< if ((line_diff<actual_looseness)∧(looseness≤line_diff))∨@|
< ((line_diff>actual_looseness)∧(looseness≥line_diff)) then
< begin best_bet←cur_p; actual_looseness←line_diff;
< fewest_demerits←total_demerits(r);
< end
< else if (line_diff=actual_looseness)∧@|
< (total_demerits(r)<fewest_demerits) then
< begin best_bet←cur_p; fewest_demerits←total_demerits(r);
< end;
< end;
< r←link(r);
---
> begin r:=link(active); actual_looseness:=0;
> repeat if type(r)<>delta_node then
> begin line_diff:=line_number(r)-best_line;
> if ((line_diff<actual_looseness)and(looseness<=line_diff))or@|
> ((line_diff>actual_looseness)and(looseness>=line_diff)) then
> begin best_bet:=r; actual_looseness:=line_diff;
> fewest_demerits:=total_demerits(r);
> end
> else if (line_diff=actual_looseness)and@|
> (total_demerits(r)<fewest_demerits) then
> begin best_bet:=r; fewest_demerits:=total_demerits(r);
> end;
> end;
> r:=link(r);
14014c17126
< best_line←line_number(best_bet);
---
> best_line:=line_number(best_bet);
14017c17129
< @ Once the best sequence of breakpoints has been found, we call on the
---
> @ Once the best sequence of breakpoints has been found (hurray), we call on the
14026c17138
< is |best_line-already-1|. The last breakpoint is specified by
---
> is |best_line-prev_graf-1|. The last breakpoint is specified by
14040a17153
> @!post_disc_break:boolean; {and did it have a nonempty post-break part?}
14047,14048c17160,17161
< first breakpoint@>;
< cur_line←already+1;
---
> first breakpoint@>;
> cur_line:=prev_graf+1;
14050,14053c17163,17167
< current vertical list, together with associated penalties and other
< insertions@>;
< incr(cur_line); cur_p←next_break(cur_p);
< if cur_p≠null then @<Prune unwanted nodes at the beginning of the next line@>;
---
> current vertical list, together with associated penalties and other
> insertions@>;
> incr(cur_line); cur_p:=next_break(cur_p);
> if cur_p<>null then if not post_disc_break then
> @<Prune unwanted nodes at the beginning of the next line@>;
14055,14058c17169,17172
< if (cur_line≠best_line)∨(link(temp_head)≠null) then
< confusion("line breaking");
< @:confusion line breaking}{\quad line breaking@>
< already←best_line-1;
---
> if (cur_line<>best_line)or(link(temp_head)<>null) then
> confusion("line breaking");
> @:this can't happen line breaking}{\quad line breaking@>
> prev_graf:=best_line-1;
14068,14069c17182,17183
< q←break_node(best_bet); cur_p←null;
< repeat r←q; q←prev_break(q); next_break(r)←cur_p; cur_p←r;
---
> q:=break_node(best_bet); cur_p:=null;
> repeat r:=q; q:=prev_break(q); next_break(r):=cur_p; cur_p:=r;
14073,14074c17187,17189
< a line, except in the unusual case that the node to be deleted is actually
< one of the chosen breakpoints. The pruning done here is designed to match
---
> a line, except in the anomalous case that the node to be deleted is actually
> one of the chosen breakpoints. Otherwise
> the pruning done here is designed to match
14079,14091c17194,17207
< begin r←temp_head;
< loop@+ begin q←link(r);
< if q=cur_break(cur_p) then goto done1;
< {|cur_break(cur_p)| is the next breakpoint}
< {now |q| cannot be |null|}
< if is_char_node(q) then goto done1;
< if non_discardable(q) then goto done1;
< r←q; {now |type(q)=glue_node|, |kern_node|, |math_node| or |penalty_node|}
< end;
< done1: if r≠temp_head then
< begin link(r)←null; flush_node_list(link(temp_head));
< link(temp_head)←q;
< end;
---
> begin r:=temp_head;
> loop@+ begin q:=link(r);
> if q=cur_break(cur_p) then goto done1;
> {|cur_break(cur_p)| is the next breakpoint}
> {now |q| cannot be |null|}
> if is_char_node(q) then goto done1;
> if non_discardable(q) then goto done1;
> if type(q)=kern_node then if subtype(q)<>explicit then goto done1;
> r:=q; {now |type(q)=glue_node|, |kern_node|, |math_node| or |penalty_node|}
> end;
> done1: if r<>temp_head then
> begin link(r):=null; flush_node_list(link(temp_head));
> link(temp_head):=q;
> end;
14104c17220
< \.{\\rightskip}; also set the proper value of |disc_break|@>;
---
> \.{\\rightskip}; also set the proper value of |disc_break|@>;
14108c17224
< special nodes taken out of the box by the packager@>;
---
> special nodes taken out of the box by the packager@>;
14115,14130c17231,17246
< q←cur_break(cur_p); disc_break←false;
< if q≠null then {|q| cannot be a |char_node|}
< if type(q)=glue_node then
< begin delete_glue_ref(glue_ptr(q));
< glue_ptr(q)←right_skip;
< subtype(q)←right_skip_code+1; add_glue_ref(right_skip);
< goto done;
< end
< else begin if type(q)=disc_node then
< @<Change discretionary to compulsory and set
< |disc_break←true|@>;
< if (type(q)=math_node)∨(type(q)=kern_node) then width(q)←0;
< end
< else begin q←temp_head;
< while link(q)≠null do q←link(q);
< end;
---
> q:=cur_break(cur_p); disc_break:=false; post_disc_break:=false;
> if q<>null then {|q| cannot be a |char_node|}
> if type(q)=glue_node then
> begin delete_glue_ref(glue_ptr(q));
> glue_ptr(q):=right_skip;
> subtype(q):=right_skip_code+1; add_glue_ref(right_skip);
> goto done;
> end
> else begin if type(q)=disc_node then
> @<Change discretionary to compulsory and set
> |disc_break:=true|@>
> else if (type(q)=math_node)or(type(q)=kern_node) then width(q):=0;
> end
> else begin q:=temp_head;
> while link(q)<>null do q:=link(q);
> end;
14135,14157c17251,17268
< begin t←replace_count(q);
< @<Destroy the |t| nodes following |q|, but save the last one if it is
< a necessary kern; make |r| point to the following node@>;
< if post_break(q)≠null then @<Transplant the post-break list@>;
< if pre_break(q)≠null then @<Transplant the pre-break list@>;
< link(q)←r; disc_break←true;
< end
<
< @ A subtle bug that would perhaps never have been detected is avoided here
< by preserving a kern node that just might equal |cur_break(next_break(cur_p))|.
<
< @<Destroy the |t| nodes following |q|...@>=
< if t=0 then r←link(q)
< else begin r←q;
< while t>1 do
< begin r←link(r); decr(t);
< end;
< s←link(r);
< if ¬is_char_node(s) then if next_break(cur_p)≠null then
< if cur_break(next_break(cur_p))=s then s←r;
< r←link(s); link(s)←null;
< flush_node_list(link(q)); replace_count(q)←0;
< end
---
> begin t:=replace_count(q);
> @<Destroy the |t| nodes following |q|, and
> make |r| point to the following node@>;
> if post_break(q)<>null then @<Transplant the post-break list@>;
> if pre_break(q)<>null then @<Transplant the pre-break list@>;
> link(q):=r; disc_break:=true;
> end
>
> @ @<Destroy the |t| nodes following |q|...@>=
> if t=0 then r:=link(q)
> else begin r:=q;
> while t>1 do
> begin r:=link(r); decr(t);
> end;
> s:=link(r);
> r:=link(s); link(s):=null;
> flush_node_list(link(q)); replace_count(q):=0;
> end
14163,14165c17274,17276
< begin s←post_break(q);
< while link(s)≠null do s←link(s);
< link(s)←r; r←post_break(q); post_break(q)←null;
---
> begin s:=post_break(q);
> while link(s)<>null do s:=link(s);
> link(s):=r; r:=post_break(q); post_break(q):=null; post_disc_break:=true;
14172,14174c17283,17285
< begin s←pre_break(q); link(q)←s;
< while link(s)≠null do s←link(s);
< pre_break(q)←null; q←s;
---
> begin s:=pre_break(q); link(q):=s;
> while link(s)<>null do s:=link(s);
> pre_break(q):=null; q:=s;
14178c17289
< r←new_param_glue(right_skip_code); link(r)←link(q); link(q)←r; q←r
---
> r:=new_param_glue(right_skip_code); link(r):=link(q); link(q):=r; q:=r
14185,14189c17296,17307
< r←link(q); link(q)←null; q←link(temp_head); link(temp_head)←r;
< if left_skip≠zero_glue then
< begin r←new_param_glue(left_skip_code);
< link(r)←q; q←r;
< end
---
> r:=link(q); link(q):=null; q:=link(temp_head); link(temp_head):=r;
> if left_skip<>zero_glue then
> begin r:=new_param_glue(left_skip_code);
> link(r):=q; q:=r;
> end
>
> @ @<Append the new box to the current vertical list...@>=
> append_to_vlist(just_box);
> if adjust_head<>adjust_tail then
> begin link(tail):=link(adjust_head); tail:=adjust_tail;
> end;
> adjust_tail:=null
14198,14199c17316,17317
< begin cur_width←second_width; cur_indent←second_indent;
< end
---
> begin cur_width:=second_width; cur_indent:=second_indent;
> end
14201,14215c17319,17325
< begin cur_width←first_width; cur_indent←first_indent;
< end
< else begin cur_width←mem[par_shape_ptr+2*cur_line].sc;
< cur_indent←mem[par_shape_ptr+2*cur_line-1].sc;
< end;
< just_box←hpack(q,cur_width,exactly);
< shift_amount(just_box)←cur_indent
<
< @ @<Append the new box to the current vertical list...@>=
< append_to_vlist(just_box);
< if adjustments≠null then
< begin link(tail)←adjustments;
< repeat tail←link(tail);
< until link(tail)=null;
< end
---
> begin cur_width:=first_width; cur_indent:=first_indent;
> end
> else begin cur_width:=mem[par_shape_ptr+2*cur_line].sc;
> cur_indent:=mem[par_shape_ptr+2*cur_line-1].sc;
> end;
> adjust_tail:=adjust_head; just_box:=hpack(q,cur_width,exactly);
> shift_amount(just_box):=cur_indent
14217,14218c17327,17328
< @ Penalties between the lines of a paragraph come from widow lines, from
< the |inter_line_penalty| parameter, and from lines that end at
---
> @ Penalties between the lines of a paragraph come from club and widow lines,
> from the |inter_line_penalty| parameter, and from lines that end at
14220,14221c17330,17332
< two contributions of widow-line penalties. The local variable |pen| will
< be set to the sum of all relevant penalties for the current line.
---
> both club-line and widow-line penalties. The local variable |pen| will
> be set to the sum of all relevant penalties for the current line, except
> that the final line is never penalized.
14224,14232c17335,17346
< if cur_line+1=best_line then pen←0@+else pen←inter_line_penalty;
< if (cur_line=already+1)∧(best_line≠already+2) then pen←pen+widow_penalty;
< if cur_line+2=best_line then pen←pen+final_widow_penalty;
< if disc_break then pen←pen+broken_penalty;
< if pen≠0 then
< begin r←new_penalty(pen);
< link(tail)←r; tail←r;
< end
< @* \[39] Pre-hyphenation.
---
> if cur_line+1<>best_line then
> begin pen:=inter_line_penalty;
> if cur_line=prev_graf+1 then pen:=pen+club_penalty;
> if cur_line+2=best_line then pen:=pen+final_widow_penalty;
> if disc_break then pen:=pen+broken_penalty;
> if pen<>0 then
> begin r:=new_penalty(pen);
> link(tail):=r; tail:=r;
> end;
> end
>
> @* \[40] Pre-hyphenation.
14248,14268c17362,17385
< This is a sequence of nodes $p↓0p↓1\ldotsm p↓m$ where $p↓0$ is a glue
< node, $p↓1\ldotsm p↓{m-1}$ are either character or ligature or kern nodes,
< and $p↓m$ is a glue or penalty or insertion or adjust or mark node.
< (Therefore hyphenation is disabled by boxes, math formulas, whatsit nodes, and
< discretionary nodes already inserted by the user.) The ligature nodes among
< $p↓1\ldotsm p↓{m-1}$ are effectively expanded into the original non-ligature
< characters, and the kern nodes are ignored. Each character $c$ is now
< classified as either a nonletter (if |c≥128| or |lc_code(c)=0|), a lower
< case letter (if |lc_code(c)=c|), or an upper case letter (otherwise); an
< upper case letter is treated as if it were |lc_code(c)| for purposes of
< hyphenation. The characters generated by $p↓1\ldotsm p↓{m-1}$ may begin with
< nonletters; let $c↓1$ be the first letter that is not in the middle
< of a ligature. All characters that do not have
< the same font as $c↓1$ will be treated as nonletters. \TeX\ looks ahead
< for as many consecutive letters $c↓1\ldotsm c↓n$ as possible; however,
< |n| must be less than 64, so a character that would otherwise be $c↓{64}$
< is effectively not a letter. Furthermore $c↓n$ must not be in the middle
< of a ligature. In this way we obtain a string of letters
< $c↓1\ldotsm c↓n$ that are generated by nodes $p↓a\ldotsm p↓b$, where
< |1≤a≤b+1≤m|. If |n≥5|, this string qualifies for hyphenation; however,
< |uc_hyph| must be nonzero, if $c↓1$ is upper case.
---
> This is a sequence of nodes $p_0p_1\ldots p_m$ where $p_0$ is a glue node,
> $p_1\ldots p_{m-1}$ are either character or ligature or whatsit or
> implicit kern nodes, and $p_m$ is a glue or penalty or insertion or adjust
> or mark or whatsit or explicit kern node. (Therefore hyphenation is
> disabled by boxes, math formulas, and discretionary nodes already inserted
> by the user.) The ligature nodes among $p_1\ldots p_{m-1}$ are effectively
> expanded into the original non-ligature characters; the kern nodes and
> whatsits are ignored. Each character |c| is now classified as either a
> nonletter (if |lc_code(c)=0|), a lowercase letter (if
> |lc_code(c)=c|), or an uppercase letter (otherwise); an uppercase letter
> is treated as if it were |lc_code(c)| for purposes of hyphenation. The
> characters generated by $p_1\ldots p_{m-1}$ may begin with nonletters; let
> $c_1$ be the first letter that is not in the middle of a ligature. Whatsit
> nodes preceding $c_1$ are ignored; a whatsit found after $c_1$ will be the
> terminating node $p_m$. All characters that do not have the same font as
> $c_1$ will be treated as nonletters. The |hyphen_char| for that font
> must be between 0 and 255, otherwise hyphenation will not be attempted.
> \TeX\ looks ahead for as many consecutive letters $c_1\ldots c_n$ as
> possible; however, |n| must be less than 64, so a character that would
> otherwise be $c_{64}$ is effectively not a letter. Furthermore $c_n$ must
> not be in the middle of a ligature. In this way we obtain a string of
> letters $c_1\ldots c_n$ that are generated by nodes $p_a\ldots p_b$, where
> |1<=a<=b+1<=m|. If |n>=l_hyf+r_hyf|, this string qualifies for hyphenation;
> however, |uc_hyph| must be positive, if $c_1$ is uppercase.
14271c17388
< sequence $c↓1\ldotsm c↓n$ is found; then potential positions for hyphens
---
> sequence $c_1\ldots c_n$ is found; then potential positions for hyphens
14273c17390
< $p↓a\ldotsm p↓b$ are replaced by a new sequence of nodes that includes the
---
> $p_a\ldots p_b$ are replaced by a new sequence of nodes that includes the
14284c17401,17406
< @ The letters $c↓1\ldotsm c↓n$ that are candidates for hyphenation are placed
---
> @<Initialize for hyphenating...@>=
> begin @!init if trie_not_ready then init_trie;@+tini@;@/
> cur_lang:=init_cur_lang; l_hyf:=init_l_hyf; r_hyf:=init_r_hyf;
> end
>
> @ The letters $c_1\ldots c_n$ that are candidates for hyphenation are placed
14286c17408
< nodes $p↓a$ and@@$p↓b$ in the description above are placed into variables
---
> nodes $p_{a-1}$ and~$p_b$ in the description above are placed into variables
14290c17412
< @!hc:array[0..65] of ascii_code; {word to be hyphenated}
---
> @!hc:array[0..65] of 0..256; {word to be hyphenated}
14294c17416,17420
< @!hu:array[1..63] of ascii_code; {like |hc|, before conversion to lower case}
---
> @!hu:array[0..63] of 0..256; {like |hc|, before conversion to lowercase}
> @!hyf_char:integer; {hyphen character of the relevant font}
> @!cur_lang,@!init_cur_lang:ASCII_code; {current hyphenation table of interest}
> @!l_hyf,@!r_hyf,@!init_l_hyf,@!init_r_hyf:integer; {limits on fragment sizes}
> @!hyf_bchar:halfword; {boundary character after $c_n$}
14299c17425
< @!i,@!j,@!l:small_number; {indices into |hc| or |hu|}
---
> @!j:small_number; {an index into |hc| or |hu|}
14306,14315c17432,17441
< begin s←link(cur_p);
< if s≠null then
< begin @<Skip to node |ha|, or |goto done1| if no hyphenation
< should be attempted@>;
< @<Skip to node |hb|, putting letters into |hu| and |hc|,
< or |goto done1| if no hyphenation should be attempted@>;
< @<Check that the nodes following |hb| permit hyphenation and that
< at least five letters have been found, otherwise |goto done1|@>;
< hyphenate;
< end;
---
> begin prev_s:=cur_p; s:=link(prev_s);
> if s<>null then
> begin @<Skip to node |ha|, or |goto done1| if no hyphenation
> should be attempted@>;
> if l_hyf+r_hyf>63 then goto done1;
> @<Skip to node |hb|, putting letters into |hu| and |hc|@>;
> @<Check that the nodes following |hb| permit hyphenation and that at least
> |l_hyf+r_hyf| letters have been found, otherwise |goto done1|@>;
> hyphenate;
> end;
14321,14323c17447,17449
< label done,found,not_found,found1,exit;
< var@?@<Local variables for hyphenation@>@;
< begin @<Find hyphen locations for the word in |hc|@>;
---
> label common_ending,done,found,found1,found2,not_found,exit;
> var @<Local variables for hyphenation@>@;
> begin @<Find hyphen locations for the word in |hc|, or |return|@>;
14326c17452
< the discretionary hyphens@>;
---
> the discretionary hyphens@>;
14329c17455
< @ The first thing we need to do is find the node |ha| that contains the
---
> @ The first thing we need to do is find the node |ha| just before the
14333,14346c17459,17480
< loop@+ begin if is_char_node(s) then
< begin c←qo(character(s)); hf←font(s);
< end
< else if type(s)=ligature_node then
< begin q←lig_ptr(s); c←qo(character(q)); hf←font(q);
< end
< else if type(s)≠kern_node then goto done1
< else c←128;
< if c<128 then if lc_code(c)≠0 then
< if (lc_code(c)=c)∨(uc_hyph≠0) then goto done2
< else goto done1;
< s←link(s);
< end;
< done2: ha←s
---
> loop@+ begin if is_char_node(s) then
> begin c:=qo(character(s)); hf:=font(s);
> end
> else if type(s)=ligature_node then
> if lig_ptr(s)=null then goto continue
> else begin q:=lig_ptr(s); c:=qo(character(q)); hf:=font(q);
> end
> else if (type(s)=kern_node)and(subtype(s)=normal) then goto continue
> else if type(s)=whatsit_node then
> begin @<Advance \(p)past a whatsit node in the \(p)pre-hyphenation loop@>;
> goto continue;
> end
> else goto done1;
> if lc_code(c)<>0 then
> if (lc_code(c)=c)or(uc_hyph>0) then goto done2
> else goto done1;
> continue: prev_s:=s; s:=link(prev_s);
> end;
> done2: hyf_char:=hyphen_char[hf];
> if hyf_char<0 then goto done1;
> if hyf_char>255 then goto done1;
> ha:=prev_s
14351,14364c17485,17502
< hn←0;
< loop@+ begin if is_char_node(s) then
< begin if font(s)≠hf then goto done3;
< c←qo(character(s));
< if c≥128 then goto done3;
< if (lc_code(c)=0)∨(hn=63) then goto done3;
< hb←s; incr(hn); hu[hn]←c; hc[hn]←lc_code(c);
< end
< else if type(s)=ligature_node then
< @<Move the characters of a ligature node to |hu| and |hc|;
< but |goto done3| if they are not all letters@>
< else if type(s)≠kern_node then goto done3;
< s←link(s);
< end;
---
> hn:=0;
> loop@+ begin if is_char_node(s) then
> begin if font(s)<>hf then goto done3;
> hyf_bchar:=character(s); c:=qo(hyf_bchar);
> if lc_code(c)=0 then goto done3;
> if hn=63 then goto done3;
> hb:=s; incr(hn); hu[hn]:=c; hc[hn]:=lc_code(c); hyf_bchar:=non_char;
> end
> else if type(s)=ligature_node then
> @<Move the characters of a ligature node to |hu| and |hc|;
> but |goto done3| if they are not all letters@>
> else if (type(s)=kern_node)and(subtype(s)=normal) then
> begin hb:=s;
> hyf_bchar:=font_bchar[hf];
> end
> else goto done3;
> s:=link(s);
> end;
14373,14381c17511,17521
< begin j←hn; q←lig_ptr(s);
< if font(q)≠hf then goto done3;
< repeat c←qo(character(q));
< if c≥128 then goto done3;
< if (lc_code(c)=0)∨(j=63) then goto done3;
< incr(j); hu[j]←c; hc[j]←lc_code(c);@/
< q←link(q);
< until q=null;
< hb←s; hn←j;
---
> begin if font(lig_char(s))<>hf then goto done3;
> j:=hn; q:=lig_ptr(s);@+if q>null then hyf_bchar:=character(q);
> while q>null do
> begin c:=qo(character(q));
> if lc_code(c)=0 then goto done3;
> if j=63 then goto done3;
> incr(j); hu[j]:=c; hc[j]:=lc_code(c);@/
> q:=link(q);
> end;
> hb:=s; hn:=j;
> if odd(subtype(s)) then hyf_bchar:=font_bchar[hf]@+else hyf_bchar:=non_char;
14385,14394c17525,17535
< if hn<5 then goto done1;
< loop@+ begin if ¬(is_char_node(s)) then
< case type(s) of
< ligature_node,kern_node: do_nothing;
< glue_node,penalty_node,ins_node,adjust_node,mark_node:
< goto done4;
< othercases goto done1
< endcases;
< s←link(s);
< end;
---
> if hn<l_hyf+r_hyf then goto done1; {|l_hyf| and |r_hyf| are |>=1|}
> loop@+ begin if not(is_char_node(s)) then
> case type(s) of
> ligature_node: do_nothing;
> kern_node: if subtype(s)<>normal then goto done4;
> whatsit_node,glue_node,penalty_node,ins_node,adjust_node,mark_node:
> goto done4;
> othercases goto done1
> endcases;
> s:=link(s);
> end;
14396c17537,17538
< @* \[40] Post-hyphenation.
---
>
> @* \[41] Post-hyphenation.
14405a17548,17550
> @!init_list:pointer; {list of punctuation characters preceding the word}
> @!init_lig:boolean; {does |init_list| represent a ligature?}
> @!init_lft:boolean; {if so, did the ligature involve a left boundary?}
14408c17553
< @!i,@!j,@!l:small_number; {indices into |hc| or |hu|}
---
> @!i,@!j,@!l:0..65; {indices into |hc| or |hu|}
14409a17555
> @!bchar:halfword; {right boundary character of hyphenated word, or |non_char|}
14411,14414c17557,17562
< @ \TeX\ will never insert a hyphen that has fewer than two letters before
< it or fewer than three after it; hence, a five-letter word has comparatively
< little chance of being hyphenated. If no hyphens have been found,
< we can save time by not having to make any changes to the paragraph.
---
> @ \TeX\ will never insert a hyphen that has fewer than
> \.{\\lefthyphenmin} letters before it or fewer than
> \.{\\righthyphenmin} after it; hence, a short word has
> comparatively little chance of being hyphenated. If no hyphens have
> been found, we can save time by not having to make any changes to the
> paragraph.
14417c17565
< for j←2 to hn-3 do if odd(hyf[j]) then goto found1;
---
> for j:=l_hyf to hn-r_hyf do if odd(hyf[j]) then goto found1;
14422,14423c17570,17577
< subsequence of nodes |ha..hb|. The variable |s| will point to the node
< preceding |ha|, and |q| will point to the node following |hb|, so that
---
> subsequence of nodes between |ha| and~|hb|. An attempt is made to
> preserve the effect that implicit boundary characters and punctuation marks
> had on ligatures inside the hyphenated word, by storing a left boundary or
> preceding character in |hu[0]| and by storing a possible right boundary
> in |bchar|. We set |j:=0| if |hu[0]| is to be part of the reconstruction;
> otherwise |j:=1|.
> The variable |s| will point to the tail of the current hlist, and
> |q| will point to the node following |hb|, so that
14427,14430c17581,17606
< q←link(hb); link(hb)←null; s←cur_p;
< while link(s)≠ha do s←link(s);
< link(s)←null; flush_node_list(ha);
< @<Reconstitute nodes for the hyphenated word, inserting discretionary hyphens@>
---
> q:=link(hb); link(hb):=null; r:=link(ha); link(ha):=null; bchar:=hyf_bchar;
> if is_char_node(ha) then
> if font(ha)<>hf then goto found2
> else begin init_list:=ha; init_lig:=false; hu[0]:=qo(character(ha));
> end
> else if type(ha)=ligature_node then
> if font(lig_char(ha))<>hf then goto found2
> else begin init_list:=lig_ptr(ha); init_lig:=true; init_lft:=(subtype(ha)>1);
> hu[0]:=qo(character(lig_char(ha)));
> if init_list=null then if init_lft then
> begin hu[0]:=256; init_lig:=false;
> end; {in this case a ligature will be reconstructed from scratch}
> free_node(ha,small_node_size);
> end
> else begin {no punctuation found; look for left boundary}
> if not is_char_node(r) then if type(r)=ligature_node then
> if subtype(r)>1 then goto found2;
> j:=1; s:=ha; init_list:=null; goto common_ending;
> end;
> s:=cur_p; {we have |cur_p<>ha| because |type(cur_p)=glue_node|}
> while link(s)<>ha do s:=link(s);
> j:=0; goto common_ending;
> found2: s:=ha; j:=0; hu[0]:=256; init_lig:=false; init_list:=null;
> common_ending: flush_node_list(r);
> @<Reconstitute nodes for the hyphenated word, inserting discretionary hyphens@>;
> flush_list(init_list)
14433c17609
< {\def\!{\kern-1pt}
---
> {\def\!{\kern-1pt}%
14435,14447c17611,17633
< because ligatures might change when a hyphen is present. The manual discusses
< the difficulties of the word ``difficult'', but since fonts can include
< highly general ligatures, the discretionary material surrounding a hyphen can
< be even more complex than that. For example, suppose that \.{abcdef} is a
< word in a font for which the only ligatures are \.{b\!c}, \.{c\!d}, \.{d\!e},
< and \.{e\!f}. If this word is to permit hyphenation between \.b and \.c, the
< two patterns with and without hyphenation are $\.a\,\.{b\!c}\,\.{d\!e}\,\.f$
< and $\.a\,\.b\,\.-\,\.{c\!d}\,\.{e\!f}$. Thus the insertion of a hyphen might
< cause effects to ripple arbitrarily far into the rest of the word. A
< further complication arises if additional hyphens appear together with
< such rippling, e.g., if the word in the example just given could also be
< hyphenated between \.c and \.d; \TeX\ avoids this by simply ignoring the
< additional hyphens in such weird cases.}
---
> because ligatures might change when a hyphen is present. {\sl The \TeX book\/}
> discusses the difficulties of the word ``difficult'', and
> the discretionary material surrounding a
> hyphen can be considerably more complex than that. Suppose
> \.{abcdef} is a word in a font for which the only ligatures are \.{b\!c},
> \.{c\!d}, \.{d\!e}, and \.{e\!f}. If this word permits hyphenation
> between \.b and \.c, the two patterns with and without hyphenation are
> $\.a\,\.b\,\.-\,\.{c\!d}\,\.{e\!f}$ and $\.a\,\.{b\!c}\,\.{d\!e}\,\.f$.
> Thus the insertion of a hyphen might cause effects to ripple arbitrarily
> far into the rest of the word. A further complication arises if additional
> hyphens appear together with such rippling, e.g., if the word in the
> example just given could also be hyphenated between \.c and \.d; \TeX\
> avoids this by simply ignoring the additional hyphens in such weird cases.}
>
> Still further complications arise in the presence of ligatures that do not
> delete the original characters. When punctuation precedes the word being
> hyphenated, \TeX's method is not perfect under all possible scenarios,
> because punctuation marks and letters can propagate information back and forth.
> For example, suppose the original pre-hyphenation pair
> \.{*a} changes to \.{*y} via a \.{\?=:} ligature, which changes to \.{xy}
> via a \.{=:\?} ligature; if $p_{a-1}=\.x$ and $p_a=\.y$, the reconstitution
> procedure isn't smart enough to obtain \.{xy} again. In such cases the
> font designer should include a ligature that goes from \.{xa} to \.{xy}.
14450,14472c17636,17668
< an index@@|j|, this function creates a node for the next character or ligature
< found in the |hu| array starting at |hu[j]|, using font |hf|. For example,
< if |hu[j..j+2]| contains the three letters `f', `i', and `x', and if
< font |hf| contains an `fi' ligature but no `fix' ligature, then |reconstitute|
< will create a ligature node for `fi'. The index of the last character
< consumed, in this case |j+1|, will be returned. Furthermore, a kern node
< is created and appended, if kerning is called for between the consumed
< character or ligature and the next (unconsumed) character.
<
< A second parameter, |n|, gives the limit beyond which this procedure does not
< advance. In other words, |hu[n]| might be consumed, but |hu[n+1]| is never
< accessed.
<
< The global variable |hyphen_passed| is set to@@|k| if this procedure
< consumes two characters |hu[k]| and |hu[k+1]| such that |hyf[k]| is odd,
< i.e., if the ligature might have to be broken by a hyphen, or if a kern is
< inserted between |hu[k]| and |hu[k+1]|. If this condition holds for more
< than one value of |k|, the smallest value is used; and if the condition
< holds for no values of |k|, |hyphen_passed| is set to zero.
<
< After |reconstitute| has acted, |link(hold_head)| points to the character
< or ligature node that was created, and |link(link(hold_head))| will either
< be |null| or a pointer to the kern node that was appended.
---
> a string of characters $x_j\ldots x_n$, there is a smallest index $m\ge j$
> such that the ``translation'' of $x_j\ldots x_n$ by ligatures and kerning
> has the form $y_1\ldots y_t$ followed by the translation of $x_{m+1}\ldots x_n$,
> where $y_1\ldots y_t$ is some nonempty sequence of character, ligature, and
> kern nodes. We call $x_j\ldots x_m$ a ``cut prefix'' of $x_j\ldots x_n$.
> For example, if $x_1x_2x_3=\.{fly}$, and if the font contains `fl' as a
> ligature and a kern between `fl' and `y', then $m=2$, $t=2$, and $y_1$ will
> be a ligature node for `fl' followed by an appropriate kern node~$y_2$.
> In the most common case, $x_j$~forms no ligature with $x_{j+1}$ and we
> simply have $m=j$, $y_1=x_j$. If $m<n$ we can repeat the procedure on
> $x_{m+1}\ldots x_n$ until the entire translation has been found.
>
> The |reconstitute| function returns the integer $m$ and puts the nodes
> $y_1\ldots y_t$ into a linked list starting at |link(hold_head)|,
> getting the input $x_j\ldots x_n$ from the |hu| array. If $x_j=256$,
> we consider $x_j$ to be an implicit left boundary character; in this
> case |j| must be strictly less than~|n|. There is a
> parameter |bchar|, which is either 256 or an implicit right boundary character
> assumed to be present just following~$x_n$. (The value |hu[n+1]| is never
> explicitly examined, but the algorithm imagines that |bchar| is there.)
>
> If there exists an index |k| in the range $j\le k\le m$ such that |hyf[k]|
> is odd and such that the result of |reconstitute| would have been different
> if $x_{k+1}$ had been |hchar|, then |reconstitute| sets |hyphen_passed|
> to the smallest such~|k|. Otherwise it sets |hyphen_passed| to zero.
>
> A special convention is used in the case |j=0|: Then we assume that the
> translation of |hu[0]| appears in a special list of charnodes starting at
> |init_list|; moreover, if |init_lig| is |true|, then |hu[0]| will be
> a ligature character, involving a left boundary if |init_lft| is |true|.
> This facility is provided for cases when a hyphenated
> word is preceded by punctuation (like single or double quotes) that might
> affect the translation of the beginning of the word.
14478,14479c17674,17675
< function reconstitute(@!j,@!n:small_number):
< small_number;
---
> function reconstitute(@!j,@!n:small_number;@!bchar,@!hchar:halfword):
> small_number;
14481,14482c17677,17678
< var p:pointer; {a node being created}
< @!s:pointer; {a node being appended to}
---
> var @!p:pointer; {temporary register for list manipulation}
> @!t:pointer; {a node being appended to}
14484,14485c17680,17681
< @!c:quarterword; {current character}
< @!d:quarterword; {current character or ligature}
---
> @!cur_rh:halfword; {hyphen character for ligature testing}
> @!test_char:halfword; {hyphen or other character for ligature testing}
14487,14503c17683,17709
< @!r:0..font_mem_size; {position of current lig/kern instruction}
< begin @<Build a list of characters in a maximal ligature, and set |w|
< to the amount of kerning that should follow@>;
< @<If the list has more than one element, create a ligature node@>;
< @<Attach kerning, if |w≠0|@>;
< reconstitute←j;
< end;
<
< @ @<Build a list of characters in a maximal ligature...@>=
< hyphen_passed←0; s←hold_head; w←0; d←qi(hu[j]); c←d;
< loop@+ begin continue: p←get_avail; font(p)←hf;
< character(p)←c; link(s)←p;@/
< @<Look for a ligature or kern between |d| and the following
< character; update the data structure and |goto continue|
< if a ligature is found, otherwise update@@|w| and |goto done|@>;
< end;
< done:
---
> @!k:font_index; {position of current lig/kern instruction}
> begin hyphen_passed:=0; t:=hold_head; w:=0; link(hold_head):=null;
> {at this point |ligature_present=lft_hit=rt_hit=false|}
> @<Set up data structures with the cursor following position |j|@>;
> continue:@<If there's a ligature or kern at the cursor position, update the data
> structures, possibly advancing~|j|; continue until the cursor moves@>;
> @<Append a ligature and/or kern to the translation;
> |goto continue| if the stack of inserted ligatures is nonempty@>;
> reconstitute:=j;
> end;
>
> @ The reconstitution procedure shares many of the global data structures
> by which \TeX\ has processed the words before they were hyphenated.
> There is an implied ``cursor'' between characters |cur_l| and |cur_r|;
> these characters will be tested for possible ligature activity. If
> |ligature_present| then |cur_l| is a ligature character formed from the
> original characters following |cur_q| in the current translation list.
> There is a ``ligature stack'' between the cursor and character |j+1|,
> consisting of pseudo-ligature nodes linked together by their |link| fields.
> This stack is normally empty unless a ligature command has created a new
> character that will need to be processed later. A pseudo-ligature is
> a special node having a |character| field that represents a potential
> ligature and a |lig_ptr| field that points to a |char_node| or is |null|.
> We have
> $$|cur_r|=\cases{|character(lig_stack)|,&if |lig_stack>null|;\cr
> |qi(hu[j+1])|,&if |lig_stack=null| and |j<n|;\cr
> bchar,&if |lig_stack=null| and |j=n|.\cr}$$
14505,14534c17711,17774
< @ @<Look for a ligature or kern between |d| and...@>=
< if j=n then goto done;
< q←char_info(hf)(d);
< if char_tag(q)≠lig_tag then goto done;
< r←lig_kern_start(hf)(q); c←qi(hu[j+1]);
< loop@+ begin q←font_info[r].qqqq;
< if next_char(q)=c then
< begin if odd(hyf[j])∧(hyphen_passed=0) then hyphen_passed←j;
< if op_bit(q)<kern_flag then
< @<Append to the ligature and |goto continue|@>
< else begin w←char_kern(hf)(q);
< goto done;
< end;
< end
< else if stop_bit(q)<stop_flag then incr(r)
< else goto done;
< end
<
< @ @<Append to the ligature...@>=
< begin d←rem_byte(q);
< incr(j); s←p; goto continue;
< end
<
< @ After the list has been built, |link(s)| points to the final list element.
<
< @<If the list has more than one element, create a ligature node@>=
< if s≠hold_head then
< begin p←new_ligature(hf,d,link(hold_head));
< link(hold_head)←p;
< end
---
> @<Glob...@>=
> @!cur_l,@!cur_r:halfword; {characters before and after the cursor}
> @!cur_q:pointer; {where a ligature should be detached}
> @!lig_stack:pointer; {unfinished business to the right of the cursor}
> @!ligature_present:boolean; {should a ligature node be made for |cur_l|?}
> @!lft_hit,@!rt_hit:boolean; {did we hit a ligature with a boundary character?}
>
> @ @d append_charnode_to_t(#)== begin link(t):=get_avail; t:=link(t);
> font(t):=hf; character(t):=#;
> end
> @d set_cur_r==begin if j<n then cur_r:=qi(hu[j+1])@+else cur_r:=bchar;
> if odd(hyf[j]) then cur_rh:=hchar@+else cur_rh:=non_char;
> end
>
> @<Set up data structures with the cursor following position |j|@>=
> cur_l:=qi(hu[j]); cur_q:=t;
> if j=0 then
> begin ligature_present:=init_lig; p:=init_list;
> if ligature_present then lft_hit:=init_lft;
> while p>null do
> begin append_charnode_to_t(character(p)); p:=link(p);
> end;
> end
> else if cur_l<non_char then append_charnode_to_t(cur_l);
> lig_stack:=null; set_cur_r
>
> @ We may want to look at the lig/kern program twice, once for a hyphen
> and once for a normal letter. (The hyphen might appear after the letter
> in the program, so we'd better not try to look for both at once.)
>
> @<If there's a ligature or kern at the cursor position, update...@>=
> if cur_l=non_char then
> begin k:=bchar_label[hf];
> if k=non_address then goto done@+else q:=font_info[k].qqqq;
> end
> else begin q:=char_info(hf)(cur_l);
> if char_tag(q)<>lig_tag then goto done;
> k:=lig_kern_start(hf)(q); q:=font_info[k].qqqq;
> if skip_byte(q)>stop_flag then
> begin k:=lig_kern_restart(hf)(q); q:=font_info[k].qqqq;
> end;
> end; {now |k| is the starting address of the lig/kern program}
> if cur_rh<non_char then test_char:=cur_rh@+else test_char:=cur_r;
> loop@+begin if next_char(q)=test_char then if skip_byte(q)<=stop_flag then
> if cur_rh<non_char then
> begin hyphen_passed:=j; hchar:=non_char; cur_rh:=non_char;
> goto continue;
> end
> else begin if hchar<non_char then if odd(hyf[j]) then
> begin hyphen_passed:=j; hchar:=non_char;
> end;
> if op_byte(q)<kern_flag then
> @<Carry out a ligature replacement, updating the cursor structure
> and possibly advancing~|j|; |goto continue| if the cursor doesn't
> advance, otherwise |goto done|@>;
> w:=char_kern(hf)(q); goto done; {this kern will be inserted below}
> end;
> if skip_byte(q)>=stop_flag then
> if cur_rh=non_char then goto done
> else begin cur_rh:=non_char; goto continue;
> end;
> k:=k+qo(skip_byte(q))+1; q:=font_info[k].qqqq;
> end;
> done:
14536,14537c17776,17836
< @ @<Attach kerning, if |w≠0|@>=
< if w≠0 then link(link(hold_head))←new_kern(w)
---
> @ @d wrap_lig(#)==if ligature_present then
> begin p:=new_ligature(hf,cur_l,link(cur_q));
> if lft_hit then
> begin subtype(p):=2; lft_hit:=false;
> end;
> if # then if lig_stack=null then
> begin incr(subtype(p)); rt_hit:=false;
> end;
> link(cur_q):=p; t:=p; ligature_present:=false;
> end
> @d pop_lig_stack==begin if lig_ptr(lig_stack)>null then
> begin link(t):=lig_ptr(lig_stack); {this is a charnode for |hu[j+1]|}
> t:=link(t); incr(j);
> end;
> p:=lig_stack; lig_stack:=link(p); free_node(p,small_node_size);
> if lig_stack=null then set_cur_r@+else cur_r:=character(lig_stack);
> end {if |lig_stack| isn't |null| we have |cur_rh=non_char|}
>
> @<Append a ligature and/or kern to the translation...@>=
> wrap_lig(rt_hit);
> if w<>0 then
> begin link(t):=new_kern(w); t:=link(t); w:=0;
> end;
> if lig_stack>null then
> begin cur_q:=t; cur_l:=character(lig_stack); ligature_present:=true;
> pop_lig_stack; goto continue;
> end
>
> @ @<Carry out a ligature replacement, updating the cursor structure...@>=
> begin if cur_l=non_char then lft_hit:=true;
> if j=n then if lig_stack=null then rt_hit:=true;
> check_interrupt; {allow a way out in case there's an infinite ligature loop}
> case op_byte(q) of
> qi(1),qi(5):begin cur_l:=rem_byte(q); {\.{=:\?}, \.{=:\?>}}
> ligature_present:=true;
> end;
> qi(2),qi(6):begin cur_r:=rem_byte(q); {\.{\?=:}, \.{\?=:>}}
> if lig_stack>null then character(lig_stack):=cur_r
> else begin lig_stack:=new_lig_item(cur_r);
> if j=n then bchar:=non_char
> else begin p:=get_avail; lig_ptr(lig_stack):=p;
> character(p):=qi(hu[j+1]); font(p):=hf;
> end;
> end;
> end;
> qi(3):begin cur_r:=rem_byte(q); {\.{\?=:\?}}
> p:=lig_stack; lig_stack:=new_lig_item(cur_r); link(lig_stack):=p;
> end;
> qi(7),qi(11):begin wrap_lig(false); {\.{\?=:\?>}, \.{\?=:\?>>}}
> cur_q:=t; cur_l:=rem_byte(q); ligature_present:=true;
> end;
> othercases begin cur_l:=rem_byte(q); ligature_present:=true; {\.{=:}}
> if lig_stack>null then pop_lig_stack
> else if j=n then goto done
> else begin append_charnode_to_t(cur_r); incr(j); set_cur_r;
> end;
> end
> endcases;
> if op_byte(q)>qi(4) then if op_byte(q)<>qi(7) then goto done;
> goto continue;
> end
14541,14542c17840,17841
< |hu[1..hn]| after node |s|, and node |q| should be appended to the result.
< During this process, the variable |i| will be a temporary counter or an
---
> |hu[1..hn]| after node |ha|, and node |q| should be appended to the result.
> During this process, the variable |i| will be a temporary
14546c17845
< we need two new local variables:
---
> we need a few new local variables:
14550c17849,17853
< discretionary branches being reconstructed}
---
> discretionary branches being reconstructed}
> @!c:ASCII_code; {character temporarily replaced by a hyphen}
> @!c_loc:0..63; {where that character came from}
> @!r_count:integer; {replacement count for discretionary}
> @!hyf_node:pointer; {the hyphen, if it exists}
14552,14553c17855
< @ When the following code is performed, |hyf[j]| will be zero for |j=1|
< and for |j≥hn-2|.
---
> @ When the following code is performed, |hyf[0]| and |hyf[hn]| will be zero.
14556,14575c17858,17889
< j←0;
< repeat l←j; j←reconstitute(j+1,hn);
< if hyphen_passed≠0 then
< @<Create and append a discretionary node as an alternative to the
< ligature, and continue to develop both branches until they
< become equivalent@>
< else begin link(s)←link(hold_head); s←link(s);
< if link(s)≠null then s←link(s);
< end;
< if odd(hyf[j]) then @<Insert a discretionary hyphen after |s|@>;
< until j=hn;
< link(s)←q
<
< @ @<Create and append a discretionary node as an alternative...@>=
< begin r←get_node(small_node_size);
< link(s)←r; link(r)←link(hold_head); type(r)←disc_node;
< major_tail←link(hold_head);
< if link(major_tail)≠null then major_tail←link(major_tail);
< i←hyphen_passed;
< @<Put the \(c)characters |hu[l+1..i]| and a hyphen into |pre_break(r)|@>;
---
> repeat l:=j; j:=reconstitute(j,hn,bchar,qi(hyf_char))+1;
> if hyphen_passed=0 then
> begin link(s):=link(hold_head);
> while link(s)>null do s:=link(s);
> if odd(hyf[j-1]) then
> begin l:=j; hyphen_passed:=j-1; link(hold_head):=null;
> end;
> end;
> if hyphen_passed>0 then
> @<Create and append a discretionary node as an alternative to the
> unhyphenated word, and continue to develop both branches until they
> become equivalent@>;
> until j>hn;
> link(s):=q
>
> @ In this repeat loop we will insert another discretionary if |hyf[j-1]| is
> odd, when both branches of the previous discretionary end at position |j-1|.
> Strictly speaking, we aren't justified in doing this, because we don't know
> that a hyphen after |j-1| is truly independent of those branches. But in almost
> all applications we would rather not lose a potentially valuable hyphenation
> point. (Consider the word `difficult', where the letter `c' is in position |j|.)
>
> @d advance_major_tail==begin major_tail:=link(major_tail); incr(r_count);
> end
>
> @<Create and append a discretionary node as an alternative...@>=
> repeat r:=get_node(small_node_size);
> link(r):=link(hold_head); type(r):=disc_node;
> major_tail:=r; r_count:=0;
> while link(major_tail)>null do advance_major_tail;
> i:=hyphen_passed; hyf[i]:=0;
> @<Put the \(c)characters |hu[l..i]| and a hyphen into |pre_break(r)|@>;
14577c17891
< list and to |major_tail| until synchronization has been achieved@>;
---
> list and to |major_tail| until synchronization has been achieved@>;
14579,14580c17893,17895
< appropriately@>;
< end
---
> appropriately@>;
> hyphen_passed:=j-1; link(hold_head):=null;
> until not odd(hyf[j-1])
14583c17898
< or kern. At this point we have |i≤j|.
---
> or kern. At this point we have |l-1<=i<j| and |i<hn|.
14585,14594c17900,17917
< @<Put the \(c)characters |hu[l+1..i]| and a hyphen into |pre_break(r)|@>=
< minor_tail←null; c←hu[i+1]; hu[i+1]←"-";
< repeat l←reconstitute(l+1,i+1);
< if minor_tail=null then pre_break(r)←link(hold_head)
< else link(minor_tail)←link(hold_head);
< minor_tail←link(hold_head);
< if link(minor_tail)≠null then minor_tail←link(minor_tail);
< until l>i;
< hu[i+1]←c; {restore the character in the hyphen position}
< decr(l); hyf[l]←0
---
> @<Put the \(c)characters |hu[l..i]| and a hyphen into |pre_break(r)|@>=
> minor_tail:=null; pre_break(r):=null; hyf_node:=new_character(hf,hyf_char);
> if hyf_node<>null then
> begin incr(i); c:=hu[i]; hu[i]:=hyf_char; free_avail(hyf_node);
> end;
> while l<=i do
> begin l:=reconstitute(l,i,font_bchar[hf],non_char)+1;
> if link(hold_head)>null then
> begin if minor_tail=null then pre_break(r):=link(hold_head)
> else link(minor_tail):=link(hold_head);
> minor_tail:=link(hold_head);
> while link(minor_tail)>null do minor_tail:=link(minor_tail);
> end;
> end;
> if hyf_node<>null then
> begin hu[i]:=c; {restore the character in the hyphen position}
> l:=i; decr(i);
> end
14596c17919
< @ The synchronization algorithm begins with |l≤j|.
---
> @ The synchronization algorithm begins with |l=i+1<=j|.
14599c17922,17925
< minor_tail←null; post_break(r)←null;
---
> minor_tail:=null; post_break(r):=null; c_loc:=0;
> if bchar_label[hf]<>non_address then {put left boundary at beginning of new line}
> begin decr(l); c:=hu[l]; c_loc:=l; hu[l]:=256;
> end;
14601,14632c17927,17960
< begin repeat l←reconstitute(l+1,hn);
< if minor_tail=null then post_break(r)←link(hold_head)
< else link(minor_tail)←link(hold_head);
< minor_tail←link(hold_head);
< if link(minor_tail)≠null then
< begin hyf[l]←0; minor_tail←link(minor_tail); {kern present}
< end;
< until l≥j;
< while l>j do
< begin j←reconstitute(j+1,hn);
< link(major_tail)←link(hold_head);
< major_tail←link(hold_head);
< if link(major_tail)≠null then
< begin hyf[j]←0; major_tail←link(major_tail); {kern present}
< end;
< end;
< end
<
< @ @<Move pointer |s| to the end of the current list...@>=
< i←0; s←r;
< while link(s)≠null do
< begin incr(i); s←link(s);
< end;
< replace_count(r)←i
<
< @ At this point |link(s)| is |null|.
<
< @<Insert a discretionary hyphen after |s|@>=
< begin r←new_disc; pre_break(r)←new_character(hf,"-");
< link(s)←r; s←r;
< end
< @* \[41] Hyphenation.
---
> begin repeat l:=reconstitute(l,hn,bchar,non_char)+1;
> if c_loc>0 then
> begin hu[c_loc]:=c; c_loc:=0;
> end;
> if link(hold_head)>null then
> begin if minor_tail=null then post_break(r):=link(hold_head)
> else link(minor_tail):=link(hold_head);
> minor_tail:=link(hold_head);
> while link(minor_tail)>null do minor_tail:=link(minor_tail);
> end;
> until l>=j;
> while l>j do
> @<Append characters of |hu[j..@,]| to |major_tail|, advancing~|j|@>;
> end
>
> @ @<Append characters of |hu[j..@,]|...@>=
> begin j:=reconstitute(j,hn,bchar,non_char)+1;
> link(major_tail):=link(hold_head);
> while link(major_tail)>null do advance_major_tail;
> end
>
> @ Ligature insertion can cause a word to grow exponentially in size. Therefore
> we must test the size of |r_count| here, even though the hyphenated text
> was at most 63 characters long.
>
> @<Move pointer |s| to the end of the current list...@>=
> if r_count>127 then {we have to forget the discretionary hyphen}
> begin link(s):=link(r); link(r):=null; flush_node_list(r);
> end
> else begin link(s):=r; replace_count(r):=r_count;
> end;
> s:=major_tail
>
> @* \[42] Hyphenation.
14636c17964
< using an algorithm due to Frank M. Liang.
---
> using an algorithm due to Frank~M. Liang.
14641c17969
< for all |j|, and invalid `\.{\^\^?}' characters are inserted into |hc[0]|
---
> for all |j|, and invalid characters are inserted into |hc[0]|
14644,14647c17972,17975
< |hc[0..(hn+1)]|. Each pattern $p↓1\ldotsm p↓k$ of length |k| has an associated
< sequence of |k+1| numbers $n↓0\ldotsm n↓k$; and if the pattern occurs in
< |hc[(j+1)..(j+k)]|, \TeX\ will set |hyf[j+i]←@tmax@>(hyf[j+i],@t$n↓i$@>)| for
< |0≤i≤k|. After this has been done for each pattern that occurs, a
---
> |hc[0..(hn+1)]|. Each pattern $p_1\ldots p_k$ of length |k| has an associated
> sequence of |k+1| numbers $n_0\ldots n_k$; and if the pattern occurs in
> |hc[(j+1)..(j+k)]|, \TeX\ will set |hyf[j+i]:=@tmax@>(hyf[j+i],@t$n_i$@>)| for
> |0<=i<=k|. After this has been done for each pattern that occurs, a
14651c17979
< The set of patterns $p↓1\ldotsm p↓k$ and associated numbers $n↓0\ldotsm n↓k$
---
> The set of patterns $p_1\ldots p_k$ and associated numbers $n_0\ldots n_k$
14656c17984
< 1982); \TeX\ simply starts with the patterns and works from there.
---
> 1983); \TeX\ simply starts with the patterns and works from there.
14660,14663c17988,17992
< Computer Program\-ming \bf3} (1973), 481--505]. We can find each pattern
< $p↓1\ldotsm p↓k$ by setting |@t$z↓1$@>←@t$p↓1$@>| and then, for |1<i≤k|,
< setting |@t$z↓i$@>←trie_link@t$(z↓{i-1})+p↓i$@>|; the pattern will be
< identified by the number $z↓k$. Since all the pattern information is
---
> Computer Programming \bf3} (1973), 481--505]. We can find each pattern
> $p_1\ldots p_k$ by letting $z_0$ be one greater than the relevant language
> index and then, for |1<=i<=k|,
> setting |@t$z_i$@>:=trie_link@t$(z_{i-1})+p_i$@>|; the pattern will be
> identified by the number $z_k$. Since all the pattern information is
14666,14668c17995,17997
< table is provided such that |trie_char@t$(z↓i)=p↓i$@>| for all |i|. There
< is also a table |trie_op|$(z↓k)$ to identify the numbers $n↓0\ldotsm n↓k$
< associated with $p↓1\ldotsm p↓k$.
---
> table is provided such that |trie_char@t$(z_i)=p_i$@>| for all |i|. There
> is also a table |trie_op|$(z_k)$ to identify the numbers $n_0\ldots n_k$
> associated with $p_1\ldots p_k$.
14670c17999
< Comparatively few different number sequences $n↓0\ldotsm n↓k$ actually occur,
---
> Comparatively few different number sequences $n_0\ldots n_k$ actually occur,
14672,14674c18001,18004
< are encoded in such a way that |trie_op|$(z↓k)$ is only one byte long.
< If |trie_op(@t$z↓k$@>)≠min_quarterword|, when $p↓1\ldotsm p↓k$ has matched
< the letters in |hc[(l-k+1)..l@,]|, we perform all of the required operations
---
> are encoded in such a way that |trie_op|$(z_k)$ is only one byte long.
> If |trie_op(@t$z_k$@>)<>min_quarterword|, when $p_1\ldots p_k$ has matched
> the letters in |hc[(l-k+1)..l@,]| of language |t|,
> we perform all of the required operations
14676,14678c18006,18008
< |v←trie_op(@t$z↓k$@>)|. Then set |hyf[l-hyf_distance[v]]←@tmax@>(
< hyf[l-hyf_distance[v]], hyf_num[v])|, and |v←hyf_next[v]|; repeat, if
< necessary, until |v=min_quarterword|.
---
> |v:=trie_op(@t$z_k$@>)|. Then set |v:=v+op_start[t]|,
> |hyf[l-hyf_distance[v]]:=@tmax@>(hyf[l-hyf_distance[v]], hyf_num[v])|,
> and |v:=hyf_next[v]|; repeat, if necessary, until |v=min_quarterword|.
14689,14691c18019,18022
< @!hyf_distance:array[quarterword] of small_number; {position |k-j| of $n↓j$}
< @!hyf_num:array[quarterword] of small_number; {value of $n↓j$}
< @!hyf_next:array[quarterword] of quarterword; {continuation of this |trie_op|}
---
> @!hyf_distance:array[1..trie_op_size] of small_number; {position |k-j| of $n_j$}
> @!hyf_num:array[1..trie_op_size] of small_number; {value of $n_j$}
> @!hyf_next:array[1..trie_op_size] of quarterword; {continuation code}
> @!op_start:array[ASCII_code] of 0..trie_op_size; {offset for current language}
14695c18026
< @!v:quarterword; {an index into |hyf_distance|, etc.}
---
> @!v:integer; {an index into |hyf_distance|, etc.}
14697,14700c18028,18031
< @ Assuming that these auxiliary tables have been set properly, the
< hyphenation algorithm is quite short. In the following code we use the
< fact that no pattern contains $p↓i=0$; setting |hc[hn+2]| to zero therefore
< guarantees that |hc[hn+3]| will never be fetched.
---
> @ Assuming that these auxiliary tables have been set up properly, the
> hyphenation algorithm is quite short. In the following code we set |hc[hn+2]|
> to the impossible value 256, in order to guarantee that |hc[hn+3]| will
> never be fetched.
14702,14703c18033,18034
< @<Find hyphen locations for the word in |hc|@>=
< for j←0 to hn do hyf[j]←0;
---
> @<Find hyphen locations for the word in |hc|...@>=
> for j:=0 to hn do hyf[j]:=0;
14705,14715c18036,18048
< |hyf| containing the hyphens) if an entry is found@>;
< hc[0]←127; hc[hn+1]←127; hc[hn+2]←0; {insert delimiters}
< for j←0 to hn-2 do
< begin z←hc[j]; l←j;
< while hc[l]=trie_char(z) do
< begin if trie_op(z)≠min_quarterword then
< @<Store \(m)maximum values in the |hyf| table@>;
< incr(l); z←trie_link(z)+hc[l];
< end;
< end;
< found: hyf[1]←0; hyf[hn-2]←0; hyf[hn-1]←0; hyf[hn]←0
---
> |hyf| containing the hyphens) if an entry is found@>;
> if trie_char(cur_lang+1)<>qi(cur_lang) then return; {no patterns for |cur_lang|}
> hc[0]:=0; hc[hn+1]:=0; hc[hn+2]:=256; {insert delimiters}
> for j:=0 to hn-r_hyf+1 do
> begin z:=trie_link(cur_lang+1)+hc[j]; l:=j;
> while hc[l]=qo(trie_char(z)) do
> begin if trie_op(z)<>min_quarterword then
> @<Store \(m)maximum values in the |hyf| table@>;
> incr(l); z:=trie_link(z)+hc[l];
> end;
> end;
> found: for j:=0 to l_hyf-1 do hyf[j]:=0;
> for j:=0 to r_hyf-1 do hyf[hn-j]:=0
14718,14721c18051,18054
< begin v←trie_op(z);
< repeat i←l-hyf_distance[v];
< if hyf_num[v]>hyf[i] then hyf[i]←hyf_num[v];
< v←hyf_next[v];
---
> begin v:=trie_op(z);
> repeat v:=v+op_start[cur_lang]; i:=l-hyf_distance[v];
> if hyf_num[v]>hyf[i] then hyf[i]:=hyf_num[v];
> v:=hyf_next[v];
14728,14732c18061,18065
< Journal\/\ \bf17} (1974), 135--142] using linear probing. If $\alpha$ and
< $\beta$ are words, we will say that $\alpha<\beta$ if $\leftv\alpha\rightv<
< \leftv\beta\rightv$ or if $\leftv\alpha\rightv=\leftv\beta\rightv$ and
< $\alpha$ is lexicographically smaller than $\beta$. (The notation $\leftv
< \alpha\rightv$ stands for the length of $\alpha$.) The idea of ordered hashing
---
> Journal\/ \bf17} (1974), 135--142] using linear probing. If $\alpha$ and
> $\beta$ are words, we will say that $\alpha<\beta$ if $\vert\alpha\vert<
> \vert\beta\vert$ or if $\vert\alpha\vert=\vert\beta\vert$ and
> $\alpha$ is lexicographically smaller than $\beta$. (The notation $\vert
> \alpha\vert$ stands for the length of $\alpha$.) The idea of ordered hashing
14734,14735c18067,18068
< a hash address $h=h(\alpha)$ and then looking in table positions $h$, $h-1$,
< $\ldotss$, until encountering the first word $\L\alpha$. If this word is
---
> a hash address $h=h(\alpha)$ and then looking in table positions |h|, |h-1|,
> \dots, until encountering the first word $\L\alpha$. If this word is
14739,14741c18072,18074
< in their |info| fields. The list for $c↓1\ldotsm c↓n$ contains $k$ if
< the word $c↓1\ldotsm c↓n$ has a discretionary hyphen between $c↓k$ and
< $c↓{k+1}$.
---
> in their |info| fields. The list for $c_1\ldots c_n$ contains the number |k| if
> the word $c_1\ldots c_n$ has a discretionary hyphen between $c_k$ and
> $c_{k+1}$.
14748c18081
< @!hyph_list:array[hyph_pointer] of pointer; {list of hyphen positions}
---
> @!hyph_list:array[hyph_pointer] of pointer; {lists of hyphen positions}
14755,14756c18088,18091
< for z←0 to hyph_size do hyph_word[z]←0;
< hyph_count←0;
---
> for z:=0 to hyph_size do
> begin hyph_word[z]:=0; hyph_list[z]:=null;
> end;
> hyph_count:=0;
14767c18102,18103
< find the word or we don't.
---
> find the word or we don't. Words from different languages are kept
> separate by appending the language code to the string.
14770,14777c18106,18113
< h←hc[1];
< for j←2 to hn do h←(h+h+hc[j]) mod hyph_size;
< loop@+ begin @<If the string |hyph_word[h]| is less than \(hc)|hc[1..hn]|,
< |goto not_found|; but if the two strings are equal,
< set |hyf| to the hyphen positions and |goto found|@>;
< if h>0 then decr(h)@+else h←hyph_size;
< end;
< not_found:
---
> h:=hc[1]; incr(hn); hc[hn]:=cur_lang;
> for j:=2 to hn do h:=(h+h+hc[j]) mod hyph_size;
> loop@+ begin @<If the string |hyph_word[h]| is less than \(hc)|hc[1..hn]|,
> |goto not_found|; but if the two strings are equal,
> set |hyf| to the hyphen positions and |goto found|@>;
> if h>0 then decr(h)@+else h:=hyph_size;
> end;
> not_found: decr(hn)
14780c18116
< k←hyph_word[h]; if k=0 then goto not_found;
---
> k:=hyph_word[h]; if k=0 then goto not_found;
14783,14790c18119,18126
< begin j←1; u←str_start[k];
< repeat if str_pool[u]<hc[j] then goto not_found;
< if str_pool[u]>hc[j] then goto done;
< incr(j); incr(u);
< until j>hn;
< @<Insert hyphens as specified in |hyph_list[h]|@>;
< goto found;
< end;
---
> begin j:=1; u:=str_start[k];
> repeat if so(str_pool[u])<hc[j] then goto not_found;
> if so(str_pool[u])>hc[j] then goto done;
> incr(j); incr(u);
> until j>hn;
> @<Insert hyphens as specified in |hyph_list[h]|@>;
> decr(hn); goto found;
> end;
14794,14797c18130,18140
< s←hyph_list[h];
< while s≠null do
< begin hyf[info(s)]←1; s←link(s);
< end
---
> s:=hyph_list[h];
> while s<>null do
> begin hyf[info(s)]:=1; s:=link(s);
> end
>
> @ @<Search |hyph_list| for pointers to |p|@>=
> for q:=0 to hyph_size do
> begin if hyph_list[q]=p then
> begin print_nl("HYPH("); print_int(q); print_char(")");
> end;
> end
14803,14804c18146,18151
< When \TeX\ has scanned the `\.{\\hyphenation}' control sequence, it calls
< on a procedure named |new_hyph_exceptions| to do the right thing.
---
> When \TeX\ has scanned `\.{\\hyphenation}', it calls on a procedure named
> |new_hyph_exceptions| to do the right thing.
>
> @d set_cur_lang==if language<=0 then cur_lang:=0
> else if language>255 then cur_lang:=0
> else cur_lang:=language
14807,14809c18154,18156
< label exit, found, not_found;
< var n:small_number; {length of current word}
< @!j:small_number; {an index into |hc|}
---
> label reswitch, exit, found, not_found;
> var n:0..64; {length of current word; not always a |small_number|}
> @!j:0..64; {an index into |hc|}
14816a18164
> set_cur_lang;
14818c18166
< until coming to a right brace; then skip an optional space and |return|@>;
---
> until coming to a right brace; then |return|@>;
14822,14834c18170,18183
< n←0; p←null;
< loop@+ begin get_nc_token;
< case cur_cmd of
< letter,other_char:@<Append a new letter or hyphen@>;
< spacer,right_brace: begin if n>4 then @<Enter a hyphenation exception@>;
< if cur_cmd=right_brace then
< begin @<Scan an optional space@>; return;
< end;
< n←0; p←null;
< end;
< othercases @<Give improper \.{\\hyphenation} error@>
< endcases;
< end
---
> n:=0; p:=null;
> loop@+ begin get_x_token;
> reswitch: case cur_cmd of
> letter,other_char,char_given:@<Append a new letter or hyphen@>;
> char_num: begin scan_char_num; cur_chr:=cur_val; cur_cmd:=char_given;
> goto reswitch;
> end;
> spacer,right_brace: begin if n>1 then @<Enter a hyphenation exception@>;
> if cur_cmd=right_brace then return;
> n:=0; p:=null;
> end;
> othercases @<Give improper \.{\\hyphenation} error@>
> endcases;
> end
14837,14839c18186
< begin help2("Hyphenation exceptions must contain only letters")@/
< ("and hyphens. But continue; I'll forgive and forget.");
< print_nl("! Improper \hyphenation will be flushed"); error;
---
> begin print_err("Improper "); print_esc("hyphenation");
14840a18188,18191
> print(" will be flushed");
> help2("Hyphenation exceptions must contain only letters")@/
> ("and hyphens. But continue; I'll forgive and forget.");
> error;
14845,14846c18196,18197
< else begin if lc_code(cur_chr)=0 then
< begin print_nl("! Not a letter");
---
> else begin if lc_code(cur_chr)=0 then
> begin print_err("Not a letter");
14848,14855c18199,18206
< help2("Letters in \hyphenation words must have \lccode>0.")@/
< ("Proceed; I'll ignore the character I just read.");
< error;
< end
< else if n<63 then
< begin incr(n); hc[n]←lc_code(cur_chr);
< end;
< end
---
> help2("Letters in \hyphenation words must have \lccode>0.")@/
> ("Proceed; I'll ignore the character I just read.");
> error;
> end
> else if n<63 then
> begin incr(n); hc[n]:=lc_code(cur_chr);
> end;
> end
14858,14860c18209,18211
< begin if n>1 then
< begin q←get_avail; link(q)←p; info(q)←n; p←q;
< end;
---
> begin if n<63 then
> begin q:=get_avail; link(q):=p; info(q):=n; p:=q;
> end;
14864,14872c18215,18220
< begin str_room(n); h←0;
< for j←1 to n do
< begin h←(h+h+hc[j]) mod hyph_size;
< append_char(hc[j]);
< end;
< s←make_string;
< while info(p)>n-3 do {eliminate hyphens \TeX\ doesn't like}
< begin q←link(p); free_avail(p); p←q;
< end;
---
> begin incr(n); hc[n]:=cur_lang; str_room(n); h:=0;
> for j:=1 to n do
> begin h:=(h+h+hc[j]) mod hyph_size;
> append_char(hc[j]);
> end;
> s:=make_string;
14877a18226
> @:TeX capacity exceeded exception dictionary}{\quad exception dictionary@>
14879,14884c18228,18233
< while hyph_word[h]≠0 do
< begin @<If the string |hyph_word[h]| is less than \(or)or equal to
< |s|, interchange |(hyph_word[h],hyph_list[h])| with |(s,p)|@>;
< if h>0 then decr(h)@+else h←hyph_size;
< end;
< hyph_word[h]←s; hyph_list[h]←p
---
> while hyph_word[h]<>0 do
> begin @<If the string |hyph_word[h]| is less than \(or)or equal to
> |s|, interchange |(hyph_word[h],hyph_list[h])| with |(s,p)|@>;
> if h>0 then decr(h)@+else h:=hyph_size;
> end;
> hyph_word[h]:=s; hyph_list[h]:=p
14887c18236
< k←hyph_word[h];
---
> k:=hyph_word[h];
14890c18239
< u←str_start[k]; v←str_start[s];
---
> u:=str_start[k]; v:=str_start[s];
14895,14896c18244,18245
< found:q←hyph_list[h]; hyph_list[h]←p; p←q;@/
< t←hyph_word[h]; hyph_word[h]←s; s←t;
---
> found:q:=hyph_list[h]; hyph_list[h]:=p; p:=q;@/
> t:=hyph_word[h]; hyph_word[h]:=s; s:=t;
14898c18247,18248
< @* \[42] Initializing the hyphenation tables.
---
>
> @* \[43] Initializing the hyphenation tables.
14900c18250
< patterns following a \.{\\patterns} speci\-fi\-ca\-tion. Such a specification
---
> patterns following a \.{\\patterns} specification. Such a specification
14905,14907c18255,18258
< The initialization first builds a trie that is linked instead of packed
< into sequential storage, so that insertions are readily made. Then it
< compresses the linked trie by identifying common subtries, and finally the
---
> The first step is to build a trie that is linked, instead of packed
> into sequential storage, so that insertions are readily made.
> After all patterns have been processed, \.{INITEX}
> compresses the linked trie by identifying common subtries. Finally the
14911c18262,18263
< @p init @<Declare procedures for preprocessing hyphenation patterns@>@;
---
> @<Declare subprocedures for |line_break|@>=
> @!init @<Declare procedures for preprocessing hyphenation patterns@>@;
14918c18270
< a pattern of length 5, with $n↓0\ldotsm n↓5=0\,0\,2\,0\,0\,1$ in the
---
> a pattern of length 5, with $n_0\ldots n_5=0\,0\,2\,0\,0\,1$ in the
14927,14928c18279,18280
< $$\hbox{|@t$v^\prime$@>←new_trie_op(0,1,min_quarterword)|,\qquad
< |v←new_trie_op(3,2,@t$v^\prime$@>)|.}$$
---
> $$\hbox{|@t$v^\prime$@>:=new_trie_op(0,1,min_quarterword)|,\qquad
> |v:=new_trie_op(3,2,@t$v^\prime$@>)|.}$$
14931c18283
< three have not appeared before.
---
> three have not appeared before for the current language.
14934,14938c18286
< is |trie_op_ptr|. If the table overflows, the excess ops are ignored,
< and |trie_op_ptr=max_quarterword|.
<
< @d quarterword_diff=max_quarterword-min_quarterword
< @d trie_op_hash_size=quarterword_diff+quarterword_diff {double}
---
> is |trie_op_ptr|.
14941,14943c18289,18297
< init@! trie_op_hash:array[0..trie_op_hash_size] of quarterword;
< {trie op codes for triples}
< @t\hskip1em@>@!trie_op_ptr:quarterword; {highest |trie_op| assigned}
---
> @!init@! trie_op_hash:array[-trie_op_size..trie_op_size] of 0..trie_op_size;
> {trie op codes for quadruples}
> @!trie_used:array[ASCII_code] of quarterword;
> {largest opcode used so far for this language}
> @!trie_op_lang:array[1..trie_op_size] of ASCII_code;
> {language part of a hashed quadruple}
> @!trie_op_val:array[1..trie_op_size] of quarterword;
> {opcode corresponding to a hashed quadruple}
> @!trie_op_ptr:0..trie_op_size; {number of stored ops so far}
14946,14949c18300,18305
< @ The hash function used by |new_trie_op| is based on the idea that
< 313/510 is an approximation to the golden ratio [cf.\ {\sl The Art of
< Computer Programming \bf3} (1973), 510--512]; but the choice is
< comparatively unimportant in this particular application.
---
> @ It's tempting to remove the |overflow| stops in the following procedure;
> |new_trie_op| could return |min_quarterword| (thereby simply ignoring
> part of a hyphenation pattern) instead of aborting the job. However, that would
> lead to different hyphenation results on different installations of \TeX\
> using the same patterns. The |overflow| stops are necessary for portability
> of patterns.
14954c18310
< var h:0..trie_op_hash_size; {trial hash location}
---
> var h:-trie_op_size..trie_op_size; {trial hash location}
14956,14972c18312,18334
< begin h←(n+313*d+361*v) mod trie_op_hash_size;
< loop@+ begin u←trie_op_hash[h];
< if u=min_quarterword then {empty position found}
< begin if trie_op_ptr≥max_quarterword-1 then {overflow}
< begin trie_op_ptr←max_quarterword;
< new_trie_op←min_quarterword; return;
< end;
< incr(trie_op_ptr); hyf_distance[trie_op_ptr]←d;
< hyf_num[trie_op_ptr]←n; hyf_next[trie_op_ptr]←v;
< trie_op_hash[h]←trie_op_ptr;
< new_trie_op←trie_op_ptr; return;
< end;
< if (hyf_distance[u]=d)∧(hyf_num[u]=n)∧(hyf_next[u]=v) then
< begin new_trie_op←u; return;
< end;
< if h>min_quarterword then decr(h)@+else h←max_quarterword;
< end;
---
> @!l:0..trie_op_size; {pointer to stored data}
> begin h:=abs(n+313*d+361*v+1009*cur_lang) mod (trie_op_size+trie_op_size)
> - trie_op_size;
> loop@+ begin l:=trie_op_hash[h];
> if l=0 then {empty position found for a new op}
> begin if trie_op_ptr=trie_op_size then
> overflow("pattern memory ops",trie_op_size);
> u:=trie_used[cur_lang];
> if u=max_quarterword then
> overflow("pattern memory ops per language",
> max_quarterword-min_quarterword);
> incr(trie_op_ptr); incr(u); trie_used[cur_lang]:=u;
> hyf_distance[trie_op_ptr]:=d;
> hyf_num[trie_op_ptr]:=n; hyf_next[trie_op_ptr]:=v;
> trie_op_lang[trie_op_ptr]:=cur_lang; trie_op_hash[h]:=trie_op_ptr;
> trie_op_val[trie_op_ptr]:=u; new_trie_op:=u; return;
> end;
> if (hyf_distance[l]=d)and(hyf_num[l]=n)and(hyf_next[l]=v)
> and(trie_op_lang[l]=cur_lang) then
> begin new_trie_op:=trie_op_val[l]; return;
> end;
> if h>-trie_op_size then decr(h)@+else h:=trie_op_size;
> end;
14974a18337,18361
> @ After |new_trie_op| has compressed the necessary opcode information,
> plenty of information is available to unscramble the data into the
> final form needed by our hyphenation algorithm.
>
> @<Sort \(t)the hyphenation op tables into proper order@>=
> op_start[0]:=-min_quarterword;
> for j:=1 to 255 do op_start[j]:=op_start[j-1]+qo(trie_used[j-1]);
> for j:=1 to trie_op_ptr do
> trie_op_hash[j]:=op_start[trie_op_lang[j]]+trie_op_val[j]; {destination}
> for j:=1 to trie_op_ptr do while trie_op_hash[j]>j do
> begin k:=trie_op_hash[j];@/
> t:=hyf_distance[k]; hyf_distance[k]:=hyf_distance[j]; hyf_distance[j]:=t;@/
> t:=hyf_num[k]; hyf_num[k]:=hyf_num[j]; hyf_num[j]:=t;@/
> t:=hyf_next[k]; hyf_next[k]:=hyf_next[j]; hyf_next[j]:=t;@/
> trie_op_hash[j]:=trie_op_hash[k]; trie_op_hash[k]:=k;
> end
>
> @ Before we forget how to initialize the data structures that have been
> mentioned so far, let's write down the code that gets them started.
>
> @<Initialize table entries...@>=
> for k:=-trie_op_size to trie_op_size do trie_op_hash[k]:=0;
> for k:=0 to 255 do trie_used[k]:=min_quarterword;
> trie_op_ptr:=0;
>
14986,14987c18373,18375
< The algorithms maintain the condition |trie_c[trie_r[z]]>trie_c[z]|
< whenever |z≠0| and |trie_r[z]≠0|; in other words, sibling nodes are
---
> The algorithms maintain the condition
> $$\hbox{|trie_c[trie_r[z]]>trie_c[z]|\qquad
> whenever |z<>0| and |trie_r[z]<>0|};$$ in other words, sibling nodes are
14992,14998c18380,18391
< @<Globals...@>=
< init @!trie_c:array[trie_pointer] of ascii_code; {characters to match}
< @t\hskip1em@>@!trie_o:array[trie_pointer] of quarterword;
< {operations to perform}
< @t\hskip1em@>@!trie_l:array[trie_pointer] of trie_pointer; {left subtrie links}
< @t\hskip1em@>@!trie_r:array[trie_pointer] of trie_pointer; {right subtrie links}
< @t\hskip1em@>@!trie_ptr:trie_pointer; {the number of nodes in the trie}
---
> @<Glob...@>=
> @!init @!trie_c:packed array[trie_pointer] of packed_ASCII_code;
> {characters to match}
> @t\hskip10pt@>@!trie_o:packed array[trie_pointer] of quarterword;
> {operations to perform}
> @t\hskip10pt@>@!trie_l:packed array[trie_pointer] of trie_pointer;
> {left subtrie links}
> @t\hskip10pt@>@!trie_r:packed array[trie_pointer] of trie_pointer;
> {right subtrie links}
> @t\hskip10pt@>@!trie_ptr:trie_pointer; {the number of nodes in the trie}
> @t\hskip10pt@>@!trie_hash:packed array[trie_pointer] of trie_pointer;
> {used to identify equivalent subtries}
15002c18395
< Experi\-ence shows that we can often reduce its size by recognizing common
---
> Experience shows that we can often reduce its size by recognizing common
15007,15011c18400
< @<Glob...@>=
< init @!trie_hash:array[trie_pointer] of trie_pointer;
< tini {to identify equivalent subtries}
<
< @ The function |trie_node(p)| returns |p| if |p| is distinct from other nodes
---
> The function |trie_node(p)| returns |p| if |p| is distinct from other nodes
15014a18404,18407
> Notice that we might make subtries equivalent even if they correspond to
> patterns for different languages, in which the trie ops might mean quite
> different things. That's perfectly all right.
>
15017c18410
< to a canonical form}
---
> to a canonical form}
15021,15032c18414,18425
< begin h←(trie_c[p]+1009*trie_o[p]+@|
< 2718*trie_l[p]+3142*trie_r[p]) mod trie_size;
< loop@+ begin q←trie_hash[h];
< if q=0 then
< begin trie_hash[h]←p; trie_node←p; return;
< end;
< if (trie_c[q]=trie_c[p])∧(trie_o[q]=trie_o[p])∧@|
< (trie_l[q]=trie_l[p])∧(trie_r[q]=trie_r[p]) then
< begin trie_node←q; return;
< end;
< if h>0 then decr(h)@+else h←trie_size;
< end;
---
> begin h:=abs(trie_c[p]+1009*trie_o[p]+@|
> 2718*trie_l[p]+3142*trie_r[p]) mod trie_size;
> loop@+ begin q:=trie_hash[h];
> if q=0 then
> begin trie_hash[h]:=p; trie_node:=p; return;
> end;
> if (trie_c[q]=trie_c[p])and(trie_o[q]=trie_o[p])and@|
> (trie_l[q]=trie_l[p])and(trie_r[q]=trie_r[p]) then
> begin trie_node:=q; return;
> end;
> if h>0 then decr(h)@+else h:=trie_size;
> end;
15038c18431
< zero and then saying `|trie_root←compress_trie(trie_root)|'.
---
> zero and then saying `|trie_root:=compress_trie(trie_root)|'.
15043,15059c18436,18440
< begin if p=0 then compress_trie←0
< else begin trie_l[p]←compress_trie(trie_l[p]);
< trie_r[p]←compress_trie(trie_r[p]);
< compress_trie←trie_node(p);
< end;
< end;
<
< @ Before we forget how to initialize the data structures that have been
< mentioned so far, let's write a procedure that does the initialization.
<
< @<Declare procedures for preprocessing hyph...@>=
< procedure init_pattern_memory; {gets ready to build a linked trie}
< var h:0..trie_op_hash_size; {an index into |trie_op_hash|}
< @!p:trie_pointer; {an index into |trie_hash|}
< begin for h←0 to trie_op_hash_size do trie_op_hash[h]←min_quarterword;
< trie_op_ptr←min_quarterword; trie_root←0; trie_c[0]←0; trie_ptr←0;
< for p←0 to trie_size do trie_hash[p]←0;
---
> begin if p=0 then compress_trie:=0
> else begin trie_l[p]:=compress_trie(trie_l[p]);
> trie_r[p]:=compress_trie(trie_r[p]);
> compress_trie:=trie_node(p);
> end;
15066c18447,18448
< |trie_ref[p]| will be nonzero if the linked trie node |p| is the oldest sibling
---
> |trie_ref[p]| will be nonzero only if the linked trie node |p| is the
> smallest character
15073a18456,18457
> To save time at the low end of the trie, we maintain array entries
> |trie_min[c]| pointing to the smallest hole that is greater than~|c|.
15083,15086c18467,18472
< init@!trie_taken:array[trie_pointer] of boolean; {does a family start here?}
< @t\hskip1em@>@!trie_max:trie_pointer; {largest location used in |trie|}
< @t\hskip1em@>@!trie_min:trie_pointer;
< {all locations |≤trie_min| are vacant in |trie|}
---
> @!init@!trie_taken:packed array[1..trie_size] of boolean;
> {does a family start here?}
> @t\hskip10pt@>@!trie_min:array[ASCII_code] of trie_pointer;
> {the first possible slot for each character}
> @t\hskip10pt@>@!trie_max:trie_pointer; {largest location used in |trie|}
> @t\hskip10pt@>@!trie_not_ready:boolean; {is the trie still in linked form?}
15089,15105c18475,18479
< @ Here is how these data structures are initialized.
<
< @<Declare procedures for preprocessing hyph...@>=
< procedure init_trie_memory; {gets ready to pack into |trie|}
< var p:trie_pointer; {index into |trie_ref|, |trie|, |trie_taken|}
< begin for p←0 to trie_ptr do trie_ref[p]←0;
< trie_max←128; trie_min←128; trie_link(0)←1; trie_taken[0]←false;
< for p←1 to 128 do
< begin trie_back(p)←p-1; trie_link(p)←p+1; trie_taken[p]←false;
< end;
< end;
<
< @ Each time \.{\\patterns} appears, it overrides any patterns that were
< entered earlier, so the arrays are not initialized until \TeX\ sees
< \.{\\patterns}. However, some of the global variables must be
< initialized when \.{INITEX} is loaded, in case the user never mentions
< any \.{\\patterns}.
---
> @ Each time \.{\\patterns} appears, it contributes further patterns to
> the future trie, which will be built only when hyphenation is attempted or
> when a format file is dumped. The boolean variable |trie_not_ready|
> will change to |false| when the trie is compressed; this will disable
> further patterns.
15108,15111c18482,18495
< trie_op_ptr←min_quarterword;@/
< trie_link(0)←0; trie_char(0)←0; trie_op(0)←0;
< for k←1 to 127 do trie[k]←trie[0];
< trie_max←127;
---
> trie_not_ready:=true; trie_root:=0; trie_c[0]:=si(0); trie_ptr:=0;
>
> @ Here is how the trie-compression data structures are initialized.
> If storage is tight, it would be possible to overlap |trie_op_hash|,
> |trie_op_lang|, and |trie_op_val| with |trie|, |trie_hash|, and |trie_taken|,
> because we finish with the former just before we need the latter.
>
> @<Get ready to compress the trie@>=
> @<Sort \(t)the hyphenation...@>;
> for p:=0 to trie_size do trie_hash[p]:=0;
> trie_root:=compress_trie(trie_root); {identify equivalent subtries}
> for p:=0 to trie_ptr do trie_ref[p]:=0;
> for p:=0 to 255 do trie_min[p]:=p+1;
> trie_link(0):=1; trie_max:=0
15126,15137c18510,18521
< @!c:ascii_code; {smallest character in the family}
< begin c←trie_c[p]; {we have |c≠0|}
< if c<trie_min then trie_min←c;
< z←trie_link(trie_min-1); {get the first conceivably good hole}
< loop@+ begin if z<c then goto not_found;
< h←z-c;@/
< @<Ensure that |trie_max≥h+128|@>;
< if trie_taken[h] then goto not_found;
< @<If all characters of the family fit relative to |h|, then
< |goto found|,\30\ otherwise |goto not_found|@>;
< not_found: z←trie_link(z); {move to the next hole}
< end;
---
> @!c:ASCII_code; {smallest character in the family}
> @!l,@!r:trie_pointer; {left and right neighbors}
> @!ll:1..256; {upper limit of |trie_min| updating}
> begin c:=so(trie_c[p]);
> z:=trie_min[c]; {get the first conceivably good hole}
> loop@+ begin h:=z-c;@/
> @<Ensure that |trie_max>=h+256|@>;
> if trie_taken[h] then goto not_found;
> @<If all characters of the family fit relative to |h|, then
> |goto found|,\30\ otherwise |goto not_found|@>;
> not_found: z:=trie_link(z); {move to the next hole}
> end;
15141,15151c18525,18536
< @ By making sure that |trie_max| is at least |h+128|, we can be sure that
< |trie_max>z|, since |h=z+c|. It follows that location |trie_max| will
< never be occupied in |trie|, and we will have |trie_max≥trie_link(z)|.
<
< @<Ensure that |trie_max≥h+128|@>=
< if trie_max<h+128 then
< begin if trie_size≤h+128 then overflow("pattern memory",trie_size);
< repeat incr(trie_max); trie_taken[trie_max]←false;
< trie_link(trie_max)←trie_max+1; trie_back(trie_max)←trie_max-1;
< until trie_max=h+128;
< end
---
> @ By making sure that |trie_max| is at least |h+256|, we can be sure that
> |trie_max>z|, since |h=z-c|. It follows that location |trie_max| will
> never be occupied in |trie|, and we will have |trie_max>=trie_link(z)|.
>
> @<Ensure that |trie_max>=h+256|@>=
> if trie_max<h+256 then
> begin if trie_size<=h+256 then overflow("pattern memory",trie_size);
> @:TeX capacity exceeded pattern memory}{\quad pattern memory@>
> repeat incr(trie_max); trie_taken[trie_max]:=false;
> trie_link(trie_max):=trie_max+1; trie_back(trie_max):=trie_max-1;
> until trie_max=h+256;
> end
15154c18539
< q←trie_r[p];
---
> q:=trie_r[p];
15156,15158c18541,18543
< begin if trie_link(h+trie_c[q])=0 then goto not_found;
< q←trie_r[q];
< end;
---
> begin if trie_link(h+so(trie_c[q]))=0 then goto not_found;
> q:=trie_r[q];
> end;
15162,15164c18547,18555
< trie_taken[h]←true; trie_ref[p]←h; q←p;
< repeat z←h+trie_c[q]; trie_back(trie_link(z))←trie_back(z);
< trie_link(trie_back(z))←trie_link(z); trie_link(z)←0; q←trie_r[q];
---
> trie_taken[h]:=true; trie_ref[p]:=h; q:=p;
> repeat z:=h+so(trie_c[q]); l:=trie_back(z); r:=trie_link(z);
> trie_back(r):=l; trie_link(l):=r; trie_link(z):=0;
> if l<256 then
> begin if z<256 then ll:=z @+else ll:=256;
> repeat trie_min[l]:=r; incr(l);
> until l=ll;
> end;
> q:=trie_r[q];
15173,15177c18564,18568
< begin repeat q←trie_l[p];
< if (q>0)∧(trie_ref[q]=0) then
< begin first_fit(q); trie_pack(q);
< end;
< p←trie_r[p];
---
> begin repeat q:=trie_l[p];
> if (q>0)and(trie_ref[q]=0) then
> begin first_fit(q); trie_pack(q);
> end;
> p:=trie_r[p];
15183,15188c18574,18575
< information. Null pointers in the linked trie will be replaced by the
< first untaken position |r| in |trie|, since this properly implements an
< ``empty'' family. The value of |r| is stored in |trie_ref[0]| just before
< the fixup process starts. Note that |trie_max| will always be at least as
< large as |r+127|, since it is always at least 128 more than each location
< that is taken.
---
> information. Null pointers in the linked trie will be represented by the
> value~0, which properly implements an ``empty'' family.
15191,15194c18578,18589
< r←0;
< while trie_taken[r] do incr(r);
< trie_ref[0]←r; {|r| will be used for null pointers}
< trie_fix(trie_root) {this fixes the non-holes in |trie|}
---
> h.rh:=0; h.b0:=min_quarterword; h.b1:=min_quarterword; {|trie_link:=0|,
> |trie_op:=min_quarterword|, |trie_char:=qi(0)|}
> if trie_root=0 then {no patterns were given}
> begin for r:=0 to 256 do trie[r]:=h;
> trie_max:=256;
> end
> else begin trie_fix(trie_root); {this fixes the non-holes in |trie|}
> r:=0; {now we will zero out all the holes}
> repeat s:=trie_link(r); trie[r]:=h; r:=s;
> until r>trie_max;
> end;
> trie_char(0):=qi("?"); {make |trie_char(c)<>c| for all |c|}
15205c18600
< @!c:ascii_code; {another one that need not be saved}
---
> @!c:ASCII_code; {another one that need not be saved}
15207,15213c18602,18607
< begin z←trie_ref[p];
< while p≠0 do
< begin q←trie_l[p]; c←trie_c[p];
< trie_link(z+c)←trie_ref[q]; trie_char(z+c)←c; trie_op(z+c)←trie_o[p];
< if q>0 then trie_fix(q);
< p←trie_r[p];
< end;
---
> begin z:=trie_ref[p];
> repeat q:=trie_l[p]; c:=so(trie_c[p]);
> trie_link(z+c):=trie_ref[q]; trie_char(z+c):=qi(c); trie_op(z+c):=trie_o[p];
> if q>0 then trie_fix(q);
> p:=trie_r[p];
> until p=0;
15216,15221c18610,18612
< @ Now let's put all these routines together. When \.{INITEX} has scanned
< the `\.{\\patterns}' control sequence, it calls on |new_patterns| to do
< the right thing. After |new_patterns| has acted, the compacted pattern data
< will appear in the array |trie[1..trie_max]|, and the associated numeric
< hyphenation data will appear in locations |[(min_quarterword+1)..trie_op_ptr]|
< of the arrays |hyf_distance|, |hyf_num|, |hyf_next|.
---
> @ Now let's go back to the easier problem, of building the linked
> trie. When \.{INITEX} has scanned the `\.{\\patterns}' control
> sequence, it calls on |new_patterns| to do the right thing.
15226c18617,18618
< var k,@!l:small_number; {indices into |hc| and |hyf|}
---
> var k,@!l:0..64; {indices into |hc| and |hyf|;
> not always in |small_number| range}
15231,15239c18623,18632
< @!c:ascii_code; {character being inserted}
< @!r,@!s:trie_pointer; {used to clean up the packed |trie|}
< @!h:two_halves; {template used to zero out |trie|'s holes}
< begin scan_left_brace; {a left brace must follow \.{\\patterns}}
< init_pattern_memory;@/
< @<Enter all of the patterns into a linked trie, until coming to a right
< brace; then skip an optional space@>;
< trie_root←compress_trie(trie_root); {compress the trie}
< @<Pack the trie@>;
---
> @!c:ASCII_code; {character being inserted}
> begin if trie_not_ready then
> begin set_cur_lang; scan_left_brace; {a left brace must follow \.{\\patterns}}
> @<Enter all of the patterns into a linked trie, until coming to a right
> brace@>;
> end
> else begin print_err("Too late for "); print_esc("patterns");
> help1("All patterns must be given before typesetting begins.");
> error; link(garbage):=scan_toks(false,false); flush_list(def_ref);
> end;
15247,15258c18640,18649
< k←0; hyf[0]←0; digit_sensed←false;
< loop@+ begin get_nc_token;
< case cur_cmd of
< letter,other_char:@<Append a new letter or a hyphen level@>;
< spacer,right_brace: begin if k>0 then
< @<Insert a new pattern into the linked trie@>;
< if cur_cmd=right_brace then
< begin @<Scan an optional space@>; goto done;
< end;
< k←0; hyf[0]←0; digit_sensed←false;
< end;
< othercases begin print_nl("! Bad \patterns");
---
> k:=0; hyf[0]:=0; digit_sensed:=false;
> loop@+ begin get_x_token;
> case cur_cmd of
> letter,other_char:@<Append a new letter or a hyphen level@>;
> spacer,right_brace: begin if k>0 then
> @<Insert a new pattern into the linked trie@>;
> if cur_cmd=right_brace then goto done;
> k:=0; hyf[0]:=0; digit_sensed:=false;
> end;
> othercases begin print_err("Bad "); print_esc("patterns");
15260,15263c18651,18654
< help1("(See Appendix H.)"); error; pass_block(1); goto done;
< end
< endcases;
< end;
---
> help1("(See Appendix H.)"); error;
> end
> endcases;
> end;
15267,15272c18658,18662
< if digit_sensed ∨(cur_chr<"0")∨(cur_chr>"9") then
< begin if cur_chr="." then cur_chr←127 {change edge-of-word delimiter
< to |@'177|}
< else begin cur_chr←lc_code(cur_chr);
< if cur_chr=0 then
< begin print_nl("! Nonletter");
---
> if digit_sensed or(cur_chr<"0")or(cur_chr>"9") then
> begin if cur_chr="." then cur_chr:=0 {edge-of-word delimiter}
> else begin cur_chr:=lc_code(cur_chr);
> if cur_chr=0 then
> begin print_err("Nonletter");
15274,15286c18664,18677
< help1("(See Appendix H.)"); error; cur_chr←127;
< end;
< end;
< if k<63 then
< begin incr(k); hc[k]←cur_chr; hyf[k]←0; digit_sensed←false;
< end;
< end
< else begin hyf[k]←cur_chr-"0"; digit_sensed←true;
< end
<
< @ When the following code comes into play, the pattern $p↓1\ldotsm p↓k$
< appears in |hc[1..k]|, and the corresponding sequence of numbers $n↓0\ldotsm
< n↓k$ appears in |hyf[0..k]|.
---
> help1("(See Appendix H.)"); error;
> end;
> end;
> if k<63 then
> begin incr(k); hc[k]:=cur_chr; hyf[k]:=0; digit_sensed:=false;
> end;
> end
> else if k<63 then
> begin hyf[k]:=cur_chr-"0"; digit_sensed:=true;
> end
>
> @ When the following code comes into play, the pattern $p_1\ldots p_k$
> appears in |hc[1..k]|, and the corresponding sequence of numbers $n_0\ldots
> n_k$ appears in |hyf[0..k]|.
15289,15302c18680,18693
< begin @<Compute the trie op code, |v|, and set |l←0|@>;
< q←0;
< while l<k do
< begin incr(l); c←hc[l]; p←trie_l[q]; first_child←true;
< while (p>0)∧(c>trie_c[p]) do
< begin q←p; p←trie_r[q]; first_child←false;
< end;
< if (p=0)∨(c<trie_c[p]) then
< @<Insert a new trie node between |q| and |p|, and
< make |p| point to it@>;
< q←p; {now node |q| represents $p↓1\ldotsm p↓l$}
< end;
< if trie_o[q]≠min_quarterword then
< begin print_nl("! Duplicate pattern");
---
> begin @<Compute the trie op code, |v|, and set |l:=0|@>;
> q:=0; hc[0]:=cur_lang;
> while l<=k do
> begin c:=hc[l]; incr(l); p:=trie_l[q]; first_child:=true;
> while (p>0)and(c>so(trie_c[p])) do
> begin q:=p; p:=trie_r[q]; first_child:=false;
> end;
> if (p=0)or(c<so(trie_c[p])) then
> @<Insert a new trie node between |q| and |p|, and
> make |p| point to it@>;
> q:=p; {now node |q| represents $p_1\ldots p_{l-1}$}
> end;
> if trie_o[q]<>min_quarterword then
> begin print_err("Duplicate pattern");
15304,15306c18695,18697
< help1("(See Appendix H.)"); error;
< end;
< trie_o[q]←v;
---
> help1("(See Appendix H.)"); error;
> end;
> trie_o[q]:=v;
15311,15313c18702,18705
< incr(trie_ptr); trie_r[trie_ptr]←p; p←trie_ptr; trie_l[p]←0;
< if first_child then trie_l[q]←p@+else trie_r[q]←p;
< trie_c[p]←c; trie_o[p]←min_quarterword;
---
> @:TeX capacity exceeded pattern memory}{\quad pattern memory@>
> incr(trie_ptr); trie_r[trie_ptr]:=p; p:=trie_ptr; trie_l[p]:=0;
> if first_child then trie_l[q]:=p@+else trie_r[q]:=p;
> trie_c[p]:=si(c); trie_o[p]:=min_quarterword;
15317,15320c18709,18714
< l←k; v←min_quarterword;
< loop@+ begin if hyf[l]≠0 then v←new_trie_op(k-l,hyf[l],v);
< if l>0 then decr(l)@+else goto done1;
< end;
---
> if hc[1]=0 then hyf[0]:=0;
> if hc[k]=0 then hyf[k]:=0;
> l:=k; v:=min_quarterword;
> loop@+ begin if hyf[l]<>0 then v:=new_trie_op(k-l,hyf[l],v);
> if l>0 then decr(l)@+else goto done1;
> end;
15323,15324c18717,18720
< @ The following packing routine is rigged so that the root of the linked
< tree gets mapped into location 0 of |trie|, as required by the hyphenation
---
> @ Finally we put everything together: Here is how the trie gets to its
> final, efficient form.
> The following packing routine is rigged so that the root of the linked
> tree gets mapped into location 1 of |trie|, as required by the hyphenation
15326c18722
< ``take'' location@@0.
---
> ``take'' location~1.
15328,15332c18724,18733
< @<Pack the trie@>=
< init_trie_memory;
< if trie_root≠0 then
< begin first_fit(trie_root); trie_pack(trie_root);
< end;
---
> @<Declare procedures for preprocessing hyphenation patterns@>=
> procedure init_trie;
> var @!p:trie_pointer; {pointer for initialization}
> @!j,@!k,@!t:integer; {all-purpose registers for initialization}
> @!r,@!s:trie_pointer; {used to clean up the packed |trie|}
> @!h:two_halves; {template used to zero out |trie|'s holes}
> begin @<Get ready to compress the trie@>;
> if trie_root<>0 then
> begin first_fit(trie_root); trie_pack(trie_root);
> end;
15334,15339c18735,18738
< r←0; {finally, we will zero out the holes}
< h.rh←0; h.b0←min_quarterword; h.b1←0; {|trie_link←0|,
< |trie_op←min_quarterword|, |trie_op←0|}
< repeat s←trie_link(r); trie[r]←h; r←s;
< until r>trie_max
< @* \[43] Breaking vertical lists into pages.
---
> trie_not_ready:=false;
> end;
>
> @* \[44] Breaking vertical lists into pages.
15355a18755
> @^data structure assumptions@>
15360,15373c18760,18773
< begin prev_p←temp_head; link(temp_head)←p;
< while p≠null do
< case type(p) of
< hlist_node,vlist_node,rule_node:@<Insert glue for |split_top_skip|
< and set@@|p←null|@>;
< whatsit_node,mark_node,ins_node: begin prev_p←p; p←link(prev_p);
< end;
< glue_node,kern_node,penalty_node: begin q←p; p←link(q); link(q)←null;
< link(prev_p)←p; flush_node_list(q);
< end;
< othercases confusion("pruning")
< @:confusion pruning}{\quad pruning@>
< endcases;
< prune_page_top←link(temp_head);
---
> begin prev_p:=temp_head; link(temp_head):=p;
> while p<>null do
> case type(p) of
> hlist_node,vlist_node,rule_node:@<Insert glue for |split_top_skip|
> and set~|p:=null|@>;
> whatsit_node,mark_node,ins_node: begin prev_p:=p; p:=link(prev_p);
> end;
> glue_node,kern_node,penalty_node: begin q:=p; p:=link(q); link(q):=null;
> link(prev_p):=p; flush_node_list(q);
> end;
> othercases confusion("pruning")
> @:this can't happen pruning}{\quad pruning@>
> endcases;
> prune_page_top:=link(temp_head);
15377,15381c18777,18781
< begin q←new_skip_param(split_top_skip_code); link(prev_p)←q; link(q)←p;
< {now |temp_ptr=glue_ptr(q)|}
< if width(temp_ptr)>height(p) then width(temp_ptr)←width(temp_ptr)-height(p)
< else width(temp_ptr)←0;
< p←null;
---
> begin q:=new_skip_param(split_top_skip_code); link(prev_p):=q; link(q):=p;
> {now |temp_ptr=glue_ptr(q)|}
> if width(temp_ptr)>height(p) then width(temp_ptr):=width(temp_ptr)-height(p)
> else width(temp_ptr):=0;
> p:=null;
15385,15386c18785,18786
< so as to obtain a box of height |h|, taking account of the |split_max_depth|
< parameter. A pointer to the beginning of the vertical list is given,
---
> so as to obtain a box of height~|h|, with maximum depth~|d|.
> A pointer to the beginning of the vertical list is given,
15398c18798
< @d set_height_zero(#)==active_height[#]←0 {initialize the height to zero}
---
> @d set_height_zero(#)==active_height[#]:=0 {initialize the height to zero}
15402,15403c18802,18803
< @p function vert_break(@!p:pointer; @!h:scaled):pointer;
< {finds optimum page break}
---
> @p function vert_break(@!p:pointer; @!h,@!d:scaled):pointer;
> {finds optimum page break}
15406c18806
< whether |p| is a legal breakpoint}
---
> whether |p| is a legal breakpoint}
15410,15411c18810,18811
< @!least_badness:integer; {the smallest badness found so far}
< @!best_place:pointer; {the most recent break that leads to |least_badness|}
---
> @!least_cost:integer; {the smallest badness plus penalties found so far}
> @!best_place:pointer; {the most recent break that leads to |least_cost|}
15414,15421c18814,18821
< begin prev_p←p; {an initial glue node is not a legal breakpoint}
< least_badness←awful_bad; do_all_six(set_height_zero); prev_dp←0;
< loop@+ begin @<If node |p| is a legal breakpoint, check if this break is
< the best known, and |goto done| if |p| is null or
< if the page-so-far is already too full to accept more stuff@>;
< prev_p←p; p←link(prev_p);
< end;
< done: vert_break←best_place;
---
> begin prev_p:=p; {an initial glue node is not a legal breakpoint}
> least_cost:=awful_bad; do_all_six(set_height_zero); prev_dp:=0;
> loop@+ begin @<If node |p| is a legal breakpoint, check if this break is
> the best known, and |goto done| if |p| is null or
> if the page-so-far is already too full to accept more stuff@>;
> prev_p:=p; p:=link(prev_p);
> end;
> done: vert_break:=best_place;
15430c18830
< shrinking}
---
> shrinking}
15432,15434c18832,18834
< @ A subtle point to be noted here is that |split_max_depth| might be negative,
< so |cur_height| and |prev_dp| might need to be corrected even after a
< glue or kern node.
---
> @ A subtle point to be noted here is that the maximum depth~|d| might be
> negative, so |cur_height| and |prev_dp| might need to be corrected even
> after a glue or kern node.
15437,15441c18837,18841
< if p=null then pi←eject_penalty
< else @<Use node |p| to update the current height and depth measurements;
< if this node is not a legal breakpoint, |goto not_found|
< or |update_heights|,
< otherwise set |pi| to the associated penalty at the break@>;
---
> if p=null then pi:=eject_penalty
> else @<Use node |p| to update the current height and depth measurements;
> if this node is not a legal breakpoint, |goto not_found|
> or |update_heights|,
> otherwise set |pi| to the associated penalty at the break@>;
15443,15444c18843,18844
< if |p| is a forced break or if the page-so-far is already too full@>;
< if (type(p)<glue_node)∨(type(p)>kern_node) then goto not_found;
---
> if |p| is a forced break or if the page-so-far is already too full@>;
> if (type(p)<glue_node)or(type(p)>kern_node) then goto not_found;
15446,15450c18846,18850
< respect to a glue or kern node |p|@>;
< not_found: if prev_dp>split_max_depth then
< begin cur_height←cur_height+prev_dp-split_max_depth;
< prev_dp←split_max_depth;
< end;
---
> respect to a glue or kern node~|p|@>;
> not_found: if prev_dp>d then
> begin cur_height:=cur_height+prev_dp-d;
> prev_dp:=d;
> end;
15455,15457c18855,18857
< cur_height←cur_height+prev_dp+height(p); prev_dp←depth(p);
< goto not_found;
< end;
---
> cur_height:=cur_height+prev_dp+height(p); prev_dp:=depth(p);
> goto not_found;
> end;
15459,15465c18859,18865
< glue_node: if precedes_break(prev_p) then pi←0
< else goto update_heights;
< kern_node: begin if link(p)=null then t←penalty_node
< else t←type(link(p));
< if t=glue_node then pi←0@+else goto update_heights;
< end;
< penalty_node: pi←penalty(p);
---
> glue_node: if precedes_break(prev_p) then pi:=0
> else goto update_heights;
> kern_node: begin if link(p)=null then t:=penalty_node
> else t:=type(link(p));
> if t=glue_node then pi:=0@+else goto update_heights;
> end;
> penalty_node: pi:=penalty(p);
15468c18868
< @:confusion vertbreak}{\quad vertbreak@>
---
> @:this can't happen vertbreak}{\quad vertbreak@>
15471c18871,18873
< @ @<Check if node |p| is a new champion breakpoint; then \(go)...@>=
---
> @ @d deplorable==100000 {more than |inf_bad|, but less than |awful_bad|}
>
> @<Check if node |p| is a new champion breakpoint; then \(go)...@>=
15473,15482c18875,18886
< begin @<Compute the badness, |b|, using |awful_bad|
< if the box is too full@>;
< if b≤inf_bad then
< if pi≤eject_penalty then b←pi@+else b←b+pi;
< if b≤least_badness then
< begin best_place←p; least_badness←b;
< best_height_plus_depth←cur_height+prev_dp;
< end;
< if (b=awful_bad)∨(pi≤eject_penalty) then goto done;
< end
---
> begin @<Compute the badness, |b|, using |awful_bad|
> if the box is too full@>;
> if b<awful_bad then
> if pi<=eject_penalty then b:=pi
> else if b<inf_bad then b:=b+pi
> else b:=deplorable;
> if b<=least_cost then
> begin best_place:=p; least_cost:=b;
> best_height_plus_depth:=cur_height+prev_dp;
> end;
> if (b=awful_bad)or(pi<=eject_penalty) then goto done;
> end
15486,15490c18890,18894
< if (active_height[3]≠0) or (active_height[4]≠0) or
< (active_height[5]≠0) then b←0
< else b←badness(h-cur_height,active_height[2])
< else if cur_height-h>active_height[6] then b←awful_bad
< else b←badness(cur_height-h,active_height[6])
---
> if (active_height[3]<>0) or (active_height[4]<>0) or
> (active_height[5]<>0) then b:=0
> else b:=badness(h-cur_height,active_height[2])
> else if cur_height-h>active_height[6] then b:=awful_bad
> else b:=badness(cur_height-h,active_height[6])
15497,15504c18901,18908
< if type(p)=kern_node then q←p
< else begin q←glue_ptr(p);
< active_height[2+stretch_order(q)]←@|
< active_height[2+stretch_order(q)]+stretch(q);@/
< active_height[6]←active_height[6]+shrink(q);
< if (shrink_order(q)≠normal)∧(shrink(q)≠0) then
< begin@t@>@;@/
< print_nl("! Infinite glue shrinkage found in box being split");@/
---
> if type(p)=kern_node then q:=p
> else begin q:=glue_ptr(p);
> active_height[2+stretch_order(q)]:=@|
> active_height[2+stretch_order(q)]+stretch(q);@/
> active_height[6]:=active_height[6]+shrink(q);
> if (shrink_order(q)<>normal)and(shrink(q)<>0) then
> begin@t@>@;@/
> print_err("Infinite glue shrinkage found in box being split");@/
15506,15514c18910,18918
< help4("The box you are \vsplitting contains some infinitely")@/
< ("shrinkable glue, e.g., `\vss' or `\vskip 0pt minus 1fil'.")@/
< ("Such glue doesn't belong there; but you can safely proceed,")@/
< ("since the offensive shrinkability has been made finite.");
< error; r←new_spec(q); shrink_order(r)←normal; delete_glue_ref(q);
< glue_ptr(p)←r;
< end;
< end;
< cur_height←cur_height+prev_dp+width(q); prev_dp←0
---
> help4("The box you are \vsplitting contains some infinitely")@/
> ("shrinkable glue, e.g., `\vss' or `\vskip 0pt minus 1fil'.")@/
> ("Such glue doesn't belong there; but you can safely proceed,")@/
> ("since the offensive shrinkability has been made finite.");
> error; r:=new_spec(q); shrink_order(r):=normal; delete_glue_ref(q);
> glue_ptr(p):=r; q:=r;
> end;
> end;
> cur_height:=cur_height+prev_dp+width(q); prev_dp:=0
15521c18925
< returns a box for a page of height@@|h|. The remainder of the vlist, if
---
> returns a box for a page of height~|h|. The remainder of the vlist, if
15527,15529c18931,18933
< The original box becomes ``absent'' if and only if it has been entirely
< extracted. The extracted box is ``absent'' if and only if the original
< box was absent (or if it was, erroneously, an hlist box).
---
> The original box becomes ``void'' if and only if it has been entirely
> extracted. The extracted box is ``void'' if and only if the original
> box was void (or if it was, erroneously, an hlist box).
15531,15532c18935,18936
< @p function vsplit(@!n:quarterword; @!h:scaled):pointer;
< {extracts a page of height |h| from box |n|}
---
> @p function vsplit(@!n:eight_bits; @!h:scaled):pointer;
> {extracts a page of height |h| from box |n|}
15537,15543c18941,18947
< begin v←box(n);
< if split_first_mark≠null then
< begin delete_token_ref(split_first_mark); split_first_mark←null;
< delete_token_ref(split_bot_mark); split_bot_mark←null;
< end;
< @<Dispense with trivial cases of absent or bad boxes@>;
< q←vert_break(list_ptr(v),h);
---
> begin v:=box(n);
> if split_first_mark<>null then
> begin delete_token_ref(split_first_mark); split_first_mark:=null;
> delete_token_ref(split_bot_mark); split_bot_mark:=null;
> end;
> @<Dispense with trivial cases of void or bad boxes@>;
> q:=vert_break(list_ptr(v),h,split_max_depth);
15545,15549c18949,18953
< link to |null| at the break@>;
< q←prune_page_top(q); p←list_ptr(v); free_node(v,box_node_size);
< if q=null then box(n)←null {the |eq_level| of the box stays the same}
< else box(n)←vpack(q,natural);
< vsplit←vpackage(p,h,exactly,split_max_depth);
---
> link to |null| at the break@>;
> q:=prune_page_top(q); p:=list_ptr(v); free_node(v,box_node_size);
> if q=null then box(n):=null {the |eq_level| of the box stays the same}
> else box(n):=vpack(q,natural);
> vsplit:=vpackage(p,h,exactly,split_max_depth);
15552c18956
< @ @<Dispense with trivial cases of absent or bad boxes@>=
---
> @ @<Dispense with trivial cases of void or bad boxes@>=
15554,15559c18958,18962
< begin vsplit←null; return;
< end;
< if type(v)≠vlist_node then
< begin help2("The box you are trying to split is an \hbox.")@/
< ("I can't split such boxes, so I'll leave it alone.");
< print_nl("! \vsplit needs a \vbox"); error; vsplit←null; return;
---
> begin vsplit:=null; return;
> end;
> if type(v)<>vlist_node then
> begin print_err(""); print_esc("vsplit"); print(" needs a ");
> print_esc("vbox");
15561c18964,18967
< end
---
> help2("The box you are trying to split is an \hbox.")@/
> ("I can't split such a box, so I'll leave it alone.");
> error; vsplit:=null; return;
> end
15567,15568c18973,18974
< p←list_ptr(v);
< if p=q then list_ptr(v)←null
---
> p:=list_ptr(v);
> if p=q then list_ptr(v):=null
15570,15584c18976,18990
< if split_first_mark=null then
< begin split_first_mark←mark_ptr(p);
< split_bot_mark←split_first_mark;
< token_ref_count(split_first_mark)←@|
< token_ref_count(split_first_mark)+2;
< end
< else begin delete_token_ref(split_bot_mark);
< split_bot_mark←mark_ptr(p);
< add_token_ref(split_bot_mark);
< end;
< if link(p)=q then
< begin link(p)←null; goto done;
< end;
< p←link(p);
< end;
---
> if split_first_mark=null then
> begin split_first_mark:=mark_ptr(p);
> split_bot_mark:=split_first_mark;
> token_ref_count(split_first_mark):=@|
> token_ref_count(split_first_mark)+2;
> end
> else begin delete_token_ref(split_bot_mark);
> split_bot_mark:=mark_ptr(p);
> add_token_ref(split_bot_mark);
> end;
> if link(p)=q then
> begin link(p):=null; goto done;
> end;
> p:=link(p);
> end;
15586c18992,18993
< @* \[44] The page builder.
---
>
> @* \[45] The page builder.
15589,15590c18996,18997
< the calculations are done ``on line'' as new items are placed on the list.
< The main complication in this process is that insertions have to be put
---
> the calculations are done ``on line'' as new items come in.
> The main complication in this process is that insertions must be put
15608,15609c19015,19016
< the current |vsize| and |max_depth| are squirreled away into |page_size|
< and |page_depth_max|; the latter values will be used until the page has
---
> the current |vsize| and |max_depth| are squirreled away into |page_goal|
> and |page_max_depth|; the latter values will be used until the page has
15613c19020
< Although |page_size| starts out equal to |vsize|, it is decreased by the
---
> Although |page_goal| starts out equal to |vsize|, it is decreased by the
15619,15623c19026,19031
< The variables |best_page_break| and |least_page_badness| correspond to the
< variables |best_place| and |least_badness| in the |vert_break| routine
< that we have already studied; i.e., they record the location and value of
< the best place currently known for breaking the current page. The value of
< |page_size| at the time of the best break is stored in |best_size|.
---
> The global variables |best_page_break| and |least_page_cost| correspond
> respectively to the local variables |best_place| and |least_cost| in the
> |vert_break| routine that we have already studied; i.e., they record the
> location and value of the best place currently known for breaking the
> current page. The value of |page_goal| at the time of the best break is
> stored in |best_size|.
15626c19034
< {|page_contents| when an insert node has been contributed, but no boxes}
---
> {|page_contents| when an insert node has been contributed, but no boxes}
15632,15633c19040
< @!page_size:scaled; {desired height of information on page being built}
< @!page_depth_max:scaled; {maximum box depth on page being built}
---
> @!page_max_depth:scaled; {maximum box depth on page being built}
15635,15636c19042,19043
< @!least_page_badness:integer; {the score for this currently best page}
< @!best_size:scaled; {its |page_size|}
---
> @!least_page_cost:integer; {the score for this currently best page}
> @!best_size:scaled; {its |page_goal|}
15640,15642c19047,19049
< That is, the first element of the list is node |r@t$↓1$@>=link(page_ins_head)|;
< node $r↓j$ is followed by |r@t$↓{j+1}$@>=link(r@t$↓j$@>)|; and if there are
< |n| items we have |r@t$↓{n+1}$@>=page_ins_head|. The |subtype| field of
---
> That is, the first element of the list is node |r@t$_1$@>=link(page_ins_head)|;
> node $r_j$ is followed by |r@t$_{j+1}$@>=link(r@t$_j$@>)|; and if there are
> |n| items we have |r@t$_{n+1}$@>=page_ins_head|. The |subtype| field of
15653c19060
< If |type(r)=inserting|, then |width(r)| contains the total of the
---
> If |type(r)=inserting|, then |height(r)| contains the total of the
15659c19066
< insertion node that was tentatively split, and |width(r)| includes the
---
> insertion node that was tentatively split, and |height(r)| includes also the
15669a19077,19080
> The data structure definitions here use the fact that the |@!height| field
> appears in the fourth word of a box node.
> @^data structure assumptions@>
>
15673,15675c19084,19086
< @d broken_ptr(#)==link(#+3)
< {an insertion for this class will break here if anywhere}
< @d broken_ins(#)==info(#+3) {this insertion might break at |broken_ptr|}
---
> @d broken_ptr(#)==link(#+1)
> {an insertion for this class will break here if anywhere}
> @d broken_ins(#)==info(#+1) {this insertion might break at |broken_ptr|}
15680,15681c19091,19092
< subtype(page_ins_head)←qi(255);
< type(page_ins_head)←split_up; link(page_ins_head)←page_ins_head;
---
> subtype(page_ins_head):=qi(255);
> type(page_ins_head):=split_up; link(page_ins_head):=page_ins_head;
15683c19094
< @ An array |page_so_far| records the heights and depths of everything that
---
> @ An array |page_so_far| records the heights and depths of everything
15685,15686c19096,19099
< similar arrays already considered in |line_break| and |vert_break|. The
< value of |page_so_far[1]| is also called |cur_page_height|. The stretch
---
> similar arrays already considered in |line_break| and |vert_break|; and it
> also contains |page_goal| and |page_depth|, since these values are
> all accessible to the user via |set_page_dimen| commands. The
> value of |page_so_far[1]| is also called |page_total|. The stretch
15689c19102,19142
< corrections are not, since they have been subtracted from |page_size|.
---
> corrections are not, since they have been subtracted from |page_goal|.
>
> The variable |page_depth| records the depth of the current page; it has been
> adjusted so that it is at most |page_max_depth|. The variable
> |last_glue| points to the glue specification of the most recent node
> contributed from the contribution list, if this was a glue node; otherwise
> |last_glue=max_halfword|. (If the contribution list is nonempty,
> however, the value of |last_glue| is not necessarily accurate.)
> The variables |last_penalty| and |last_kern| are similar. And
> finally, |insert_penalties| holds the sum of the penalties associated with
> all split and floating insertions.
>
> @d page_goal==page_so_far[0] {desired height of information on page being built}
> @d page_total==page_so_far[1] {height of the current page}
> @d page_shrink==page_so_far[6] {shrinkability of the current page}
> @d page_depth==page_so_far[7] {depth of the current page}
>
> @<Glob...@>=
> @!page_so_far:array [0..7] of scaled; {height and glue of the current page}
> @!last_glue:pointer; {used to implement \.{\\lastskip}}
> @!last_penalty:integer; {used to implement \.{\\lastpenalty}}
> @!last_kern:scaled; {used to implement \.{\\lastkern}}
> @!insert_penalties:integer; {sum of the penalties for held-over insertions}
>
> @ @<Put each...@>=
> primitive("pagegoal",set_page_dimen,0);
> @!@:page_goal_}{\.{\\pagegoal} primitive@>
> primitive("pagetotal",set_page_dimen,1);
> @!@:page_total_}{\.{\\pagetotal} primitive@>
> primitive("pagestretch",set_page_dimen,2);
> @!@:page_stretch_}{\.{\\pagestretch} primitive@>
> primitive("pagefilstretch",set_page_dimen,3);
> @!@:page_fil_stretch_}{\.{\\pagefilstretch} primitive@>
> primitive("pagefillstretch",set_page_dimen,4);
> @!@:page_fill_stretch_}{\.{\\pagefillstretch} primitive@>
> primitive("pagefilllstretch",set_page_dimen,5);
> @!@:page_filll_stretch_}{\.{\\pagefilllstretch} primitive@>
> primitive("pageshrink",set_page_dimen,6);
> @!@:page_shrink_}{\.{\\pageshrink} primitive@>
> primitive("pagedepth",set_page_dimen,7);
> @!@:page_depth_}{\.{\\pagedepth} primitive@>
15691,15706c19144,19154
< Another variable, |cur_page_depth|, records the depth of the current page,
< adjusted to be at most |page_depth_max|. The variable |last_page_glue|
< points to the glue specification of the most recent node contributed from
< the contribution list, if this was a glue node; otherwise
< |last_page_glue=max_halfword|. (If the contribution list is nonempty,
< however, the value of |last_page_glue| is not necessarily accurate.) And
< finally, |ins_penalties| holds the sum of the penalties associated with
< all split insertions.
<
< @d cur_page_height==page_so_far[1] {height of the current page}
<
< @<Glob...@>=
< @!page_so_far:array [1..6] of scaled; {height and glue of the current page}
< @!cur_page_depth:scaled; {depth of the current page}
< @!last_page_glue:pointer; {used to implement \.{\\lastskip}}
< @!ins_penalties:integer; {sum of the penalties for split insertions}
---
> @ @<Cases of |print_cmd_chr|...@>=
> set_page_dimen: case chr_code of
> 0: print_esc("pagegoal");
> 1: print_esc("pagetotal");
> 2: print_esc("pagestretch");
> 3: print_esc("pagefilstretch");
> 4: print_esc("pagefillstretch");
> 5: print_esc("pagefilllstretch");
> 6: print_esc("pageshrink");
> othercases print_esc("pagedepth")
> endcases;
15709,15710c19157,19158
< @d print_plus(#)==if page_so_far[#]≠0 then
< begin print(" plus "); print_scaled(page_so_far[#]); print_plus_end
---
> @d print_plus(#)==if page_so_far[#]<>0 then
> begin print(" plus "); print_scaled(page_so_far[#]); print_plus_end
15712,15738c19160,19199
< @<Show the status of the current page@>=
< show_box(link(page_head));
< if page_contents>empty then
< begin print_nl("total height "); print_scaled(page_so_far[1]);
< print_plus(2)("");
< print_plus(3)("fil");
< print_plus(4)("fill");
< print_plus(5)("filll");
< if page_so_far[6]≠0 then
< begin print(" minus "); print_scaled(page_so_far[6]);
< end;
< print_nl(" goal height"); print_scaled(page_size);
< r←link(page_ins_head);
< while r≠page_ins_head do
< begin print_ln; print_esc("insert"); a←qo(subtype(r));
< print_int(a); print(" adds ");
< a←x_over_n(width(r),1000)*count(a); print_scaled(a);
< if type(r)=split_up then
< begin q←page_head; a←0;
< repeat q←link(q);
< if (type(q)=ins_node)∧(subtype(q)=subtype(r)) then incr(a);
< until q=broken_ins(r);
< print(", #"); print_int(a); print(" might split");
< end;
< r←link(r);
< end;
< end
---
> @p procedure print_totals;
> begin print_scaled(page_total);
> print_plus(2)("");
> print_plus(3)("fil");
> print_plus(4)("fill");
> print_plus(5)("filll");
> if page_shrink<>0 then
> begin print(" minus "); print_scaled(page_shrink);
> end;
> end;
>
> @ @<Show the status of the current page@>=
> if page_head<>page_tail then
> begin print_nl("### current page:");
> if output_active then print(" (held over for next output)");
> @.held over for next output@>
> show_box(link(page_head));
> if page_contents>empty then
> begin print_nl("total height "); print_totals;
> @:total_height}{\.{total height}@>
> print_nl(" goal height "); print_scaled(page_goal);
> @.goal height@>
> r:=link(page_ins_head);
> while r<>page_ins_head do
> begin print_ln; print_esc("insert"); t:=qo(subtype(r));
> print_int(t); print(" adds ");
> if count(t)=1000 then t:=height(r)
> else t:=x_over_n(height(r),1000)*count(t);
> print_scaled(t);
> if type(r)=split_up then
> begin q:=page_head; t:=0;
> repeat q:=link(q);
> if (type(q)=ins_node)and(subtype(q)=subtype(r)) then incr(t);
> until q=broken_ins(r);
> print(", #"); print_int(t); print(" might split");
> end;
> r:=link(r);
> end;
> end;
> end
15743c19204
< @d set_page_so_far_zero(#)==page_so_far[#]←0
---
> @d set_page_so_far_zero(#)==page_so_far[#]:=0
15746,15749c19207,19217
< begin page_contents←s;
< page_size←vsize; page_depth_max←max_depth;
< cur_page_depth←0; do_all_six(set_page_so_far_zero);
< least_page_badness←awful_bad;
---
> begin page_contents:=s;
> page_goal:=vsize; page_max_depth:=max_depth;
> page_depth:=0; do_all_six(set_page_so_far_zero);
> least_page_cost:=awful_bad;
> @!stat if tracing_pages>0 then
> begin begin_diagnostic;
> print_nl("%% goal height="); print_scaled(page_goal);
> @.goal height@>
> print(", max depth="); print_scaled(page_max_depth);
> end_diagnostic(false);
> end;@;@+tats@;@/
15759c19227,19228
< generated by other parts of \TeX\ but not yet seen by the page builder.
---
> generated by other parts of \TeX\ but have not yet been
> seen by the page builder.
15776c19245
< type(page_head)←glue_node; subtype(page_head)←normal;
---
> type(page_head):=glue_node; subtype(page_head):=normal;
15785c19254
< output_active←false;
---
> output_active:=false; insert_penalties:=0;
15792,15794c19261,19292
< page_contents←empty; page_tail←page_head; link(page_head)←null;@/
< last_page_glue←max_halfword; ins_penalties←0;
< cur_page_depth←0; page_depth_max←0;
---
> page_contents:=empty; page_tail:=page_head; link(page_head):=null;@/
> last_glue:=max_halfword; last_penalty:=0; last_kern:=0;
> page_depth:=0; page_max_depth:=0
>
> @ At certain times box 255 is supposed to be void (i.e., |null|),
> or an insertion box is supposed to be ready to accept a vertical list.
> If not, an error message is printed, and the following subroutine
> flushes the unwanted contents, reporting them to the user.
>
> @p procedure box_error(@!n:eight_bits);
> begin error; begin_diagnostic;
> print_nl("The following box has been deleted:");
> @.The following...deleted@>
> show_box(box(n)); end_diagnostic(true);
> flush_node_list(box(n)); box(n):=null;
> end;
>
> @ The following procedure guarantees that a given box register
> does not contain an \.{\\hbox}.
>
> @p procedure ensure_vbox(@!n:eight_bits);
> var p:pointer; {the box register contents}
> begin p:=box(n);
> if p<>null then if type(p)=hlist_node then
> begin print_err("Insertions can only be added to a vbox");
> @.Insertions can only...@>
> help3("Tut tut: You're trying to \insert into a")@/
> ("\box register that now contains an \hbox.")@/
> ("Proceed, and I'll discard its present contents.");
> box_error(n);
> end;
> end;
15804c19302,19303
< @p procedure build_page; {append contributions to the current page}
---
> @p @t\4@>@<Declare the procedure called |fire_up|@>@;@/
> procedure build_page; {append contributions to the current page}
15807,15809c19306,19307
< @!q,@!r,@!s:pointer; {nodes being examined}
< @!prev_p:pointer; {precedessor of |p|}
< @!b:integer; {badness of current page}
---
> @!q,@!r:pointer; {nodes being examined}
> @!b,@!c:integer; {badness and cost of current page}
15813,15816c19311,19313
< @!wait:boolean; {should the present insertion be held over?}
< begin if (link(contrib_head)=null)∨ output_active then return;
< repeat continue: p←link(contrib_head);@/
< @<Update the value of |last_page_glue|@>;
---
> begin if (link(contrib_head)=null)or output_active then return;
> repeat continue: p:=link(contrib_head);@/
> @<Update the values of |last_glue|, |last_penalty|, and |last_kern|@>;
15818,15819c19315,19316
< put the nodes following the break back onto the contribution list,
< and |return| to the user's output routine if there is one@>;
---
> put the nodes following the break back onto the contribution list,
> and |return| to the user's output routine if there is one@>;
15827,15828c19324,19325
< if nest_ptr=0 then tail←contrib_head {vertical mode}
< else contrib_tail←contrib_head {other modes}
---
> if nest_ptr=0 then tail:=contrib_head {vertical mode}
> else contrib_tail:=contrib_head {other modes}
15830,15831c19327,19329
< @ @<Update the value of |last_page_glue|@>=
< if last_page_glue≠max_halfword then delete_glue_ref(last_page_glue);
---
> @ @<Update the values of |last_glue|...@>=
> if last_glue<>max_halfword then delete_glue_ref(last_glue);
> last_penalty:=0; last_kern:=0;
15833,15835c19331,19336
< begin last_page_glue←glue_ptr(p); add_glue_ref(last_page_glue);
< end
< else last_page_glue←max_halfword
---
> begin last_glue:=glue_ptr(p); add_glue_ref(last_glue);
> end
> else begin last_glue:=max_halfword;
> if type(p)=penalty_node then last_penalty:=penalty(p)
> else if type(p)=kern_node then last_kern:=width(p);
> end
15845,15848c19346,19349
< otherwise use node |p| to update the state of the current page;
< if this node is an insertion, |goto contribute|; otherwise if this node
< is not a legal breakpoint, |goto contribute| or |update_heights|;
< otherwise set |pi| to the penalty associated with this breakpoint@>;
---
> otherwise use node |p| to update the state of the current page;
> if this node is an insertion, |goto contribute|; otherwise if this node
> is not a legal breakpoint, |goto contribute| or |update_heights|;
> otherwise set |pi| to the penalty associated with this breakpoint@>;
15850,15852c19351,19353
< a page break, prepare for output, and either fire up the user's
< output routine and |return| or ship out the page and |goto done|@>;
< if (type(p)<glue_node)∨(type(p)>kern_node) then goto contribute;
---
> a page break, prepare for output, and either fire up the user's
> output routine and |return| or ship out the page and |goto done|@>;
> if (type(p)<glue_node)or(type(p)>kern_node) then goto contribute;
15854,15855c19355,19356
< glue or kern specified by node |p|@>;
< contribute: @<Make sure that |page_depth_max| is not exceeded@>;
---
> glue or kern specified by node~|p|@>;
> contribute: @<Make sure that |page_max_depth| is not exceeded@>;
15861,15862c19362,19363
< link(page_tail)←p; page_tail←p;
< link(contrib_head)←link(p); link(p)←null; goto done
---
> link(page_tail):=p; page_tail:=p;
> link(contrib_head):=link(p); link(p):=null; goto done
15865c19366
< link(contrib_head)←link(p); link(p)←null; flush_node_list(p)
---
> link(contrib_head):=link(p); link(p):=null; flush_node_list(p)
15875,15878c19376,19379
< @<Initialize the current page, insert the \.{\\topskip} glue
< ahead of |p|, and |goto continue|@>
< else @<Prepare to move a box or rule node to the current page,
< then |goto contribute|@>;
---
> @<Initialize the current page, insert the \.{\\topskip} glue
> ahead of |p|, and |goto continue|@>
> else @<Prepare to move a box or rule node to the current page,
> then |goto contribute|@>;
15880c19381
< then |goto contribute|@>;
---
> then |goto contribute|@>;
15882,15883c19383,19384
< else if precedes_break(page_tail) then pi←0
< else goto update_heights;
---
> else if precedes_break(page_tail) then pi:=0
> else goto update_heights;
15885,15888c19386,19389
< else if link(p)=null then return
< else if type(link(p))=glue_node then pi←0
< else goto update_heights;
< penalty_node: if page_contents<box_there then goto done1@+else pi←penalty(p);
---
> else if link(p)=null then return
> else if type(link(p))=glue_node then pi:=0
> else goto update_heights;
> penalty_node: if page_contents<box_there then goto done1@+else pi:=penalty(p);
15892c19393
< @:confusion page}{\quad page@>
---
> @:this can't happen page}{\quad page@>
15897,15901c19398,19402
< else page_contents←box_there;
< q←new_skip_param(top_skip_code); link(q)←p; {now |temp_ptr=glue_ptr(q)|}
< if width(temp_ptr)>height(p) then width(temp_ptr)←width(temp_ptr)-height(p)
< else width(temp_ptr)←0;
< link(q)←p; link(contrib_head)←q; goto continue;
---
> else page_contents:=box_there;
> q:=new_skip_param(top_skip_code); {now |temp_ptr=glue_ptr(q)|}
> if width(temp_ptr)>height(p) then width(temp_ptr):=width(temp_ptr)-height(p)
> else width(temp_ptr):=0;
> link(q):=p; link(contrib_head):=q; goto continue;
15905,15906c19406,19407
< begin cur_page_height←cur_page_height+cur_page_depth+height(p);
< cur_page_depth←depth(p);
---
> begin page_total:=page_total+page_depth+height(p);
> page_depth:=depth(p);
15910,15915c19411,19416
< @ @<Make sure that |page_depth_max| is not exceeded@>=
< if cur_page_depth>page_depth_max then
< begin cur_page_height←@|
< cur_page_height+cur_page_depth-page_depth_max;@/
< cur_page_depth←page_depth_max;
< end;
---
> @ @<Make sure that |page_max_depth| is not exceeded@>=
> if page_depth>page_max_depth then
> begin page_total:=@|
> page_total+page_depth-page_max_depth;@/
> page_depth:=page_max_depth;
> end;
15918,15925c19419,19426
< if type(p)=kern_node then q←p
< else begin q←glue_ptr(p);
< page_so_far[2+stretch_order(q)]←@|
< page_so_far[2+stretch_order(q)]+stretch(q);@/
< page_so_far[6]←page_so_far[6]+shrink(q);
< if (shrink_order(q)≠normal)∧(shrink(q)≠0) then
< begin@t@>@;@/
< print_nl("! Infinite glue shrinkage found on current page");@/
---
> if type(p)=kern_node then q:=p
> else begin q:=glue_ptr(p);
> page_so_far[2+stretch_order(q)]:=@|
> page_so_far[2+stretch_order(q)]+stretch(q);@/
> page_shrink:=page_shrink+shrink(q);
> if (shrink_order(q)<>normal)and(shrink(q)<>0) then
> begin@t@>@;@/
> print_err("Infinite glue shrinkage found on current page");@/
15927,15936c19428,19437
< help4("The page about to be output contains some infinitely")@/
< ("shrinkable glue, e.g., `\vss' or `\vskip 0pt minus 1fil'.")@/
< ("Such glue doesn't belong there; but you can safely proceed,")@/
< ("since the offensive shrinkability has been made finite.");
< error;
< r←new_spec(q); shrink_order(r)←normal; delete_glue_ref(q);
< glue_ptr(p)←r;
< end;
< end;
< cur_page_height←cur_page_height+cur_page_depth+width(q); cur_page_depth←0
---
> help4("The page about to be output contains some infinitely")@/
> ("shrinkable glue, e.g., `\vss' or `\vskip 0pt minus 1fil'.")@/
> ("Such glue doesn't belong there; but you can safely proceed,")@/
> ("since the offensive shrinkability has been made finite.");
> error;
> r:=new_spec(q); shrink_order(r):=normal; delete_glue_ref(q);
> glue_ptr(p):=r; q:=r;
> end;
> end;
> page_total:=page_total+page_depth+width(q); page_depth:=0
15940,15958c19441,19478
< begin @<Compute the badness, |b|, of the current page,
< using |awful_bad| if the box is too full@>;
< if b≤inf_bad then
< if pi≤eject_penalty then b←pi
< else b←b+pi+ins_penalties;
< if b≤least_page_badness then
< begin best_page_break←p; best_size←page_size;
< least_page_badness←b;
< r←link(page_ins_head);
< while r≠page_ins_head do
< begin best_ins_ptr(r)←last_ins_ptr(r);
< r←link(r);
< end;
< end;
< if (b=awful_bad)∨(pi≤eject_penalty) then
< @<Prepare to output the current page at the best place;
< then fire up the user's output routine and |return|,
< or ship out the page and |goto done|@>;
< end
---
> begin @<Compute the badness, |b|, of the current page,
> using |awful_bad| if the box is too full@>;
> if b<awful_bad then
> if pi<=eject_penalty then c:=pi
> else if b<inf_bad then c:=b+pi+insert_penalties
> else c:=deplorable
> else c:=b;
> if insert_penalties>=10000 then c:=awful_bad;
> @!stat if tracing_pages>0 then @<Display the page break cost@>;@+tats@;@/
> if c<=least_page_cost then
> begin best_page_break:=p; best_size:=page_goal;
> least_page_cost:=c;
> r:=link(page_ins_head);
> while r<>page_ins_head do
> begin best_ins_ptr(r):=last_ins_ptr(r);
> r:=link(r);
> end;
> end;
> if (c=awful_bad)or(pi<=eject_penalty) then
> begin fire_up(p); {output the current page at the best place}
> if output_active then return; {user's output routine will act}
> goto done; {the page has been shipped out by default output routine}
> end;
> end
>
> @ @<Display the page break cost@>=
> begin begin_diagnostic; print_nl("%");
> print(" t="); print_totals;@/
> print(" g="); print_scaled(page_goal);@/
> print(" b=");
> if b=awful_bad then print_char("*")@+else print_int(b);
> @.*\relax@>
> print(" p="); print_int(pi);
> print(" c=");
> if c=awful_bad then print_char("*")@+else print_int(c);
> if c<=least_page_cost then print_char("#");
> end_diagnostic(false);
> end
15961,15966c19481,19486
< if cur_page_height<page_size then
< if (page_so_far[3]≠0) or (page_so_far[4]≠0) or@|
< (page_so_far[5]≠0) then b←0
< else b←badness(page_size-cur_page_height,page_so_far[2])
< else if cur_page_height-page_size>page_so_far[6] then b←awful_bad
< else b←badness(cur_page_height-page_size,page_so_far[6])
---
> if page_total<page_goal then
> if (page_so_far[3]<>0) or (page_so_far[4]<>0) or@|
> (page_so_far[5]<>0) then b:=0
> else b:=badness(page_goal-page_total,page_so_far[2])
> else if page_total-page_goal>page_shrink then b:=awful_bad
> else b:=badness(page_total-page_goal,page_shrink)
15970,15987c19490,19508
< n←subtype(p); r←page_ins_head;
< while n≥subtype(link(r)) do r←link(r);
< n←qo(n);
< if subtype(r)≠qi(n) then
< @<Create a page insertion node with |subtype(r)=qi(n)|, and
< include the glue correction for box |n| in the
< current page state@>;
< if type(r)=inserting then
< begin last_ins_ptr(r)←p;
< delta←page_size-cur_page_height+page_so_far[6];
< {this much room is left if we shrink the maximum}
< h←x_over_n(width(p),1000)*count(n); {this much room is needed}
< if (h≤delta)∧(width(p)+width(r)≤dimen(n)) then
< begin page_size←page_size-h; width(r)←width(r)+width(p);
< end
< else @<Find the best way to split the insertion, and change
< |type(r)| to |split_up|@>;
< end;
---
> n:=subtype(p); r:=page_ins_head;
> while n>=subtype(link(r)) do r:=link(r);
> n:=qo(n);
> if subtype(r)<>qi(n) then
> @<Create a page insertion node with |subtype(r)=qi(n)|, and
> include the glue correction for box |n| in the
> current page state@>;
> if type(r)=split_up then insert_penalties:=insert_penalties+float_cost(p)
> else begin last_ins_ptr(r):=p;
> delta:=page_goal-page_total-page_depth+page_shrink;
> {this much room is left if we shrink the maximum}
> if count(n)=1000 then h:=height(p)
> else h:=x_over_n(height(p),1000)*count(n); {this much room is needed}
> if ((h<=0)or(h<=delta))and(height(p)+height(r)<=dimen(n)) then
> begin page_goal:=page_goal-h; height(r):=height(r)+height(p);
> end
> else @<Find the best way to split the insertion, and change
> |type(r)| to |split_up|@>;
> end;
15992,15994c19513,19515
< of \.{\\box}@@|n| only when the first \.{\\insert}@@|n| node is
< encountered for a new page. A user who changes the contents of \.{\\box}@@|n|
< after that first \.{\\insert}@@|n| had better be either extremely careful
---
> of \.{\\box}~|n| only when the first \.{\\insert}~|n| node is
> encountered for a new page. A user who changes the contents of \.{\\box}~|n|
> after that first \.{\\insert}~|n| had better be either extremely careful
15998,16016c19519,19538
< begin q←get_node(page_ins_node_size); link(q)←link(r); link(r)←q; r←q;
< subtype(r)←qi(n); type(r)←inserting;
< if box(n)=null then width(r)←0
< else width(r)←height(box(n))+depth(box(n));
< best_ins_ptr(r)←null;@/
< q←skip(n); h←x_over_n(width(r),1000)*count(n);
< page_size←page_size-h;@/
< page_so_far[1]←page_so_far[1]+width(q);@/
< page_so_far[2+stretch_order(q)]←@|page_so_far[2+stretch_order(q)]+stretch(q);@/
< page_so_far[6]←page_so_far[6]+shrink(q);
< if (shrink_order(q)≠normal)∧(shrink(q)≠0) then
< begin print_nl("! Infinite glue shrinkage inserted from \skip ");
< @.Infinite glue shrinkage@>
< print_int(n);
< help3("The correction glue for page breaking with insertions")@/
< ("must have finite shrinkability. But you may proceed,")@/
< ("since the offensive shrinkability has been made finite.");
< error;
< end;
---
> begin q:=get_node(page_ins_node_size); link(q):=link(r); link(r):=q; r:=q;
> subtype(r):=qi(n); type(r):=inserting; ensure_vbox(n);
> if box(n)=null then height(r):=0
> else height(r):=height(box(n))+depth(box(n));
> best_ins_ptr(r):=null;@/
> q:=skip(n);
> if count(n)=1000 then h:=height(r)
> else h:=x_over_n(height(r),1000)*count(n);
> page_goal:=page_goal-h-width(q);@/
> page_so_far[2+stretch_order(q)]:=@|page_so_far[2+stretch_order(q)]+stretch(q);@/
> page_shrink:=page_shrink+shrink(q);
> if (shrink_order(q)<>normal)and(shrink(q)<>0) then
> begin print_err("Infinite glue shrinkage inserted from "); print_esc("skip");
> @.Infinite glue shrinkage...@>
> print_int(n);
> help3("The correction glue for page breaking with insertions")@/
> ("must have finite shrinkability. But you may proceed,")@/
> ("since the offensive shrinkability has been made finite.");
> error;
> end;
16030,16039c19552,19577
< begin if count(n)≤0 then w←max_dimen
< else w←x_over_n(delta,count(n))*1000;
< if w>dimen(n)-width(r) then w←dimen(n)-width(r);
< q←vert_break(ins_ptr(p),w);
< width(r)←width(r)+best_height_plus_depth;
< best_height_plus_depth←x_over_n(best_height_plus_depth,1000)*count(n);
< page_size←page_size-best_height_plus_depth;
< type(r)←split_up; broken_ptr(r)←q; broken_ins(r)←p;
< if q=null then ins_penalties←ins_penalties+eject_penalty
< else if type(q)=penalty_node then ins_penalties←ins_penalties+penalty(q);
---
> begin if count(n)<=0 then w:=max_dimen
> else begin w:=page_goal-page_total-page_depth;
> if count(n)<>1000 then w:=x_over_n(w,count(n))*1000;
> end;
> if w>dimen(n)-height(r) then w:=dimen(n)-height(r);
> q:=vert_break(ins_ptr(p),w,depth(p));
> height(r):=height(r)+best_height_plus_depth;
> @!stat if tracing_pages>0 then @<Display the insertion split cost@>;@+tats@;@/
> if count(n)<>1000 then
> best_height_plus_depth:=x_over_n(best_height_plus_depth,1000)*count(n);
> page_goal:=page_goal-best_height_plus_depth;
> type(r):=split_up; broken_ptr(r):=q; broken_ins(r):=p;
> if q=null then insert_penalties:=insert_penalties+eject_penalty
> else if type(q)=penalty_node then insert_penalties:=insert_penalties+penalty(q);
> end
>
> @ @<Display the insertion split cost@>=
> begin begin_diagnostic; print_nl("% split"); print_int(n);
> @.split@>
> print(" to "); print_scaled(w);
> print_char(","); print_scaled(best_height_plus_depth);@/
> print(" p=");
> if q=null then print_int(eject_penalty)
> else if type(q)=penalty_node then print_int(penalty(q))
> else print_char("0");
> end_diagnostic(false);
16048,16049c19586,19593
< program uses the fact that |bot_mark≠null| implies |first_mark≠null|;
< |bot_mark=null| implies |top_mark=first_mark=null|.
---
> program uses the fact that |bot_mark<>null| implies |first_mark<>null|;
> it also knows that |bot_mark=null| implies |top_mark=first_mark=null|.
>
> The |fire_up| subroutine prepares to output the current page at the best
> place; then it fires up the user's output routine, if there is one,
> or it simply ships out the page. There is one parameter, |c|, which represents
> the node that was being contributed to the page when the decision to
> force an output was made.
16051c19595,19604
< @<Prepare to output the current page at the best place...@>=
---
> @<Declare the procedure called |fire_up|@>=
> procedure fire_up(@!c:pointer);
> label exit;
> var p,@!q,@!r,@!s:pointer; {nodes being examined and/or changed}
> @!prev_p:pointer; {predecessor of |p|}
> @!n:min_quarterword..255; {insertion box number}
> @!wait:boolean; {should the present insertion be held over?}
> @!save_vbadness:integer; {saved value of |vbadness|}
> @!save_vfuzz: scaled; {saved value of |vfuzz|}
> @!save_split_top_skip: pointer; {saved value of |split_top_skip|}
16053,16057c19606,19610
< if bot_mark≠null then
< begin if top_mark≠null then delete_token_ref(top_mark);
< top_mark←bot_mark; add_token_ref(top_mark);
< delete_token_ref(first_mark); first_mark←null;
< end;
---
> if bot_mark<>null then
> begin if top_mark<>null then delete_token_ref(top_mark);
> top_mark:=bot_mark; add_token_ref(top_mark);
> delete_token_ref(first_mark); first_mark:=null;
> end;
16059,16066c19612,19622
< |bot_mark|, append insertions to their boxes, and put the
< remaining nodes back on the contribution list@>;
< if (top_mark≠null)∧(first_mark=null) then
< begin first_mark←top_mark; add_token_ref(top_mark);
< end;
< if output_routine≠null then @<Fire up the user's output routine and |return|@>
< else @<Perform the default output routine and |goto done|@>;
< end
---
> |bot_mark|, append insertions to their boxes, and put the
> remaining nodes back on the contribution list@>;
> if (top_mark<>null)and(first_mark=null) then
> begin first_mark:=top_mark; add_token_ref(top_mark);
> end;
> if output_routine<>null then
> if dead_cycles>=max_dead_cycles then
> @<Explain that too many dead cycles have occurred in a row@>
> else @<Fire up the user's output routine and |return|@>;
> @<Perform the default output routine@>;
> exit:end;
16070,16072c19626,19628
< begin geq_word_define(int_base+output_penalty_code,penalty(best_page_break));
< penalty(best_page_break)←inf_penalty;
< end
---
> begin geq_word_define(int_base+output_penalty_code,penalty(best_page_break));
> penalty(best_page_break):=inf_penalty;
> end
16075,16076c19631,19633
< @ As the page is finally being prepared for output, |p| runs through the vlist,
< with |prev_p| trailing behind, and |q| is the tail of a list of insertions that
---
> @ As the page is finally being prepared for output,
> pointer |p| runs through the vlist, with |prev_p| trailing behind;
> pointer |q| is the tail of a list of insertions that
16080c19637
< if p=best_page_break then best_page_break←null; {|p| not yet linked in}
---
> if c=best_page_break then best_page_break:=null; {|c| not yet linked in}
16082,16095c19639,19658
< @<Prepare all the boxes involved in insertions to act as queues@>;
< q←hold_head; link(q)←null; prev_p←page_head; p←link(prev_p);
< while p≠best_page_break do
< begin if type(p)=ins_node then @<Either insert the material
< specified by node |p| into the appropriate box, or
< hold it for the next page; also delete node |p| from
< the current page@>
< else if type(p)=mark_node then @<Update the values of
< |first_mark| and |bot_mark|@>;
< prev_p←p; p←link(prev_p);
< end;
< @<Break the current page at node |p|, put it in box@@255,
< and put the remaining nodes on the contribution list@>;
< @<Delete the page-insertion nodes@>
---
> insert_penalties:=0; {this will count the number of insertions held over}
> save_split_top_skip:=split_top_skip;
> if holding_inserts<=0 then
> @<Prepare all the boxes involved in insertions to act as queues@>;
> q:=hold_head; link(q):=null; prev_p:=page_head; p:=link(prev_p);
> while p<>best_page_break do
> begin if type(p)=ins_node then
> begin if holding_inserts<=0 then
> @<Either insert the material specified by node |p| into the
> appropriate box, or hold it for the next page;
> also delete node |p| from the current page@>;
> end
> else if type(p)=mark_node then @<Update the values of
> |first_mark| and |bot_mark|@>;
> prev_p:=p; p:=link(prev_p);
> end;
> split_top_skip:=save_split_top_skip;
> @<Break the current page at node |p|, put it in box~255,
> and put the remaining nodes on the contribution list@>;
> @<Delete \(t)the page-insertion nodes@>
16098,16104c19661,19667
< if box(255)≠null then
< begin print_nl("! \box255 is not absent");
< @:box255}{\.{\\box255 is not absent}@>
< help2("You shouldn't use \box255 except in \output routines.")@/
< ("Proceed, and I'll discard its present contents.");
< error; flush_node_list(box(255)); box(255)←null;
< end
---
> if box(255)<>null then
> begin print_err(""); print_esc("box"); print("255 is not void");
> @:box255}{\.{\\box255 is not void}@>
> help2("You shouldn't use \box255 except in \output routines.")@/
> ("Proceed, and I'll discard its present contents.");
> box_error(255);
> end
16108,16112c19671,19675
< begin first_mark←mark_ptr(p);
< add_token_ref(first_mark);
< end;
< if bot_mark≠null then delete_token_ref(bot_mark);
< bot_mark←mark_ptr(p); add_token_ref(bot_mark);
---
> begin first_mark:=mark_ptr(p);
> add_token_ref(first_mark);
> end;
> if bot_mark<>null then delete_token_ref(bot_mark);
> bot_mark:=mark_ptr(p); add_token_ref(bot_mark);
16121c19684,19687
< and only if |prev_p=page_tail|.
---
> and only if |prev_p=page_tail|. Error messages are suppressed within
> |vpackage|, since the box might appear to be overfull or underfull simply
> because the stretch and shrink from the \.{\\skip} registers for inserts
> are not actually present in the box.
16124,16136c19690,19706
< if p≠null then
< begin if link(contrib_head)=null then
< if nest_ptr=0 then tail←page_tail
< else contrib_tail←page_tail;
< link(page_tail)←link(contrib_head);
< link(contrib_head)←p;
< link(prev_p)←null;
< end;
< box(255)←vpackage(link(page_head),best_size,exactly,page_depth_max);
< @<Start a new current page@>;
< if q≠hold_head then
< begin link(page_head)←link(hold_head); page_tail←q;
< end
---
> if p<>null then
> begin if link(contrib_head)=null then
> if nest_ptr=0 then tail:=page_tail
> else contrib_tail:=page_tail;
> link(page_tail):=link(contrib_head);
> link(contrib_head):=p;
> link(prev_p):=null;
> end;
> save_vbadness:=vbadness; vbadness:=inf_bad;
> save_vfuzz:=vfuzz; vfuzz:=max_dimen; {inhibit error messages}
> box(255):=vpackage(link(page_head),best_size,exactly,page_max_depth);
> vbadness:=save_vbadness; vfuzz:=save_vfuzz;
> if last_glue<>max_halfword then delete_glue_ref(last_glue);
> @<Start a new current page@>; {this sets |last_glue:=max_halfword|}
> if q<>hold_head then
> begin link(page_head):=link(hold_head); page_tail:=q;
> end
16145,16162c19715,19733
< r←link(page_ins_head);
< while r≠page_ins_head do
< begin if best_ins_ptr(r)≠null then
< begin n←qo(subtype(r));
< if box(n)=null then box(n)←new_null_box;
< p←box(n)+list_offset;
< while link(p)≠null do p←link(p);
< last_ins_ptr(r)←p;
< end;
< r←link(r);
< end
<
< @ @<Delete the page-insertion nodes@>=
< r←link(page_ins_head);
< while r≠page_ins_head do
< begin q←link(r); free_node(r,page_ins_node_size); r←q;
< end;
< link(page_ins_head)←page_ins_head
---
> begin r:=link(page_ins_head);
> while r<>page_ins_head do
> begin if best_ins_ptr(r)<>null then
> begin n:=qo(subtype(r)); ensure_vbox(n);
> if box(n)=null then box(n):=new_null_box;
> p:=box(n)+list_offset;
> while link(p)<>null do p:=link(p);
> last_ins_ptr(r):=p;
> end;
> r:=link(r);
> end;
> end
>
> @ @<Delete \(t)the page-insertion nodes@>=
> r:=link(page_ins_head);
> while r<>page_ins_head do
> begin q:=link(r); free_node(r,page_ins_node_size); r:=q;
> end;
> link(page_ins_head):=page_ins_head
16164,16165c19735,19736
< @ We will set |best_ins_ptr←null| and package the box corresponding to
< insertion node@@|r|, just after making the final insertion into that box.
---
> @ We will set |best_ins_ptr:=null| and package the box corresponding to
> insertion node~|r|, just after making the final insertion into that box.
16170,16182c19741,19752
< begin r←link(page_ins_head);
< while subtype(r)≠subtype(p) do r←link(r);
< if best_ins_ptr(r)=null then wait←true
< else begin wait←false; s←ins_ptr(p); {|s≠null|}
< link(last_ins_ptr(r))←s; s←last_ins_ptr(r);
< if best_ins_ptr(r)=p then
< @<Wrap up the box specified by node |r|, splitting node |p| if
< called for; set |wait←true| if node |p| holds a remainder after
< splitting@>
< else begin while link(s)≠null do s←link(s);
< last_ins_ptr(r)←s;
< end;
< end;
---
> begin r:=link(page_ins_head);
> while subtype(r)<>subtype(p) do r:=link(r);
> if best_ins_ptr(r)=null then wait:=true
> else begin wait:=false; s:=last_ins_ptr(r); link(s):=ins_ptr(p);
> if best_ins_ptr(r)=p then
> @<Wrap up the box specified by node |r|, splitting node |p| if
> called for; set |wait:=true| if node |p| holds a remainder after
> splitting@>
> else begin while link(s)<>null do s:=link(s);
> last_ins_ptr(r):=s;
> end;
> end;
16184c19754
< from the current page, or delete |node(p)|@>;
---
> from the current page, or delete |node(p)|@>;
16189,16201c19759,19772
< if (broken_ins(r)=p)∧(broken_ptr(r)≠null) then
< begin while link(s)≠broken_ptr(r) do s←link(s);
< ins_ptr(p)←prune_page_top(broken_ptr(r));
< if ins_ptr(p)≠null then
< begin temp_ptr←vpack(ins_ptr(p),natural);
< width(p)←height(temp_ptr)+depth(temp_ptr);
< free_node(temp_ptr,box_node_size);
< end;
< link(s)←null; wait←(ins_ptr(p)≠null);
< end;
< best_ins_ptr(r)←null;
< n←qo(subtype(r));
< temp_ptr←list_ptr(box(n));
---
> if (broken_ins(r)=p)and(broken_ptr(r)<>null) then
> begin while link(s)<>broken_ptr(r) do s:=link(s);
> link(s):=null;
> split_top_skip:=split_top_ptr(p);
> ins_ptr(p):=prune_page_top(broken_ptr(r));
> if ins_ptr(p)<>null then
> begin temp_ptr:=vpack(ins_ptr(p),natural);
> height(p):=height(temp_ptr)+depth(temp_ptr);
> free_node(temp_ptr,box_node_size); wait:=true;
> end;
> end;
> best_ins_ptr(r):=null;
> n:=qo(subtype(r));
> temp_ptr:=list_ptr(box(n));
16203c19774
< box(n)←vpack(temp_ptr,natural);
---
> box(n):=vpack(temp_ptr,natural);
16207c19778
< link(prev_p)←link(p); link(p)←null;
---
> link(prev_p):=link(p); link(p):=null;
16209,16212c19780,19785
< begin link(q)←p; q←p;
< end
< else free_node(p,ins_node_size);
< p←prev_p
---
> begin link(q):=p; q:=p; incr(insert_penalties);
> end
> else begin delete_glue_ref(split_top_ptr(p));
> free_node(p,ins_node_size);
> end;
> p:=prev_p
16218,16226c19791,19808
< @<Perform the default output routine and |goto done|@>=
< begin if link(page_head)≠null then
< begin if link(contrib_head)=null then
< if nest_ptr=0 then tail←page_tail@+else contrib_tail←page_tail
< else link(page_tail)←link(contrib_head);
< link(contrib_head)←link(page_head);
< link(page_head)←null; page_tail←page_head;
< end;
< ship_out(box(255)); box(255)←null; goto done;
---
> @<Perform the default output routine@>=
> begin if link(page_head)<>null then
> begin if link(contrib_head)=null then
> if nest_ptr=0 then tail:=page_tail@+else contrib_tail:=page_tail
> else link(page_tail):=link(contrib_head);
> link(contrib_head):=link(page_head);
> link(page_head):=null; page_tail:=page_head;
> end;
> ship_out(box(255)); box(255):=null;
> end
>
> @ @<Explain that too many dead cycles have occurred in a row@>=
> begin print_err("Output loop---"); print_int(dead_cycles);
> @.Output loop...@>
> print(" consecutive dead cycles");
> help3("I've concluded that your \output is awry; it never does a")@/
> ("\shipout, so I'm shipping \box255 out myself. Next time")@/
> ("increase \maxdeadcycles if you want me to be more patient!"); error;
16230,16231c19812,19814
< begin output_active←true;
< push_nest; mode←-vmode; prev_depth←ignore_depth; mode_line←-line;
---
> begin output_active:=true;
> incr(dead_cycles);
> push_nest; mode:=-vmode; prev_depth:=ignore_depth; mode_line:=-line;
16233c19816
< new_save_level(output_group);
---
> new_save_level(output_group); normal_paragraph;
16242c19825,19829
< begin end_graf; unsave; output_active←false;
---
> begin if (loc<>null) or
> ((token_type<>output_text)and(token_type<>backed_up)) then
> @<Recover from an unbalanced output routine@>;
> end_token_list; {conserve stack space in case more outputs are triggered}
> end_graf; unsave; output_active:=false; insert_penalties:=0;@/
16244,16253c19831,19840
< if tail≠head then {current list goes after heldover insertions}
< begin link(page_tail)←link(head);
< page_tail←tail;
< end;
< if link(page_head)≠null then {and both go before heldover contributions}
< begin if link(contrib_head)=null then contrib_tail←page_tail;
< link(page_tail)←link(contrib_head);
< link(contrib_head)←link(page_head);
< link(page_head)←null; page_tail←page_head;
< end;
---
> if tail<>head then {current list goes after heldover insertions}
> begin link(page_tail):=link(head);
> page_tail:=tail;
> end;
> if link(page_head)<>null then {and both go before heldover contributions}
> begin if link(contrib_head)=null then contrib_tail:=page_tail;
> link(page_tail):=link(contrib_head);
> link(contrib_head):=link(page_head);
> link(page_head):=null; page_tail:=page_head;
> end;
16256a19844,19852
> @ @<Recover from an unbalanced output routine@>=
> begin print_err("Unbalanced output routine");
> @.Unbalanced output routine@>
> help2("Your sneaky output routine has problematic {'s and/or }'s.")@/
> ("I can't handle that very well; good luck."); error;
> repeat get_token;
> until loc=null;
> end {loops forever if reading from a file, since |null=min_halfword<=0|}
>
16258,16267c19854,19864
< if box(255)≠null then
< begin help3("Your \output commands should empty \box255,")@/
< ("e.g., by saying `\shipout\box255'.")@/
< ("Proceed; I'll discard its present contents.");
< print_nl("! \output routine didn't use all of \box255"); error;
< @:output_}{\.{\\output routine didn't use...}@>
< flush_node_list(box(255)); box(255)←null;
< end
< @* \[45] The chief executive.
< \hskip-1.1pt % avoid overfull box in published version!
---
> if box(255)<>null then
> begin print_err("Output routine didn't use all of ");
> print_esc("box"); print_int(255);
> @.Output routine didn't use...@>
> help3("Your \output commands should empty \box255,")@/
> ("e.g., by saying `\shipout\box255'.")@/
> ("Proceed; I'll discard its present contents.");
> box_error(255);
> end
>
> @* \[46] The chief executive.
16272c19869
< In a sense, this is the grand climax of the program: It applies all of the
---
> In a sense, this is the grand climax of the program: It applies all the
16283,16284c19880,19881
< using |get_nc_token|. Then the program branches at high speed into one of
< about 100 possible directions, based on the the value of the current
---
> using |get_x_token|. Then the program branches at high speed into one of
> about 100 possible directions, based on the value of the current
16307c19904
< with special care.
---
> with particular care.
16314,16318c19911,19917
< @d main_loop=70 {go here to typeset |cur_chr| in the current font}
< @d main_loop_1=71 {like |main_loop|, but |(f,c)| = current font and char}
< @d main_loop_2=72 {like |main_loop_1|, but |c| is known to be in range}
< @d main_loop_3=73 {like |main_loop_2|, but several variables are set up}
< @d append_normal_space=74 {go here to append a normal space between words}
---
> @d main_loop=70 {go here to typeset a string of consecutive characters}
> @d main_loop_wrapup=80 {go here to finish a character or ligature}
> @d main_loop_move=90 {go here to advance the ligature cursor}
> @d main_loop_move_lig=95 {same, when advancing past a generated ligature}
> @d main_loop_lookahead=100 {go here to bring in another character, if any}
> @d main_lig_loop=110 {go here to check for ligatures or kerning}
> @d append_normal_space=120 {go here to append a normal space between words}
16323,16327c19922,19929
< label big_switch,reswitch,main_loop,main_loop_1,main_loop_2,main_loop_3,
< append_normal_space,exit;
< var t:integer; {general-purpose temporary variable}
< @<Local variables for the inner loop of |main_control|@>@;
< begin big_switch: get_nc_token;@/
---
> label big_switch,reswitch,main_loop,main_loop_wrapup,
> main_loop_move,main_loop_move+1,main_loop_move+2,main_loop_move_lig,
> main_loop_lookahead,main_loop_lookahead+1,
> main_lig_loop,main_lig_loop+1,main_lig_loop+2,
> append_normal_space,exit;
> var@!t:integer; {general-purpose temporary variable}
> begin if every_job<>null then begin_token_list(every_job,every_job_text);
> big_switch: get_x_token;@/
16330,16332c19932,19938
< hmode+letter,hmode+other_char: goto main_loop;
< hmode+char_num: begin scan_char_num; cur_chr←cur_val; goto main_loop;
< end;
---
> hmode+letter,hmode+other_char,hmode+char_given: goto main_loop;
> hmode+char_num: begin scan_char_num; cur_chr:=cur_val; goto main_loop;@+end;
> hmode+no_boundary: begin get_x_token;
> if (cur_cmd=letter)or(cur_cmd=other_char)or(cur_cmd=char_given)or
> (cur_cmd=char_num) then cancel_boundary:=true;
> goto reswitch;
> end;
16334c19940
< else app_space;
---
> else app_space;
16339,16341c19945,19947
< main_loop:@<Append character |cur_chr| and the following characters (if@@any)
< to the current hlist in the current font; |goto reswitch| when
< a non-character has been fetched@>;
---
> main_loop:@<Append character |cur_chr| and the following characters (if~any)
> to the current hlist in the current font; |goto reswitch| when
> a non-character has been fetched@>;
16343c19949
< then |goto big_switch|@>;
---
> then |goto big_switch|@>;
16351,16399c19957,19979
< if interrupt>0 then if OK_to_interrupt then
< begin back_input; pause_for_instructions; goto big_switch;
< end;
< debug if panicking then check_mem(false);@+@;@+gubed
< if tracing_commands≠0 then
< begin begin_diagnostic; print_nl("{");
< if mode≠shown_mode then
< begin print_mode(mode); print(": "); shown_mode←mode;
< end;
< print_cmd_chr(cur_cmd,cur_chr); print_char("}");
< end_diagnostic;
< end
<
< @ In the following program, |l| is the current character or ligature;
< it might grow into a longer ligature. One or more characters has been
< used to define |l|, and the last of these was |c|. The chief use of |c|
< will be to modify |space_factor| and to insert discretionary nodes after
< explicit hyphens in the text.
<
< @<Local variables for the inner loop of |main_control|@>=
< @!l:quarterword; {the current character or ligature}
< @!c:eight_bits; {the most recent character}
< @!f:internal_font_number; {the current font}
< @!r:halfword; {the next character for ligature/kern matching}
< @!p:pointer; {the current |char_node|}
< @!k:0..font_mem_size; {index into |font_info|}
< @!q:pointer; {where a ligature should be detached}
< @!i:four_quarters; {character information bytes for |l|}
< @!j:four_quarters; {ligature/kern command}
< @!s:integer; {space factor code}
< @!ligature_present:boolean; {should a ligature node be made?}
<
< @ @<Append character |cur_chr| and the following characters...@>=
< @^inner loop@>
< f←cur_font;
< if f=undefined_font then
< begin missing_font; goto big_switch;
< end;
< c←cur_chr;
< main_loop_1: if (c<font_bc[f])∨(c>font_ec[f]) then
< b
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment