home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  31.1 KB  |  1,437 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. #ifdef STAT
  5. void zshoweqtb ( n ) 
  6. halfword n ; 
  7. {showeqtb_regmem 
  8.   if ( n < 1 ) 
  9.   printchar ( 63 ) ; 
  10.   else if ( n < 3782 ) 
  11.   {
  12.     sprintcs ( n ) ; 
  13.     printchar ( 61 ) ; 
  14.     printcmdchr ( eqtb [ n ] .hh.b0 , eqtb [ n ] .hh .v.RH ) ; 
  15.     if ( eqtb [ n ] .hh.b0 >= 111 ) 
  16.     {
  17.       printchar ( 58 ) ; 
  18.       showtokenlist ( mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  19.     } 
  20.   } 
  21.   else if ( n < 4312 ) 
  22.   if ( n < 3800 ) 
  23.   {
  24.     printskipparam ( n - 3782 ) ; 
  25.     printchar ( 61 ) ; 
  26.     if ( n < 3797 ) 
  27.     printspec ( eqtb [ n ] .hh .v.RH , 393 ) ; 
  28.     else printspec ( eqtb [ n ] .hh .v.RH , 334 ) ; 
  29.   } 
  30.   else if ( n < 4056 ) 
  31.   {
  32.     printesc ( 391 ) ; 
  33.     printint ( n - 3800 ) ; 
  34.     printchar ( 61 ) ; 
  35.     printspec ( eqtb [ n ] .hh .v.RH , 393 ) ; 
  36.   } 
  37.   else {
  38.       
  39.     printesc ( 392 ) ; 
  40.     printint ( n - 4056 ) ; 
  41.     printchar ( 61 ) ; 
  42.     printspec ( eqtb [ n ] .hh .v.RH , 334 ) ; 
  43.   } 
  44.   else if ( n < 6163 ) 
  45.   if ( n == 4312 ) 
  46.   {
  47.     printesc ( 404 ) ; 
  48.     printchar ( 61 ) ; 
  49.     if ( eqtb [ 4312 ] .hh .v.RH == 0 ) 
  50.     printchar ( 48 ) ; 
  51.     else printint ( mem [ eqtb [ 4312 ] .hh .v.RH ] .hh .v.LH ) ; 
  52.   } 
  53.   else if ( n < 4322 ) 
  54.   {
  55.     printcmdchr ( 72 , n ) ; 
  56.     printchar ( 61 ) ; 
  57.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  58.     showtokenlist ( mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  59.   } 
  60.   else if ( n < 4578 ) 
  61.   {
  62.     printesc ( 403 ) ; 
  63.     printint ( n - 4322 ) ; 
  64.     printchar ( 61 ) ; 
  65.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  66.     showtokenlist ( mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  67.   } 
  68.   else if ( n < 4834 ) 
  69.   {
  70.     printesc ( 405 ) ; 
  71.     printint ( n - 4578 ) ; 
  72.     printchar ( 61 ) ; 
  73.     if ( eqtb [ n ] .hh .v.RH == 0 ) 
  74.     print ( 406 ) ; 
  75.     else {
  76.     
  77.       depththreshold = 0 ; 
  78.       breadthmax = 1 ; 
  79.       shownodelist ( eqtb [ n ] .hh .v.RH ) ; 
  80.     } 
  81.   } 
  82.   else if ( n < 4883 ) 
  83.   {
  84.     if ( n == 4834 ) 
  85.     print ( 407 ) ; 
  86.     else if ( n < 4851 ) 
  87.     {
  88.       printesc ( 408 ) ; 
  89.       printint ( n - 4835 ) ; 
  90.     } 
  91.     else if ( n < 4867 ) 
  92.     {
  93.       printesc ( 409 ) ; 
  94.       printint ( n - 4851 ) ; 
  95.     } 
  96.     else {
  97.     
  98.       printesc ( 410 ) ; 
  99.       printint ( n - 4867 ) ; 
  100.     } 
  101.     printchar ( 61 ) ; 
  102.     printesc ( hash [ 3524 + eqtb [ n ] .hh .v.RH ] .v.RH ) ; 
  103.   } 
  104.   else if ( n < 5907 ) 
  105.   {
  106.     if ( n < 5139 ) 
  107.     {
  108.       printesc ( 411 ) ; 
  109.       printint ( n - 4883 ) ; 
  110.     } 
  111.     else if ( n < 5395 ) 
  112.     {
  113.       printesc ( 412 ) ; 
  114.       printint ( n - 5139 ) ; 
  115.     } 
  116.     else if ( n < 5651 ) 
  117.     {
  118.       printesc ( 413 ) ; 
  119.       printint ( n - 5395 ) ; 
  120.     } 
  121.     else {
  122.     
  123.       printesc ( 414 ) ; 
  124.       printint ( n - 5651 ) ; 
  125.     } 
  126.     printchar ( 61 ) ; 
  127.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  128.   } 
  129.   else {
  130.       
  131.     printesc ( 415 ) ; 
  132.     printint ( n - 5907 ) ; 
  133.     printchar ( 61 ) ; 
  134.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  135.   } 
  136.   else if ( n < 6730 ) 
  137.   {
  138.     if ( n < 6218 ) 
  139.     printparam ( n - 6163 ) ; 
  140.     else if ( n < 6474 ) 
  141.     {
  142.       printesc ( 472 ) ; 
  143.       printint ( n - 6218 ) ; 
  144.     } 
  145.     else {
  146.     
  147.       printesc ( 473 ) ; 
  148.       printint ( n - 6474 ) ; 
  149.     } 
  150.     printchar ( 61 ) ; 
  151.     printint ( eqtb [ n ] .cint ) ; 
  152.   } 
  153.   else if ( n <= 7006 ) 
  154.   {
  155.     if ( n < 6751 ) 
  156.     printlengthparam ( n - 6730 ) ; 
  157.     else {
  158.     
  159.       printesc ( 496 ) ; 
  160.       printint ( n - 6751 ) ; 
  161.     } 
  162.     printchar ( 61 ) ; 
  163.     printscaled ( eqtb [ n ] .cint ) ; 
  164.     print ( 393 ) ; 
  165.   } 
  166.   else printchar ( 63 ) ; 
  167. } 
  168. #endif /* STAT */
  169. halfword zidlookup ( j , l ) 
  170. integer j ; 
  171. integer l ; 
  172. {/* 40 */ register halfword Result; idlookup_regmem 
  173.   integer h  ; 
  174.   integer d  ; 
  175.   halfword p  ; 
  176.   halfword k  ; 
  177.   h = buffer [ j ] ; 
  178.   {register integer for_end; k = j + 1 ; for_end = j + l - 1 ; if ( k <= 
  179.   for_end) do 
  180.     {
  181.       h = h + h + buffer [ k ] ; 
  182.       while ( h >= 2551 ) h = h - 2551 ; 
  183.     } 
  184.   while ( k++ < for_end ) ; } 
  185.   p = h + 514 ; 
  186.   while ( true ) {
  187.       
  188.     if ( hash [ p ] .v.RH > 0 ) 
  189.     if ( ( strstart [ hash [ p ] .v.RH + 1 ] - strstart [ hash [ p ] .v.RH ] ) 
  190.     == l ) 
  191.     if ( streqbuf ( hash [ p ] .v.RH , j ) ) 
  192.     goto lab40 ; 
  193.     if ( hash [ p ] .v.LH == 0 ) 
  194.     {
  195.       if ( nonewcontrolsequence ) 
  196.       p = 3781 ; 
  197.       else {
  198.       
  199.     if ( hash [ p ] .v.RH > 0 ) 
  200.     {
  201.       do {
  202.           if ( ( hashused == 514 ) ) 
  203.         overflow ( 499 , 3000 ) ; 
  204.         decr ( hashused ) ; 
  205.       } while ( ! ( hash [ hashused ] .v.RH == 0 ) ) ; 
  206.       hash [ p ] .v.LH = hashused ; 
  207.       p = hashused ; 
  208.     } 
  209.     {
  210.       if ( poolptr + l > poolsize ) 
  211.       overflow ( 257 , poolsize - initpoolptr ) ; 
  212.     } 
  213.     d = ( poolptr - strstart [ strptr ] ) ; 
  214.     while ( poolptr > strstart [ strptr ] ) {
  215.         
  216.       decr ( poolptr ) ; 
  217.       strpool [ poolptr + l ] = strpool [ poolptr ] ; 
  218.     } 
  219.     {register integer for_end; k = j ; for_end = j + l - 1 ; if ( k <= 
  220.     for_end) do 
  221.       {
  222.         strpool [ poolptr ] = buffer [ k ] ; 
  223.         incr ( poolptr ) ; 
  224.       } 
  225.     while ( k++ < for_end ) ; } 
  226.     hash [ p ] .v.RH = makestring () ; 
  227.     poolptr = poolptr + d ; 
  228.     ;
  229. #ifdef STAT
  230.     incr ( cscount ) ; 
  231. #endif /* STAT */
  232.       } 
  233.       goto lab40 ; 
  234.     } 
  235.     p = hash [ p ] .v.LH ; 
  236.   } 
  237.   lab40: Result = p ; 
  238.   return(Result) ; 
  239. } 
  240. void znewsavelevel ( c ) 
  241. groupcode c ; 
  242. {newsavelevel_regmem 
  243.   if ( saveptr > maxsavestack ) 
  244.   {
  245.     maxsavestack = saveptr ; 
  246.     if ( maxsavestack > savesize - 6 ) 
  247.     overflow ( 537 , savesize ) ; 
  248.   } 
  249.   savestack [ saveptr ] .hh.b0 = 3 ; 
  250.   savestack [ saveptr ] .hh.b1 = curgroup ; 
  251.   savestack [ saveptr ] .hh .v.RH = curboundary ; 
  252.   if ( curlevel == 255 ) 
  253.   overflow ( 538 , 255 ) ; 
  254.   curboundary = saveptr ; 
  255.   incr ( curlevel ) ; 
  256.   incr ( saveptr ) ; 
  257.   curgroup = c ; 
  258. } 
  259. void zeqdestroy ( w ) 
  260. memoryword w ; 
  261. {eqdestroy_regmem 
  262.   halfword q  ; 
  263.   switch ( w .hh.b0 ) 
  264.   {case 111 : 
  265.   case 112 : 
  266.   case 113 : 
  267.   case 114 : 
  268.     deletetokenref ( w .hh .v.RH ) ; 
  269.     break ; 
  270.   case 117 : 
  271.     deleteglueref ( w .hh .v.RH ) ; 
  272.     break ; 
  273.   case 118 : 
  274.     {
  275.       q = w .hh .v.RH ; 
  276.       if ( q != 0 ) 
  277.       freenode ( q , mem [ q ] .hh .v.LH + mem [ q ] .hh .v.LH + 1 ) ; 
  278.     } 
  279.     break ; 
  280.   case 119 : 
  281.     flushnodelist ( w .hh .v.RH ) ; 
  282.     break ; 
  283.     default: 
  284.     ; 
  285.     break ; 
  286.   } 
  287. } 
  288. void zeqsave ( p , l ) 
  289. halfword p ; 
  290. quarterword l ; 
  291. {eqsave_regmem 
  292.   if ( saveptr > maxsavestack ) 
  293.   {
  294.     maxsavestack = saveptr ; 
  295.     if ( maxsavestack > savesize - 6 ) 
  296.     overflow ( 537 , savesize ) ; 
  297.   } 
  298.   if ( l == 0 ) 
  299.   savestack [ saveptr ] .hh.b0 = 1 ; 
  300.   else {
  301.       
  302.     savestack [ saveptr ] = eqtb [ p ] ; 
  303.     incr ( saveptr ) ; 
  304.     savestack [ saveptr ] .hh.b0 = 0 ; 
  305.   } 
  306.   savestack [ saveptr ] .hh.b1 = l ; 
  307.   savestack [ saveptr ] .hh .v.RH = p ; 
  308.   incr ( saveptr ) ; 
  309. } 
  310. void zeqdefine ( p , t , e ) 
  311. halfword p ; 
  312. quarterword t ; 
  313. halfword e ; 
  314. {eqdefine_regmem 
  315.   if ( eqtb [ p ] .hh.b1 == curlevel ) 
  316.   eqdestroy ( eqtb [ p ] ) ; 
  317.   else if ( curlevel > 1 ) 
  318.   eqsave ( p , eqtb [ p ] .hh.b1 ) ; 
  319.   eqtb [ p ] .hh.b1 = curlevel ; 
  320.   eqtb [ p ] .hh.b0 = t ; 
  321.   eqtb [ p ] .hh .v.RH = e ; 
  322. } 
  323. void zeqworddefine ( p , w ) 
  324. halfword p ; 
  325. integer w ; 
  326. {eqworddefine_regmem 
  327.   if ( xeqlevel [ p ] != curlevel ) 
  328.   {
  329.     eqsave ( p , xeqlevel [ p ] ) ; 
  330.     xeqlevel [ p ] = curlevel ; 
  331.   } 
  332.   eqtb [ p ] .cint = w ; 
  333. } 
  334. void zgeqdefine ( p , t , e ) 
  335. halfword p ; 
  336. quarterword t ; 
  337. halfword e ; 
  338. {geqdefine_regmem 
  339.   eqdestroy ( eqtb [ p ] ) ; 
  340.   eqtb [ p ] .hh.b1 = 1 ; 
  341.   eqtb [ p ] .hh.b0 = t ; 
  342.   eqtb [ p ] .hh .v.RH = e ; 
  343. } 
  344. void zgeqworddefine ( p , w ) 
  345. halfword p ; 
  346. integer w ; 
  347. {geqworddefine_regmem 
  348.   eqtb [ p ] .cint = w ; 
  349.   xeqlevel [ p ] = 1 ; 
  350. } 
  351. void zsaveforafter ( t ) 
  352. halfword t ; 
  353. {saveforafter_regmem 
  354.   if ( curlevel > 1 ) 
  355.   {
  356.     if ( saveptr > maxsavestack ) 
  357.     {
  358.       maxsavestack = saveptr ; 
  359.       if ( maxsavestack > savesize - 6 ) 
  360.       overflow ( 537 , savesize ) ; 
  361.     } 
  362.     savestack [ saveptr ] .hh.b0 = 2 ; 
  363.     savestack [ saveptr ] .hh.b1 = 0 ; 
  364.     savestack [ saveptr ] .hh .v.RH = t ; 
  365.     incr ( saveptr ) ; 
  366.   } 
  367. } 
  368. #ifdef STAT
  369. void zrestoretrace ( p , s ) 
  370. halfword p ; 
  371. strnumber s ; 
  372. {restoretrace_regmem 
  373.   begindiagnostic () ; 
  374.   printchar ( 123 ) ; 
  375.   print ( s ) ; 
  376.   printchar ( 32 ) ; 
  377.   showeqtb ( p ) ; 
  378.   printchar ( 125 ) ; 
  379.   enddiagnostic ( false ) ; 
  380. } 
  381. #endif /* STAT */
  382. void unsave ( ) 
  383. {/* 30 */ unsave_regmem 
  384.   halfword p  ; 
  385.   quarterword l  ; 
  386.   halfword t  ; 
  387.   if ( curlevel > 1 ) 
  388.   {
  389.     decr ( curlevel ) ; 
  390.     while ( true ) {
  391.     
  392.       decr ( saveptr ) ; 
  393.       if ( savestack [ saveptr ] .hh.b0 == 3 ) 
  394.       goto lab30 ; 
  395.       p = savestack [ saveptr ] .hh .v.RH ; 
  396.       if ( savestack [ saveptr ] .hh.b0 == 2 ) 
  397.       {
  398.     t = curtok ; 
  399.     curtok = p ; 
  400.     backinput () ; 
  401.     curtok = t ; 
  402.       } 
  403.       else {
  404.       
  405.     if ( savestack [ saveptr ] .hh.b0 == 0 ) 
  406.     {
  407.       l = savestack [ saveptr ] .hh.b1 ; 
  408.       decr ( saveptr ) ; 
  409.     } 
  410.     else savestack [ saveptr ] = eqtb [ 3781 ] ; 
  411.     if ( p < 6163 ) 
  412.     if ( eqtb [ p ] .hh.b1 == 1 ) 
  413.     {
  414.       eqdestroy ( savestack [ saveptr ] ) ; 
  415.     ;
  416. #ifdef STAT
  417.       if ( eqtb [ 6200 ] .cint > 0 ) 
  418.       restoretrace ( p , 540 ) ; 
  419. #endif /* STAT */
  420.     } 
  421.     else {
  422.         
  423.       eqdestroy ( eqtb [ p ] ) ; 
  424.       eqtb [ p ] = savestack [ saveptr ] ; 
  425.     ;
  426. #ifdef STAT
  427.       if ( eqtb [ 6200 ] .cint > 0 ) 
  428.       restoretrace ( p , 541 ) ; 
  429. #endif /* STAT */
  430.     } 
  431.     else if ( xeqlevel [ p ] != 1 ) 
  432.     {
  433.       eqtb [ p ] = savestack [ saveptr ] ; 
  434.       xeqlevel [ p ] = l ; 
  435.     ;
  436. #ifdef STAT
  437.       if ( eqtb [ 6200 ] .cint > 0 ) 
  438.       restoretrace ( p , 541 ) ; 
  439. #endif /* STAT */
  440.     } 
  441.     else {
  442.         
  443.     ;
  444. #ifdef STAT
  445.       if ( eqtb [ 6200 ] .cint > 0 ) 
  446.       restoretrace ( p , 540 ) ; 
  447. #endif /* STAT */
  448.     } 
  449.       } 
  450.     } 
  451.     lab30: curgroup = savestack [ saveptr ] .hh.b1 ; 
  452.     curboundary = savestack [ saveptr ] .hh .v.RH ; 
  453.   } 
  454.   else confusion ( 539 ) ; 
  455. } 
  456. void preparemag ( ) 
  457. {preparemag_regmem 
  458.   if ( ( magset > 0 ) && ( eqtb [ 6180 ] .cint != magset ) ) 
  459.   {
  460.     {
  461.       if ( interaction == 3 ) 
  462.       wakeupterminal () ; 
  463.       printnl ( 262 ) ; 
  464.       print ( 543 ) ; 
  465.     } 
  466.     printint ( eqtb [ 6180 ] .cint ) ; 
  467.     print ( 544 ) ; 
  468.     printnl ( 545 ) ; 
  469.     {
  470.       helpptr = 2 ; 
  471.       helpline [ 1 ] = 546 ; 
  472.       helpline [ 0 ] = 547 ; 
  473.     } 
  474.     interror ( magset ) ; 
  475.     geqworddefine ( 6180 , magset ) ; 
  476.   } 
  477.   if ( ( eqtb [ 6180 ] .cint <= 0 ) || ( eqtb [ 6180 ] .cint > 32768L ) ) 
  478.   {
  479.     {
  480.       if ( interaction == 3 ) 
  481.       wakeupterminal () ; 
  482.       printnl ( 262 ) ; 
  483.       print ( 548 ) ; 
  484.     } 
  485.     {
  486.       helpptr = 1 ; 
  487.       helpline [ 0 ] = 549 ; 
  488.     } 
  489.     interror ( eqtb [ 6180 ] .cint ) ; 
  490.     geqworddefine ( 6180 , 1000 ) ; 
  491.   } 
  492.   magset = eqtb [ 6180 ] .cint ; 
  493. } 
  494. void ztokenshow ( p ) 
  495. halfword p ; 
  496. {tokenshow_regmem 
  497.   if ( p != 0 ) 
  498.   showtokenlist ( mem [ p ] .hh .v.RH , 0 , 10000000L ) ; 
  499. } 
  500. void printmeaning ( ) 
  501. {printmeaning_regmem 
  502.   printcmdchr ( curcmd , curchr ) ; 
  503.   if ( curcmd >= 111 ) 
  504.   {
  505.     printchar ( 58 ) ; 
  506.     println () ; 
  507.     tokenshow ( curchr ) ; 
  508.   } 
  509.   else if ( curcmd == 110 ) 
  510.   {
  511.     printchar ( 58 ) ; 
  512.     println () ; 
  513.     tokenshow ( curmark [ curchr ] ) ; 
  514.   } 
  515. } 
  516. void showcurcmdchr ( ) 
  517. {showcurcmdchr_regmem 
  518.   begindiagnostic () ; 
  519.   printnl ( 123 ) ; 
  520.   if ( curlist .modefield != shownmode ) 
  521.   {
  522.     printmode ( curlist .modefield ) ; 
  523.     print ( 564 ) ; 
  524.     shownmode = curlist .modefield ; 
  525.   } 
  526.   printcmdchr ( curcmd , curchr ) ; 
  527.   printchar ( 125 ) ; 
  528.   enddiagnostic ( false ) ; 
  529. } 
  530. void showcontext ( ) 
  531. {/* 30 */ showcontext_regmem 
  532.   schar oldsetting  ; 
  533.   integer nn  ; 
  534.   boolean bottomline  ; 
  535.   integer i  ; 
  536.   integer j  ; 
  537.   integer l  ; 
  538.   integer m  ; 
  539.   integer n  ; 
  540.   integer p  ; 
  541.   integer q  ; 
  542.   baseptr = inputptr ; 
  543.   inputstack [ baseptr ] = curinput ; 
  544.   nn = -1 ; 
  545.   bottomline = false ; 
  546.   while ( true ) {
  547.       
  548.     curinput = inputstack [ baseptr ] ; 
  549.     if ( ( curinput .statefield != 0 ) ) 
  550.     if ( ( curinput .namefield > 17 ) || ( baseptr == 0 ) ) 
  551.     bottomline = true ; 
  552.     if ( ( baseptr == inputptr ) || bottomline || ( nn < eqtb [ 6217 ] .cint ) 
  553.     ) 
  554.     {
  555.       if ( ( baseptr == inputptr ) || ( curinput .statefield != 0 ) || ( 
  556.       curinput .indexfield != 3 ) || ( curinput .locfield != 0 ) ) 
  557.       {
  558.     tally = 0 ; 
  559.     oldsetting = selector ; 
  560.     if ( curinput .statefield != 0 ) 
  561.     {
  562.       if ( curinput .namefield <= 17 ) 
  563.       if ( ( curinput .namefield == 0 ) ) 
  564.       if ( baseptr == 0 ) 
  565.       printnl ( 570 ) ; 
  566.       else printnl ( 571 ) ; 
  567.       else {
  568.           
  569.         printnl ( 572 ) ; 
  570.         if ( curinput .namefield == 17 ) 
  571.         printchar ( 42 ) ; 
  572.         else printint ( curinput .namefield - 1 ) ; 
  573.         printchar ( 62 ) ; 
  574.       } 
  575.       else {
  576.           
  577.         printnl ( 573 ) ; 
  578.         printint ( line ) ; 
  579.       } 
  580.       printchar ( 32 ) ; 
  581.       {
  582.         l = tally ; 
  583.         tally = 0 ; 
  584.         selector = 20 ; 
  585.         trickcount = 1000000L ; 
  586.       } 
  587.       if ( buffer [ curinput .limitfield ] == eqtb [ 6211 ] .cint ) 
  588.       j = curinput .limitfield ; 
  589.       else j = curinput .limitfield + 1 ; 
  590.       if ( j > 0 ) 
  591.       {register integer for_end; i = curinput .startfield ; for_end = j - 
  592.       1 ; if ( i <= for_end) do 
  593.         {
  594.           if ( i == curinput .locfield ) 
  595.           {
  596.         firstcount = tally ; 
  597.         trickcount = tally + 1 + errorline - halferrorline ; 
  598.         if ( trickcount < errorline ) 
  599.         trickcount = errorline ; 
  600.           } 
  601.           print ( buffer [ i ] ) ; 
  602.         } 
  603.       while ( i++ < for_end ) ; } 
  604.     } 
  605.     else {
  606.         
  607.       switch ( curinput .indexfield ) 
  608.       {case 0 : 
  609.         printnl ( 574 ) ; 
  610.         break ; 
  611.       case 1 : 
  612.       case 2 : 
  613.         printnl ( 575 ) ; 
  614.         break ; 
  615.       case 3 : 
  616.         if ( curinput .locfield == 0 ) 
  617.         printnl ( 576 ) ; 
  618.         else printnl ( 577 ) ; 
  619.         break ; 
  620.       case 4 : 
  621.         printnl ( 578 ) ; 
  622.         break ; 
  623.       case 5 : 
  624.         {
  625.           println () ; 
  626.           printcs ( curinput .namefield ) ; 
  627.         } 
  628.         break ; 
  629.       case 6 : 
  630.         printnl ( 579 ) ; 
  631.         break ; 
  632.       case 7 : 
  633.         printnl ( 580 ) ; 
  634.         break ; 
  635.       case 8 : 
  636.         printnl ( 581 ) ; 
  637.         break ; 
  638.       case 9 : 
  639.         printnl ( 582 ) ; 
  640.         break ; 
  641.       case 10 : 
  642.         printnl ( 583 ) ; 
  643.         break ; 
  644.       case 11 : 
  645.         printnl ( 584 ) ; 
  646.         break ; 
  647.       case 12 : 
  648.         printnl ( 585 ) ; 
  649.         break ; 
  650.       case 13 : 
  651.         printnl ( 586 ) ; 
  652.         break ; 
  653.       case 14 : 
  654.         printnl ( 587 ) ; 
  655.         break ; 
  656.       case 15 : 
  657.         printnl ( 588 ) ; 
  658.         break ; 
  659.         default: 
  660.         printnl ( 63 ) ; 
  661.         break ; 
  662.       } 
  663.       {
  664.         l = tally ; 
  665.         tally = 0 ; 
  666.         selector = 20 ; 
  667.         trickcount = 1000000L ; 
  668.       } 
  669.       if ( curinput .indexfield < 5 ) 
  670.       showtokenlist ( curinput .startfield , curinput .locfield , 100000L 
  671.       ) ; 
  672.       else showtokenlist ( mem [ curinput .startfield ] .hh .v.RH , 
  673.       curinput .locfield , 100000L ) ; 
  674.     } 
  675.     selector = oldsetting ; 
  676.     if ( trickcount == 1000000L ) 
  677.     {
  678.       firstcount = tally ; 
  679.       trickcount = tally + 1 + errorline - halferrorline ; 
  680.       if ( trickcount < errorline ) 
  681.       trickcount = errorline ; 
  682.     } 
  683.     if ( tally < trickcount ) 
  684.     m = tally - firstcount ; 
  685.     else m = trickcount - firstcount ; 
  686.     if ( l + firstcount <= halferrorline ) 
  687.     {
  688.       p = 0 ; 
  689.       n = l + firstcount ; 
  690.     } 
  691.     else {
  692.         
  693.       print ( 275 ) ; 
  694.       p = l + firstcount - halferrorline + 3 ; 
  695.       n = halferrorline ; 
  696.     } 
  697.     {register integer for_end; q = p ; for_end = firstcount - 1 ; if ( q 
  698.     <= for_end) do 
  699.       printchar ( trickbuf [ q % errorline ] ) ; 
  700.     while ( q++ < for_end ) ; } 
  701.     println () ; 
  702.     {register integer for_end; q = 1 ; for_end = n ; if ( q <= for_end) 
  703.     do 
  704.       printchar ( 32 ) ; 
  705.     while ( q++ < for_end ) ; } 
  706.     if ( m + n <= errorline ) 
  707.     p = firstcount + m ; 
  708.     else p = firstcount + ( errorline - n - 3 ) ; 
  709.     {register integer for_end; q = firstcount ; for_end = p - 1 ; if ( q 
  710.     <= for_end) do 
  711.       printchar ( trickbuf [ q % errorline ] ) ; 
  712.     while ( q++ < for_end ) ; } 
  713.     if ( m + n > errorline ) 
  714.     print ( 275 ) ; 
  715.     incr ( nn ) ; 
  716.       } 
  717.     } 
  718.     else if ( nn == eqtb [ 6217 ] .cint ) 
  719.     {
  720.       printnl ( 275 ) ; 
  721.       incr ( nn ) ; 
  722.     } 
  723.     if ( bottomline ) 
  724.     goto lab30 ; 
  725.     decr ( baseptr ) ; 
  726.   } 
  727.   lab30: curinput = inputstack [ inputptr ] ; 
  728. } 
  729. void zbegintokenlist ( p , t ) 
  730. halfword p ; 
  731. quarterword t ; 
  732. {begintokenlist_regmem 
  733.   {
  734.     if ( inputptr > maxinstack ) 
  735.     {
  736.       maxinstack = inputptr ; 
  737.       if ( inputptr == stacksize ) 
  738.       overflow ( 589 , stacksize ) ; 
  739.     } 
  740.     inputstack [ inputptr ] = curinput ; 
  741.     incr ( inputptr ) ; 
  742.   } 
  743.   curinput .statefield = 0 ; 
  744.   curinput .startfield = p ; 
  745.   curinput .indexfield = t ; 
  746.   if ( t >= 5 ) 
  747.   {
  748.     incr ( mem [ p ] .hh .v.LH ) ; 
  749.     if ( t == 5 ) 
  750.     curinput .limitfield = paramptr ; 
  751.     else {
  752.     
  753.       curinput .locfield = mem [ p ] .hh .v.RH ; 
  754.       if ( eqtb [ 6193 ] .cint > 1 ) 
  755.       {
  756.     begindiagnostic () ; 
  757.     printnl ( 335 ) ; 
  758.     switch ( t ) 
  759.     {case 14 : 
  760.       printesc ( 348 ) ; 
  761.       break ; 
  762.     case 15 : 
  763.       printesc ( 590 ) ; 
  764.       break ; 
  765.       default: 
  766.       printcmdchr ( 72 , t + 4307 ) ; 
  767.       break ; 
  768.     } 
  769.     print ( 552 ) ; 
  770.     tokenshow ( p ) ; 
  771.     enddiagnostic ( false ) ; 
  772.       } 
  773.     } 
  774.   } 
  775.   else curinput .locfield = p ; 
  776. } 
  777. void endtokenlist ( ) 
  778. {endtokenlist_regmem 
  779.   if ( curinput .indexfield >= 3 ) 
  780.   {
  781.     if ( curinput .indexfield <= 4 ) 
  782.     flushlist ( curinput .startfield ) ; 
  783.     else {
  784.     
  785.       deletetokenref ( curinput .startfield ) ; 
  786.       if ( curinput .indexfield == 5 ) 
  787.       while ( paramptr > curinput .limitfield ) {
  788.       
  789.     decr ( paramptr ) ; 
  790.     flushlist ( paramstack [ paramptr ] ) ; 
  791.       } 
  792.     } 
  793.   } 
  794.   else if ( curinput .indexfield == 1 ) 
  795.   if ( alignstate > 500000L ) 
  796.   alignstate = 0 ; 
  797.   else fatalerror ( 591 ) ; 
  798.   {
  799.     decr ( inputptr ) ; 
  800.     curinput = inputstack [ inputptr ] ; 
  801.   } 
  802.   {
  803.     if ( interrupt != 0 ) 
  804.     pauseforinstructions () ; 
  805.   } 
  806. } 
  807. void backinput ( ) 
  808. {backinput_regmem 
  809.   halfword p  ; 
  810.   while ( ( curinput .statefield == 0 ) && ( curinput .locfield == 0 ) ) 
  811.   endtokenlist () ; 
  812.   p = getavail () ; 
  813.   mem [ p ] .hh .v.LH = curtok ; 
  814.   if ( curtok < 768 ) 
  815.   if ( curtok < 512 ) 
  816.   decr ( alignstate ) ; 
  817.   else incr ( alignstate ) ; 
  818.   {
  819.     if ( inputptr > maxinstack ) 
  820.     {
  821.       maxinstack = inputptr ; 
  822.       if ( inputptr == stacksize ) 
  823.       overflow ( 589 , stacksize ) ; 
  824.     } 
  825.     inputstack [ inputptr ] = curinput ; 
  826.     incr ( inputptr ) ; 
  827.   } 
  828.   curinput .statefield = 0 ; 
  829.   curinput .startfield = p ; 
  830.   curinput .indexfield = 3 ; 
  831.   curinput .locfield = p ; 
  832. } 
  833. void backerror ( ) 
  834. {backerror_regmem 
  835.   OKtointerrupt = false ; 
  836.   backinput () ; 
  837.   OKtointerrupt = true ; 
  838.   error () ; 
  839. } 
  840. void inserror ( ) 
  841. {inserror_regmem 
  842.   OKtointerrupt = false ; 
  843.   backinput () ; 
  844.   curinput .indexfield = 4 ; 
  845.   OKtointerrupt = true ; 
  846.   error () ; 
  847. } 
  848. void beginfilereading ( ) 
  849. {beginfilereading_regmem 
  850.   if ( inopen == maxinopen ) 
  851.   overflow ( 592 , maxinopen ) ; 
  852.   if ( first == bufsize ) 
  853.   overflow ( 256 , bufsize ) ; 
  854.   incr ( inopen ) ; 
  855.   {
  856.     if ( inputptr > maxinstack ) 
  857.     {
  858.       maxinstack = inputptr ; 
  859.       if ( inputptr == stacksize ) 
  860.       overflow ( 589 , stacksize ) ; 
  861.     } 
  862.     inputstack [ inputptr ] = curinput ; 
  863.     incr ( inputptr ) ; 
  864.   } 
  865.   curinput .indexfield = inopen ; 
  866.   linestack [ curinput .indexfield ] = line ; 
  867.   curinput .startfield = first ; 
  868.   curinput .statefield = 1 ; 
  869.   curinput .namefield = 0 ; 
  870. } 
  871. void endfilereading ( ) 
  872. {endfilereading_regmem 
  873.   first = curinput .startfield ; 
  874.   line = linestack [ curinput .indexfield ] ; 
  875.   if ( curinput .namefield > 17 ) 
  876.   aclose ( inputfile [ curinput .indexfield ] ) ; 
  877.   {
  878.     decr ( inputptr ) ; 
  879.     curinput = inputstack [ inputptr ] ; 
  880.   } 
  881.   decr ( inopen ) ; 
  882. } 
  883. void clearforerrorprompt ( ) 
  884. {clearforerrorprompt_regmem 
  885.   while ( ( curinput .statefield != 0 ) && ( curinput .namefield == 0 ) && ( 
  886.   inputptr > 0 ) && ( curinput .locfield > curinput .limitfield ) ) 
  887.   endfilereading () ; 
  888.   println () ; 
  889.   clearterminal () ; 
  890. } 
  891. void checkoutervalidity ( ) 
  892. {checkoutervalidity_regmem 
  893.   halfword p  ; 
  894.   halfword q  ; 
  895.   if ( scannerstatus != 0 ) 
  896.   {
  897.     deletionsallowed = false ; 
  898.     if ( curcs != 0 ) 
  899.     {
  900.       if ( ( curinput .statefield == 0 ) || ( curinput .namefield < 1 ) || ( 
  901.       curinput .namefield > 17 ) ) 
  902.       {
  903.     p = getavail () ; 
  904.     mem [ p ] .hh .v.LH = 4095 + curcs ; 
  905.     begintokenlist ( p , 3 ) ; 
  906.       } 
  907.       curcmd = 10 ; 
  908.       curchr = 32 ; 
  909.     } 
  910.     if ( scannerstatus > 1 ) 
  911.     {
  912.       runaway () ; 
  913.       if ( curcs == 0 ) 
  914.       {
  915.     if ( interaction == 3 ) 
  916.     wakeupterminal () ; 
  917.     printnl ( 262 ) ; 
  918.     print ( 600 ) ; 
  919.       } 
  920.       else {
  921.       
  922.     curcs = 0 ; 
  923.     {
  924.       if ( interaction == 3 ) 
  925.       wakeupterminal () ; 
  926.       printnl ( 262 ) ; 
  927.       print ( 601 ) ; 
  928.     } 
  929.       } 
  930.       print ( 602 ) ; 
  931.       p = getavail () ; 
  932.       switch ( scannerstatus ) 
  933.       {case 2 : 
  934.     {
  935.       print ( 566 ) ; 
  936.       mem [ p ] .hh .v.LH = 637 ; 
  937.     } 
  938.     break ; 
  939.       case 3 : 
  940.     {
  941.       print ( 608 ) ; 
  942.       mem [ p ] .hh .v.LH = partoken ; 
  943.       longstate = 113 ; 
  944.     } 
  945.     break ; 
  946.       case 4 : 
  947.     {
  948.       print ( 568 ) ; 
  949.       mem [ p ] .hh .v.LH = 637 ; 
  950.       q = p ; 
  951.       p = getavail () ; 
  952.       mem [ p ] .hh .v.RH = q ; 
  953.       mem [ p ] .hh .v.LH = 7610 ; 
  954.       alignstate = -1000000L ; 
  955.     } 
  956.     break ; 
  957.       case 5 : 
  958.     {
  959.       print ( 569 ) ; 
  960.       mem [ p ] .hh .v.LH = 637 ; 
  961.     } 
  962.     break ; 
  963.       } 
  964.       begintokenlist ( p , 4 ) ; 
  965.       print ( 603 ) ; 
  966.       sprintcs ( warningindex ) ; 
  967.       {
  968.     helpptr = 4 ; 
  969.     helpline [ 3 ] = 604 ; 
  970.     helpline [ 2 ] = 605 ; 
  971.     helpline [ 1 ] = 606 ; 
  972.     helpline [ 0 ] = 607 ; 
  973.       } 
  974.       error () ; 
  975.     } 
  976.     else {
  977.     
  978.       {
  979.     if ( interaction == 3 ) 
  980.     wakeupterminal () ; 
  981.     printnl ( 262 ) ; 
  982.     print ( 594 ) ; 
  983.       } 
  984.       printcmdchr ( 105 , curif ) ; 
  985.       print ( 595 ) ; 
  986.       printint ( skipline ) ; 
  987.       {
  988.     helpptr = 3 ; 
  989.     helpline [ 2 ] = 596 ; 
  990.     helpline [ 1 ] = 597 ; 
  991.     helpline [ 0 ] = 598 ; 
  992.       } 
  993.       if ( curcs != 0 ) 
  994.       curcs = 0 ; 
  995.       else helpline [ 2 ] = 599 ; 
  996.       curtok = 7613 ; 
  997.       inserror () ; 
  998.     } 
  999.     deletionsallowed = true ; 
  1000.   } 
  1001. } 
  1002. void getnext ( ) 
  1003. {/* 20 25 21 26 40 10 */ getnext_regmem 
  1004.   integer k  ; 
  1005.   halfword t  ; 
  1006.   schar cat  ; 
  1007.   ASCIIcode c, cc  ; 
  1008.   schar d  ; 
  1009.   lab20: curcs = 0 ; 
  1010.   if ( curinput .statefield != 0 ) 
  1011.   {
  1012.     lab25: if ( curinput .locfield <= curinput .limitfield ) 
  1013.     {
  1014.       curchr = buffer [ curinput .locfield ] ; 
  1015.       incr ( curinput .locfield ) ; 
  1016.       lab21: curcmd = eqtb [ 4883 + curchr ] .hh .v.RH ; 
  1017.       switch ( curinput .statefield + curcmd ) 
  1018.       {case 10 : 
  1019.       case 26 : 
  1020.       case 42 : 
  1021.       case 27 : 
  1022.       case 43 : 
  1023.     goto lab25 ; 
  1024.     break ; 
  1025.       case 1 : 
  1026.       case 17 : 
  1027.       case 33 : 
  1028.     {
  1029.       if ( curinput .locfield > curinput .limitfield ) 
  1030.       curcs = 513 ; 
  1031.       else {
  1032.           
  1033.         lab26: k = curinput .locfield ; 
  1034.         curchr = buffer [ k ] ; 
  1035.         cat = eqtb [ 4883 + curchr ] .hh .v.RH ; 
  1036.         incr ( k ) ; 
  1037.         if ( cat == 11 ) 
  1038.         curinput .statefield = 17 ; 
  1039.         else if ( cat == 10 ) 
  1040.         curinput .statefield = 17 ; 
  1041.         else curinput .statefield = 1 ; 
  1042.         if ( ( cat == 11 ) && ( k <= curinput .limitfield ) ) 
  1043.         {
  1044.           do {
  1045.           curchr = buffer [ k ] ; 
  1046.         cat = eqtb [ 4883 + curchr ] .hh .v.RH ; 
  1047.         incr ( k ) ; 
  1048.           } while ( ! ( ( cat != 11 ) || ( k > curinput .limitfield ) ) ) 
  1049.           ; 
  1050.           {
  1051.         if ( buffer [ k ] == curchr ) 
  1052.         if ( cat == 7 ) 
  1053.         if ( k < curinput .limitfield ) 
  1054.         {
  1055.           c = buffer [ k + 1 ] ; 
  1056.           if ( c < 128 ) 
  1057.           {
  1058.             d = 2 ; 
  1059.             if ( ( ( ( c >= 48 ) && ( c <= 57 ) ) || ( ( c >= 97 ) && 
  1060.             ( c <= 102 ) ) ) ) 
  1061.             if ( k + 2 <= curinput .limitfield ) 
  1062.             {
  1063.               cc = buffer [ k + 2 ] ; 
  1064.               if ( ( ( ( cc >= 48 ) && ( cc <= 57 ) ) || ( ( cc >= 97 
  1065.               ) && ( cc <= 102 ) ) ) ) 
  1066.               incr ( d ) ; 
  1067.             } 
  1068.             if ( d > 2 ) 
  1069.             {
  1070.               if ( c <= 57 ) 
  1071.               curchr = c - 48 ; 
  1072.               else curchr = c - 87 ; 
  1073.               if ( cc <= 57 ) 
  1074.               curchr = 16 * curchr + cc - 48 ; 
  1075.               else curchr = 16 * curchr + cc - 87 ; 
  1076.               buffer [ k - 1 ] = curchr ; 
  1077.             } 
  1078.             else if ( c < 64 ) 
  1079.             buffer [ k - 1 ] = c + 64 ; 
  1080.             else buffer [ k - 1 ] = c - 64 ; 
  1081.             curinput .limitfield = curinput .limitfield - d ; 
  1082.             first = first - d ; 
  1083.             while ( k <= curinput .limitfield ) {
  1084.             
  1085.               buffer [ k ] = buffer [ k + d ] ; 
  1086.               incr ( k ) ; 
  1087.             } 
  1088.             goto lab26 ; 
  1089.           } 
  1090.         } 
  1091.           } 
  1092.           if ( cat != 11 ) 
  1093.           decr ( k ) ; 
  1094.           if ( k > curinput .locfield + 1 ) 
  1095.           {
  1096.         curcs = idlookup ( curinput .locfield , k - curinput .locfield 
  1097.         ) ; 
  1098.         curinput .locfield = k ; 
  1099.         goto lab40 ; 
  1100.           } 
  1101.         } 
  1102.         else {
  1103.         
  1104.           if ( buffer [ k ] == curchr ) 
  1105.           if ( cat == 7 ) 
  1106.           if ( k < curinput .limitfield ) 
  1107.           {
  1108.         c = buffer [ k + 1 ] ; 
  1109.         if ( c < 128 ) 
  1110.         {
  1111.           d = 2 ; 
  1112.           if ( ( ( ( c >= 48 ) && ( c <= 57 ) ) || ( ( c >= 97 ) && ( 
  1113.           c <= 102 ) ) ) ) 
  1114.           if ( k + 2 <= curinput .limitfield ) 
  1115.           {
  1116.             cc = buffer [ k + 2 ] ; 
  1117.             if ( ( ( ( cc >= 48 ) && ( cc <= 57 ) ) || ( ( cc >= 97 ) 
  1118.             && ( cc <= 102 ) ) ) ) 
  1119.             incr ( d ) ; 
  1120.           } 
  1121.           if ( d > 2 ) 
  1122.           {
  1123.             if ( c <= 57 ) 
  1124.             curchr = c - 48 ; 
  1125.             else curchr = c - 87 ; 
  1126.             if ( cc <= 57 ) 
  1127.             curchr = 16 * curchr + cc - 48 ; 
  1128.             else curchr = 16 * curchr + cc - 87 ; 
  1129.             buffer [ k - 1 ] = curchr ; 
  1130.           } 
  1131.           else if ( c < 64 ) 
  1132.           buffer [ k - 1 ] = c + 64 ; 
  1133.           else buffer [ k - 1 ] = c - 64 ; 
  1134.           curinput .limitfield = curinput .limitfield - d ; 
  1135.           first = first - d ; 
  1136.           while ( k <= curinput .limitfield ) {
  1137.               
  1138.             buffer [ k ] = buffer [ k + d ] ; 
  1139.             incr ( k ) ; 
  1140.           } 
  1141.           goto lab26 ; 
  1142.         } 
  1143.           } 
  1144.         } 
  1145.         curcs = 257 + buffer [ curinput .locfield ] ; 
  1146.         incr ( curinput .locfield ) ; 
  1147.       } 
  1148.       lab40: curcmd = eqtb [ curcs ] .hh.b0 ; 
  1149.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1150.       if ( curcmd >= 113 ) 
  1151.       checkoutervalidity () ; 
  1152.     } 
  1153.     break ; 
  1154.       case 14 : 
  1155.       case 30 : 
  1156.       case 46 : 
  1157.     {
  1158.       curcs = curchr + 1 ; 
  1159.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  1160.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1161.       curinput .statefield = 1 ; 
  1162.       if ( curcmd >= 113 ) 
  1163.       checkoutervalidity () ; 
  1164.     } 
  1165.     break ; 
  1166.       case 8 : 
  1167.       case 24 : 
  1168.       case 40 : 
  1169.     {
  1170.       if ( curchr == buffer [ curinput .locfield ] ) 
  1171.       if ( curinput .locfield < curinput .limitfield ) 
  1172.       {
  1173.         c = buffer [ curinput .locfield + 1 ] ; 
  1174.         if ( c < 128 ) 
  1175.         {
  1176.           curinput .locfield = curinput .locfield + 2 ; 
  1177.           if ( ( ( ( c >= 48 ) && ( c <= 57 ) ) || ( ( c >= 97 ) && ( c <= 
  1178.           102 ) ) ) ) 
  1179.           if ( curinput .locfield <= curinput .limitfield ) 
  1180.           {
  1181.         cc = buffer [ curinput .locfield ] ; 
  1182.         if ( ( ( ( cc >= 48 ) && ( cc <= 57 ) ) || ( ( cc >= 97 ) && ( 
  1183.         cc <= 102 ) ) ) ) 
  1184.         {
  1185.           incr ( curinput .locfield ) ; 
  1186.           if ( c <= 57 ) 
  1187.           curchr = c - 48 ; 
  1188.           else curchr = c - 87 ; 
  1189.           if ( cc <= 57 ) 
  1190.           curchr = 16 * curchr + cc - 48 ; 
  1191.           else curchr = 16 * curchr + cc - 87 ; 
  1192.           goto lab21 ; 
  1193.         } 
  1194.           } 
  1195.           if ( c < 64 ) 
  1196.           curchr = c + 64 ; 
  1197.           else curchr = c - 64 ; 
  1198.           goto lab21 ; 
  1199.         } 
  1200.       } 
  1201.       curinput .statefield = 1 ; 
  1202.     } 
  1203.     break ; 
  1204.       case 16 : 
  1205.       case 32 : 
  1206.       case 48 : 
  1207.     {
  1208.       {
  1209.         if ( interaction == 3 ) 
  1210.         wakeupterminal () ; 
  1211.         printnl ( 262 ) ; 
  1212.         print ( 609 ) ; 
  1213.       } 
  1214.       {
  1215.         helpptr = 2 ; 
  1216.         helpline [ 1 ] = 610 ; 
  1217.         helpline [ 0 ] = 611 ; 
  1218.       } 
  1219.       deletionsallowed = false ; 
  1220.       error () ; 
  1221.       deletionsallowed = true ; 
  1222.       goto lab20 ; 
  1223.     } 
  1224.     break ; 
  1225.       case 11 : 
  1226.     {
  1227.       curinput .statefield = 17 ; 
  1228.       curchr = 32 ; 
  1229.     } 
  1230.     break ; 
  1231.       case 6 : 
  1232.     {
  1233.       curinput .locfield = curinput .limitfield + 1 ; 
  1234.       curcmd = 10 ; 
  1235.       curchr = 32 ; 
  1236.     } 
  1237.     break ; 
  1238.       case 22 : 
  1239.       case 15 : 
  1240.       case 31 : 
  1241.       case 47 : 
  1242.     {
  1243.       curinput .locfield = curinput .limitfield + 1 ; 
  1244.       goto lab25 ; 
  1245.     } 
  1246.     break ; 
  1247.       case 38 : 
  1248.     {
  1249.       curinput .locfield = curinput .limitfield + 1 ; 
  1250.       curcs = parloc ; 
  1251.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  1252.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1253.       if ( curcmd >= 113 ) 
  1254.       checkoutervalidity () ; 
  1255.     } 
  1256.     break ; 
  1257.       case 2 : 
  1258.     incr ( alignstate ) ; 
  1259.     break ; 
  1260.       case 18 : 
  1261.       case 34 : 
  1262.     {
  1263.       curinput .statefield = 1 ; 
  1264.       incr ( alignstate ) ; 
  1265.     } 
  1266.     break ; 
  1267.       case 3 : 
  1268.     decr ( alignstate ) ; 
  1269.     break ; 
  1270.       case 19 : 
  1271.       case 35 : 
  1272.     {
  1273.       curinput .statefield = 1 ; 
  1274.       decr ( alignstate ) ; 
  1275.     } 
  1276.     break ; 
  1277.       case 20 : 
  1278.       case 21 : 
  1279.       case 23 : 
  1280.       case 25 : 
  1281.       case 28 : 
  1282.       case 29 : 
  1283.       case 36 : 
  1284.       case 37 : 
  1285.       case 39 : 
  1286.       case 41 : 
  1287.       case 44 : 
  1288.       case 45 : 
  1289.     curinput .statefield = 1 ; 
  1290.     break ; 
  1291.     default: 
  1292.     ; 
  1293.     break ; 
  1294.       } 
  1295.     } 
  1296.     else {
  1297.     
  1298.       curinput .statefield = 33 ; 
  1299.       if ( curinput .namefield > 17 ) 
  1300.       {
  1301.     incr ( line ) ; 
  1302.     first = curinput .startfield ; 
  1303.     if ( ! forceeof ) 
  1304.     {
  1305.       if ( inputln ( inputfile [ curinput .indexfield ] , true ) ) 
  1306.       firmuptheline () ; 
  1307.       else forceeof = true ; 
  1308.     } 
  1309.     if ( forceeof ) 
  1310.     {
  1311.       printchar ( 41 ) ; 
  1312.       decr ( openparens ) ; 
  1313.       flush ( stdout ) ; 
  1314.       forceeof = false ; 
  1315.       endfilereading () ; 
  1316.       checkoutervalidity () ; 
  1317.       goto lab20 ; 
  1318.     } 
  1319.     if ( ( eqtb [ 6211 ] .cint < 0 ) || ( eqtb [ 6211 ] .cint > 255 ) ) 
  1320.     decr ( curinput .limitfield ) ; 
  1321.     else buffer [ curinput .limitfield ] = eqtb [ 6211 ] .cint ; 
  1322.     first = curinput .limitfield + 1 ; 
  1323.     curinput .locfield = curinput .startfield ; 
  1324.       } 
  1325.       else {
  1326.       
  1327.     if ( ! ( curinput .namefield == 0 ) ) 
  1328.     {
  1329.       curcmd = 0 ; 
  1330.       curchr = 0 ; 
  1331.       return ; 
  1332.     } 
  1333.     if ( inputptr > 0 ) 
  1334.     {
  1335.       endfilereading () ; 
  1336.       goto lab20 ; 
  1337.     } 
  1338.     if ( selector < 18 ) 
  1339.     openlogfile () ; 
  1340.     if ( interaction > 1 ) 
  1341.     {
  1342.       if ( ( eqtb [ 6211 ] .cint < 0 ) || ( eqtb [ 6211 ] .cint > 255 ) ) 
  1343.       incr ( curinput .limitfield ) ; 
  1344.       if ( curinput .limitfield == curinput .startfield ) 
  1345.       printnl ( 612 ) ; 
  1346.       println () ; 
  1347.       first = curinput .startfield ; 
  1348.       {
  1349.         wakeupterminal () ; 
  1350.         print ( 42 ) ; 
  1351.         terminput () ; 
  1352.       } 
  1353.       curinput .limitfield = last ; 
  1354.       if ( ( eqtb [ 6211 ] .cint < 0 ) || ( eqtb [ 6211 ] .cint > 255 ) ) 
  1355.       decr ( curinput .limitfield ) ; 
  1356.       else buffer [ curinput .limitfield ] = eqtb [ 6211 ] .cint ; 
  1357.       first = curinput .limitfield + 1 ; 
  1358.       curinput .locfield = curinput .startfield ; 
  1359.     } 
  1360.     else fatalerror ( 613 ) ; 
  1361.       } 
  1362.       {
  1363.     if ( interrupt != 0 ) 
  1364.     pauseforinstructions () ; 
  1365.       } 
  1366.       goto lab25 ; 
  1367.     } 
  1368.   } 
  1369.   else if ( curinput .locfield != 0 ) 
  1370.   {
  1371.     t = mem [ curinput .locfield ] .hh .v.LH ; 
  1372.     curinput .locfield = mem [ curinput .locfield ] .hh .v.RH ; 
  1373.     if ( t >= 4095 ) 
  1374.     {
  1375.       curcs = t - 4095 ; 
  1376.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  1377.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1378.       if ( curcmd >= 113 ) 
  1379.       if ( curcmd == 116 ) 
  1380.       {
  1381.     curcs = mem [ curinput .locfield ] .hh .v.LH - 4095 ; 
  1382.     curinput .locfield = 0 ; 
  1383.     curcmd = eqtb [ curcs ] .hh.b0 ; 
  1384.     curchr = eqtb [ curcs ] .hh .v.RH ; 
  1385.     if ( curcmd > 100 ) 
  1386.     {
  1387.       curcmd = 0 ; 
  1388.       curchr = 257 ; 
  1389.     } 
  1390.       } 
  1391.       else checkoutervalidity () ; 
  1392.     } 
  1393.     else {
  1394.     
  1395.       curcmd = t / 256 ; 
  1396.       curchr = t % 256 ; 
  1397.       switch ( curcmd ) 
  1398.       {case 1 : 
  1399.     incr ( alignstate ) ; 
  1400.     break ; 
  1401.       case 2 : 
  1402.     decr ( alignstate ) ; 
  1403.     break ; 
  1404.       case 5 : 
  1405.     {
  1406.       begintokenlist ( paramstack [ curinput .limitfield + curchr - 1 ] , 
  1407.       0 ) ; 
  1408.       goto lab20 ; 
  1409.     } 
  1410.     break ; 
  1411.     default: 
  1412.     ; 
  1413.     break ; 
  1414.       } 
  1415.     } 
  1416.   } 
  1417.   else {
  1418.       
  1419.     endtokenlist () ; 
  1420.     goto lab20 ; 
  1421.   } 
  1422.   if ( curcmd <= 5 ) 
  1423.   if ( curcmd >= 4 ) 
  1424.   if ( alignstate == 0 ) 
  1425.   {
  1426.     if ( scannerstatus == 4 ) 
  1427.     fatalerror ( 591 ) ; 
  1428.     curcmd = mem [ curalign + 5 ] .hh .v.LH ; 
  1429.     mem [ curalign + 5 ] .hh .v.LH = curchr ; 
  1430.     if ( curcmd == 63 ) 
  1431.     begintokenlist ( memtop - 10 , 2 ) ; 
  1432.     else begintokenlist ( mem [ curalign + 2 ] .cint , 2 ) ; 
  1433.     alignstate = 1000000L ; 
  1434.     goto lab20 ; 
  1435.   } 
  1436. } 
  1437.