home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / texsrc.arc / TEX0.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  48KB  |  2,068 lines
  1. overlay "tex0"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5. initialize () { r_initialize 
  6.   quarterword i ; 
  7.   integer k ; 
  8.   hyphpointer z ; 
  9.   xchr [ 32 ] = ' ' ; 
  10.   xchr [ 33 ] = '!' ; 
  11.   xchr [ 34 ] = '"' ; 
  12.   xchr [ 35 ] = '#' ; 
  13.   xchr [ 36 ] = '$' ; 
  14.   xchr [ 37 ] = '%' ; 
  15.   xchr [ 38 ] = '&' ; 
  16.   xchr [ 39 ] = '\'' ; 
  17.   xchr [ 40 ] = '(' ; 
  18.   xchr [ 41 ] = ')' ; 
  19.   xchr [ 42 ] = '*' ; 
  20.   xchr [ 43 ] = '+' ; 
  21.   xchr [ 44 ] = ',' ; 
  22.   xchr [ 45 ] = '-' ; 
  23.   xchr [ 46 ] = '.' ; 
  24.   xchr [ 47 ] = '/' ; 
  25.   xchr [ 48 ] = '0' ; 
  26.   xchr [ 49 ] = '1' ; 
  27.   xchr [ 50 ] = '2' ; 
  28.   xchr [ 51 ] = '3' ; 
  29.   xchr [ 52 ] = '4' ; 
  30.   xchr [ 53 ] = '5' ; 
  31.   xchr [ 54 ] = '6' ; 
  32.   xchr [ 55 ] = '7' ; 
  33.   xchr [ 56 ] = '8' ; 
  34.   xchr [ 57 ] = '9' ; 
  35.   xchr [ 58 ] = ':' ; 
  36.   xchr [ 59 ] = ';' ; 
  37.   xchr [ 60 ] = '<' ; 
  38.   xchr [ 61 ] = '=' ; 
  39.   xchr [ 62 ] = '>' ; 
  40.   xchr [ 63 ] = '?' ; 
  41.   xchr [ 64 ] = '@' ; 
  42.   xchr [ 65 ] = 'A' ; 
  43.   xchr [ 66 ] = 'B' ; 
  44.   xchr [ 67 ] = 'C' ; 
  45.   xchr [ 68 ] = 'D' ; 
  46.   xchr [ 69 ] = 'E' ; 
  47.   xchr [ 70 ] = 'F' ; 
  48.   xchr [ 71 ] = 'G' ; 
  49.   xchr [ 72 ] = 'H' ; 
  50.   xchr [ 73 ] = 'I' ; 
  51.   xchr [ 74 ] = 'J' ; 
  52.   xchr [ 75 ] = 'K' ; 
  53.   xchr [ 76 ] = 'L' ; 
  54.   xchr [ 77 ] = 'M' ; 
  55.   xchr [ 78 ] = 'N' ; 
  56.   xchr [ 79 ] = 'O' ; 
  57.   xchr [ 80 ] = 'P' ; 
  58.   xchr [ 81 ] = 'Q' ; 
  59.   xchr [ 82 ] = 'R' ; 
  60.   xchr [ 83 ] = 'S' ; 
  61.   xchr [ 84 ] = 'T' ; 
  62.   xchr [ 85 ] = 'U' ; 
  63.   xchr [ 86 ] = 'V' ; 
  64.   xchr [ 87 ] = 'W' ; 
  65.   xchr [ 88 ] = 'X' ; 
  66.   xchr [ 89 ] = 'Y' ; 
  67.   xchr [ 90 ] = 'Z' ; 
  68.   xchr [ 91 ] = '[' ; 
  69.   xchr [ 92 ] = '\\' ; 
  70.   xchr [ 93 ] = ']' ; 
  71.   xchr [ 94 ] = '^' ; 
  72.   xchr [ 95 ] = '_' ; 
  73.   xchr [ 96 ] = '`' ; 
  74.   xchr [ 97 ] = 'a' ; 
  75.   xchr [ 98 ] = 'b' ; 
  76.   xchr [ 99 ] = 'c' ; 
  77.   xchr [ 100 ] = 'd' ; 
  78.   xchr [ 101 ] = 'e' ; 
  79.   xchr [ 102 ] = 'f' ; 
  80.   xchr [ 103 ] = 'g' ; 
  81.   xchr [ 104 ] = 'h' ; 
  82.   xchr [ 105 ] = 'i' ; 
  83.   xchr [ 106 ] = 'j' ; 
  84.   xchr [ 107 ] = 'k' ; 
  85.   xchr [ 108 ] = 'l' ; 
  86.   xchr [ 109 ] = 'm' ; 
  87.   xchr [ 110 ] = 'n' ; 
  88.   xchr [ 111 ] = 'o' ; 
  89.   xchr [ 112 ] = 'p' ; 
  90.   xchr [ 113 ] = 'q' ; 
  91.   xchr [ 114 ] = 'r' ; 
  92.   xchr [ 115 ] = 's' ; 
  93.   xchr [ 116 ] = 't' ; 
  94.   xchr [ 117 ] = 'u' ; 
  95.   xchr [ 118 ] = 'v' ; 
  96.   xchr [ 119 ] = 'w' ; 
  97.   xchr [ 120 ] = 'x' ; 
  98.   xchr [ 121 ] = 'y' ; 
  99.   xchr [ 122 ] = 'z' ; 
  100.   xchr [ 123 ] = '{' ; 
  101.   xchr [ 124 ] = '|' ; 
  102.   xchr [ 125 ] = '}' ; 
  103.   xchr [ 126 ] = '~' ; 
  104.   xchr [ 0 ] = ' ' ; 
  105.   xchr [ 127 ] = ' ' ; 
  106.   for ( i = 1 ; i <= 31 ; i ++ ) 
  107.   xchr [ i ] = chr ( i ) ; 
  108.   for ( i = 0 ; i <= 127 ; i ++ ) 
  109.   xord [ chr ( i ) ] = 127 ; 
  110.   for ( i = 1 ; i <= 126 ; i ++ ) 
  111.   xord [ xchr [ i ] ] = i ; 
  112.   interaction = 3 ; 
  113.   deletionsall = true ; 
  114.   errorcount = 0 ; 
  115.   helpptr = 0 ; 
  116.   useerrhelp = false ; 
  117.   interrupt = 0 ; 
  118.   OKtointerrup = true ; 
  119.  
  120. #ifdef DEBUG
  121.   wasmemend = memmin ; 
  122.   waslomax = memmin ; 
  123.   washimin = memmax ; 
  124.   panicking = false ; 
  125. #endif /* DEBUG */
  126.   nestptr = 0 ; 
  127.   maxneststack = 0 ; 
  128.   curlist .modefield = 1 ; 
  129.   curlist .headfield = memtop - 1 ; 
  130.   curlist .tailfield = memtop - 1 ; 
  131.   curlist .auxfield = - 65536000 ; 
  132.   curlist .mlfield = 0 ; 
  133.   curlist .pgfield = 0 ; 
  134.   shownmode = 0 ; 
  135.   pagecontents = 0 ; 
  136.   pagetail = memtop - 2 ; 
  137.   mem [(long) memtop - 2 ] .hh .v.RH = 0 ; 
  138.   lastglue = 65535L ; 
  139.   lastpenalty = 0 ; 
  140.   lastkern = 0 ; 
  141.   pagesofar [ 7 ] = 0 ; 
  142.   pagemaxdepth = 0 ; 
  143.   for ( k = 5267 ; k <= 5976 ; k ++ ) 
  144.   xeqlevel [ k ] = 1 ; 
  145.   nonewcontrol = true ; 
  146.   hash [ 258 ] .v.LH = 0 ; 
  147.   hash [ 258 ] .v.RH = 0 ; 
  148.   for ( k = 259 ; k <= 3524 ; k ++ ) 
  149.   hash [ k ] = hash [ 258 ] ; 
  150.   saveptr = 0 ; 
  151.   curlevel = 1 ; 
  152.   curgroup = 0 ; 
  153.   curboundary = 0 ; 
  154.   maxsavestack = 0 ; 
  155.   magset = 0 ; 
  156.   curmark [ 0 ] = 0 ; 
  157.   curmark [ 1 ] = 0 ; 
  158.   curmark [ 2 ] = 0 ; 
  159.   curmark [ 3 ] = 0 ; 
  160.   curmark [ 4 ] = 0 ; 
  161.   curval = 0 ; 
  162.   curvallevel = 0 ; 
  163.   radix = 0 ; 
  164.   for ( k = 0 ; k <= 16 ; k ++ ) 
  165.   readopen [ k ] = 2 ; 
  166.   condptr = 0 ; 
  167.   iflimit = 0 ; 
  168.   curif = 0 ; 
  169.   ifline = 0 ; 
  170.   TEXformatdef = " plain.fmt" ; 
  171.   for ( k = 0 ; k <= fontmax ; k ++ ) 
  172.   fontused [ k ] = false ; 
  173.   nullcharacte .b0 = 0 ; 
  174.   nullcharacte .b1 = 0 ; 
  175.   nullcharacte .b2 = 0 ; 
  176.   nullcharacte .b3 = 0 ; 
  177.   totalpages = 0 ; 
  178.   maxv = 0 ; 
  179.   maxh = 0 ; 
  180.   maxpush = 0 ; 
  181.   lastbop = - 1 ; 
  182.   doingleaders = false ; 
  183.   deadcycles = 0 ; 
  184.   curs = - 1 ; 
  185.   halfbuf = dvibufsize / 2 ; 
  186.   dvilimit = dvibufsize ; 
  187.   dviptr = 0 ; 
  188.   dvioffset = 0 ; 
  189.   dvigone = 0 ; 
  190.   downptr = 0 ; 
  191.   rightptr = 0 ; 
  192.   adjusttail = 0 ; 
  193.   packbeginlin = 0 ; 
  194.   emptyfield .v.RH = 0 ; 
  195.   emptyfield .v.LH = 0 ; 
  196.   nulldelimite .b0 = 0 ; 
  197.   nulldelimite .b1 = 0 ; 
  198.   nulldelimite .b2 = 0 ; 
  199.   nulldelimite .b3 = 0 ; 
  200.   alignptr = 0 ; 
  201.   curalign = 0 ; 
  202.   curspan = 0 ; 
  203.   curloop = 0 ; 
  204.   curhead = 0 ; 
  205.   curtail = 0 ; 
  206.   for ( z = 0 ; z <= 307 ; z ++ ) 
  207.   {
  208.     hyphword [ z ] = 0 ; 
  209.     hyphlist [ z ] = 0 ; 
  210.   } 
  211.   hyphcount = 0 ; 
  212.   outputactive = false ; 
  213.   insertpenalt = 0 ; 
  214.   aftertoken = 0 ; 
  215.   longhelpseen = false ; 
  216.   formatident = 0 ; 
  217.   for ( k = 0 ; k <= 17 ; k ++ ) 
  218.   writeopen [ k ] = false ; 
  219.   editnamestar = 0 ; 
  220.  
  221. #ifdef INITEX
  222.   for ( k = 1 ; k <= 19 ; k ++ ) 
  223.   mem [(long) k ] .cint = 0 ; 
  224.   k = 0 ; 
  225.   while ( k <= 19 ) { 
  226.     mem [(long) k ] .hh .v.RH = 1 ; 
  227.     mem [(long) k ] .hh.b0 = 0 ; 
  228.     mem [(long) k ] .hh.b1 = 0 ; 
  229.     k = k + 4 ; 
  230.   } 
  231.   mem [(long) 6 ] .cint = 65536L ; 
  232.   mem [(long) 4 ] .hh.b0 = 1 ; 
  233.   mem [(long) 10 ] .cint = 65536L ; 
  234.   mem [(long) 8 ] .hh.b0 = 2 ; 
  235.   mem [(long) 14 ] .cint = 65536L ; 
  236.   mem [(long) 12 ] .hh.b0 = 1 ; 
  237.   mem [(long) 15 ] .cint = 65536L ; 
  238.   mem [(long) 12 ] .hh.b1 = 1 ; 
  239.   mem [(long) 18 ] .cint = - 65536L ; 
  240.   mem [(long) 16 ] .hh.b0 = 1 ; 
  241.   rover = 20 ; 
  242.   mem [(long) rover ] .hh .v.RH = 65535L ; 
  243.   mem [(long) rover ] .hh .v.LH = 1000 ; 
  244.   mem [(long) rover + 1 ] .hh .v.LH = rover ; 
  245.   mem [(long) rover + 1 ] .hh .v.RH = rover ; 
  246.   lomemmax = rover + 1000 ; 
  247.   mem [(long) lomemmax ] .hh .v.RH = 0 ; 
  248.   mem [(long) lomemmax ] .hh .v.LH = 0 ; 
  249.   for ( k = memtop - 13 ; k <= memtop ; k ++ ) 
  250.   mem [(long) k ] = mem [(long) lomemmax ] ; 
  251.   mem [(long) memtop - 10 ] .hh .v.LH = 7359 ; 
  252.   mem [(long) memtop - 9 ] .hh .v.RH = 256 ; 
  253.   mem [(long) memtop - 9 ] .hh .v.LH = 0 ; 
  254.   mem [(long) memtop - 7 ] .hh.b0 = 1 ; 
  255.   mem [(long) memtop - 6 ] .hh .v.LH = 65535L ; 
  256.   mem [(long) memtop - 7 ] .hh.b1 = 0 ; 
  257.   mem [(long) memtop ] .hh.b1 = 255 ; 
  258.   mem [(long) memtop ] .hh.b0 = 1 ; 
  259.   mem [(long) memtop ] .hh .v.RH = memtop ; 
  260.   mem [(long) memtop - 2 ] .hh.b0 = 10 ; 
  261.   mem [(long) memtop - 2 ] .hh.b1 = 0 ; 
  262.   avail = 0 ; 
  263.   memend = memtop ; 
  264.   himemmin = memtop - 13 ; 
  265.   varused = 20 ; 
  266.   dynused = 14 ; 
  267.   eqtb [ 3525 ] .hh.b0 = 100 ; 
  268.   eqtb [ 3525 ] .hh .v.RH = 0 ; 
  269.   eqtb [ 3525 ] .hh.b1 = 0 ; 
  270.   for ( k = 1 ; k <= 3524 ; k ++ ) 
  271.   eqtb [ k ] = eqtb [ 3525 ] ; 
  272.   eqtb [ 3526 ] .hh .v.RH = 0 ; 
  273.   eqtb [ 3526 ] .hh.b1 = 1 ; 
  274.   eqtb [ 3526 ] .hh.b0 = 116 ; 
  275.   for ( k = 3527 ; k <= 4055 ; k ++ ) 
  276.   eqtb [ k ] = eqtb [ 3526 ] ; 
  277.   mem [(long) 0 ] .hh .v.RH = mem [(long) 0 ] .hh .v.RH + 530 ; 
  278.   eqtb [ 4056 ] .hh .v.RH = 0 ; 
  279.   eqtb [ 4056 ] .hh.b0 = 117 ; 
  280.   eqtb [ 4056 ] .hh.b1 = 1 ; 
  281.   for ( k = 4057 ; k <= 4321 ; k ++ ) 
  282.   eqtb [ k ] = eqtb [ 3525 ] ; 
  283.   eqtb [ 4322 ] .hh .v.RH = 0 ; 
  284.   eqtb [ 4322 ] .hh.b0 = 118 ; 
  285.   eqtb [ 4322 ] .hh.b1 = 1 ; 
  286.   for ( k = 4323 ; k <= 4577 ; k ++ ) 
  287.   eqtb [ k ] = eqtb [ 4322 ] ; 
  288.   eqtb [ 4578 ] .hh .v.RH = 0 ; 
  289.   eqtb [ 4578 ] .hh.b0 = 119 ; 
  290.   eqtb [ 4578 ] .hh.b1 = 1 ; 
  291.   for ( k = 4579 ; k <= 4626 ; k ++ ) 
  292.   eqtb [ k ] = eqtb [ 4578 ] ; 
  293.   eqtb [ 4627 ] .hh .v.RH = 0 ; 
  294.   eqtb [ 4627 ] .hh.b0 = 119 ; 
  295.   eqtb [ 4627 ] .hh.b1 = 1 ; 
  296.   for ( k = 4628 ; k <= 5266 ; k ++ ) 
  297.   eqtb [ k ] = eqtb [ 4627 ] ; 
  298.   for ( k = 0 ; k <= 127 ; k ++ ) 
  299.   {
  300.     eqtb [ 4627 + k ] .hh .v.RH = 12 ; 
  301.     eqtb [ 5139 + k ] .hh .v.RH = k ; 
  302.     eqtb [ 5011 + k ] .hh .v.RH = 1000 ; 
  303.   } 
  304.   eqtb [ 4640 ] .hh .v.RH = 5 ; 
  305.   eqtb [ 4659 ] .hh .v.RH = 10 ; 
  306.   eqtb [ 4719 ] .hh .v.RH = 0 ; 
  307.   eqtb [ 4664 ] .hh .v.RH = 14 ; 
  308.   eqtb [ 4754 ] .hh .v.RH = 15 ; 
  309.   eqtb [ 4627 ] .hh .v.RH = 9 ; 
  310.   for ( k = 48 ; k <= 57 ; k ++ ) 
  311.   eqtb [ 5139 + k ] .hh .v.RH = k + 28672 ; 
  312.   for ( k = 65 ; k <= 90 ; k ++ ) 
  313.   {
  314.     eqtb [ 4627 + k ] .hh .v.RH = 11 ; 
  315.     eqtb [ 4627 + k + 32 ] .hh .v.RH = 11 ; 
  316.     eqtb [ 5139 + k ] .hh .v.RH = k + 28928 ; 
  317.     eqtb [ 5139 + k + 32 ] .hh .v.RH = k + 28960 ; 
  318.     eqtb [ 4755 + k ] .hh .v.RH = k + 32 ; 
  319.     eqtb [ 4755 + k + 32 ] .hh .v.RH = k + 32 ; 
  320.     eqtb [ 4883 + k ] .hh .v.RH = k ; 
  321.     eqtb [ 4883 + k + 32 ] .hh .v.RH = k ; 
  322.     eqtb [ 5011 + k ] .hh .v.RH = 999 ; 
  323.   } 
  324.   for ( k = 5267 ; k <= 5572 ; k ++ ) 
  325.   eqtb [ k ] .cint = 0 ; 
  326.   eqtb [ 5284 ] .cint = 1000 ; 
  327.   eqtb [ 5268 ] .cint = 10000 ; 
  328.   eqtb [ 5308 ] .cint = 1 ; 
  329.   eqtb [ 5307 ] .cint = 25 ; 
  330.   eqtb [ 5312 ] .cint = 92 ; 
  331.   eqtb [ 5315 ] .cint = 13 ; 
  332.   for ( k = 0 ; k <= 127 ; k ++ ) 
  333.   eqtb [ 5573 + k ] .cint = - 1 ; 
  334.   eqtb [ 5619 ] .cint = 0 ; 
  335.   for ( k = 5701 ; k <= 5976 ; k ++ ) 
  336.   eqtb [ k ] .cint = 0 ; 
  337.   hashused = 3258 ; 
  338.   cscount = 0 ; 
  339.   eqtb [ 3267 ] .hh.b0 = 115 ; 
  340.   hash [ 3267 ] .v.RH = 361 ; 
  341.   fontptr = 0 ; 
  342.   fmemptr = 7 ; 
  343.   fontname [ 0 ] = 654 ; 
  344.   fontarea [ 0 ] = 206 ; 
  345.   hyphenchar [ 0 ] = 45 ; 
  346.   skewchar [ 0 ] = - 1 ; 
  347.   fontbc [ 0 ] = 1 ; 
  348.   fontec [ 0 ] = 0 ; 
  349.   fontsize [ 0 ] = 0 ; 
  350.   fontdsize [ 0 ] = 0 ; 
  351.   charbase [ 0 ] = 0 ; 
  352.   widthbase [ 0 ] = 0 ; 
  353.   heightbase [ 0 ] = 0 ; 
  354.   depthbase [ 0 ] = 0 ; 
  355.   italicbase [ 0 ] = 0 ; 
  356.   ligkernbase [ 0 ] = 0 ; 
  357.   kernbase [ 0 ] = 0 ; 
  358.   extenbase [ 0 ] = 0 ; 
  359.   fontglue [ 0 ] = 0 ; 
  360.   fontparams [ 0 ] = 7 ; 
  361.   parambase [ 0 ] = - 1 ; 
  362.   for ( k = 0 ; k <= 6 ; k ++ ) 
  363.   fontinfo [ k ] .cint = 0 ; 
  364.   trieopptr = 0 ; 
  365.   trie [ 0 ] .v.RH = 0 ; 
  366.   trie [ 0 ] .b1 = 0 ; 
  367.   trie [ 0 ] .b0 = 0 ; 
  368.   for ( k = 1 ; k <= 127 ; k ++ ) 
  369.   trie [ k ] = trie [ 0 ] ; 
  370.   triemax = 127 ; 
  371.   hash [ 3258 ] .v.RH = 1038 ; 
  372.   formatident = 1103 ; 
  373.   hash [ 3266 ] .v.RH = 1138 ; 
  374.   eqtb [ 3266 ] .hh.b1 = 1 ; 
  375.   eqtb [ 3266 ] .hh.b0 = 112 ; 
  376.   eqtb [ 3266 ] .hh .v.RH = 0 ; 
  377. #endif /* INITEX */
  378. } 
  379. println () { r_println 
  380.   switch ( selector ) 
  381.   {case 19 : 
  382.     {
  383.       putc('\n',  output );
  384.       putc('\n',  logfile );
  385.       termoffset = 0 ; 
  386.       fileoffset = 0 ; 
  387.     } 
  388.     break ; 
  389.   case 18 : 
  390.     {
  391.       putc('\n',  logfile );
  392.       fileoffset = 0 ; 
  393.     } 
  394.     break ; 
  395.   case 17 : 
  396.     {
  397.       putc('\n',  output );
  398.       termoffset = 0 ; 
  399.     } 
  400.     break ; 
  401.   case 16 : 
  402.   case 20 : 
  403.   case 21 : 
  404.     ; 
  405.     break ; 
  406.   default : 
  407.     putc('\n',  writefile [ selector ] );
  408.     break ; 
  409.   } 
  410. } 
  411. zprintchar ( s ) 
  412. ASCIIcode s ; 
  413. {/* 10 */ r_printchar 
  414.   if ( s == eqtb [ 5316 ] .cint ) 
  415.   if ( selector < 20 ) 
  416.   {
  417.     println () ; 
  418.     return ; 
  419.   } 
  420.   switch ( selector ) 
  421.   {case 19 : 
  422.     {
  423.       putc( xchr [ s ] ,  output );
  424.       putc( xchr [ s ] ,  logfile );
  425.       incr ( termoffset ) ; 
  426.       incr ( fileoffset ) ; 
  427.       if ( termoffset == maxprintline ) 
  428.       {
  429.     putc('\n',  output );
  430.     termoffset = 0 ; 
  431.       } 
  432.       if ( fileoffset == maxprintline ) 
  433.       {
  434.     putc('\n',  logfile );
  435.     fileoffset = 0 ; 
  436.       } 
  437.     } 
  438.     break ; 
  439.   case 18 : 
  440.     {
  441.       putc( xchr [ s ] ,  logfile );
  442.       incr ( fileoffset ) ; 
  443.       if ( fileoffset == maxprintline ) 
  444.       println () ; 
  445.     } 
  446.     break ; 
  447.   case 17 : 
  448.     {
  449.       putc( xchr [ s ] ,  output );
  450.       incr ( termoffset ) ; 
  451.       if ( termoffset == maxprintline ) 
  452.       println () ; 
  453.     } 
  454.     break ; 
  455.   case 16 : 
  456.     ; 
  457.     break ; 
  458.   case 20 : 
  459.     if ( tally < trickcount ) 
  460.     trickbuf [ tally % errorline ] = s ; 
  461.     break ; 
  462.   case 21 : 
  463.     {
  464.       if ( poolptr < poolsize ) 
  465.       {
  466.     strpool [ poolptr ] = s ; 
  467.     incr ( poolptr ) ; 
  468.       } 
  469.     } 
  470.     break ; 
  471.   default : 
  472.     putc( xchr [ s ] ,  writefile [ selector ] );
  473.     break ; 
  474.   } 
  475.   incr ( tally ) ; 
  476. } 
  477. zprint ( s ) 
  478. integer s ; 
  479. {/* 10 */ r_print 
  480.   poolpointer j ; 
  481.   if ( s >= strptr ) 
  482.   s = 130 ; 
  483.   else if ( s < 128 ) 
  484.   if ( s < 0 ) 
  485.   s = 130 ; 
  486.   else if ( ( s == eqtb [ 5316 ] .cint ) ) 
  487.   if ( selector < 20 ) 
  488.   {
  489.     println () ; 
  490.     return ; 
  491.   } 
  492.   j = strstart [ s ] ; 
  493.   while ( j < strstart [ s + 1 ] ) { 
  494.     printchar ( strpool [ j ] ) ; 
  495.     incr ( j ) ; 
  496.   } 
  497. } 
  498. zslowprint ( s ) 
  499. integer s ; 
  500. {/* 10 */ r_slowprint 
  501.   poolpointer j ; 
  502.   if ( s >= strptr ) 
  503.   s = 130 ; 
  504.   else if ( s < 128 ) 
  505.   if ( s < 0 ) 
  506.   s = 130 ; 
  507.   else if ( ( s == eqtb [ 5316 ] .cint ) ) 
  508.   if ( selector < 20 ) 
  509.   {
  510.     println () ; 
  511.     return ; 
  512.   } 
  513.   j = strstart [ s ] ; 
  514.   while ( j < strstart [ s + 1 ] ) { 
  515.     print ( strpool [ j ] ) ; 
  516.     incr ( j ) ; 
  517.   } 
  518. } 
  519. zprintnl ( s ) 
  520. strnumber s ; 
  521. {r_printnl 
  522.   if ( ( ( termoffset > 0 ) && ( odd ( selector ) ) ) || ( ( fileoffset > 0 ) 
  523.   && ( selector >= 18 ) ) ) 
  524.   println () ; 
  525.   print ( s ) ; 
  526. } 
  527. zprintesc ( s ) 
  528. strnumber s ; 
  529. {r_printesc 
  530.   integer c ; 
  531.   c = eqtb [ 5312 ] .cint ; 
  532.   if ( c >= 0 ) 
  533.   if ( c < 128 ) 
  534.   print ( c ) ; 
  535.   print ( s ) ; 
  536. } 
  537. zprintthedigs ( k ) 
  538. eightbits k ; 
  539. {r_printthedigs 
  540.   while ( k > 0 ) { 
  541.     decr ( k ) ; 
  542.     if ( dig [ k ] < 10 ) 
  543.     printchar ( 48 + dig [ k ] ) ; 
  544.     else printchar ( 55 + dig [ k ] ) ; 
  545.   } 
  546. } 
  547. zprintint ( n ) 
  548. integer n ; 
  549. {r_printint 
  550.   quarterword k ; 
  551.   integer m ; 
  552.   k = 0 ; 
  553.   if ( n < 0 ) 
  554.   {
  555.     printchar ( 45 ) ; 
  556.     if ( n > - 100000000 ) 
  557.     n = - n ; 
  558.     else { 
  559.       m = - 1 - n ; 
  560.       n = m / 10 ; 
  561.       m = ( m % 10 ) + 1 ; 
  562.       k = 1 ; 
  563.       if ( m < 10 ) 
  564.       dig [ 0 ] = m ; 
  565.       else { 
  566.     dig [ 0 ] = 0 ; 
  567.     incr ( n ) ; 
  568.       } 
  569.     } 
  570.   } 
  571.   do { dig [ k ] = n % 10 ; 
  572.     n = n / 10 ; 
  573.     incr ( k ) ; 
  574.   } while ( ! ( n == 0 ) ) ; 
  575.   printthedigs ( k ) ; 
  576. } 
  577. zprintcs ( p ) 
  578. integer p ; 
  579. {r_printcs 
  580.   if ( p < 258 ) 
  581.   if ( p >= 129 ) 
  582.   if ( p == 257 ) 
  583.   {
  584.     printesc ( 363 ) ; 
  585.     printesc ( 364 ) ; 
  586.   } 
  587.   else { 
  588.     printesc ( p - 129 ) ; 
  589.     if ( eqtb [ 4627 + p - 129 ] .hh .v.RH == 11 ) 
  590.     printchar ( 32 ) ; 
  591.   } 
  592.   else if ( p < 1 ) 
  593.   printesc ( 365 ) ; 
  594.   else print ( p - 1 ) ; 
  595.   else if ( p >= 3525 ) 
  596.   printesc ( 365 ) ; 
  597.   else if ( ( hash [ p ] .v.RH < 0 ) || ( hash [ p ] .v.RH >= strptr ) ) 
  598.   printesc ( 366 ) ; 
  599.   else { 
  600.     printesc ( 206 ) ; 
  601.     slowprint ( hash [ p ] .v.RH ) ; 
  602.     printchar ( 32 ) ; 
  603.   } 
  604. } 
  605. zsprintcs ( p ) 
  606. halfword p ; 
  607. {r_sprintcs 
  608.   if ( p < 258 ) 
  609.   if ( p < 129 ) 
  610.   print ( p - 1 ) ; 
  611.   else if ( p < 257 ) 
  612.   printesc ( p - 129 ) ; 
  613.   else { 
  614.     printesc ( 363 ) ; 
  615.     printesc ( 364 ) ; 
  616.   } 
  617.   else { 
  618.     printesc ( 206 ) ; 
  619.     slowprint ( hash [ p ] .v.RH ) ; 
  620.   } 
  621. } 
  622. zprintfilenam ( n , a , e ) 
  623. integer n , a , e ; 
  624. {r_printfilenam 
  625.   print ( a ) ; 
  626.   print ( n ) ; 
  627.   print ( e ) ; 
  628. } 
  629. zprintsize ( s ) 
  630. integer s ; 
  631. {r_printsize 
  632.   if ( s == 0 ) 
  633.   printesc ( 277 ) ; 
  634.   else if ( s == 16 ) 
  635.   printesc ( 278 ) ; 
  636.   else printesc ( 279 ) ; 
  637. } 
  638. zprintwritewh ( s , p ) 
  639. strnumber s ; 
  640. halfword p ; 
  641. {r_printwritewh 
  642.   printesc ( s ) ; 
  643.   if ( mem [(long) p + 1 ] .hh .v.LH < 16 ) 
  644.   printint ( mem [(long) p + 1 ] .hh .v.LH ) ; 
  645.   else if ( mem [(long) p + 1 ] .hh .v.LH == 16 ) 
  646.   printchar ( 42 ) ; 
  647.   else printchar ( 45 ) ; 
  648. } 
  649.  
  650. #ifdef DEBUG
  651. #endif /* DEBUG */
  652. jumpout () { r_jumpout 
  653.   closefilesan () ; 
  654.   {
  655.     termflush ( output ) ; 
  656.     readyalready = 0 ; 
  657.     if ( ( history != 0 ) && ( history != 1 ) ) 
  658.     uexit ( 1 ) ; 
  659.     else uexit ( 0 ) ; 
  660.   } 
  661. } 
  662. error () { /* 22 10 */ r_error 
  663.   ASCIIcode c ; 
  664.   integer s1, s2, s3, s4 ; 
  665.   if ( history < 2 ) 
  666.   history = 2 ; 
  667.   printchar ( 46 ) ; 
  668.   showcontext () ; 
  669.   if ( interaction == 3 ) 
  670.   while ( true ) { 
  671.     lab22: clearforerro () ; 
  672.     {
  673.       wakeuptermin () ; 
  674.       print ( 135 ) ; 
  675.       terminput () ; 
  676.     } 
  677.     if ( last == first ) 
  678.     return ; 
  679.     c = buffer [ first ] ; 
  680.     if ( c >= 97 ) 
  681.     c = c - 32 ; 
  682.     switch ( c ) 
  683.     {case 48 : 
  684.     case 49 : 
  685.     case 50 : 
  686.     case 51 : 
  687.     case 52 : 
  688.     case 53 : 
  689.     case 54 : 
  690.     case 55 : 
  691.     case 56 : 
  692.     case 57 : 
  693.       if ( deletionsall ) 
  694.       {
  695.     s1 = curtok ; 
  696.     s2 = curcmd ; 
  697.     s3 = curchr ; 
  698.     s4 = alignstate ; 
  699.     alignstate = 1000000 ; 
  700.     OKtointerrup = false ; 
  701.     if ( ( last > first + 1 ) && ( buffer [ first + 1 ] >= 48 ) && ( 
  702.     buffer [ first + 1 ] <= 57 ) ) 
  703.     c = c * 10 + buffer [ first + 1 ] - 48 * 11 ; 
  704.     else c = c - 48 ; 
  705.     while ( c > 0 ) { 
  706.       gettoken () ; 
  707.       decr ( c ) ; 
  708.     } 
  709.     curtok = s1 ; 
  710.     curcmd = s2 ; 
  711.     curchr = s3 ; 
  712.     alignstate = s4 ; 
  713.     OKtointerrup = true ; 
  714.     {
  715.       helpptr = 2 ; 
  716.       helpline [ 1 ] = 148 ; 
  717.       helpline [ 0 ] = 149 ; 
  718.     } 
  719.     showcontext () ; 
  720.     goto lab22 ; 
  721.       } 
  722.       break ; 
  723.  
  724. #ifdef DEBUG
  725.     case 68 : 
  726.       {
  727.     debughelp () ; 
  728.     goto lab22 ; 
  729.       } 
  730.       break ; 
  731. #endif /* DEBUG */
  732.     case 69 : 
  733.       if ( baseptr > 0 ) 
  734.       {
  735.     editnamestar = strstart [ inputstack [ baseptr ] .namefield ] ; 
  736.     editnameleng = strstart [ inputstack [ baseptr ] .namefield + 1 ] - 
  737.     strstart [ inputstack [ baseptr ] .namefield ] ; 
  738.     editline = line ; 
  739.     jumpout () ; 
  740.       } 
  741.       break ; 
  742.     case 72 : 
  743.       {
  744.     if ( useerrhelp ) 
  745.     {
  746.       giveerrhelp () ; 
  747.       useerrhelp = false ; 
  748.     } 
  749.     else { 
  750.       if ( helpptr == 0 ) 
  751.       {
  752.         helpptr = 2 ; 
  753.         helpline [ 1 ] = 150 ; 
  754.         helpline [ 0 ] = 151 ; 
  755.       } 
  756.       do { decr ( helpptr ) ; 
  757.         print ( helpline [ helpptr ] ) ; 
  758.         println () ; 
  759.       } while ( ! ( helpptr == 0 ) ) ; 
  760.     } 
  761.     {
  762.       helpptr = 4 ; 
  763.       helpline [ 3 ] = 152 ; 
  764.       helpline [ 2 ] = 151 ; 
  765.       helpline [ 1 ] = 153 ; 
  766.       helpline [ 0 ] = 154 ; 
  767.     } 
  768.     goto lab22 ; 
  769.       } 
  770.       break ; 
  771.     case 73 : 
  772.       {
  773.     beginfilerea () ; 
  774.     if ( last > first + 1 ) 
  775.     {
  776.       curinput .locfield = first + 1 ; 
  777.       buffer [ first ] = 32 ; 
  778.     } 
  779.     else { 
  780.       {
  781.         wakeuptermin () ; 
  782.         print ( 147 ) ; 
  783.         terminput () ; 
  784.       } 
  785.       curinput .locfield = first ; 
  786.     } 
  787.     first = last ; 
  788.     curinput .limitfield = last - 1 ; 
  789.     return ; 
  790.       } 
  791.       break ; 
  792.     case 81 : 
  793.     case 82 : 
  794.     case 83 : 
  795.       {
  796.     errorcount = 0 ; 
  797.     interaction = 0 + c - 81 ; 
  798.     print ( 142 ) ; 
  799.     switch ( c ) 
  800.     {case 81 : 
  801.       {
  802.         printesc ( 143 ) ; 
  803.         decr ( selector ) ; 
  804.       } 
  805.       break ; 
  806.     case 82 : 
  807.       printesc ( 144 ) ; 
  808.       break ; 
  809.     case 83 : 
  810.       printesc ( 145 ) ; 
  811.       break ; 
  812.     } 
  813.     print ( 146 ) ; 
  814.     println () ; 
  815.     termflush ( output ) ; 
  816.     return ; 
  817.       } 
  818.       break ; 
  819.     case 88 : 
  820.       {
  821.     interaction = 2 ; 
  822.     jumpout () ; 
  823.       } 
  824.       break ; 
  825.     default : 
  826.       ; 
  827.       break ; 
  828.     } 
  829.     {
  830.       print ( 136 ) ; 
  831.       printnl ( 137 ) ; 
  832.       printnl ( 138 ) ; 
  833.       if ( baseptr > 0 ) 
  834.       print ( 139 ) ; 
  835.       if ( deletionsall ) 
  836.       printnl ( 140 ) ; 
  837.       printnl ( 141 ) ; 
  838.     } 
  839.   } 
  840.   incr ( errorcount ) ; 
  841.   if ( errorcount == 100 ) 
  842.   {
  843.     printnl ( 134 ) ; 
  844.     history = 3 ; 
  845.     jumpout () ; 
  846.   } 
  847.   if ( interaction > 0 ) 
  848.   decr ( selector ) ; 
  849.   if ( useerrhelp ) 
  850.   {
  851.     println () ; 
  852.     giveerrhelp () ; 
  853.   } 
  854.   else while ( helpptr > 0 ) { 
  855.     decr ( helpptr ) ; 
  856.     printnl ( helpline [ helpptr ] ) ; 
  857.   } 
  858.   println () ; 
  859.   if ( interaction > 0 ) 
  860.   incr ( selector ) ; 
  861.   println () ; 
  862. } 
  863. zfatalerror ( s ) 
  864. strnumber s ; 
  865. {r_fatalerror 
  866.   normalizesel () ; 
  867.   {
  868.     if ( interaction == 3 ) 
  869.     wakeuptermin () ; 
  870.     printnl ( 133 ) ; 
  871.     print ( 156 ) ; 
  872.   } 
  873.   {
  874.     helpptr = 1 ; 
  875.     helpline [ 0 ] = s ; 
  876.   } 
  877.   {
  878.     if ( interaction == 3 ) 
  879.     interaction = 2 ; 
  880.     error () ; 
  881.  
  882. #ifdef DEBUG
  883.     if ( interaction > 0 ) 
  884.     debughelp () ; 
  885. #endif /* DEBUG */
  886.     history = 3 ; 
  887.     jumpout () ; 
  888.   } 
  889. } 
  890. zoverflow ( s , n ) 
  891. strnumber s ; 
  892. integer n ; 
  893. {r_overflow 
  894.   normalizesel () ; 
  895.   {
  896.     if ( interaction == 3 ) 
  897.     wakeuptermin () ; 
  898.     printnl ( 133 ) ; 
  899.     print ( 157 ) ; 
  900.   } 
  901.   print ( s ) ; 
  902.   printchar ( 61 ) ; 
  903.   printint ( n ) ; 
  904.   printchar ( 93 ) ; 
  905.   {
  906.     helpptr = 2 ; 
  907.     helpline [ 1 ] = 158 ; 
  908.     helpline [ 0 ] = 159 ; 
  909.   } 
  910.   {
  911.     if ( interaction == 3 ) 
  912.     interaction = 2 ; 
  913.     error () ; 
  914.  
  915. #ifdef DEBUG
  916.     if ( interaction > 0 ) 
  917.     debughelp () ; 
  918. #endif /* DEBUG */
  919.     history = 3 ; 
  920.     jumpout () ; 
  921.   } 
  922. } 
  923. zconfusion ( s ) 
  924. strnumber s ; 
  925. {r_confusion 
  926.   normalizesel () ; 
  927.   if ( history < 2 ) 
  928.   {
  929.     {
  930.       if ( interaction == 3 ) 
  931.       wakeuptermin () ; 
  932.       printnl ( 133 ) ; 
  933.       print ( 160 ) ; 
  934.     } 
  935.     print ( s ) ; 
  936.     printchar ( 41 ) ; 
  937.     {
  938.       helpptr = 1 ; 
  939.       helpline [ 0 ] = 161 ; 
  940.     } 
  941.   } 
  942.   else { 
  943.     {
  944.       if ( interaction == 3 ) 
  945.       wakeuptermin () ; 
  946.       printnl ( 133 ) ; 
  947.       print ( 162 ) ; 
  948.     } 
  949.     {
  950.       helpptr = 2 ; 
  951.       helpline [ 1 ] = 163 ; 
  952.       helpline [ 0 ] = 164 ; 
  953.     } 
  954.   } 
  955.   {
  956.     if ( interaction == 3 ) 
  957.     interaction = 2 ; 
  958.     error () ; 
  959.  
  960. #ifdef DEBUG
  961.     if ( interaction > 0 ) 
  962.     debughelp () ; 
  963. #endif /* DEBUG */
  964.     history = 3 ; 
  965.     jumpout () ; 
  966.   } 
  967. } 
  968. boolean initterminal () { /* 10 */ register boolean Result; 
  969.   r_initterminal 
  970.   integer i, j ; 
  971.   topenin () ; 
  972.   if ( last > first ) 
  973.   {
  974.     curinput .locfield = first ; 
  975.     while ( ( curinput .locfield < last ) && ( buffer [ curinput .locfield ] 
  976.     == ' ' ) ) incr ( curinput .locfield ) ; 
  977.     if ( curinput .locfield < last ) 
  978.     {
  979.       Result = true ; 
  980.       return(Result) ; 
  981.     } 
  982.   } 
  983.   while ( true ) { 
  984.     wakeuptermin () ; 
  985.     Fputs( output ,  "**" ) ; 
  986.     termflush ( output ) ; 
  987.     if ( ! inputln ( input , true ) ) 
  988.     {
  989.       putc('\n',  output );
  990.       Fputs( output ,  "! End of file on the terminal... why?" ) ; 
  991.       Result = false ; 
  992.       return(Result) ; 
  993.     } 
  994.     curinput .locfield = first ; 
  995.     while ( ( curinput .locfield < last ) && ( buffer [ curinput .locfield ] 
  996.     == 32 ) ) incr ( curinput .locfield ) ; 
  997.     if ( curinput .locfield < last ) 
  998.     {
  999.       Result = true ; 
  1000.       return(Result) ; 
  1001.     } 
  1002.     (void) fprintf( output , "%s\n",  "Please type the name of your input file." ) ; 
  1003.   } 
  1004.   return(Result) ; 
  1005. } 
  1006. strnumber makestring () { register strnumber Result; r_makestring 
  1007.   if ( strptr == maxstrings ) 
  1008.   overflow ( 129 , maxstrings - initstrptr ) ; 
  1009.   incr ( strptr ) ; 
  1010.   strstart [ strptr ] = poolptr ; 
  1011.   Result = strptr - 1 ; 
  1012.   return(Result) ; 
  1013. } 
  1014. boolean zstreqbuf ( s , k ) 
  1015. strnumber s ; 
  1016. integer k ; 
  1017. {/* 45 */ register boolean Result; r_streqbuf 
  1018.   poolpointer j ; 
  1019.   boolean result ; 
  1020.   j = strstart [ s ] ; 
  1021.   while ( j < strstart [ s + 1 ] ) { 
  1022.     if ( strpool [ j ] != buffer [ k ] ) 
  1023.     {
  1024.       result = false ; 
  1025.       goto lab45 ; 
  1026.     } 
  1027.     incr ( j ) ; 
  1028.     incr ( k ) ; 
  1029.   } 
  1030.   result = true ; 
  1031.   lab45: Result = result ; 
  1032.   return(Result) ; 
  1033. } 
  1034. boolean zstreqstr ( s , t ) 
  1035. strnumber s , t ; 
  1036. {/* 45 */ register boolean Result; r_streqstr 
  1037.   poolpointer j, k ; 
  1038.   boolean result ; 
  1039.   result = false ; 
  1040.   if ( ( strstart [ s + 1 ] - strstart [ s ] ) != ( strstart [ t + 1 ] - 
  1041.   strstart [ t ] ) ) 
  1042.   goto lab45 ; 
  1043.   j = strstart [ s ] ; 
  1044.   k = strstart [ t ] ; 
  1045.   while ( j < strstart [ s + 1 ] ) { 
  1046.     if ( strpool [ j ] != strpool [ k ] ) 
  1047.     goto lab45 ; 
  1048.     incr ( j ) ; 
  1049.     incr ( k ) ; 
  1050.   } 
  1051.   result = true ; 
  1052.   lab45: Result = result ; 
  1053.   return(Result) ; 
  1054. } 
  1055.  
  1056. #ifdef INITEX
  1057. boolean getstringsst () { /* 30 10 */ register boolean Result; 
  1058.   r_getstringsst 
  1059.   quarterword k, l ; 
  1060.   char m, n ; 
  1061.   strnumber g ; 
  1062.   integer a ; 
  1063.   boolean c ; 
  1064.   poolptr = 0 ; 
  1065.   strptr = 0 ; 
  1066.   strstart [ 0 ] = 0 ; 
  1067.   for ( k = 0 ; k <= 127 ; k ++ ) 
  1068.   {
  1069.     if ( ( ( k < 32 ) || ( k > 126 ) ) ) 
  1070.     {
  1071.       {
  1072.     strpool [ poolptr ] = 94 ; 
  1073.     incr ( poolptr ) ; 
  1074.       } 
  1075.       {
  1076.     strpool [ poolptr ] = 94 ; 
  1077.     incr ( poolptr ) ; 
  1078.       } 
  1079.       if ( k < 64 ) 
  1080.       {
  1081.     strpool [ poolptr ] = k + 64 ; 
  1082.     incr ( poolptr ) ; 
  1083.       } 
  1084.       else { 
  1085.     strpool [ poolptr ] = k - 64 ; 
  1086.     incr ( poolptr ) ; 
  1087.       } 
  1088.     } 
  1089.     else { 
  1090.       strpool [ poolptr ] = k ; 
  1091.       incr ( poolptr ) ; 
  1092.     } 
  1093.     g = makestring () ; 
  1094.   } 
  1095.   vstrcpy ( nameoffile + 1 , poolname ) ; 
  1096.   if ( aopenin ( poolfile , poolpathspec ) ) 
  1097.   {
  1098.     c = false ; 
  1099.     do { { 
  1100.     if ( eof ( poolfile ) ) 
  1101.     {
  1102.       wakeuptermin () ; 
  1103.       (void) fprintf( output , "%s\n",  "! tex.pool has no check sum." ) ; 
  1104.       aclose ( poolfile ) ; 
  1105.       Result = false ; 
  1106.       return(Result) ; 
  1107.     } 
  1108.     read ( poolfile , m ) ; 
  1109.     read ( poolfile , n ) ; 
  1110.     if ( m == '*' ) 
  1111.     {
  1112.       a = 0 ; 
  1113.       k = 1 ; 
  1114.       while ( true ) { 
  1115.         if ( ( xord [ n ] < 48 ) || ( xord [ n ] > 57 ) ) 
  1116.         {
  1117.           wakeuptermin () ; 
  1118.           (void) fprintf( output , "%s\n",                "! tex.pool check sum doesn't have nine digits." ) ; 
  1119.           aclose ( poolfile ) ; 
  1120.           Result = false ; 
  1121.           return(Result) ; 
  1122.         } 
  1123.         a = 10 * a + xord [ n ] - 48 ; 
  1124.         if ( k == 9 ) 
  1125.         goto lab30 ; 
  1126.         incr ( k ) ; 
  1127.         read ( poolfile , n ) ; 
  1128.       } 
  1129.       lab30: if ( a != 13634946 ) 
  1130.       {
  1131.         wakeuptermin () ; 
  1132.         (void) fprintf( output , "%s\n",  "! tex.pool doesn't match; tangle me again." ) 
  1133.         ; 
  1134.         aclose ( poolfile ) ; 
  1135.         Result = false ; 
  1136.         return(Result) ; 
  1137.       } 
  1138.       c = true ; 
  1139.     } 
  1140.     else { 
  1141.       if ( ( xord [ m ] < 48 ) || ( xord [ m ] > 57 ) || ( xord [ n ] < 48 
  1142.       ) || ( xord [ n ] > 57 ) ) 
  1143.       {
  1144.         wakeuptermin () ; 
  1145.         (void) fprintf( output , "%s\n",              "! tex.pool line doesn't begin with two digits." ) ; 
  1146.         aclose ( poolfile ) ; 
  1147.         Result = false ; 
  1148.         return(Result) ; 
  1149.       } 
  1150.       l = xord [ m ] * 10 + xord [ n ] - 48 * 11 ; 
  1151.       if ( poolptr + l + stringvacanc > poolsize ) 
  1152.       {
  1153.         wakeuptermin () ; 
  1154.         (void) fprintf( output , "%s\n",  "! You have to increase POOLSIZE." ) ; 
  1155.         aclose ( poolfile ) ; 
  1156.         Result = false ; 
  1157.         return(Result) ; 
  1158.       } 
  1159.       for ( k = 1 ; k <= l ; k ++ ) 
  1160.       {
  1161.         if ( eoln ( poolfile ) ) 
  1162.         m = ' ' ; 
  1163.         else read ( poolfile , m ) ; 
  1164.         {
  1165.           strpool [ poolptr ] = xord [ m ] ; 
  1166.           incr ( poolptr ) ; 
  1167.         } 
  1168.       } 
  1169.       readln ( poolfile ) ; 
  1170.       g = makestring () ; 
  1171.     } 
  1172.       } 
  1173.     } while ( ! ( c ) ) ; 
  1174.     aclose ( poolfile ) ; 
  1175.     Result = true ; 
  1176.   } 
  1177.   else { 
  1178.     wakeuptermin () ; 
  1179.     (void) fprintf( output , "%s\n",  "! I can't read tex.pool." ) ; 
  1180.     Result = false ; 
  1181.     return(Result) ; 
  1182.   } 
  1183.   return(Result) ; 
  1184. } 
  1185. #endif /* INITEX */
  1186. zprinttwo ( n ) 
  1187. integer n ; 
  1188. {r_printtwo 
  1189.   n = abs ( n ) % 100 ; 
  1190.   printchar ( 48 + ( n / 10 ) ) ; 
  1191.   printchar ( 48 + ( n % 10 ) ) ; 
  1192. } 
  1193. zprinthex ( n ) 
  1194. integer n ; 
  1195. {r_printhex 
  1196.   quarterword k ; 
  1197.   k = 0 ; 
  1198.   printchar ( 34 ) ; 
  1199.   do { dig [ k ] = n % 16 ; 
  1200.     n = n / 16 ; 
  1201.     incr ( k ) ; 
  1202.   } while ( ! ( n == 0 ) ) ; 
  1203.   printthedigs ( k ) ; 
  1204. } 
  1205. zprintASCII ( c ) 
  1206. integer c ; 
  1207. {r_printASCII 
  1208.   if ( ( c >= 0 ) && ( c <= 127 ) ) 
  1209.   print ( c ) ; 
  1210.   else { 
  1211.     printchar ( 91 ) ; 
  1212.     if ( c < 0 ) 
  1213.     printint ( c ) ; 
  1214.     else printhex ( c ) ; 
  1215.     printchar ( 93 ) ; 
  1216.   } 
  1217. } 
  1218. zprintromanin ( n ) 
  1219. integer n ; 
  1220. {/* 10 */ r_printromanin 
  1221.   poolpointer j, k ; 
  1222.   nonnegativei u, v ; 
  1223.   j = strstart [ 131 ] ; 
  1224.   v = 1000 ; 
  1225.   while ( true ) { 
  1226.     while ( n >= v ) { 
  1227.       printchar ( strpool [ j ] ) ; 
  1228.       n = n - v ; 
  1229.     } 
  1230.     if ( n <= 0 ) 
  1231.     return ; 
  1232.     k = j + 2 ; 
  1233.     u = v / ( strpool [ k - 1 ] - 48 ) ; 
  1234.     if ( strpool [ k - 1 ] == 50 ) 
  1235.     {
  1236.       k = k + 2 ; 
  1237.       u = u / ( strpool [ k - 1 ] - 48 ) ; 
  1238.     } 
  1239.     if ( n + u >= v ) 
  1240.     {
  1241.       printchar ( strpool [ k ] ) ; 
  1242.       n = n + u ; 
  1243.     } 
  1244.     else { 
  1245.       j = j + 2 ; 
  1246.       v = v / ( strpool [ j - 1 ] - 48 ) ; 
  1247.     } 
  1248.   } 
  1249. } 
  1250. printcurrent () { r_printcurrent 
  1251.   poolpointer j ; 
  1252.   j = strstart [ strptr ] ; 
  1253.   while ( j < poolptr ) { 
  1254.     printchar ( strpool [ j ] ) ; 
  1255.     incr ( j ) ; 
  1256.   } 
  1257. } 
  1258. terminput () { r_terminput 
  1259.   integer k ; 
  1260.   termflush ( output ) ; 
  1261.   if ( ! inputln ( input , true ) ) 
  1262.   fatalerror ( 132 ) ; 
  1263.   termoffset = 0 ; 
  1264.   decr ( selector ) ; 
  1265.   if ( last != first ) 
  1266.   for ( k = first ; k <= last - 1 ; k ++ ) 
  1267.   print ( buffer [ k ] ) ; 
  1268.   println () ; 
  1269.   incr ( selector ) ; 
  1270. } 
  1271. zinterror ( n ) 
  1272. integer n ; 
  1273. {r_interror 
  1274.   print ( 155 ) ; 
  1275.   printint ( n ) ; 
  1276.   printchar ( 41 ) ; 
  1277.   error () ; 
  1278. } 
  1279. normalizesel () { r_normalizesel 
  1280.   if ( jobname > 0 ) 
  1281.   selector = 19 ; 
  1282.   else selector = 17 ; 
  1283.   if ( jobname == 0 ) 
  1284.   openlogfile () ; 
  1285.   if ( interaction == 0 ) 
  1286.   decr ( selector ) ; 
  1287. } 
  1288. pauseforinst () { r_pauseforinst 
  1289.   if ( OKtointerrup ) 
  1290.   {
  1291.     interaction = 3 ; 
  1292.     if ( ( selector == 18 ) || ( selector == 16 ) ) 
  1293.     incr ( selector ) ; 
  1294.     {
  1295.       if ( interaction == 3 ) 
  1296.       wakeuptermin () ; 
  1297.       printnl ( 133 ) ; 
  1298.       print ( 165 ) ; 
  1299.     } 
  1300.     {
  1301.       helpptr = 3 ; 
  1302.       helpline [ 2 ] = 166 ; 
  1303.       helpline [ 1 ] = 167 ; 
  1304.       helpline [ 0 ] = 168 ; 
  1305.     } 
  1306.     deletionsall = false ; 
  1307.     error () ; 
  1308.     deletionsall = true ; 
  1309.     interrupt = 0 ; 
  1310.   } 
  1311. } 
  1312. integer zhalf ( x ) 
  1313. integer x ; 
  1314. {register integer Result; r_half 
  1315.   if ( odd ( x ) ) 
  1316.   Result = ( x + 1 ) / 2 ; 
  1317.   else Result = x / 2 ; 
  1318.   return(Result) ; 
  1319. } 
  1320. scaled zrounddecimal ( k ) 
  1321. smallnumber k ; 
  1322. {register scaled Result; r_rounddecimal 
  1323.   integer a ; 
  1324.   a = 0 ; 
  1325.   while ( k > 0 ) { 
  1326.     decr ( k ) ; 
  1327.     a = ( a + dig [ k ] * 131072 ) / 10 ; 
  1328.   } 
  1329.   Result = ( a + 1 ) / 2 ; 
  1330.   return(Result) ; 
  1331. } 
  1332. zprintscaled ( s ) 
  1333. scaled s ; 
  1334. {r_printscaled 
  1335.   scaled delta ; 
  1336.   if ( s < 0 ) 
  1337.   {
  1338.     printchar ( 45 ) ; 
  1339.     s = - s ; 
  1340.   } 
  1341.   printint ( s / 65536 ) ; 
  1342.   printchar ( 46 ) ; 
  1343.   s = 10 * ( s % 65536 ) + 5 ; 
  1344.   delta = 10 ; 
  1345.   do { if ( delta > 65536 ) 
  1346.     s = s + 32768L - ( delta / 2 ) ; 
  1347.     printchar ( 48 + ( s / 65536 ) ) ; 
  1348.     s = 10 * ( s % 65536 ) ; 
  1349.     delta = delta * 10 ; 
  1350.   } while ( ! ( s <= delta ) ) ; 
  1351. } 
  1352. scaled znxplusy ( n , x , y ) 
  1353. integer n ; 
  1354. scaled x , y ; 
  1355. {register scaled Result; r_nxplusy 
  1356.   if ( n < 0 ) 
  1357.   {
  1358.     x = - x ; 
  1359.     n = - n ; 
  1360.   } 
  1361.   if ( n == 0 ) 
  1362.   Result = y ; 
  1363.   else if ( ( ( x <= ( 1073741823 - y ) / n ) && ( - x <= ( 1073741823 + y ) / 
  1364.   n ) ) ) 
  1365.   Result = n * x + y ; 
  1366.   else { 
  1367.     aritherror = true ; 
  1368.     Result = 0 ; 
  1369.   } 
  1370.   return(Result) ; 
  1371. } 
  1372. scaled zxovern ( x , n ) 
  1373. scaled x ; 
  1374. integer n ; 
  1375. {register scaled Result; r_xovern 
  1376.   boolean negative ; 
  1377.   negative = false ; 
  1378.   if ( n == 0 ) 
  1379.   {
  1380.     aritherror = true ; 
  1381.     Result = 0 ; 
  1382.     remainder = x ; 
  1383.   } 
  1384.   else { 
  1385.     if ( n < 0 ) 
  1386.     {
  1387.       x = - x ; 
  1388.       n = - n ; 
  1389.       negative = true ; 
  1390.     } 
  1391.     if ( x >= 0 ) 
  1392.     {
  1393.       Result = x / n ; 
  1394.       remainder = x % n ; 
  1395.     } 
  1396.     else { 
  1397.       Result = - ( ( - x ) / n ) ; 
  1398.       remainder = - ( ( - x ) % n ) ; 
  1399.     } 
  1400.   } 
  1401.   if ( negative ) 
  1402.   remainder = - remainder ; 
  1403.   return(Result) ; 
  1404. } 
  1405. scaled zxnoverd ( x , n , d ) 
  1406. scaled x ; 
  1407. integer n , d ; 
  1408. {register scaled Result; r_xnoverd 
  1409.   boolean positive ; 
  1410.   nonnegativei t, u, v ; 
  1411.   if ( x >= 0 ) 
  1412.   positive = true ; 
  1413.   else { 
  1414.     x = - x ; 
  1415.     positive = false ; 
  1416.   } 
  1417.   t = ( x % 32768L ) * n ; 
  1418.   u = ( x / 32768L ) * n + ( t / 32768L ) ; 
  1419.   v = ( u % d ) * 32768 + ( t % 32768 ) ; 
  1420.   if ( u / d >= 32768 ) 
  1421.   aritherror = true ; 
  1422.   else u = 32768L * ( u / d ) + ( v / d ) ; 
  1423.   if ( positive ) 
  1424.   {
  1425.     Result = u ; 
  1426.     remainder = v % d ; 
  1427.   } 
  1428.   else { 
  1429.     Result = - u ; 
  1430.     remainder = - ( v % d ) ; 
  1431.   } 
  1432.   return(Result) ; 
  1433. } 
  1434. halfword zbadness ( t , s ) 
  1435. scaled t , s ; 
  1436. {register halfword Result; r_badness 
  1437.   integer r ; 
  1438.   if ( t == 0 ) 
  1439.   Result = 0 ; 
  1440.   else if ( s <= 0 ) 
  1441.   Result = 10000 ; 
  1442.   else { 
  1443.     if ( t <= 7230584 ) 
  1444.     r = ( t * 297 ) / s ; 
  1445.     else if ( s >= 1663497 ) 
  1446.     r = t / ( s / 297 ) ; 
  1447.     else r = t ; 
  1448.     if ( r > 1290 ) 
  1449.     Result = 10000 ; 
  1450.     else Result = ( r * r * r + 131072 ) / 262144 ; 
  1451.   } 
  1452.   return(Result) ; 
  1453. } 
  1454.  
  1455. #ifdef DEBUG
  1456. zprintword ( w ) 
  1457. memoryword w ; 
  1458. {r_printword 
  1459.   printint ( w .cint ) ; 
  1460.   printchar ( 32 ) ; 
  1461.   printscaled ( w .cint ) ; 
  1462.   printchar ( 32 ) ; 
  1463.   printscaled ( round ( 65536 * w .gr ) ) ; 
  1464.   println () ; 
  1465.   printint ( w .hh .v.LH ) ; 
  1466.   printchar ( 61 ) ; 
  1467.   printint ( w .hh.b0 ) ; 
  1468.   printchar ( 58 ) ; 
  1469.   printint ( w .hh.b1 ) ; 
  1470.   printchar ( 59 ) ; 
  1471.   printint ( w .hh .v.RH ) ; 
  1472.   printchar ( 32 ) ; 
  1473.   printint ( w .qqqq .b0 ) ; 
  1474.   printchar ( 58 ) ; 
  1475.   printint ( w .qqqq .b1 ) ; 
  1476.   printchar ( 58 ) ; 
  1477.   printint ( w .qqqq .b2 ) ; 
  1478.   printchar ( 58 ) ; 
  1479.   printint ( w .qqqq .b3 ) ; 
  1480. } 
  1481. #endif /* DEBUG */
  1482. zshowtokenlis ( p , q , l ) 
  1483. integer p , q ; 
  1484. integer l ; 
  1485. {/* 10 */ r_showtokenlis 
  1486.   integer m, c ; 
  1487.   ASCIIcode matchchr ; 
  1488.   ASCIIcode n ; 
  1489.   matchchr = 35 ; 
  1490.   n = 48 ; 
  1491.   tally = 0 ; 
  1492.   while ( ( p != 0 ) && ( tally < l ) ) { 
  1493.     if ( p == q ) 
  1494.     {
  1495.       firstcount = tally ; 
  1496.       trickcount = tally + 1 + errorline - halferrorlin ; 
  1497.       if ( trickcount < errorline ) 
  1498.       trickcount = errorline ; 
  1499.     } 
  1500.     if ( ( p < himemmin ) || ( p > memend ) ) 
  1501.     {
  1502.       printesc ( 178 ) ; 
  1503.       return ; 
  1504.     } 
  1505.     if ( mem [(long) p ] .hh .v.LH >= 4096 ) 
  1506.     printcs ( mem [(long) p ] .hh .v.LH - 4096 ) ; 
  1507.     else { 
  1508.       m = mem [(long) p ] .hh .v.LH / 256 ; 
  1509.       c = mem [(long) p ] .hh .v.LH % 256 ; 
  1510.       if ( ( mem [(long) p ] .hh .v.LH < 0 ) || ( c > 127 ) ) 
  1511.       printesc ( 413 ) ; 
  1512.       else switch ( m ) 
  1513.       {case 1 : 
  1514.       case 2 : 
  1515.       case 3 : 
  1516.       case 4 : 
  1517.       case 7 : 
  1518.       case 8 : 
  1519.       case 10 : 
  1520.       case 11 : 
  1521.       case 12 : 
  1522.     print ( c ) ; 
  1523.     break ; 
  1524.       case 6 : 
  1525.     {
  1526.       print ( c ) ; 
  1527.       print ( c ) ; 
  1528.     } 
  1529.     break ; 
  1530.       case 5 : 
  1531.     {
  1532.       print ( matchchr ) ; 
  1533.       if ( c <= 9 ) 
  1534.       printchar ( c + 48 ) ; 
  1535.       else { 
  1536.         printchar ( 33 ) ; 
  1537.         return ; 
  1538.       } 
  1539.     } 
  1540.     break ; 
  1541.       case 13 : 
  1542.     {
  1543.       matchchr = c ; 
  1544.       print ( c ) ; 
  1545.       incr ( n ) ; 
  1546.       printchar ( n ) ; 
  1547.       if ( n > 57 ) 
  1548.       return ; 
  1549.     } 
  1550.     break ; 
  1551.       case 14 : 
  1552.     print ( 414 ) ; 
  1553.     break ; 
  1554.       default : 
  1555.     printesc ( 413 ) ; 
  1556.     break ; 
  1557.       } 
  1558.     } 
  1559.     p = mem [(long) p ] .hh .v.RH ; 
  1560.   } 
  1561.   if ( p != 0 ) 
  1562.   printesc ( 412 ) ; 
  1563. } 
  1564. runaway () { r_runaway 
  1565.   halfword p ; 
  1566.   if ( scannerstatu > 1 ) 
  1567.   {
  1568.     printnl ( 427 ) ; 
  1569.     switch ( scannerstatu ) 
  1570.     {case 2 : 
  1571.       {
  1572.     print ( 428 ) ; 
  1573.     p = defref ; 
  1574.       } 
  1575.       break ; 
  1576.     case 3 : 
  1577.       {
  1578.     print ( 429 ) ; 
  1579.     p = memtop - 3 ; 
  1580.       } 
  1581.       break ; 
  1582.     case 4 : 
  1583.       {
  1584.     print ( 430 ) ; 
  1585.     p = memtop - 4 ; 
  1586.       } 
  1587.       break ; 
  1588.     case 5 : 
  1589.       {
  1590.     print ( 431 ) ; 
  1591.     p = defref ; 
  1592.       } 
  1593.       break ; 
  1594.     } 
  1595.     printchar ( 63 ) ; 
  1596.     println () ; 
  1597.     showtokenlis ( mem [(long) p ] .hh .v.RH , 0 , errorline - 10 ) ; 
  1598.   } 
  1599. } 
  1600. halfword getavail () { register halfword Result; r_getavail 
  1601.   halfword p ; 
  1602.   p = avail ; 
  1603.   if ( p != 0 ) 
  1604.   avail = mem [(long) avail ] .hh .v.RH ; 
  1605.   else if ( memend < memmax ) 
  1606.   {
  1607.     incr ( memend ) ; 
  1608.     p = memend ; 
  1609.   } 
  1610.   else { 
  1611.     decr ( himemmin ) ; 
  1612.     p = himemmin ; 
  1613.     if ( himemmin <= lomemmax ) 
  1614.     {
  1615.       runaway () ; 
  1616.       overflow ( 169 , memmax + 1 - memmin ) ; 
  1617.     } 
  1618.   } 
  1619.   mem [(long) p ] .hh .v.RH = 0 ; 
  1620.  
  1621. #ifdef STAT
  1622.   incr ( dynused ) ; 
  1623. #endif /* STAT */
  1624.   Result = p ; 
  1625.   return(Result) ; 
  1626. } 
  1627. zflushlist ( p ) 
  1628. halfword p ; 
  1629. {r_flushlist 
  1630.   halfword q, r ; 
  1631.   if ( p != 0 ) 
  1632.   {
  1633.     r = p ; 
  1634.     do { q = r ; 
  1635.       r = mem [(long) r ] .hh .v.RH ; 
  1636.  
  1637. #ifdef STAT
  1638.       decr ( dynused ) ; 
  1639. #endif /* STAT */
  1640.     } while ( ! ( r == 0 ) ) ; 
  1641.     mem [(long) q ] .hh .v.RH = avail ; 
  1642.     avail = p ; 
  1643.   } 
  1644. } 
  1645. halfword zgetnode ( s ) 
  1646. integer s ; 
  1647. {/* 40 10 20 */ register halfword Result; r_getnode 
  1648.   halfword p ; 
  1649.   halfword q ; 
  1650.   integer r ; 
  1651.   integer t ; 
  1652.   lab20: p = rover ; 
  1653.   do { q = p + mem [(long) p ] .hh .v.LH ; 
  1654.     while ( ( mem [(long) q ] .hh .v.RH == 65535L ) ) { 
  1655.       t = mem [(long) q + 1 ] .hh .v.RH ; 
  1656.       if ( q == rover ) 
  1657.       rover = t ; 
  1658.       mem [(long) t + 1 ] .hh .v.LH = mem [(long) q + 1 ] .hh .v.LH ; 
  1659.       mem [(long) mem [(long) q + 1 ] .hh .v.LH + 1 ] .hh .v.RH = t ; 
  1660.       q = q + mem [(long) q ] .hh .v.LH ; 
  1661.     } 
  1662.     r = q - s ; 
  1663.     if ( r > toint ( p + 1 ) ) 
  1664.     {
  1665.       mem [(long) p ] .hh .v.LH = r - p ; 
  1666.       rover = p ; 
  1667.       goto lab40 ; 
  1668.     } 
  1669.     if ( r == p ) 
  1670.     if ( mem [(long) p + 1 ] .hh .v.RH != p ) 
  1671.     {
  1672.       rover = mem [(long) p + 1 ] .hh .v.RH ; 
  1673.       t = mem [(long) p + 1 ] .hh .v.LH ; 
  1674.       mem [(long) rover + 1 ] .hh .v.LH = t ; 
  1675.       mem [(long) t + 1 ] .hh .v.RH = rover ; 
  1676.       goto lab40 ; 
  1677.     } 
  1678.     mem [(long) p ] .hh .v.LH = q - p ; 
  1679.     p = mem [(long) p + 1 ] .hh .v.RH ; 
  1680.   } while ( ! ( p == rover ) ) ; 
  1681.   if ( s == 1073741824 ) 
  1682.   {
  1683.     Result = 65535L ; 
  1684.     return(Result) ; 
  1685.   } 
  1686.   if ( lomemmax + 2 < himemmin ) 
  1687.   if ( lomemmax + 2 <= 65535L ) 
  1688.   {
  1689.     if ( lomemmax + 1000 < himemmin ) 
  1690.     t = lomemmax + 1000 ; 
  1691.     else t = ( lomemmax + himemmin + 2 ) / 2 ; 
  1692.     p = mem [(long) rover + 1 ] .hh .v.LH ; 
  1693.     q = lomemmax ; 
  1694.     mem [(long) p + 1 ] .hh .v.RH = q ; 
  1695.     mem [(long) rover + 1 ] .hh .v.LH = q ; 
  1696.     if ( t > 65535L ) 
  1697.     t = 65535L ; 
  1698.     mem [(long) q + 1 ] .hh .v.RH = rover ; 
  1699.     mem [(long) q + 1 ] .hh .v.LH = p ; 
  1700.     mem [(long) q ] .hh .v.RH = 65535L ; 
  1701.     mem [(long) q ] .hh .v.LH = t - lomemmax ; 
  1702.     lomemmax = t ; 
  1703.     mem [(long) lomemmax ] .hh .v.RH = 0 ; 
  1704.     mem [(long) lomemmax ] .hh .v.LH = 0 ; 
  1705.     rover = q ; 
  1706.     goto lab20 ; 
  1707.   } 
  1708.   overflow ( 169 , memmax + 1 - memmin ) ; 
  1709.   lab40: mem [(long) r ] .hh .v.RH = 0 ; 
  1710.  
  1711. #ifdef STAT
  1712.   varused = varused + s ; 
  1713. #endif /* STAT */
  1714.   Result = r ; 
  1715.   return(Result) ; 
  1716. } 
  1717. zfreenode ( p , s ) 
  1718. halfword p ; 
  1719. halfword s ; 
  1720. {r_freenode 
  1721.   halfword q ; 
  1722.   mem [(long) p ] .hh .v.LH = s ; 
  1723.   mem [(long) p ] .hh .v.RH = 65535L ; 
  1724.   q = mem [(long) rover + 1 ] .hh .v.LH ; 
  1725.   mem [(long) p + 1 ] .hh .v.LH = q ; 
  1726.   mem [(long) p + 1 ] .hh .v.RH = rover ; 
  1727.   mem [(long) rover + 1 ] .hh .v.LH = p ; 
  1728.   mem [(long) q + 1 ] .hh .v.RH = p ; 
  1729.  
  1730. #ifdef STAT
  1731.   varused = varused - s ; 
  1732. #endif /* STAT */
  1733. } 
  1734.  
  1735. #ifdef INITEX
  1736. sortavail () { r_sortavail 
  1737.   halfword p, q, r ; 
  1738.   halfword oldrover ; 
  1739.   p = getnode ( 1073741824 ) ; 
  1740.   p = mem [(long) rover + 1 ] .hh .v.RH ; 
  1741.   mem [(long) rover + 1 ] .hh .v.RH = 65535L ; 
  1742.   oldrover = rover ; 
  1743.   while ( p != oldrover ) if ( p < rover ) 
  1744.   {
  1745.     q = p ; 
  1746.     p = mem [(long) q + 1 ] .hh .v.RH ; 
  1747.     mem [(long) q + 1 ] .hh .v.RH = rover ; 
  1748.     rover = q ; 
  1749.   } 
  1750.   else { 
  1751.     q = rover ; 
  1752.     while ( mem [(long) q + 1 ] .hh .v.RH < p ) q = mem [(long) q + 1 ] .hh .v.RH ; 
  1753.     r = mem [(long) p + 1 ] .hh .v.RH ; 
  1754.     mem [(long) p + 1 ] .hh .v.RH = mem [(long) q + 1 ] .hh .v.RH ; 
  1755.     mem [(long) q + 1 ] .hh .v.RH = p ; 
  1756.     p = r ; 
  1757.   } 
  1758.   p = rover ; 
  1759.   while ( mem [(long) p + 1 ] .hh .v.RH != 65535L ) { 
  1760.     mem [(long) mem [(long) p + 1 ] .hh .v.RH + 1 ] .hh .v.LH = p ; 
  1761.     p = mem [(long) p + 1 ] .hh .v.RH ; 
  1762.   } 
  1763.   mem [(long) p + 1 ] .hh .v.RH = rover ; 
  1764.   mem [(long) rover + 1 ] .hh .v.LH = p ; 
  1765. } 
  1766. #endif /* INITEX */
  1767. halfword newnullbox () { register halfword Result; r_newnullbox 
  1768.   halfword p ; 
  1769.   p = getnode ( 7 ) ; 
  1770.   mem [(long) p ] .hh.b0 = 0 ; 
  1771.   mem [(long) p ] .hh.b1 = 0 ; 
  1772.   mem [(long) p + 1 ] .cint = 0 ; 
  1773.   mem [(long) p + 2 ] .cint = 0 ; 
  1774.   mem [(long) p + 3 ] .cint = 0 ; 
  1775.   mem [(long) p + 4 ] .cint = 0 ; 
  1776.   mem [(long) p + 5 ] .hh .v.RH = 0 ; 
  1777.   mem [(long) p + 5 ] .hh.b0 = 0 ; 
  1778.   mem [(long) p + 5 ] .hh.b1 = 0 ; 
  1779.   mem [(long) p + 6 ] .gr = 0.0 ; 
  1780.   Result = p ; 
  1781.   return(Result) ; 
  1782. } 
  1783. halfword newrule () { register halfword Result; r_newrule 
  1784.   halfword p ; 
  1785.   p = getnode ( 4 ) ; 
  1786.   mem [(long) p ] .hh.b0 = 2 ; 
  1787.   mem [(long) p ] .hh.b1 = 0 ; 
  1788.   mem [(long) p + 1 ] .cint = - 1073741824 ; 
  1789.   mem [(long) p + 2 ] .cint = - 1073741824 ; 
  1790.   mem [(long) p + 3 ] .cint = - 1073741824 ; 
  1791.   Result = p ; 
  1792.   return(Result) ; 
  1793. } 
  1794. halfword znewligature ( f , c , q ) 
  1795. quarterword f , c ; 
  1796. halfword q ; 
  1797. {register halfword Result; r_newligature 
  1798.   halfword p ; 
  1799.   p = getnode ( 2 ) ; 
  1800.   mem [(long) p ] .hh.b0 = 6 ; 
  1801.   mem [(long) p ] .hh.b1 = 0 ; 
  1802.   mem [(long) p + 1 ] .hh.b0 = f ; 
  1803.   mem [(long) p + 1 ] .hh.b1 = c ; 
  1804.   mem [(long) p + 1 ] .hh .v.RH = q ; 
  1805.   Result = p ; 
  1806.   return(Result) ; 
  1807. } 
  1808. halfword newdisc () { register halfword Result; r_newdisc 
  1809.   halfword p ; 
  1810.   p = getnode ( 2 ) ; 
  1811.   mem [(long) p ] .hh.b0 = 7 ; 
  1812.   mem [(long) p ] .hh.b1 = 0 ; 
  1813.   mem [(long) p + 1 ] .hh .v.LH = 0 ; 
  1814.   mem [(long) p + 1 ] .hh .v.RH = 0 ; 
  1815.   Result = p ; 
  1816.   return(Result) ; 
  1817. } 
  1818. halfword znewmath ( w , s ) 
  1819. scaled w ; 
  1820. smallnumber s ; 
  1821. {register halfword Result; r_newmath 
  1822.   halfword p ; 
  1823.   p = getnode ( 2 ) ; 
  1824.   mem [(long) p ] .hh.b0 = 9 ; 
  1825.   mem [(long) p ] .hh.b1 = s ; 
  1826.   mem [(long) p + 1 ] .cint = w ; 
  1827.   Result = p ; 
  1828.   return(Result) ; 
  1829. } 
  1830. halfword znewspec ( p ) 
  1831. halfword p ; 
  1832. {register halfword Result; r_newspec 
  1833.   halfword q ; 
  1834.   q = getnode ( 4 ) ; 
  1835.   mem [(long) q ] = mem [(long) p ] ; 
  1836.   mem [(long) q ] .hh .v.RH = 0 ; 
  1837.   mem [(long) q + 1 ] .cint = mem [(long) p + 1 ] .cint ; 
  1838.   mem [(long) q + 2 ] .cint = mem [(long) p + 2 ] .cint ; 
  1839.   mem [(long) q + 3 ] .cint = mem [(long) p + 3 ] .cint ; 
  1840.   Result = q ; 
  1841.   return(Result) ; 
  1842. } 
  1843. halfword znewparamglue ( n ) 
  1844. smallnumber n ; 
  1845. {register halfword Result; r_newparamglue 
  1846.   halfword p ; 
  1847.   halfword q ; 
  1848.   p = getnode ( 2 ) ; 
  1849.   mem [(long) p ] .hh.b0 = 10 ; 
  1850.   mem [(long) p ] .hh.b1 = n + 1 ; 
  1851.   mem [(long) p + 1 ] .hh .v.RH = 0 ; 
  1852.   q = eqtb [ 3526 + n ] .hh .v.RH ; 
  1853.   mem [(long) p + 1 ] .hh .v.LH = q ; 
  1854.   incr ( mem [(long) q ] .hh .v.RH ) ; 
  1855.   Result = p ; 
  1856.   return(Result) ; 
  1857. } 
  1858. halfword znewglue ( q ) 
  1859. halfword q ; 
  1860. {register halfword Result; r_newglue 
  1861.   halfword p ; 
  1862.   p = getnode ( 2 ) ; 
  1863.   mem [(long) p ] .hh.b0 = 10 ; 
  1864.   mem [(long) p ] .hh.b1 = 0 ; 
  1865.   mem [(long) p + 1 ] .hh .v.RH = 0 ; 
  1866.   mem [(long) p + 1 ] .hh .v.LH = q ; 
  1867.   incr ( mem [(long) q ] .hh .v.RH ) ; 
  1868.   Result = p ; 
  1869.   return(Result) ; 
  1870. } 
  1871. halfword znewskipparam ( n ) 
  1872. smallnumber n ; 
  1873. {register halfword Result; r_newskipparam 
  1874.   halfword p ; 
  1875.   tempptr = newspec ( eqtb [ 3526 + n ] .hh .v.RH ) ; 
  1876.   p = newglue ( tempptr ) ; 
  1877.   mem [(long) tempptr ] .hh .v.RH = 0 ; 
  1878.   mem [(long) p ] .hh.b1 = n + 1 ; 
  1879.   Result = p ; 
  1880.   return(Result) ; 
  1881. } 
  1882. halfword znewkern ( w ) 
  1883. scaled w ; 
  1884. {register halfword Result; r_newkern 
  1885.   halfword p ; 
  1886.   p = getnode ( 2 ) ; 
  1887.   mem [(long) p ] .hh.b0 = 11 ; 
  1888.   mem [(long) p ] .hh.b1 = 0 ; 
  1889.   mem [(long) p + 1 ] .cint = w ; 
  1890.   Result = p ; 
  1891.   return(Result) ; 
  1892. } 
  1893. halfword znewpenalty ( m ) 
  1894. integer m ; 
  1895. {register halfword Result; r_newpenalty 
  1896.   halfword p ; 
  1897.   p = getnode ( 2 ) ; 
  1898.   mem [(long) p ] .hh.b0 = 12 ; 
  1899.   mem [(long) p ] .hh.b1 = 0 ; 
  1900.   mem [(long) p + 1 ] .cint = m ; 
  1901.   Result = p ; 
  1902.   return(Result) ; 
  1903. } 
  1904.  
  1905. #ifdef DEBUG
  1906. zcheckmem ( printlocs ) 
  1907. boolean printlocs ; 
  1908. {/* 31 32 */ r_checkmem 
  1909.   halfword p, q ; 
  1910.   boolean clobbered ; 
  1911.   for ( p = memmin ; p <= lomemmax ; p ++ ) 
  1912.   freearr [ p ] = false ; 
  1913.   for ( p = himemmin ; p <= memend ; p ++ ) 
  1914.   freearr [ p ] = false ; 
  1915.   p = avail ; 
  1916.   q = 0 ; 
  1917.   clobbered = false ; 
  1918.   while ( p != 0 ) { 
  1919.     if ( ( p > memend ) || ( p < himemmin ) ) 
  1920.     clobbered = true ; 
  1921.     else if ( freearr [ p ] ) 
  1922.     clobbered = true ; 
  1923.     if ( clobbered ) 
  1924.     {
  1925.       printnl ( 170 ) ; 
  1926.       printint ( q ) ; 
  1927.       goto lab31 ; 
  1928.     } 
  1929.     freearr [ p ] = true ; 
  1930.     q = p ; 
  1931.     p = mem [(long) q ] .hh .v.RH ; 
  1932.   } 
  1933.   lab31: ; 
  1934.   p = rover ; 
  1935.   q = 0 ; 
  1936.   clobbered = false ; 
  1937.   do { if ( ( p >= lomemmax ) || ( p < memmin ) ) 
  1938.     clobbered = true ; 
  1939.     else if ( ( mem [(long) p + 1 ] .hh .v.RH >= lomemmax ) || ( mem [(long) p + 1 ] .hh 
  1940.     .v.RH < memmin ) ) 
  1941.     clobbered = true ; 
  1942.     else if ( ! ( ( mem [(long) p ] .hh .v.RH == 65535L ) ) || ( mem [(long) p ] .hh .v.LH 
  1943.     < 2 ) || ( p + mem [(long) p ] .hh .v.LH > lomemmax ) || ( mem [(long) mem [(long) p + 1 ] 
  1944.     .hh .v.RH + 1 ] .hh .v.LH != p ) ) 
  1945.     clobbered = true ; 
  1946.     if ( clobbered ) 
  1947.     {
  1948.       printnl ( 171 ) ; 
  1949.       printint ( q ) ; 
  1950.       goto lab32 ; 
  1951.     } 
  1952.     for ( q = p ; q <= p + mem [(long) p ] .hh .v.LH - 1 ; q ++ ) 
  1953.     {
  1954.       if ( freearr [ q ] ) 
  1955.       {
  1956.     printnl ( 172 ) ; 
  1957.     printint ( q ) ; 
  1958.     goto lab32 ; 
  1959.       } 
  1960.       freearr [ q ] = true ; 
  1961.     } 
  1962.     q = p ; 
  1963.     p = mem [(long) p + 1 ] .hh .v.RH ; 
  1964.   } while ( ! ( p == rover ) ) ; 
  1965.   lab32: ; 
  1966.   p = memmin ; 
  1967.   while ( p <= lomemmax ) { 
  1968.     if ( ( mem [(long) p ] .hh .v.RH == 65535L ) ) 
  1969.     {
  1970.       printnl ( 173 ) ; 
  1971.       printint ( p ) ; 
  1972.     } 
  1973.     while ( ( p <= lomemmax ) && ! freearr [ p ] ) incr ( p ) ; 
  1974.     while ( ( p <= lomemmax ) && freearr [ p ] ) incr ( p ) ; 
  1975.   } 
  1976.   if ( printlocs ) 
  1977.   {
  1978.     printnl ( 174 ) ; 
  1979.     for ( p = memmin ; p <= lomemmax ; p ++ ) 
  1980.     if ( ! freearr [ p ] && ( ( p > waslomax ) || wasfree [ p ] ) ) 
  1981.     {
  1982.       printchar ( 32 ) ; 
  1983.       printint ( p ) ; 
  1984.     } 
  1985.     for ( p = himemmin ; p <= memend ; p ++ ) 
  1986.     if ( ! freearr [ p ] && ( ( p < washimin ) || ( p > wasmemend ) || wasfree 
  1987.     [ p ] ) ) 
  1988.     {
  1989.       printchar ( 32 ) ; 
  1990.       printint ( p ) ; 
  1991.     } 
  1992.   } 
  1993.   for ( p = memmin ; p <= lomemmax ; p ++ ) 
  1994.   wasfree [ p ] = freearr [ p ] ; 
  1995.   for ( p = himemmin ; p <= memend ; p ++ ) 
  1996.   wasfree [ p ] = freearr [ p ] ; 
  1997.   wasmemend = memend ; 
  1998.   waslomax = lomemmax ; 
  1999.   washimin = himemmin ; 
  2000. } 
  2001. #endif /* DEBUG */
  2002.  
  2003. #ifdef DEBUG
  2004. zsearchmem ( p ) 
  2005. halfword p ; 
  2006. { r_searchmem 
  2007.   integer q ; 
  2008.   for ( q = memmin ; q <= lomemmax ; q ++ ) 
  2009.   {
  2010.     if ( mem [(long) q ] .hh .v.RH == p ) 
  2011.     {
  2012.       printnl ( 175 ) ; 
  2013.       printint ( q ) ; 
  2014.       printchar ( 41 ) ; 
  2015.     } 
  2016.     if ( mem [(long) q ] .hh .v.LH == p ) 
  2017.     {
  2018.       printnl ( 176 ) ; 
  2019.       printint ( q ) ; 
  2020.       printchar ( 41 ) ; 
  2021.     } 
  2022.   } 
  2023.   for ( q = himemmin ; q <= memend ; q ++ ) 
  2024.   {
  2025.     if ( mem [(long) q ] .hh .v.RH == p ) 
  2026.     {
  2027.       printnl ( 175 ) ; 
  2028.       printint ( q ) ; 
  2029.       printchar ( 41 ) ; 
  2030.     } 
  2031.     if ( mem [(long) q ] .hh .v.LH == p ) 
  2032.     {
  2033.       printnl ( 176 ) ; 
  2034.       printint ( q ) ; 
  2035.       printchar ( 41 ) ; 
  2036.     } 
  2037.   } 
  2038.   for ( q = 1 ; q <= 4577 ; q ++ ) 
  2039.   {
  2040.     if ( eqtb [ q ] .hh .v.RH == p ) 
  2041.     {
  2042.       printnl ( 360 ) ; 
  2043.       printint ( q ) ; 
  2044.       printchar ( 41 ) ; 
  2045.     } 
  2046.   } 
  2047.   if ( saveptr > 0 ) 
  2048.   for ( q = 0 ; q <= saveptr - 1 ; q ++ ) 
  2049.   {
  2050.     if ( savestack [ q ] .hh .v.RH == p ) 
  2051.     {
  2052.       printnl ( 404 ) ; 
  2053.       printint ( q ) ; 
  2054.       printchar ( 41 ) ; 
  2055.     } 
  2056.   } 
  2057.   for ( q = 0 ; q <= 307 ; q ++ ) 
  2058.   {
  2059.     if ( hyphlist [ q ] == p ) 
  2060.     {
  2061.       printnl ( 792 ) ; 
  2062.       printint ( q ) ; 
  2063.       printchar ( 41 ) ; 
  2064.     } 
  2065.   } 
  2066. } 
  2067. #endif /* DEBUG */
  2068.