home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / texsrc.arc / TEX2.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  46KB  |  2,010 lines
  1. overlay "tex2"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5.  
  6. #ifdef STAT
  7. zshoweqtb ( n ) 
  8. halfword n ; 
  9. {r_showeqtb 
  10.   if ( n < 1 ) 
  11.   printchar ( 63 ) ; 
  12.   else if ( n < 3526 ) 
  13.   {
  14.     sprintcs ( n ) ; 
  15.     printchar ( 61 ) ; 
  16.     printcmdchr ( eqtb [ n ] .hh.b0 , eqtb [ n ] .hh .v.RH ) ; 
  17.     if ( eqtb [ n ] .hh.b0 >= 110 ) 
  18.     {
  19.       printchar ( 58 ) ; 
  20.       showtokenlis ( mem [(long) eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  21.     } 
  22.   } 
  23.   else if ( n < 4056 ) 
  24.   if ( n < 3544 ) 
  25.   {
  26.     printskippar ( n - 3526 ) ; 
  27.     printchar ( 61 ) ; 
  28.     if ( n < 3541 ) 
  29.     printspec ( eqtb [ n ] .hh .v.RH , 262 ) ; 
  30.     else printspec ( eqtb [ n ] .hh .v.RH , 205 ) ; 
  31.   } 
  32.   else if ( n < 3800 ) 
  33.   {
  34.     printesc ( 260 ) ; 
  35.     printint ( n - 3544 ) ; 
  36.     printchar ( 61 ) ; 
  37.     printspec ( eqtb [ n ] .hh .v.RH , 262 ) ; 
  38.   } 
  39.   else { 
  40.     printesc ( 261 ) ; 
  41.     printint ( n - 3800 ) ; 
  42.     printchar ( 61 ) ; 
  43.     printspec ( eqtb [ n ] .hh .v.RH , 205 ) ; 
  44.   } 
  45.   else if ( n < 5267 ) 
  46.   if ( n == 4056 ) 
  47.   {
  48.     printesc ( 273 ) ; 
  49.     printchar ( 61 ) ; 
  50.     if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  51.     printchar ( 48 ) ; 
  52.     else printint ( mem [(long) eqtb [ 4056 ] .hh .v.RH ] .hh .v.LH ) ; 
  53.   } 
  54.   else if ( n < 4066 ) 
  55.   {
  56.     printcmdchr ( 71 , n ) ; 
  57.     printchar ( 61 ) ; 
  58.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  59.     showtokenlis ( mem [(long) eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  60.   } 
  61.   else if ( n < 4322 ) 
  62.   {
  63.     printesc ( 272 ) ; 
  64.     printint ( n - 4066 ) ; 
  65.     printchar ( 61 ) ; 
  66.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  67.     showtokenlis ( mem [(long) eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  68.   } 
  69.   else if ( n < 4578 ) 
  70.   {
  71.     printesc ( 274 ) ; 
  72.     printint ( n - 4322 ) ; 
  73.     printchar ( 61 ) ; 
  74.     if ( eqtb [ n ] .hh .v.RH == 0 ) 
  75.     print ( 275 ) ; 
  76.     else { 
  77.       depththresho = 0 ; 
  78.       breadthmax = 1 ; 
  79.       shownodelist ( eqtb [ n ] .hh .v.RH ) ; 
  80.     } 
  81.   } 
  82.   else if ( n < 4627 ) 
  83.   {
  84.     if ( n == 4578 ) 
  85.     print ( 276 ) ; 
  86.     else if ( n < 4595 ) 
  87.     {
  88.       printesc ( 277 ) ; 
  89.       printint ( n - 4579 ) ; 
  90.     } 
  91.     else if ( n < 4611 ) 
  92.     {
  93.       printesc ( 278 ) ; 
  94.       printint ( n - 4595 ) ; 
  95.     } 
  96.     else { 
  97.       printesc ( 279 ) ; 
  98.       printint ( n - 4611 ) ; 
  99.     } 
  100.     printchar ( 61 ) ; 
  101.     printesc ( hash [ 3268 + eqtb [ n ] .hh .v.RH ] .v.RH ) ; 
  102.   } 
  103.   else if ( n < 5139 ) 
  104.   {
  105.     if ( n < 4755 ) 
  106.     {
  107.       printesc ( 280 ) ; 
  108.       printint ( n - 4627 ) ; 
  109.     } 
  110.     else if ( n < 4883 ) 
  111.     {
  112.       printesc ( 281 ) ; 
  113.       printint ( n - 4755 ) ; 
  114.     } 
  115.     else if ( n < 5011 ) 
  116.     {
  117.       printesc ( 282 ) ; 
  118.       printint ( n - 4883 ) ; 
  119.     } 
  120.     else { 
  121.       printesc ( 283 ) ; 
  122.       printint ( n - 5011 ) ; 
  123.     } 
  124.     printchar ( 61 ) ; 
  125.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  126.   } 
  127.   else { 
  128.     printesc ( 284 ) ; 
  129.     printint ( n - 5139 ) ; 
  130.     printchar ( 61 ) ; 
  131.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  132.   } 
  133.   else if ( n < 5701 ) 
  134.   {
  135.     if ( n < 5317 ) 
  136.     printparam ( n - 5267 ) ; 
  137.     else if ( n < 5573 ) 
  138.     {
  139.       printesc ( 336 ) ; 
  140.       printint ( n - 5317 ) ; 
  141.     } 
  142.     else { 
  143.       printesc ( 337 ) ; 
  144.       printint ( n - 5573 ) ; 
  145.     } 
  146.     printchar ( 61 ) ; 
  147.     printint ( eqtb [ n ] .cint ) ; 
  148.   } 
  149.   else if ( n <= 5976 ) 
  150.   {
  151.     if ( n < 5721 ) 
  152.     printlengthp ( n - 5701 ) ; 
  153.     else { 
  154.       printesc ( 359 ) ; 
  155.       printint ( n - 5721 ) ; 
  156.     } 
  157.     printchar ( 61 ) ; 
  158.     printscaled ( eqtb [ n ] .cint ) ; 
  159.     print ( 262 ) ; 
  160.   } 
  161.   else printchar ( 63 ) ; 
  162. } 
  163. #endif /* STAT */
  164. halfword zidlookup ( j , l ) 
  165. integer j , l ; 
  166. {/* 40 */ register halfword Result; r_idlookup 
  167.   integer h ; 
  168.   halfword p ; 
  169.   halfword k ; 
  170.   h = buffer [ j ] ; 
  171.   for ( k = j + 1 ; k <= j + l - 1 ; k ++ ) 
  172.   {
  173.     h = h + h + buffer [ k ] ; 
  174.     while ( h >= 2551 ) h = h - 2551 ; 
  175.   } 
  176.   p = h + 258 ; 
  177.   while ( true ) { 
  178.     if ( hash [ p ] .v.RH > 0 ) 
  179.     if ( ( strstart [ hash [ p ] .v.RH + 1 ] - strstart [ hash [ p ] .v.RH ] ) 
  180.     == l ) 
  181.     if ( streqbuf ( hash [ p ] .v.RH , j ) ) 
  182.     goto lab40 ; 
  183.     if ( hash [ p ] .v.LH == 0 ) 
  184.     {
  185.       if ( nonewcontrol ) 
  186.       p = 3525 ; 
  187.       else { 
  188.     if ( hash [ p ] .v.RH > 0 ) 
  189.     {
  190.       do { if ( ( hashused == 258 ) ) 
  191.         overflow ( 362 , 3000 ) ; 
  192.         decr ( hashused ) ; 
  193.       } while ( ! ( hash [ hashused ] .v.RH == 0 ) ) ; 
  194.       hash [ p ] .v.LH = hashused ; 
  195.       p = hashused ; 
  196.     } 
  197.     {
  198.       if ( poolptr + l > poolsize ) 
  199.       overflow ( 128 , poolsize - initpoolptr ) ; 
  200.     } 
  201.     for ( k = j ; k <= j + l - 1 ; k ++ ) 
  202.     {
  203.       strpool [ poolptr ] = buffer [ k ] ; 
  204.       incr ( poolptr ) ; 
  205.     } 
  206.     hash [ p ] .v.RH = makestring () ; 
  207.  
  208. #ifdef STAT
  209.     incr ( cscount ) ; 
  210. #endif /* STAT */
  211.       } 
  212.       goto lab40 ; 
  213.     } 
  214.     p = hash [ p ] .v.LH ; 
  215.   } 
  216.   lab40: Result = p ; 
  217.   return(Result) ; 
  218. } 
  219.  
  220. #ifdef INITEX
  221. zprimitive ( s , c , o ) 
  222. strnumber s ; 
  223. quarterword c ; 
  224. halfword o ; 
  225. {r_primitive 
  226.   poolpointer k ; 
  227.   smallnumber j ; 
  228.   smallnumber l ; 
  229.   if ( s < 128 ) 
  230.   curval = s + 129 ; 
  231.   else { 
  232.     k = strstart [ s ] ; 
  233.     l = strstart [ s + 1 ] - k ; 
  234.     for ( j = 0 ; j <= l - 1 ; j ++ ) 
  235.     buffer [ j ] = strpool [ k + j ] ; 
  236.     curval = idlookup ( 0 , l ) ; 
  237.     {
  238.       decr ( strptr ) ; 
  239.       poolptr = strstart [ strptr ] ; 
  240.     } 
  241.     hash [ curval ] .v.RH = s ; 
  242.   } 
  243.   eqtb [ curval ] .hh.b1 = 1 ; 
  244.   eqtb [ curval ] .hh.b0 = c ; 
  245.   eqtb [ curval ] .hh .v.RH = o ; 
  246. } 
  247. #endif /* INITEX */
  248. znewsavelevel ( c ) 
  249. groupcode c ; 
  250. {r_newsavelevel 
  251.   if ( saveptr > maxsavestack ) 
  252.   {
  253.     maxsavestack = saveptr ; 
  254.     if ( maxsavestack > savesize - 6 ) 
  255.     overflow ( 399 , savesize ) ; 
  256.   } 
  257.   savestack [ saveptr ] .hh.b0 = 3 ; 
  258.   savestack [ saveptr ] .hh.b1 = curgroup ; 
  259.   savestack [ saveptr ] .hh .v.RH = curboundary ; 
  260.   if ( curlevel == 255 ) 
  261.   overflow ( 400 , 255 ) ; 
  262.   curboundary = saveptr ; 
  263.   incr ( curlevel ) ; 
  264.   incr ( saveptr ) ; 
  265.   curgroup = c ; 
  266. } 
  267. zeqdestroy ( w ) 
  268. memoryword w ; 
  269. {r_eqdestroy 
  270.   halfword q ; 
  271.   switch ( w .hh.b0 ) 
  272.   {case 110 : 
  273.   case 111 : 
  274.   case 112 : 
  275.   case 113 : 
  276.     deletetokenr ( w .hh .v.RH ) ; 
  277.     break ; 
  278.   case 116 : 
  279.     deletegluere ( w .hh .v.RH ) ; 
  280.     break ; 
  281.   case 117 : 
  282.     {
  283.       q = w .hh .v.RH ; 
  284.       if ( q != 0 ) 
  285.       freenode ( q , mem [(long) q ] .hh .v.LH + mem [(long) q ] .hh .v.LH + 1 ) ; 
  286.     } 
  287.     break ; 
  288.   case 118 : 
  289.     flushnodelis ( w .hh .v.RH ) ; 
  290.     break ; 
  291.   default : 
  292.     ; 
  293.     break ; 
  294.   } 
  295. } 
  296. zeqsave ( p , l ) 
  297. halfword p ; 
  298. quarterword l ; 
  299. {r_eqsave 
  300.   if ( saveptr > maxsavestack ) 
  301.   {
  302.     maxsavestack = saveptr ; 
  303.     if ( maxsavestack > savesize - 6 ) 
  304.     overflow ( 399 , savesize ) ; 
  305.   } 
  306.   if ( l == 0 ) 
  307.   savestack [ saveptr ] .hh.b0 = 1 ; 
  308.   else { 
  309.     savestack [ saveptr ] = eqtb [ p ] ; 
  310.     incr ( saveptr ) ; 
  311.     savestack [ saveptr ] .hh.b0 = 0 ; 
  312.   } 
  313.   savestack [ saveptr ] .hh.b1 = l ; 
  314.   savestack [ saveptr ] .hh .v.RH = p ; 
  315.   incr ( saveptr ) ; 
  316. } 
  317. zeqdefine ( p , t , e ) 
  318. halfword p ; 
  319. quarterword t ; 
  320. halfword e ; 
  321. {r_eqdefine 
  322.   if ( eqtb [ p ] .hh.b1 == curlevel ) 
  323.   eqdestroy ( eqtb [ p ] ) ; 
  324.   else if ( curlevel > 1 ) 
  325.   eqsave ( p , eqtb [ p ] .hh.b1 ) ; 
  326.   eqtb [ p ] .hh.b1 = curlevel ; 
  327.   eqtb [ p ] .hh.b0 = t ; 
  328.   eqtb [ p ] .hh .v.RH = e ; 
  329. } 
  330. zeqworddefine ( p , w ) 
  331. halfword p ; 
  332. integer w ; 
  333. {r_eqworddefine 
  334.   if ( xeqlevel [ p ] != curlevel ) 
  335.   {
  336.     eqsave ( p , xeqlevel [ p ] ) ; 
  337.     xeqlevel [ p ] = curlevel ; 
  338.   } 
  339.   eqtb [ p ] .cint = w ; 
  340. } 
  341. zgeqdefine ( p , t , e ) 
  342. halfword p ; 
  343. quarterword t ; 
  344. halfword e ; 
  345. {r_geqdefine 
  346.   eqdestroy ( eqtb [ p ] ) ; 
  347.   eqtb [ p ] .hh.b1 = 1 ; 
  348.   eqtb [ p ] .hh.b0 = t ; 
  349.   eqtb [ p ] .hh .v.RH = e ; 
  350. } 
  351. zgeqworddefin ( p , w ) 
  352. halfword p ; 
  353. integer w ; 
  354. {r_geqworddefin 
  355.   eqtb [ p ] .cint = w ; 
  356.   xeqlevel [ p ] = 1 ; 
  357. } 
  358. zsaveforafter ( t ) 
  359. halfword t ; 
  360. {r_saveforafter 
  361.   if ( saveptr > maxsavestack ) 
  362.   {
  363.     maxsavestack = saveptr ; 
  364.     if ( maxsavestack > savesize - 6 ) 
  365.     overflow ( 399 , savesize ) ; 
  366.   } 
  367.   savestack [ saveptr ] .hh.b0 = 2 ; 
  368.   savestack [ saveptr ] .hh.b1 = 0 ; 
  369.   savestack [ saveptr ] .hh .v.RH = t ; 
  370.   incr ( saveptr ) ; 
  371. } 
  372.  
  373. #ifdef STAT
  374. zrestoretrace ( p , s ) 
  375. halfword p ; 
  376. strnumber s ; 
  377. {r_restoretrace 
  378.   begindiagnos () ; 
  379.   printchar ( 123 ) ; 
  380.   print ( s ) ; 
  381.   printchar ( 32 ) ; 
  382.   showeqtb ( p ) ; 
  383.   printchar ( 125 ) ; 
  384.   enddiagnosti ( false ) ; 
  385. } 
  386. #endif /* STAT */
  387. unsave () { /* 30 */ r_unsave 
  388.   halfword p ; 
  389.   quarterword l ; 
  390.   halfword t ; 
  391.   if ( curlevel > 1 ) 
  392.   {
  393.     decr ( curlevel ) ; 
  394.     while ( true ) { 
  395.       decr ( saveptr ) ; 
  396.       if ( savestack [ saveptr ] .hh.b0 == 3 ) 
  397.       goto lab30 ; 
  398.       p = savestack [ saveptr ] .hh .v.RH ; 
  399.       if ( savestack [ saveptr ] .hh.b0 == 2 ) 
  400.       {
  401.     t = curtok ; 
  402.     curtok = p ; 
  403.     backinput () ; 
  404.     curtok = t ; 
  405.       } 
  406.       else { 
  407.     if ( savestack [ saveptr ] .hh.b0 == 0 ) 
  408.     {
  409.       l = savestack [ saveptr ] .hh.b1 ; 
  410.       decr ( saveptr ) ; 
  411.     } 
  412.     else savestack [ saveptr ] = eqtb [ 3525 ] ; 
  413.     if ( p < 5267 ) 
  414.     if ( eqtb [ p ] .hh.b1 == 1 ) 
  415.     {
  416.       eqdestroy ( savestack [ saveptr ] ) ; 
  417.  
  418. #ifdef STAT
  419.       if ( eqtb [ 5304 ] .cint > 0 ) 
  420.       restoretrace ( p , 402 ) ; 
  421. #endif /* STAT */
  422.     } 
  423.     else { 
  424.       eqdestroy ( eqtb [ p ] ) ; 
  425.       eqtb [ p ] = savestack [ saveptr ] ; 
  426.  
  427. #ifdef STAT
  428.       if ( eqtb [ 5304 ] .cint > 0 ) 
  429.       restoretrace ( p , 403 ) ; 
  430. #endif /* STAT */
  431.     } 
  432.     else if ( xeqlevel [ p ] != 1 ) 
  433.     {
  434.       eqtb [ p ] = savestack [ saveptr ] ; 
  435.       xeqlevel [ p ] = l ; 
  436.  
  437. #ifdef STAT
  438.       if ( eqtb [ 5304 ] .cint > 0 ) 
  439.       restoretrace ( p , 403 ) ; 
  440. #endif /* STAT */
  441.     } 
  442.     else { 
  443.  
  444. #ifdef STAT
  445.       if ( eqtb [ 5304 ] .cint > 0 ) 
  446.       restoretrace ( p , 402 ) ; 
  447. #endif /* STAT */
  448.     } 
  449.       } 
  450.     } 
  451.     lab30: curgroup = savestack [ saveptr ] .hh.b1 ; 
  452.     curboundary = savestack [ saveptr ] .hh .v.RH ; 
  453.   } 
  454.   else confusion ( 401 ) ; 
  455. } 
  456. preparemag () { r_preparemag 
  457.   if ( ( magset > 0 ) && ( eqtb [ 5284 ] .cint != magset ) ) 
  458.   {
  459.     {
  460.       if ( interaction == 3 ) 
  461.       wakeuptermin () ; 
  462.       printnl ( 133 ) ; 
  463.       print ( 405 ) ; 
  464.     } 
  465.     printint ( eqtb [ 5284 ] .cint ) ; 
  466.     print ( 406 ) ; 
  467.     printnl ( 407 ) ; 
  468.     {
  469.       helpptr = 2 ; 
  470.       helpline [ 1 ] = 408 ; 
  471.       helpline [ 0 ] = 409 ; 
  472.     } 
  473.     interror ( magset ) ; 
  474.     geqworddefin ( 5284 , magset ) ; 
  475.   } 
  476.   if ( ( eqtb [ 5284 ] .cint <= 0 ) || ( eqtb [ 5284 ] .cint > 32768 ) ) 
  477.   {
  478.     {
  479.       if ( interaction == 3 ) 
  480.       wakeuptermin () ; 
  481.       printnl ( 133 ) ; 
  482.       print ( 410 ) ; 
  483.     } 
  484.     {
  485.       helpptr = 1 ; 
  486.       helpline [ 0 ] = 411 ; 
  487.     } 
  488.     interror ( eqtb [ 5284 ] .cint ) ; 
  489.     geqworddefin ( 5284 , 1000 ) ; 
  490.   } 
  491.   magset = eqtb [ 5284 ] .cint ; 
  492. } 
  493. ztokenshow ( p ) 
  494. halfword p ; 
  495. {r_tokenshow 
  496.   if ( p != 0 ) 
  497.   showtokenlis ( mem [(long) p ] .hh .v.RH , 0 , 1000 ) ; 
  498. } 
  499. printmeaning () { r_printmeaning 
  500.   printcmdchr ( curcmd , curchr ) ; 
  501.   if ( curcmd >= 110 ) 
  502.   {
  503.     printchar ( 58 ) ; 
  504.     println () ; 
  505.     tokenshow ( curchr ) ; 
  506.   } 
  507.   else if ( curcmd == 109 ) 
  508.   {
  509.     printchar ( 58 ) ; 
  510.     println () ; 
  511.     tokenshow ( curmark [ curchr ] ) ; 
  512.   } 
  513. } 
  514. showcurcmdch () { r_showcurcmdch 
  515.   begindiagnos () ; 
  516.   printnl ( 123 ) ; 
  517.   if ( curlist .modefield != shownmode ) 
  518.   {
  519.     printmode ( curlist .modefield ) ; 
  520.     print ( 426 ) ; 
  521.     shownmode = curlist .modefield ; 
  522.   } 
  523.   printcmdchr ( curcmd , curchr ) ; 
  524.   printchar ( 125 ) ; 
  525.   enddiagnosti ( false ) ; 
  526. } 
  527. showcontext () { /* 30 */ r_showcontext 
  528.   quarterword oldsetting ; 
  529.   integer i ; 
  530.   integer j ; 
  531.   integer l ; 
  532.   integer m ; 
  533.   integer n ; 
  534.   integer p ; 
  535.   integer q ; 
  536.   baseptr = inputptr ; 
  537.   inputstack [ baseptr ] = curinput ; 
  538.   while ( true ) { 
  539.     curinput = inputstack [ baseptr ] ; 
  540.     if ( ( baseptr == inputptr ) || ( curinput .statefield != 0 ) || ( 
  541.     curinput .indexfield != 3 ) || ( curinput .locfield != 0 ) ) 
  542.     {
  543.       tally = 0 ; 
  544.       oldsetting = selector ; 
  545.       if ( curinput .statefield != 0 ) 
  546.       {
  547.     if ( curinput .namefield <= 17 ) 
  548.     if ( ( curinput .namefield == 0 ) ) 
  549.     if ( baseptr == 0 ) 
  550.     printnl ( 432 ) ; 
  551.     else printnl ( 433 ) ; 
  552.     else { 
  553.       printnl ( 434 ) ; 
  554.       if ( curinput .namefield == 17 ) 
  555.       printchar ( 42 ) ; 
  556.       else printint ( curinput .namefield - 1 ) ; 
  557.       printchar ( 62 ) ; 
  558.     } 
  559.     else { 
  560.       printnl ( 435 ) ; 
  561.       printint ( line ) ; 
  562.     } 
  563.     printchar ( 32 ) ; 
  564.     {
  565.       l = tally ; 
  566.       tally = 0 ; 
  567.       selector = 20 ; 
  568.       trickcount = 1000000 ; 
  569.     } 
  570.     if ( buffer [ curinput .limitfield ] == eqtb [ 5315 ] .cint ) 
  571.     j = curinput .limitfield ; 
  572.     else j = curinput .limitfield + 1 ; 
  573.     if ( j > 0 ) 
  574.     for ( i = curinput .startfield ; i <= j - 1 ; i ++ ) 
  575.     {
  576.       if ( i == curinput .locfield ) 
  577.       {
  578.         firstcount = tally ; 
  579.         trickcount = tally + 1 + errorline - halferrorlin ; 
  580.         if ( trickcount < errorline ) 
  581.         trickcount = errorline ; 
  582.       } 
  583.       print ( buffer [ i ] ) ; 
  584.     } 
  585.       } 
  586.       else { 
  587.     switch ( curinput .indexfield ) 
  588.     {case 0 : 
  589.       printnl ( 436 ) ; 
  590.       break ; 
  591.     case 1 : 
  592.     case 2 : 
  593.       printnl ( 437 ) ; 
  594.       break ; 
  595.     case 3 : 
  596.       if ( curinput .locfield == 0 ) 
  597.       printnl ( 438 ) ; 
  598.       else printnl ( 439 ) ; 
  599.       break ; 
  600.     case 4 : 
  601.       printnl ( 440 ) ; 
  602.       break ; 
  603.     case 5 : 
  604.       {
  605.         println () ; 
  606.         printcs ( curinput .namefield ) ; 
  607.       } 
  608.       break ; 
  609.     case 6 : 
  610.       printnl ( 441 ) ; 
  611.       break ; 
  612.     case 7 : 
  613.       printnl ( 442 ) ; 
  614.       break ; 
  615.     case 8 : 
  616.       printnl ( 443 ) ; 
  617.       break ; 
  618.     case 9 : 
  619.       printnl ( 444 ) ; 
  620.       break ; 
  621.     case 10 : 
  622.       printnl ( 445 ) ; 
  623.       break ; 
  624.     case 11 : 
  625.       printnl ( 446 ) ; 
  626.       break ; 
  627.     case 12 : 
  628.       printnl ( 447 ) ; 
  629.       break ; 
  630.     case 13 : 
  631.       printnl ( 448 ) ; 
  632.       break ; 
  633.     case 14 : 
  634.       printnl ( 449 ) ; 
  635.       break ; 
  636.     case 15 : 
  637.       printnl ( 450 ) ; 
  638.       break ; 
  639.     default : 
  640.       printnl ( 63 ) ; 
  641.       break ; 
  642.     } 
  643.     {
  644.       l = tally ; 
  645.       tally = 0 ; 
  646.       selector = 20 ; 
  647.       trickcount = 1000000 ; 
  648.     } 
  649.     if ( curinput .indexfield < 5 ) 
  650.     showtokenlis ( curinput .startfield , curinput .locfield , 100000 ) ; 
  651.     else showtokenlis ( mem [(long) curinput .startfield ] .hh .v.RH , curinput 
  652.     .locfield , 100000 ) ; 
  653.       } 
  654.       selector = oldsetting ; 
  655.       if ( trickcount == 1000000 ) 
  656.       {
  657.     firstcount = tally ; 
  658.     trickcount = tally + 1 + errorline - halferrorlin ; 
  659.     if ( trickcount < errorline ) 
  660.     trickcount = errorline ; 
  661.       } 
  662.       if ( tally < trickcount ) 
  663.       m = tally - firstcount ; 
  664.       else m = trickcount - firstcount ; 
  665.       if ( l + firstcount <= halferrorlin ) 
  666.       {
  667.     p = 0 ; 
  668.     n = l + firstcount ; 
  669.       } 
  670.       else { 
  671.     print ( 146 ) ; 
  672.     p = l + firstcount - halferrorlin + 3 ; 
  673.     n = halferrorlin ; 
  674.       } 
  675.       for ( q = p ; q <= firstcount - 1 ; q ++ ) 
  676.       printchar ( trickbuf [ q % errorline ] ) ; 
  677.       println () ; 
  678.       for ( q = 1 ; q <= n ; q ++ ) 
  679.       printchar ( 32 ) ; 
  680.       if ( m + n <= errorline ) 
  681.       p = firstcount + m ; 
  682.       else p = firstcount + ( errorline - n - 3 ) ; 
  683.       for ( q = firstcount ; q <= p - 1 ; q ++ ) 
  684.       printchar ( trickbuf [ q % errorline ] ) ; 
  685.       if ( m + n > errorline ) 
  686.       print ( 146 ) ; 
  687.     } 
  688.     if ( ( curinput .statefield != 0 ) ) 
  689.     if ( ( curinput .namefield > 17 ) || ( baseptr == 0 ) ) 
  690.     goto lab30 ; 
  691.     decr ( baseptr ) ; 
  692.   } 
  693.   lab30: curinput = inputstack [ inputptr ] ; 
  694. } 
  695. zbegintokenli ( p , t ) 
  696. halfword p ; 
  697. quarterword t ; 
  698. {r_begintokenli 
  699.   {
  700.     if ( inputptr > maxinstack ) 
  701.     {
  702.       maxinstack = inputptr ; 
  703.       if ( inputptr == stacksize ) 
  704.       overflow ( 451 , stacksize ) ; 
  705.     } 
  706.     inputstack [ inputptr ] = curinput ; 
  707.     incr ( inputptr ) ; 
  708.   } 
  709.   curinput .statefield = 0 ; 
  710.   curinput .startfield = p ; 
  711.   curinput .indexfield = t ; 
  712.   if ( t >= 5 ) 
  713.   {
  714.     incr ( mem [(long) p ] .hh .v.LH ) ; 
  715.     if ( t == 5 ) 
  716.     curinput .limitfield = paramptr ; 
  717.     else { 
  718.       curinput .locfield = mem [(long) p ] .hh .v.RH ; 
  719.       if ( eqtb [ 5297 ] .cint > 1 ) 
  720.       {
  721.     begindiagnos () ; 
  722.     printnl ( 206 ) ; 
  723.     switch ( t ) 
  724.     {case 14 : 
  725.       printesc ( 219 ) ; 
  726.       break ; 
  727.     case 15 : 
  728.       printesc ( 452 ) ; 
  729.       break ; 
  730.     default : 
  731.       printcmdchr ( 71 , t + 4051 ) ; 
  732.       break ; 
  733.     } 
  734.     print ( 414 ) ; 
  735.     tokenshow ( p ) ; 
  736.     enddiagnosti ( false ) ; 
  737.       } 
  738.     } 
  739.   } 
  740.   else curinput .locfield = p ; 
  741. } 
  742. endtokenlist () { r_endtokenlist 
  743.   if ( curinput .indexfield >= 3 ) 
  744.   {
  745.     if ( curinput .indexfield <= 4 ) 
  746.     flushlist ( curinput .startfield ) ; 
  747.     else { 
  748.       deletetokenr ( curinput .startfield ) ; 
  749.       if ( curinput .indexfield == 5 ) 
  750.       while ( paramptr > curinput .limitfield ) { 
  751.     decr ( paramptr ) ; 
  752.     flushlist ( paramstack [ paramptr ] ) ; 
  753.       } 
  754.     } 
  755.   } 
  756.   else if ( curinput .indexfield == 1 ) 
  757.   alignstate = 0 ; 
  758.   {
  759.     decr ( inputptr ) ; 
  760.     curinput = inputstack [ inputptr ] ; 
  761.   } 
  762.   {
  763.     if ( interrupt != 0 ) 
  764.     pauseforinst () ; 
  765.   } 
  766. } 
  767. backinput () { r_backinput 
  768.   halfword p ; 
  769.   while ( ( curinput .statefield == 0 ) && ( curinput .locfield == 0 ) ) 
  770.   endtokenlist () ; 
  771.   p = getavail () ; 
  772.   mem [(long) p ] .hh .v.LH = curtok ; 
  773.   if ( curtok < 768 ) 
  774.   if ( curtok < 512 ) 
  775.   decr ( alignstate ) ; 
  776.   else incr ( alignstate ) ; 
  777.   {
  778.     if ( inputptr > maxinstack ) 
  779.     {
  780.       maxinstack = inputptr ; 
  781.       if ( inputptr == stacksize ) 
  782.       overflow ( 451 , stacksize ) ; 
  783.     } 
  784.     inputstack [ inputptr ] = curinput ; 
  785.     incr ( inputptr ) ; 
  786.   } 
  787.   curinput .statefield = 0 ; 
  788.   curinput .startfield = p ; 
  789.   curinput .indexfield = 3 ; 
  790.   curinput .locfield = p ; 
  791. } 
  792. backerror () { r_backerror 
  793.   OKtointerrup = false ; 
  794.   backinput () ; 
  795.   OKtointerrup = true ; 
  796.   error () ; 
  797. } 
  798. inserror () { r_inserror 
  799.   OKtointerrup = false ; 
  800.   backinput () ; 
  801.   curinput .indexfield = 4 ; 
  802.   OKtointerrup = true ; 
  803.   error () ; 
  804. } 
  805. beginfilerea () { r_beginfilerea 
  806.   if ( inopen == maxinopen ) 
  807.   overflow ( 453 , maxinopen ) ; 
  808.   if ( first == bufsize ) 
  809.   overflow ( 454 , bufsize ) ; 
  810.   incr ( inopen ) ; 
  811.   {
  812.     if ( inputptr > maxinstack ) 
  813.     {
  814.       maxinstack = inputptr ; 
  815.       if ( inputptr == stacksize ) 
  816.       overflow ( 451 , stacksize ) ; 
  817.     } 
  818.     inputstack [ inputptr ] = curinput ; 
  819.     incr ( inputptr ) ; 
  820.   } 
  821.   curinput .indexfield = inopen ; 
  822.   linestack [ curinput .indexfield ] = line ; 
  823.   curinput .startfield = first ; 
  824.   curinput .statefield = 1 ; 
  825.   curinput .namefield = 0 ; 
  826. } 
  827. endfilereadi () { r_endfilereadi 
  828.   first = curinput .startfield ; 
  829.   line = linestack [ curinput .indexfield ] ; 
  830.   if ( curinput .namefield > 17 ) 
  831.   aclose ( inputfile [ curinput .indexfield ] ) ; 
  832.   {
  833.     decr ( inputptr ) ; 
  834.     curinput = inputstack [ inputptr ] ; 
  835.   } 
  836.   decr ( inopen ) ; 
  837. } 
  838. clearforerro () { r_clearforerro 
  839.   while ( ( curinput .statefield != 0 ) && ( curinput .namefield == 0 ) && ( 
  840.   inputptr > 0 ) && ( curinput .locfield > curinput .limitfield ) ) 
  841.   endfilereadi () ; 
  842.   println () ; 
  843.   cleartermina () ; 
  844. } 
  845. checkouterva () { r_checkouterva 
  846.   halfword p ; 
  847.   halfword q ; 
  848.   if ( scannerstatu != 0 ) 
  849.   {
  850.     deletionsall = false ; 
  851.     if ( curcs != 0 ) 
  852.     {
  853.       if ( ( curinput .statefield == 0 ) || ( curinput .namefield < 1 ) || ( 
  854.       curinput .namefield > 17 ) ) 
  855.       {
  856.     p = getavail () ; 
  857.     mem [(long) p ] .hh .v.LH = 4096 + curcs ; 
  858.     begintokenli ( p , 3 ) ; 
  859.       } 
  860.       curcmd = 10 ; 
  861.       curchr = 32 ; 
  862.     } 
  863.     if ( scannerstatu > 1 ) 
  864.     {
  865.       runaway () ; 
  866.       if ( curcs == 0 ) 
  867.       {
  868.     if ( interaction == 3 ) 
  869.     wakeuptermin () ; 
  870.     printnl ( 133 ) ; 
  871.     print ( 462 ) ; 
  872.       } 
  873.       else { 
  874.     curcs = 0 ; 
  875.     {
  876.       if ( interaction == 3 ) 
  877.       wakeuptermin () ; 
  878.       printnl ( 133 ) ; 
  879.       print ( 463 ) ; 
  880.     } 
  881.       } 
  882.       print ( 464 ) ; 
  883.       p = getavail () ; 
  884.       switch ( scannerstatu ) 
  885.       {case 2 : 
  886.     {
  887.       print ( 428 ) ; 
  888.       mem [(long) p ] .hh .v.LH = 637 ; 
  889.     } 
  890.     break ; 
  891.       case 3 : 
  892.     {
  893.       print ( 470 ) ; 
  894.       mem [(long) p ] .hh .v.LH = partoken ; 
  895.       longstate = 112 ; 
  896.     } 
  897.     break ; 
  898.       case 4 : 
  899.     {
  900.       print ( 430 ) ; 
  901.       mem [(long) p ] .hh .v.LH = 637 ; 
  902.       q = p ; 
  903.       p = getavail () ; 
  904.       mem [(long) p ] .hh .v.RH = q ; 
  905.       mem [(long) p ] .hh .v.LH = 7355 ; 
  906.       alignstate = - 1000000 ; 
  907.     } 
  908.     break ; 
  909.       case 5 : 
  910.     {
  911.       print ( 431 ) ; 
  912.       mem [(long) p ] .hh .v.LH = 637 ; 
  913.     } 
  914.     break ; 
  915.       } 
  916.       begintokenli ( p , 4 ) ; 
  917.       print ( 465 ) ; 
  918.       sprintcs ( warningindex ) ; 
  919.       {
  920.     helpptr = 4 ; 
  921.     helpline [ 3 ] = 466 ; 
  922.     helpline [ 2 ] = 467 ; 
  923.     helpline [ 1 ] = 468 ; 
  924.     helpline [ 0 ] = 469 ; 
  925.       } 
  926.       error () ; 
  927.     } 
  928.     else { 
  929.       {
  930.     if ( interaction == 3 ) 
  931.     wakeuptermin () ; 
  932.     printnl ( 133 ) ; 
  933.     print ( 456 ) ; 
  934.       } 
  935.       printcmdchr ( 104 , curif ) ; 
  936.       print ( 457 ) ; 
  937.       printint ( skipline ) ; 
  938.       {
  939.     helpptr = 3 ; 
  940.     helpline [ 2 ] = 458 ; 
  941.     helpline [ 1 ] = 459 ; 
  942.     helpline [ 0 ] = 460 ; 
  943.       } 
  944.       if ( curcs != 0 ) 
  945.       curcs = 0 ; 
  946.       else helpline [ 2 ] = 461 ; 
  947.       curtok = 7358 ; 
  948.       inserror () ; 
  949.     } 
  950.     deletionsall = true ; 
  951.   } 
  952. } 
  953. getnext () { /* 20 25 21 26 40 10 */ r_getnext 
  954.   integer k ; 
  955.   halfword t ; 
  956.   quarterword cat ; 
  957.   lab20: curcs = 0 ; 
  958.   if ( curinput .statefield != 0 ) 
  959.   {
  960.     lab25: if ( curinput .locfield <= curinput .limitfield ) 
  961.     {
  962.       curchr = buffer [ curinput .locfield ] ; 
  963.       incr ( curinput .locfield ) ; 
  964.       lab21: curcmd = eqtb [ 4627 + curchr ] .hh .v.RH ; 
  965.       switch ( curinput .statefield + curcmd ) 
  966.       {case 10 : 
  967.       case 26 : 
  968.       case 42 : 
  969.       case 27 : 
  970.       case 43 : 
  971.     goto lab25 ; 
  972.     break ; 
  973.       case 1 : 
  974.       case 17 : 
  975.       case 33 : 
  976.     {
  977.       if ( curinput .locfield > curinput .limitfield ) 
  978.       curcs = 257 ; 
  979.       else { 
  980.         lab26: k = curinput .locfield ; 
  981.         curchr = buffer [ k ] ; 
  982.         cat = eqtb [ 4627 + curchr ] .hh .v.RH ; 
  983.         incr ( k ) ; 
  984.         if ( cat == 11 ) 
  985.         curinput .statefield = 17 ; 
  986.         else if ( cat == 10 ) 
  987.         curinput .statefield = 17 ; 
  988.         else curinput .statefield = 1 ; 
  989.         if ( ( cat == 11 ) && ( k <= curinput .limitfield ) ) 
  990.         {
  991.           do { curchr = buffer [ k ] ; 
  992.         cat = eqtb [ 4627 + curchr ] .hh .v.RH ; 
  993.         incr ( k ) ; 
  994.           } while ( ! ( ( cat != 11 ) || ( k > curinput .limitfield ) ) ) 
  995.           ; 
  996.           {
  997.         if ( buffer [ k ] == curchr ) 
  998.         if ( cat == 7 ) 
  999.         if ( k < curinput .limitfield ) 
  1000.         {
  1001.           curchr = buffer [ k + 1 ] ; 
  1002.           if ( curchr < 64 ) 
  1003.           buffer [ k - 1 ] = curchr + 64 ; 
  1004.           else buffer [ k - 1 ] = curchr - 64 ; 
  1005.           curinput .limitfield = curinput .limitfield - 2 ; 
  1006.           first = first - 2 ; 
  1007.           while ( k <= curinput .limitfield ) { 
  1008.             buffer [ k ] = buffer [ k + 2 ] ; 
  1009.             incr ( k ) ; 
  1010.           } 
  1011.           goto lab26 ; 
  1012.         } 
  1013.           } 
  1014.           if ( cat != 11 ) 
  1015.           decr ( k ) ; 
  1016.           if ( k > curinput .locfield + 1 ) 
  1017.           {
  1018.         curcs = idlookup ( curinput .locfield , k - curinput .locfield 
  1019.         ) ; 
  1020.         curinput .locfield = k ; 
  1021.         goto lab40 ; 
  1022.           } 
  1023.         } 
  1024.         else { 
  1025.           if ( buffer [ k ] == curchr ) 
  1026.           if ( cat == 7 ) 
  1027.           if ( k < curinput .limitfield ) 
  1028.           {
  1029.         curchr = buffer [ k + 1 ] ; 
  1030.         if ( curchr < 64 ) 
  1031.         buffer [ k - 1 ] = curchr + 64 ; 
  1032.         else buffer [ k - 1 ] = curchr - 64 ; 
  1033.         curinput .limitfield = curinput .limitfield - 2 ; 
  1034.         first = first - 2 ; 
  1035.         while ( k <= curinput .limitfield ) { 
  1036.           buffer [ k ] = buffer [ k + 2 ] ; 
  1037.           incr ( k ) ; 
  1038.         } 
  1039.         goto lab26 ; 
  1040.           } 
  1041.         } 
  1042.         curcs = 129 + buffer [ curinput .locfield ] ; 
  1043.         incr ( curinput .locfield ) ; 
  1044.       } 
  1045.       lab40: curcmd = eqtb [ curcs ] .hh.b0 ; 
  1046.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1047.       if ( curcmd >= 112 ) 
  1048.       checkouterva () ; 
  1049.     } 
  1050.     break ; 
  1051.       case 14 : 
  1052.       case 30 : 
  1053.       case 46 : 
  1054.     {
  1055.       curcs = curchr + 1 ; 
  1056.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  1057.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1058.       curinput .statefield = 1 ; 
  1059.       if ( curcmd >= 112 ) 
  1060.       checkouterva () ; 
  1061.     } 
  1062.     break ; 
  1063.       case 8 : 
  1064.       case 24 : 
  1065.       case 40 : 
  1066.     {
  1067.       if ( ( curchr == buffer [ curinput .locfield ] ) && ( curinput 
  1068.       .locfield < curinput .limitfield ) ) 
  1069.       {
  1070.         if ( buffer [ curinput .locfield + 1 ] < 64 ) 
  1071.         curchr = buffer [ curinput .locfield + 1 ] + 64 ; 
  1072.         else curchr = buffer [ curinput .locfield + 1 ] - 64 ; 
  1073.         curinput .locfield = curinput .locfield + 2 ; 
  1074.         goto lab21 ; 
  1075.       } 
  1076.       curinput .statefield = 1 ; 
  1077.     } 
  1078.     break ; 
  1079.       case 16 : 
  1080.       case 32 : 
  1081.       case 48 : 
  1082.     {
  1083.       {
  1084.         if ( interaction == 3 ) 
  1085.         wakeuptermin () ; 
  1086.         printnl ( 133 ) ; 
  1087.         print ( 471 ) ; 
  1088.       } 
  1089.       {
  1090.         helpptr = 2 ; 
  1091.         helpline [ 1 ] = 472 ; 
  1092.         helpline [ 0 ] = 473 ; 
  1093.       } 
  1094.       deletionsall = false ; 
  1095.       error () ; 
  1096.       deletionsall = true ; 
  1097.       goto lab20 ; 
  1098.     } 
  1099.     break ; 
  1100.       case 11 : 
  1101.     {
  1102.       curinput .statefield = 17 ; 
  1103.       curchr = 32 ; 
  1104.     } 
  1105.     break ; 
  1106.       case 6 : 
  1107.     {
  1108.       curinput .locfield = curinput .limitfield + 1 ; 
  1109.       curcmd = 10 ; 
  1110.       curchr = 32 ; 
  1111.     } 
  1112.     break ; 
  1113.       case 22 : 
  1114.       case 15 : 
  1115.       case 31 : 
  1116.       case 47 : 
  1117.     {
  1118.       curinput .locfield = curinput .limitfield + 1 ; 
  1119.       goto lab25 ; 
  1120.     } 
  1121.     break ; 
  1122.       case 38 : 
  1123.     {
  1124.       curinput .locfield = curinput .limitfield + 1 ; 
  1125.       curcs = parloc ; 
  1126.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  1127.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1128.       if ( curcmd >= 112 ) 
  1129.       checkouterva () ; 
  1130.     } 
  1131.     break ; 
  1132.       case 2 : 
  1133.     incr ( alignstate ) ; 
  1134.     break ; 
  1135.       case 18 : 
  1136.       case 34 : 
  1137.     {
  1138.       curinput .statefield = 1 ; 
  1139.       incr ( alignstate ) ; 
  1140.     } 
  1141.     break ; 
  1142.       case 3 : 
  1143.     decr ( alignstate ) ; 
  1144.     break ; 
  1145.       case 19 : 
  1146.       case 35 : 
  1147.     {
  1148.       curinput .statefield = 1 ; 
  1149.       decr ( alignstate ) ; 
  1150.     } 
  1151.     break ; 
  1152.       case 20 : 
  1153.       case 21 : 
  1154.       case 23 : 
  1155.       case 25 : 
  1156.       case 28 : 
  1157.       case 29 : 
  1158.       case 36 : 
  1159.       case 37 : 
  1160.       case 39 : 
  1161.       case 41 : 
  1162.       case 44 : 
  1163.       case 45 : 
  1164.     curinput .statefield = 1 ; 
  1165.     break ; 
  1166.       default : 
  1167.  
  1168.     break ; 
  1169.       } 
  1170.     } 
  1171.     else { 
  1172.       curinput .statefield = 33 ; 
  1173.       if ( curinput .namefield > 17 ) 
  1174.       {
  1175.     incr ( line ) ; 
  1176.     first = curinput .startfield ; 
  1177.     if ( ! forceeof ) 
  1178.     {
  1179.       if ( inputln ( inputfile [ curinput .indexfield ] , true ) ) 
  1180.       firmupthelin () ; 
  1181.       else forceeof = true ; 
  1182.     } 
  1183.     if ( forceeof ) 
  1184.     {
  1185.       printchar ( 41 ) ; 
  1186.       forceeof = false ; 
  1187.       termflush ( output ) ; 
  1188.       endfilereadi () ; 
  1189.       checkouterva () ; 
  1190.       goto lab20 ; 
  1191.     } 
  1192.     if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  1193.     decr ( curinput .limitfield ) ; 
  1194.     else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  1195.     first = curinput .limitfield + 1 ; 
  1196.     curinput .locfield = curinput .startfield ; 
  1197.       } 
  1198.       else { 
  1199.     if ( ! ( curinput .namefield == 0 ) ) 
  1200.     {
  1201.       curcmd = 0 ; 
  1202.       curchr = 0 ; 
  1203.       return ; 
  1204.     } 
  1205.     if ( inputptr > 0 ) 
  1206.     {
  1207.       endfilereadi () ; 
  1208.       goto lab20 ; 
  1209.     } 
  1210.     if ( selector < 18 ) 
  1211.     openlogfile () ; 
  1212.     if ( interaction > 1 ) 
  1213.     {
  1214.       if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  1215.       incr ( curinput .limitfield ) ; 
  1216.       if ( curinput .limitfield == curinput .startfield ) 
  1217.       printnl ( 474 ) ; 
  1218.       println () ; 
  1219.       first = curinput .startfield ; 
  1220.       {
  1221.         wakeuptermin () ; 
  1222.         print ( 42 ) ; 
  1223.         terminput () ; 
  1224.       } 
  1225.       curinput .limitfield = last ; 
  1226.       if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  1227.       decr ( curinput .limitfield ) ; 
  1228.       else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  1229.       first = curinput .limitfield + 1 ; 
  1230.       curinput .locfield = curinput .startfield ; 
  1231.     } 
  1232.     else fatalerror ( 475 ) ; 
  1233.       } 
  1234.       {
  1235.     if ( interrupt != 0 ) 
  1236.     pauseforinst () ; 
  1237.       } 
  1238.       goto lab25 ; 
  1239.     } 
  1240.   } 
  1241.   else if ( curinput .locfield != 0 ) 
  1242.   {
  1243.     t = mem [(long) curinput .locfield ] .hh .v.LH ; 
  1244.     curinput .locfield = mem [(long) curinput .locfield ] .hh .v.RH ; 
  1245.     if ( t >= 4096 ) 
  1246.     {
  1247.       curcs = t - 4096 ; 
  1248.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  1249.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1250.       if ( curcmd >= 112 ) 
  1251.       if ( curcmd == 115 ) 
  1252.       {
  1253.     curcs = mem [(long) curinput .locfield ] .hh .v.LH - 4096 ; 
  1254.     curinput .locfield = 0 ; 
  1255.     curcmd = eqtb [ curcs ] .hh.b0 ; 
  1256.     curchr = eqtb [ curcs ] .hh .v.RH ; 
  1257.     if ( curcmd > 99 ) 
  1258.     {
  1259.       curcmd = 0 ; 
  1260.       curchr = 257 ; 
  1261.     } 
  1262.       } 
  1263.       else checkouterva () ; 
  1264.     } 
  1265.     else { 
  1266.       curcmd = t / 256 ; 
  1267.       curchr = t % 256 ; 
  1268.       switch ( curcmd ) 
  1269.       {case 1 : 
  1270.     incr ( alignstate ) ; 
  1271.     break ; 
  1272.       case 2 : 
  1273.     decr ( alignstate ) ; 
  1274.     break ; 
  1275.       case 5 : 
  1276.     {
  1277.       begintokenli ( paramstack [ curinput .limitfield + curchr - 1 ] , 0 
  1278.       ) ; 
  1279.       goto lab20 ; 
  1280.     } 
  1281.     break ; 
  1282.       default : 
  1283.  
  1284.     break ; 
  1285.       } 
  1286.     } 
  1287.   } 
  1288.   else { 
  1289.     endtokenlist () ; 
  1290.     goto lab20 ; 
  1291.   } 
  1292.   if ( curcmd <= 5 ) 
  1293.   if ( curcmd >= 4 ) 
  1294.   if ( alignstate == 0 ) 
  1295.   {
  1296.     if ( scannerstatu == 4 ) 
  1297.     fatalerror ( 762 ) ; 
  1298.     curcmd = mem [(long) curalign + 5 ] .hh .v.LH ; 
  1299.     mem [(long) curalign + 5 ] .hh .v.LH = curchr ; 
  1300.     if ( curcmd == 63 ) 
  1301.     begintokenli ( memtop - 10 , 2 ) ; 
  1302.     else begintokenli ( mem [(long) curalign + 2 ] .cint , 2 ) ; 
  1303.     alignstate = 1000000 ; 
  1304.     goto lab20 ; 
  1305.   } 
  1306. } 
  1307. firmupthelin () { r_firmupthelin 
  1308.   integer k ; 
  1309.   curinput .limitfield = last ; 
  1310.   if ( eqtb [ 5295 ] .cint > 0 ) 
  1311.   if ( interaction > 1 ) 
  1312.   {
  1313.     wakeuptermin () ; 
  1314.     println () ; 
  1315.     if ( curinput .startfield < curinput .limitfield ) 
  1316.     for ( k = curinput .startfield ; k <= curinput .limitfield - 1 ; k ++ ) 
  1317.     print ( buffer [ k ] ) ; 
  1318.     first = curinput .limitfield ; 
  1319.     {
  1320.       wakeuptermin () ; 
  1321.       print ( 476 ) ; 
  1322.       terminput () ; 
  1323.     } 
  1324.     if ( last > first ) 
  1325.     {
  1326.       for ( k = first ; k <= last - 1 ; k ++ ) 
  1327.       buffer [ k + curinput .startfield - first ] = buffer [ k ] ; 
  1328.       curinput .limitfield = curinput .startfield + last - first ; 
  1329.     } 
  1330.   } 
  1331. } 
  1332. gettoken () { r_gettoken 
  1333.   nonewcontrol = false ; 
  1334.   getnext () ; 
  1335.   nonewcontrol = true ; 
  1336.   if ( curcs == 0 ) 
  1337.   curtok = ( curcmd * 256 ) + curchr ; 
  1338.   else curtok = 4096 + curcs ; 
  1339. } 
  1340. macrocall () { /* 10 22 30 31 40 */ r_macrocall 
  1341.   halfword r ; 
  1342.   halfword p ; 
  1343.   halfword q ; 
  1344.   halfword s ; 
  1345.   halfword t ; 
  1346.   halfword u, v ; 
  1347.   halfword rbraceptr ; 
  1348.   smallnumber n ; 
  1349.   halfword unbalance ; 
  1350.   halfword m ; 
  1351.   halfword refcount ; 
  1352.   smallnumber savescanners ; 
  1353.   halfword savewarningi ; 
  1354.   ASCIIcode matchchr ; 
  1355.   savescanners = scannerstatu ; 
  1356.   savewarningi = warningindex ; 
  1357.   warningindex = curcs ; 
  1358.   refcount = curchr ; 
  1359.   r = mem [(long) refcount ] .hh .v.RH ; 
  1360.   n = 0 ; 
  1361.   if ( eqtb [ 5297 ] .cint > 0 ) 
  1362.   {
  1363.     begindiagnos () ; 
  1364.     println () ; 
  1365.     printcs ( warningindex ) ; 
  1366.     tokenshow ( refcount ) ; 
  1367.     enddiagnosti ( false ) ; 
  1368.   } 
  1369.   if ( mem [(long) r ] .hh .v.LH != 3584 ) 
  1370.   {
  1371.     scannerstatu = 3 ; 
  1372.     unbalance = 0 ; 
  1373.     longstate = eqtb [ curcs ] .hh.b0 ; 
  1374.     if ( longstate >= 112 ) 
  1375.     longstate = longstate - 2 ; 
  1376.     do { if ( ( mem [(long) r ] .hh .v.LH > 3455 ) || ( mem [(long) r ] .hh .v.LH < 3328 ) 
  1377.       ) 
  1378.       s = 0 ; 
  1379.       else { 
  1380.     matchchr = mem [(long) r ] .hh .v.LH - 3328 ; 
  1381.     s = mem [(long) r ] .hh .v.RH ; 
  1382.     r = s ; 
  1383.     p = memtop - 3 ; 
  1384.     mem [(long) p ] .hh .v.RH = 0 ; 
  1385.     m = 0 ; 
  1386.       } 
  1387.       lab22: gettoken () ; 
  1388.       if ( curtok == mem [(long) r ] .hh .v.LH ) 
  1389.       {
  1390.     r = mem [(long) r ] .hh .v.RH ; 
  1391.     if ( ( mem [(long) r ] .hh .v.LH >= 3328 ) && ( mem [(long) r ] .hh .v.LH <= 3584 
  1392.     ) ) 
  1393.     {
  1394.       if ( curtok < 512 ) 
  1395.       decr ( alignstate ) ; 
  1396.       goto lab40 ; 
  1397.     } 
  1398.     else goto lab22 ; 
  1399.       } 
  1400.       if ( s != r ) 
  1401.       if ( s == 0 ) 
  1402.       {
  1403.     {
  1404.       if ( interaction == 3 ) 
  1405.       wakeuptermin () ; 
  1406.       printnl ( 133 ) ; 
  1407.       print ( 508 ) ; 
  1408.     } 
  1409.     sprintcs ( warningindex ) ; 
  1410.     print ( 509 ) ; 
  1411.     {
  1412.       helpptr = 4 ; 
  1413.       helpline [ 3 ] = 510 ; 
  1414.       helpline [ 2 ] = 511 ; 
  1415.       helpline [ 1 ] = 512 ; 
  1416.       helpline [ 0 ] = 513 ; 
  1417.     } 
  1418.     error () ; 
  1419.     goto lab10 ; 
  1420.       } 
  1421.       else { 
  1422.     t = s ; 
  1423.     do { { 
  1424.         q = getavail () ; 
  1425.         mem [(long) p ] .hh .v.RH = q ; 
  1426.         mem [(long) q ] .hh .v.LH = mem [(long) t ] .hh .v.LH ; 
  1427.         p = q ; 
  1428.       } 
  1429.       incr ( m ) ; 
  1430.       u = mem [(long) t ] .hh .v.RH ; 
  1431.       v = s ; 
  1432.       while ( true ) { 
  1433.         if ( u == r ) 
  1434.         if ( curtok != mem [(long) v ] .hh .v.LH ) 
  1435.         goto lab30 ; 
  1436.         else { 
  1437.           r = mem [(long) v ] .hh .v.RH ; 
  1438.           goto lab22 ; 
  1439.         } 
  1440.         if ( mem [(long) u ] .hh .v.LH != mem [(long) v ] .hh .v.LH ) 
  1441.         goto lab30 ; 
  1442.         u = mem [(long) u ] .hh .v.RH ; 
  1443.         v = mem [(long) v ] .hh .v.RH ; 
  1444.       } 
  1445.       lab30: t = mem [(long) t ] .hh .v.RH ; 
  1446.     } while ( ! ( t == r ) ) ; 
  1447.     r = s ; 
  1448.       } 
  1449.       if ( curtok == partoken ) 
  1450.       if ( longstate != 111 ) 
  1451.       {
  1452.     if ( longstate == 110 ) 
  1453.     {
  1454.       runaway () ; 
  1455.       {
  1456.         if ( interaction == 3 ) 
  1457.         wakeuptermin () ; 
  1458.         printnl ( 133 ) ; 
  1459.         print ( 503 ) ; 
  1460.       } 
  1461.       sprintcs ( warningindex ) ; 
  1462.       print ( 504 ) ; 
  1463.       {
  1464.         helpptr = 3 ; 
  1465.         helpline [ 2 ] = 505 ; 
  1466.         helpline [ 1 ] = 506 ; 
  1467.         helpline [ 0 ] = 507 ; 
  1468.       } 
  1469.       backerror () ; 
  1470.     } 
  1471.     pstack [ n ] = mem [(long) memtop - 3 ] .hh .v.RH ; 
  1472.     alignstate = alignstate - unbalance ; 
  1473.     for ( m = 0 ; m <= n ; m ++ ) 
  1474.     flushlist ( pstack [ m ] ) ; 
  1475.     goto lab10 ; 
  1476.       } 
  1477.       if ( curtok < 768 ) 
  1478.       if ( curtok < 512 ) 
  1479.       {
  1480.     unbalance = 1 ; 
  1481.     while ( true ) { 
  1482.       {
  1483.         {
  1484.           q = avail ; 
  1485.           if ( q == 0 ) 
  1486.           q = getavail () ; 
  1487.           else { 
  1488.         avail = mem [(long) q ] .hh .v.RH ; 
  1489.         mem [(long) q ] .hh .v.RH = 0 ; 
  1490.  
  1491. #ifdef STAT
  1492.         incr ( dynused ) ; 
  1493. #endif /* STAT */
  1494.           } 
  1495.         } 
  1496.         mem [(long) p ] .hh .v.RH = q ; 
  1497.         mem [(long) q ] .hh .v.LH = curtok ; 
  1498.         p = q ; 
  1499.       } 
  1500.       gettoken () ; 
  1501.       if ( curtok == partoken ) 
  1502.       if ( longstate != 111 ) 
  1503.       {
  1504.         if ( longstate == 110 ) 
  1505.         {
  1506.           runaway () ; 
  1507.           {
  1508.         if ( interaction == 3 ) 
  1509.         wakeuptermin () ; 
  1510.         printnl ( 133 ) ; 
  1511.         print ( 503 ) ; 
  1512.           } 
  1513.           sprintcs ( warningindex ) ; 
  1514.           print ( 504 ) ; 
  1515.           {
  1516.         helpptr = 3 ; 
  1517.         helpline [ 2 ] = 505 ; 
  1518.         helpline [ 1 ] = 506 ; 
  1519.         helpline [ 0 ] = 507 ; 
  1520.           } 
  1521.           backerror () ; 
  1522.         } 
  1523.         pstack [ n ] = mem [(long) memtop - 3 ] .hh .v.RH ; 
  1524.         alignstate = alignstate - unbalance ; 
  1525.         for ( m = 0 ; m <= n ; m ++ ) 
  1526.         flushlist ( pstack [ m ] ) ; 
  1527.         goto lab10 ; 
  1528.       } 
  1529.       if ( curtok < 768 ) 
  1530.       if ( curtok < 512 ) 
  1531.       incr ( unbalance ) ; 
  1532.       else { 
  1533.         decr ( unbalance ) ; 
  1534.         if ( unbalance == 0 ) 
  1535.         goto lab31 ; 
  1536.       } 
  1537.     } 
  1538.     lab31: rbraceptr = p ; 
  1539.     {
  1540.       q = getavail () ; 
  1541.       mem [(long) p ] .hh .v.RH = q ; 
  1542.       mem [(long) q ] .hh .v.LH = curtok ; 
  1543.       p = q ; 
  1544.     } 
  1545.       } 
  1546.       else { 
  1547.     backinput () ; 
  1548.     {
  1549.       if ( interaction == 3 ) 
  1550.       wakeuptermin () ; 
  1551.       printnl ( 133 ) ; 
  1552.       print ( 495 ) ; 
  1553.     } 
  1554.     sprintcs ( warningindex ) ; 
  1555.     print ( 496 ) ; 
  1556.     {
  1557.       helpptr = 6 ; 
  1558.       helpline [ 5 ] = 497 ; 
  1559.       helpline [ 4 ] = 498 ; 
  1560.       helpline [ 3 ] = 499 ; 
  1561.       helpline [ 2 ] = 500 ; 
  1562.       helpline [ 1 ] = 501 ; 
  1563.       helpline [ 0 ] = 502 ; 
  1564.     } 
  1565.     incr ( alignstate ) ; 
  1566.     longstate = 110 ; 
  1567.     curtok = partoken ; 
  1568.     inserror () ; 
  1569.       } 
  1570.       else { 
  1571.     if ( curtok == 2592 ) 
  1572.     if ( mem [(long) r ] .hh .v.LH <= 3584 ) 
  1573.     if ( mem [(long) r ] .hh .v.LH >= 3328 ) 
  1574.     goto lab22 ; 
  1575.     {
  1576.       q = getavail () ; 
  1577.       mem [(long) p ] .hh .v.RH = q ; 
  1578.       mem [(long) q ] .hh .v.LH = curtok ; 
  1579.       p = q ; 
  1580.     } 
  1581.       } 
  1582.       incr ( m ) ; 
  1583.       if ( mem [(long) r ] .hh .v.LH > 3584 ) 
  1584.       goto lab22 ; 
  1585.       if ( mem [(long) r ] .hh .v.LH < 3328 ) 
  1586.       goto lab22 ; 
  1587.       lab40: if ( s != 0 ) 
  1588.       {
  1589.     if ( ( m == 1 ) && ( mem [(long) p ] .hh .v.LH < 768 ) && ( p != memtop - 3 
  1590.     ) ) 
  1591.     {
  1592.       mem [(long) rbraceptr ] .hh .v.RH = 0 ; 
  1593.       {
  1594.         mem [(long) p ] .hh .v.RH = avail ; 
  1595.         avail = p ; 
  1596.  
  1597. #ifdef STAT
  1598.         decr ( dynused ) ; 
  1599. #endif /* STAT */
  1600.       } 
  1601.       p = mem [(long) memtop - 3 ] .hh .v.RH ; 
  1602.       pstack [ n ] = mem [(long) p ] .hh .v.RH ; 
  1603.       {
  1604.         mem [(long) p ] .hh .v.RH = avail ; 
  1605.         avail = p ; 
  1606.  
  1607. #ifdef STAT
  1608.         decr ( dynused ) ; 
  1609. #endif /* STAT */
  1610.       } 
  1611.     } 
  1612.     else pstack [ n ] = mem [(long) memtop - 3 ] .hh .v.RH ; 
  1613.     incr ( n ) ; 
  1614.     if ( eqtb [ 5297 ] .cint > 0 ) 
  1615.     {
  1616.       begindiagnos () ; 
  1617.       printnl ( matchchr ) ; 
  1618.       printint ( n ) ; 
  1619.       print ( 514 ) ; 
  1620.       showtokenlis ( pstack [ n - 1 ] , 0 , 1000 ) ; 
  1621.       enddiagnosti ( false ) ; 
  1622.     } 
  1623.       } 
  1624.     } while ( ! ( mem [(long) r ] .hh .v.LH == 3584 ) ) ; 
  1625.   } 
  1626.   while ( ( curinput .statefield == 0 ) && ( curinput .locfield == 0 ) ) 
  1627.   endtokenlist () ; 
  1628.   begintokenli ( refcount , 5 ) ; 
  1629.   curinput .namefield = warningindex ; 
  1630.   curinput .locfield = mem [(long) r ] .hh .v.RH ; 
  1631.   if ( n > 0 ) 
  1632.   {
  1633.     if ( paramptr + n > maxparamstac ) 
  1634.     {
  1635.       maxparamstac = paramptr + n ; 
  1636.       if ( maxparamstac > paramsize ) 
  1637.       overflow ( 494 , paramsize ) ; 
  1638.     } 
  1639.     for ( m = 0 ; m <= n - 1 ; m ++ ) 
  1640.     paramstack [ paramptr + m ] = pstack [ m ] ; 
  1641.     paramptr = paramptr + n ; 
  1642.   } 
  1643.   lab10: scannerstatu = savescanners ; 
  1644.   warningindex = savewarningi ; 
  1645. } 
  1646. insertrelax () { r_insertrelax 
  1647.   curtok = 4096 + curcs ; 
  1648.   backinput () ; 
  1649.   curtok = 7361 ; 
  1650.   backinput () ; 
  1651.   curinput .indexfield = 4 ; 
  1652. } 
  1653. expand () { r_expand 
  1654.   halfword t ; 
  1655.   halfword p, q, r ; 
  1656.   integer j ; 
  1657.   integer cvbackup ; 
  1658.   smallnumber cvlbackup, radixbackup, cobackup ; 
  1659.   halfword backupbackup ; 
  1660.   smallnumber savescanners ; 
  1661.   cvbackup = curval ; 
  1662.   cvlbackup = curvallevel ; 
  1663.   radixbackup = radix ; 
  1664.   cobackup = curorder ; 
  1665.   backupbackup = mem [(long) memtop - 13 ] .hh .v.RH ; 
  1666.   if ( curcmd < 110 ) 
  1667.   {
  1668.     if ( eqtb [ 5303 ] .cint > 1 ) 
  1669.     showcurcmdch () ; 
  1670.     switch ( curcmd ) 
  1671.     {case 109 : 
  1672.       {
  1673.     if ( curmark [ curchr ] != 0 ) 
  1674.     begintokenli ( curmark [ curchr ] , 14 ) ; 
  1675.       } 
  1676.       break ; 
  1677.     case 101 : 
  1678.       {
  1679.     gettoken () ; 
  1680.     t = curtok ; 
  1681.     gettoken () ; 
  1682.     if ( curcmd > 99 ) 
  1683.     expand () ; 
  1684.     else backinput () ; 
  1685.     curtok = t ; 
  1686.     backinput () ; 
  1687.       } 
  1688.       break ; 
  1689.     case 102 : 
  1690.       {
  1691.     savescanners = scannerstatu ; 
  1692.     scannerstatu = 0 ; 
  1693.     gettoken () ; 
  1694.     scannerstatu = savescanners ; 
  1695.     t = curtok ; 
  1696.     backinput () ; 
  1697.     if ( t >= 4096 ) 
  1698.     {
  1699.       p = getavail () ; 
  1700.       mem [(long) p ] .hh .v.LH = 7363 ; 
  1701.       mem [(long) p ] .hh .v.RH = curinput .locfield ; 
  1702.       curinput .startfield = p ; 
  1703.       curinput .locfield = p ; 
  1704.     } 
  1705.       } 
  1706.       break ; 
  1707.     case 106 : 
  1708.       {
  1709.     r = getavail () ; 
  1710.     p = r ; 
  1711.     do { getxtoken () ; 
  1712.       if ( curcs == 0 ) 
  1713.       {
  1714.         q = getavail () ; 
  1715.         mem [(long) p ] .hh .v.RH = q ; 
  1716.         mem [(long) q ] .hh .v.LH = curtok ; 
  1717.         p = q ; 
  1718.       } 
  1719.     } while ( ! ( curcs != 0 ) ) ; 
  1720.     if ( curcmd != 66 ) 
  1721.     {
  1722.       {
  1723.         if ( interaction == 3 ) 
  1724.         wakeuptermin () ; 
  1725.         printnl ( 133 ) ; 
  1726.         print ( 483 ) ; 
  1727.       } 
  1728.       printesc ( 364 ) ; 
  1729.       print ( 484 ) ; 
  1730.       {
  1731.         helpptr = 2 ; 
  1732.         helpline [ 1 ] = 485 ; 
  1733.         helpline [ 0 ] = 486 ; 
  1734.       } 
  1735.       backerror () ; 
  1736.     } 
  1737.     j = first ; 
  1738.     p = mem [(long) r ] .hh .v.RH ; 
  1739.     while ( p != 0 ) { 
  1740.       if ( j >= maxbufstack ) 
  1741.       {
  1742.         maxbufstack = j + 1 ; 
  1743.         if ( maxbufstack == bufsize ) 
  1744.         overflow ( 454 , bufsize ) ; 
  1745.       } 
  1746.       buffer [ j ] = mem [(long) p ] .hh .v.LH % 256 ; 
  1747.       incr ( j ) ; 
  1748.       p = mem [(long) p ] .hh .v.RH ; 
  1749.     } 
  1750.     if ( j > first + 1 ) 
  1751.     {
  1752.       nonewcontrol = false ; 
  1753.       curcs = idlookup ( first , j - first ) ; 
  1754.       nonewcontrol = true ; 
  1755.     } 
  1756.     else if ( j == first ) 
  1757.     curcs = 257 ; 
  1758.     else curcs = 129 + buffer [ first ] ; 
  1759.     flushlist ( r ) ; 
  1760.     if ( eqtb [ curcs ] .hh.b0 == 100 ) 
  1761.     {
  1762.       eqdefine ( curcs , 0 , 256 ) ; 
  1763.     } 
  1764.     curtok = curcs + 4096 ; 
  1765.     backinput () ; 
  1766.       } 
  1767.       break ; 
  1768.     case 107 : 
  1769.       convtoks () ; 
  1770.       break ; 
  1771.     case 108 : 
  1772.       insthetoks () ; 
  1773.       break ; 
  1774.     case 104 : 
  1775.       conditional () ; 
  1776.       break ; 
  1777.     case 105 : 
  1778.       if ( curchr > iflimit ) 
  1779.       if ( iflimit == 1 ) 
  1780.       insertrelax () ; 
  1781.       else { 
  1782.     {
  1783.       if ( interaction == 3 ) 
  1784.       wakeuptermin () ; 
  1785.       printnl ( 133 ) ; 
  1786.       print ( 633 ) ; 
  1787.     } 
  1788.     printcmdchr ( 105 , curchr ) ; 
  1789.     {
  1790.       helpptr = 1 ; 
  1791.       helpline [ 0 ] = 634 ; 
  1792.     } 
  1793.     error () ; 
  1794.       } 
  1795.       else { 
  1796.     while ( curchr != 2 ) passtext () ; 
  1797.     {
  1798.       p = condptr ; 
  1799.       ifline = mem [(long) p + 1 ] .cint ; 
  1800.       curif = mem [(long) p ] .hh.b1 ; 
  1801.       iflimit = mem [(long) p ] .hh.b0 ; 
  1802.       condptr = mem [(long) p ] .hh .v.RH ; 
  1803.       freenode ( p , 2 ) ; 
  1804.     } 
  1805.       } 
  1806.       break ; 
  1807.     case 103 : 
  1808.       if ( curchr > 0 ) 
  1809.       forceeof = true ; 
  1810.       else if ( nameinprogre ) 
  1811.       insertrelax () ; 
  1812.       else startinput () ; 
  1813.       break ; 
  1814.     default : 
  1815.       {
  1816.     {
  1817.       if ( interaction == 3 ) 
  1818.       wakeuptermin () ; 
  1819.       printnl ( 133 ) ; 
  1820.       print ( 477 ) ; 
  1821.     } 
  1822.     {
  1823.       helpptr = 5 ; 
  1824.       helpline [ 4 ] = 478 ; 
  1825.       helpline [ 3 ] = 479 ; 
  1826.       helpline [ 2 ] = 480 ; 
  1827.       helpline [ 1 ] = 481 ; 
  1828.       helpline [ 0 ] = 482 ; 
  1829.     } 
  1830.     error () ; 
  1831.       } 
  1832.       break ; 
  1833.     } 
  1834.   } 
  1835.   else if ( curcmd < 114 ) 
  1836.   macrocall () ; 
  1837.   else { 
  1838.     curtok = 7360 ; 
  1839.     backinput () ; 
  1840.   } 
  1841.   curval = cvbackup ; 
  1842.   curvallevel = cvlbackup ; 
  1843.   radix = radixbackup ; 
  1844.   curorder = cobackup ; 
  1845.   mem [(long) memtop - 13 ] .hh .v.RH = backupbackup ; 
  1846. } 
  1847. getxtoken () { /* 20 30 */ r_getxtoken 
  1848.   lab20: getnext () ; 
  1849.   if ( curcmd <= 99 ) 
  1850.   goto lab30 ; 
  1851.   if ( curcmd >= 110 ) 
  1852.   if ( curcmd < 114 ) 
  1853.   macrocall () ; 
  1854.   else { 
  1855.     curcs = 3264 ; 
  1856.     curcmd = 9 ; 
  1857.     goto lab30 ; 
  1858.   } 
  1859.   else expand () ; 
  1860.   goto lab20 ; 
  1861.   lab30: if ( curcs == 0 ) 
  1862.   curtok = ( curcmd * 256 ) + curchr ; 
  1863.   else curtok = 4096 + curcs ; 
  1864. } 
  1865. xtoken () { r_xtoken 
  1866.   while ( curcmd > 99 ) { 
  1867.     expand () ; 
  1868.     getnext () ; 
  1869.   } 
  1870.   if ( curcs == 0 ) 
  1871.   curtok = ( curcmd * 256 ) + curchr ; 
  1872.   else curtok = 4096 + curcs ; 
  1873. } 
  1874. scanleftbrac () { r_scanleftbrac 
  1875.   do { getxtoken () ; 
  1876.   } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1877.   if ( curcmd != 1 ) 
  1878.   {
  1879.     {
  1880.       if ( interaction == 3 ) 
  1881.       wakeuptermin () ; 
  1882.       printnl ( 133 ) ; 
  1883.       print ( 515 ) ; 
  1884.     } 
  1885.     {
  1886.       helpptr = 4 ; 
  1887.       helpline [ 3 ] = 516 ; 
  1888.       helpline [ 2 ] = 517 ; 
  1889.       helpline [ 1 ] = 518 ; 
  1890.       helpline [ 0 ] = 519 ; 
  1891.     } 
  1892.     backerror () ; 
  1893.     curtok = 379 ; 
  1894.     curcmd = 1 ; 
  1895.     curchr = 123 ; 
  1896.     incr ( alignstate ) ; 
  1897.   } 
  1898. } 
  1899. scanoptional () { r_scanoptional 
  1900.   do { getxtoken () ; 
  1901.   } while ( ! ( curcmd != 10 ) ) ; 
  1902.   if ( curtok != 3133 ) 
  1903.   backinput () ; 
  1904. } 
  1905. boolean zscankeyword ( s ) 
  1906. strnumber s ; 
  1907. {/* 10 */ register boolean Result; r_scankeyword 
  1908.   halfword p ; 
  1909.   halfword q ; 
  1910.   poolpointer k ; 
  1911.   p = memtop - 13 ; 
  1912.   mem [(long) p ] .hh .v.RH = 0 ; 
  1913.   k = strstart [ s ] ; 
  1914.   while ( k < strstart [ s + 1 ] ) { 
  1915.     getxtoken () ; 
  1916.     if ( ( curcs == 0 ) && ( ( curchr == strpool [ k ] ) || ( curchr == 
  1917.     strpool [ k ] - 32 ) ) ) 
  1918.     {
  1919.       {
  1920.     q = getavail () ; 
  1921.     mem [(long) p ] .hh .v.RH = q ; 
  1922.     mem [(long) q ] .hh .v.LH = curtok ; 
  1923.     p = q ; 
  1924.       } 
  1925.       incr ( k ) ; 
  1926.     } 
  1927.     else if ( ( curcmd != 10 ) || ( p != memtop - 13 ) ) 
  1928.     {
  1929.       backinput () ; 
  1930.       if ( p != memtop - 13 ) 
  1931.       begintokenli ( mem [(long) memtop - 13 ] .hh .v.RH , 3 ) ; 
  1932.       Result = false ; 
  1933.       return(Result) ; 
  1934.     } 
  1935.   } 
  1936.   flushlist ( mem [(long) memtop - 13 ] .hh .v.RH ) ; 
  1937.   Result = true ; 
  1938.   return(Result) ; 
  1939. } 
  1940. muerror () { r_muerror 
  1941.   {
  1942.     if ( interaction == 3 ) 
  1943.     wakeuptermin () ; 
  1944.     printnl ( 133 ) ; 
  1945.     print ( 520 ) ; 
  1946.   } 
  1947.   {
  1948.     helpptr = 1 ; 
  1949.     helpline [ 0 ] = 521 ; 
  1950.   } 
  1951.   error () ; 
  1952. } 
  1953. scansevenbit () { r_scansevenbit 
  1954.   scanint () ; 
  1955.   if ( ( curval < 0 ) || ( curval > 127 ) ) 
  1956.   {
  1957.     {
  1958.       if ( interaction == 3 ) 
  1959.       wakeuptermin () ; 
  1960.       printnl ( 133 ) ; 
  1961.       print ( 543 ) ; 
  1962.     } 
  1963.     {
  1964.       helpptr = 2 ; 
  1965.       helpline [ 1 ] = 544 ; 
  1966.       helpline [ 0 ] = 545 ; 
  1967.     } 
  1968.     interror ( curval ) ; 
  1969.     curval = 0 ; 
  1970.   } 
  1971. } 
  1972. scaneightbit () { r_scaneightbit 
  1973.   scanint () ; 
  1974.   if ( ( curval < 0 ) || ( curval > 255 ) ) 
  1975.   {
  1976.     {
  1977.       if ( interaction == 3 ) 
  1978.       wakeuptermin () ; 
  1979.       printnl ( 133 ) ; 
  1980.       print ( 546 ) ; 
  1981.     } 
  1982.     {
  1983.       helpptr = 2 ; 
  1984.       helpline [ 1 ] = 547 ; 
  1985.       helpline [ 0 ] = 545 ; 
  1986.     } 
  1987.     interror ( curval ) ; 
  1988.     curval = 0 ; 
  1989.   } 
  1990. } 
  1991. scanfourbiti () { r_scanfourbiti 
  1992.   scanint () ; 
  1993.   if ( ( curval < 0 ) || ( curval > 15 ) ) 
  1994.   {
  1995.     {
  1996.       if ( interaction == 3 ) 
  1997.       wakeuptermin () ; 
  1998.       printnl ( 133 ) ; 
  1999.       print ( 548 ) ; 
  2000.     } 
  2001.     {
  2002.       helpptr = 2 ; 
  2003.       helpline [ 1 ] = 549 ; 
  2004.       helpline [ 0 ] = 545 ; 
  2005.     } 
  2006.     interror ( curval ) ; 
  2007.     curval = 0 ; 
  2008.   } 
  2009. } 
  2010.