home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex4.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  24.6 KB  |  1,223 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void firmuptheline ( ) 
  5. {firmuptheline_regmem 
  6.   integer k  ; 
  7.   curinput .limitfield = last ; 
  8.   if ( eqtb [ 6191 ] .cint > 0 ) 
  9.   if ( interaction > 1 ) 
  10.   {
  11.     wakeupterminal () ; 
  12.     println () ; 
  13.     if ( curinput .startfield < curinput .limitfield ) 
  14.     {register integer for_end; k = curinput .startfield ; for_end = curinput 
  15.     .limitfield - 1 ; if ( k <= for_end) do 
  16.       print ( buffer [ k ] ) ; 
  17.     while ( k++ < for_end ) ; } 
  18.     first = curinput .limitfield ; 
  19.     {
  20.       wakeupterminal () ; 
  21.       print ( 614 ) ; 
  22.       terminput () ; 
  23.     } 
  24.     if ( last > first ) 
  25.     {
  26.       {register integer for_end; k = first ; for_end = last - 1 ; if ( k <= 
  27.       for_end) do 
  28.     buffer [ k + curinput .startfield - first ] = buffer [ k ] ; 
  29.       while ( k++ < for_end ) ; } 
  30.       curinput .limitfield = curinput .startfield + last - first ; 
  31.     } 
  32.   } 
  33. } 
  34. void gettoken ( ) 
  35. {gettoken_regmem 
  36.   nonewcontrolsequence = false ; 
  37.   getnext () ; 
  38.   nonewcontrolsequence = true ; 
  39.   if ( curcs == 0 ) 
  40.   curtok = ( curcmd * 256 ) + curchr ; 
  41.   else curtok = 4095 + curcs ; 
  42. } 
  43. void macrocall ( ) 
  44. {/* 10 22 30 31 40 */ macrocall_regmem 
  45.   halfword r  ; 
  46.   halfword p  ; 
  47.   halfword q  ; 
  48.   halfword s  ; 
  49.   halfword t  ; 
  50.   halfword u, v  ; 
  51.   halfword rbraceptr  ; 
  52.   smallnumber n  ; 
  53.   halfword unbalance  ; 
  54.   halfword m  ; 
  55.   halfword refcount  ; 
  56.   smallnumber savescannerstatus  ; 
  57.   halfword savewarningindex  ; 
  58.   ASCIIcode matchchr  ; 
  59.   savescannerstatus = scannerstatus ; 
  60.   savewarningindex = warningindex ; 
  61.   warningindex = curcs ; 
  62.   refcount = curchr ; 
  63.   r = mem [ refcount ] .hh .v.RH ; 
  64.   n = 0 ; 
  65.   if ( eqtb [ 6193 ] .cint > 0 ) 
  66.   {
  67.     begindiagnostic () ; 
  68.     println () ; 
  69.     printcs ( warningindex ) ; 
  70.     tokenshow ( refcount ) ; 
  71.     enddiagnostic ( false ) ; 
  72.   } 
  73.   if ( mem [ r ] .hh .v.LH != 3584 ) 
  74.   {
  75.     scannerstatus = 3 ; 
  76.     unbalance = 0 ; 
  77.     longstate = eqtb [ curcs ] .hh.b0 ; 
  78.     if ( longstate >= 113 ) 
  79.     longstate = longstate - 2 ; 
  80.     do {
  81.     mem [ memtop - 3 ] .hh .v.RH = 0 ; 
  82.       if ( ( mem [ r ] .hh .v.LH > 3583 ) || ( mem [ r ] .hh .v.LH < 3328 ) ) 
  83.       s = 0 ; 
  84.       else {
  85.       
  86.     matchchr = mem [ r ] .hh .v.LH - 3328 ; 
  87.     s = mem [ r ] .hh .v.RH ; 
  88.     r = s ; 
  89.     p = memtop - 3 ; 
  90.     m = 0 ; 
  91.       } 
  92.       lab22: gettoken () ; 
  93.       if ( curtok == mem [ r ] .hh .v.LH ) 
  94.       {
  95.     r = mem [ r ] .hh .v.RH ; 
  96.     if ( ( mem [ r ] .hh .v.LH >= 3328 ) && ( mem [ r ] .hh .v.LH <= 3584 
  97.     ) ) 
  98.     {
  99.       if ( curtok < 512 ) 
  100.       decr ( alignstate ) ; 
  101.       goto lab40 ; 
  102.     } 
  103.     else goto lab22 ; 
  104.       } 
  105.       if ( s != r ) 
  106.       if ( s == 0 ) 
  107.       {
  108.     {
  109.       if ( interaction == 3 ) 
  110.       wakeupterminal () ; 
  111.       printnl ( 262 ) ; 
  112.       print ( 646 ) ; 
  113.     } 
  114.     sprintcs ( warningindex ) ; 
  115.     print ( 647 ) ; 
  116.     {
  117.       helpptr = 4 ; 
  118.       helpline [ 3 ] = 648 ; 
  119.       helpline [ 2 ] = 649 ; 
  120.       helpline [ 1 ] = 650 ; 
  121.       helpline [ 0 ] = 651 ; 
  122.     } 
  123.     error () ; 
  124.     goto lab10 ; 
  125.       } 
  126.       else {
  127.       
  128.     t = s ; 
  129.     do {
  130.         { 
  131.         q = getavail () ; 
  132.         mem [ p ] .hh .v.RH = q ; 
  133.         mem [ q ] .hh .v.LH = mem [ t ] .hh .v.LH ; 
  134.         p = q ; 
  135.       } 
  136.       incr ( m ) ; 
  137.       u = mem [ t ] .hh .v.RH ; 
  138.       v = s ; 
  139.       while ( true ) {
  140.           
  141.         if ( u == r ) 
  142.         if ( curtok != mem [ v ] .hh .v.LH ) 
  143.         goto lab30 ; 
  144.         else {
  145.         
  146.           r = mem [ v ] .hh .v.RH ; 
  147.           goto lab22 ; 
  148.         } 
  149.         if ( mem [ u ] .hh .v.LH != mem [ v ] .hh .v.LH ) 
  150.         goto lab30 ; 
  151.         u = mem [ u ] .hh .v.RH ; 
  152.         v = mem [ v ] .hh .v.RH ; 
  153.       } 
  154.       lab30: t = mem [ t ] .hh .v.RH ; 
  155.     } while ( ! ( t == r ) ) ; 
  156.     r = s ; 
  157.       } 
  158.       if ( curtok == partoken ) 
  159.       if ( longstate != 112 ) 
  160.       {
  161.     if ( longstate == 111 ) 
  162.     {
  163.       runaway () ; 
  164.       {
  165.         if ( interaction == 3 ) 
  166.         wakeupterminal () ; 
  167.         printnl ( 262 ) ; 
  168.         print ( 641 ) ; 
  169.       } 
  170.       sprintcs ( warningindex ) ; 
  171.       print ( 642 ) ; 
  172.       {
  173.         helpptr = 3 ; 
  174.         helpline [ 2 ] = 643 ; 
  175.         helpline [ 1 ] = 644 ; 
  176.         helpline [ 0 ] = 645 ; 
  177.       } 
  178.       backerror () ; 
  179.     } 
  180.     pstack [ n ] = mem [ memtop - 3 ] .hh .v.RH ; 
  181.     alignstate = alignstate - unbalance ; 
  182.     {register integer for_end; m = 0 ; for_end = n ; if ( m <= for_end) 
  183.     do 
  184.       flushlist ( pstack [ m ] ) ; 
  185.     while ( m++ < for_end ) ; } 
  186.     goto lab10 ; 
  187.       } 
  188.       if ( curtok < 768 ) 
  189.       if ( curtok < 512 ) 
  190.       {
  191.     unbalance = 1 ; 
  192.     while ( true ) {
  193.         
  194.       {
  195.         {
  196.           q = avail ; 
  197.           if ( q == 0 ) 
  198.           q = getavail () ; 
  199.           else {
  200.           
  201.         avail = mem [ q ] .hh .v.RH ; 
  202.         mem [ q ] .hh .v.RH = 0 ; 
  203.     ;
  204. #ifdef STAT
  205.         incr ( dynused ) ; 
  206. #endif /* STAT */
  207.           } 
  208.         } 
  209.         mem [ p ] .hh .v.RH = q ; 
  210.         mem [ q ] .hh .v.LH = curtok ; 
  211.         p = q ; 
  212.       } 
  213.       gettoken () ; 
  214.       if ( curtok == partoken ) 
  215.       if ( longstate != 112 ) 
  216.       {
  217.         if ( longstate == 111 ) 
  218.         {
  219.           runaway () ; 
  220.           {
  221.         if ( interaction == 3 ) 
  222.         wakeupterminal () ; 
  223.         printnl ( 262 ) ; 
  224.         print ( 641 ) ; 
  225.           } 
  226.           sprintcs ( warningindex ) ; 
  227.           print ( 642 ) ; 
  228.           {
  229.         helpptr = 3 ; 
  230.         helpline [ 2 ] = 643 ; 
  231.         helpline [ 1 ] = 644 ; 
  232.         helpline [ 0 ] = 645 ; 
  233.           } 
  234.           backerror () ; 
  235.         } 
  236.         pstack [ n ] = mem [ memtop - 3 ] .hh .v.RH ; 
  237.         alignstate = alignstate - unbalance ; 
  238.         {register integer for_end; m = 0 ; for_end = n ; if ( m <= 
  239.         for_end) do 
  240.           flushlist ( pstack [ m ] ) ; 
  241.         while ( m++ < for_end ) ; } 
  242.         goto lab10 ; 
  243.       } 
  244.       if ( curtok < 768 ) 
  245.       if ( curtok < 512 ) 
  246.       incr ( unbalance ) ; 
  247.       else {
  248.           
  249.         decr ( unbalance ) ; 
  250.         if ( unbalance == 0 ) 
  251.         goto lab31 ; 
  252.       } 
  253.     } 
  254.     lab31: rbraceptr = p ; 
  255.     {
  256.       q = getavail () ; 
  257.       mem [ p ] .hh .v.RH = q ; 
  258.       mem [ q ] .hh .v.LH = curtok ; 
  259.       p = q ; 
  260.     } 
  261.       } 
  262.       else {
  263.       
  264.     backinput () ; 
  265.     {
  266.       if ( interaction == 3 ) 
  267.       wakeupterminal () ; 
  268.       printnl ( 262 ) ; 
  269.       print ( 633 ) ; 
  270.     } 
  271.     sprintcs ( warningindex ) ; 
  272.     print ( 634 ) ; 
  273.     {
  274.       helpptr = 6 ; 
  275.       helpline [ 5 ] = 635 ; 
  276.       helpline [ 4 ] = 636 ; 
  277.       helpline [ 3 ] = 637 ; 
  278.       helpline [ 2 ] = 638 ; 
  279.       helpline [ 1 ] = 639 ; 
  280.       helpline [ 0 ] = 640 ; 
  281.     } 
  282.     incr ( alignstate ) ; 
  283.     longstate = 111 ; 
  284.     curtok = partoken ; 
  285.     inserror () ; 
  286.       } 
  287.       else {
  288.       
  289.     if ( curtok == 2592 ) 
  290.     if ( mem [ r ] .hh .v.LH <= 3584 ) 
  291.     if ( mem [ r ] .hh .v.LH >= 3328 ) 
  292.     goto lab22 ; 
  293.     {
  294.       q = getavail () ; 
  295.       mem [ p ] .hh .v.RH = q ; 
  296.       mem [ q ] .hh .v.LH = curtok ; 
  297.       p = q ; 
  298.     } 
  299.       } 
  300.       incr ( m ) ; 
  301.       if ( mem [ r ] .hh .v.LH > 3584 ) 
  302.       goto lab22 ; 
  303.       if ( mem [ r ] .hh .v.LH < 3328 ) 
  304.       goto lab22 ; 
  305.       lab40: if ( s != 0 ) 
  306.       {
  307.     if ( ( m == 1 ) && ( mem [ p ] .hh .v.LH < 768 ) && ( p != memtop - 3 
  308.     ) ) 
  309.     {
  310.       mem [ rbraceptr ] .hh .v.RH = 0 ; 
  311.       {
  312.         mem [ p ] .hh .v.RH = avail ; 
  313.         avail = p ; 
  314.     ;
  315. #ifdef STAT
  316.         decr ( dynused ) ; 
  317. #endif /* STAT */
  318.       } 
  319.       p = mem [ memtop - 3 ] .hh .v.RH ; 
  320.       pstack [ n ] = mem [ p ] .hh .v.RH ; 
  321.       {
  322.         mem [ p ] .hh .v.RH = avail ; 
  323.         avail = p ; 
  324.     ;
  325. #ifdef STAT
  326.         decr ( dynused ) ; 
  327. #endif /* STAT */
  328.       } 
  329.     } 
  330.     else pstack [ n ] = mem [ memtop - 3 ] .hh .v.RH ; 
  331.     incr ( n ) ; 
  332.     if ( eqtb [ 6193 ] .cint > 0 ) 
  333.     {
  334.       begindiagnostic () ; 
  335.       printnl ( matchchr ) ; 
  336.       printint ( n ) ; 
  337.       print ( 652 ) ; 
  338.       showtokenlist ( pstack [ n - 1 ] , 0 , 1000 ) ; 
  339.       enddiagnostic ( false ) ; 
  340.     } 
  341.       } 
  342.     } while ( ! ( mem [ r ] .hh .v.LH == 3584 ) ) ; 
  343.   } 
  344.   while ( ( curinput .statefield == 0 ) && ( curinput .locfield == 0 ) ) 
  345.   endtokenlist () ; 
  346.   begintokenlist ( refcount , 5 ) ; 
  347.   curinput .namefield = warningindex ; 
  348.   curinput .locfield = mem [ r ] .hh .v.RH ; 
  349.   if ( n > 0 ) 
  350.   {
  351.     if ( paramptr + n > maxparamstack ) 
  352.     {
  353.       maxparamstack = paramptr + n ; 
  354.       if ( maxparamstack > paramsize ) 
  355.       overflow ( 632 , paramsize ) ; 
  356.     } 
  357.     {register integer for_end; m = 0 ; for_end = n - 1 ; if ( m <= for_end) 
  358.     do 
  359.       paramstack [ paramptr + m ] = pstack [ m ] ; 
  360.     while ( m++ < for_end ) ; } 
  361.     paramptr = paramptr + n ; 
  362.   } 
  363.   lab10: scannerstatus = savescannerstatus ; 
  364.   warningindex = savewarningindex ; 
  365. } 
  366. void insertrelax ( ) 
  367. {insertrelax_regmem 
  368.   curtok = 4095 + curcs ; 
  369.   backinput () ; 
  370.   curtok = 7616 ; 
  371.   backinput () ; 
  372.   curinput .indexfield = 4 ; 
  373. } 
  374. void expand ( ) 
  375. {expand_regmem 
  376.   halfword t  ; 
  377.   halfword p, q, r  ; 
  378.   integer j  ; 
  379.   integer cvbackup  ; 
  380.   smallnumber cvlbackup, radixbackup, cobackup  ; 
  381.   halfword backupbackup  ; 
  382.   smallnumber savescannerstatus  ; 
  383.   cvbackup = curval ; 
  384.   cvlbackup = curvallevel ; 
  385.   radixbackup = radix ; 
  386.   cobackup = curorder ; 
  387.   backupbackup = mem [ memtop - 13 ] .hh .v.RH ; 
  388.   if ( curcmd < 111 ) 
  389.   {
  390.     if ( eqtb [ 6199 ] .cint > 1 ) 
  391.     showcurcmdchr () ; 
  392.     switch ( curcmd ) 
  393.     {case 110 : 
  394.       {
  395.     if ( curmark [ curchr ] != 0 ) 
  396.     begintokenlist ( curmark [ curchr ] , 14 ) ; 
  397.       } 
  398.       break ; 
  399.     case 102 : 
  400.       {
  401.     gettoken () ; 
  402.     t = curtok ; 
  403.     gettoken () ; 
  404.     if ( curcmd > 100 ) 
  405.     expand () ; 
  406.     else backinput () ; 
  407.     curtok = t ; 
  408.     backinput () ; 
  409.       } 
  410.       break ; 
  411.     case 103 : 
  412.       {
  413.     savescannerstatus = scannerstatus ; 
  414.     scannerstatus = 0 ; 
  415.     gettoken () ; 
  416.     scannerstatus = savescannerstatus ; 
  417.     t = curtok ; 
  418.     backinput () ; 
  419.     if ( t >= 4095 ) 
  420.     {
  421.       p = getavail () ; 
  422.       mem [ p ] .hh .v.LH = 7618 ; 
  423.       mem [ p ] .hh .v.RH = curinput .locfield ; 
  424.       curinput .startfield = p ; 
  425.       curinput .locfield = p ; 
  426.     } 
  427.       } 
  428.       break ; 
  429.     case 107 : 
  430.       {
  431.     r = getavail () ; 
  432.     p = r ; 
  433.     do {
  434.         getxtoken () ; 
  435.       if ( curcs == 0 ) 
  436.       {
  437.         q = getavail () ; 
  438.         mem [ p ] .hh .v.RH = q ; 
  439.         mem [ q ] .hh .v.LH = curtok ; 
  440.         p = q ; 
  441.       } 
  442.     } while ( ! ( curcs != 0 ) ) ; 
  443.     if ( curcmd != 67 ) 
  444.     {
  445.       {
  446.         if ( interaction == 3 ) 
  447.         wakeupterminal () ; 
  448.         printnl ( 262 ) ; 
  449.         print ( 621 ) ; 
  450.       } 
  451.       printesc ( 501 ) ; 
  452.       print ( 622 ) ; 
  453.       {
  454.         helpptr = 2 ; 
  455.         helpline [ 1 ] = 623 ; 
  456.         helpline [ 0 ] = 624 ; 
  457.       } 
  458.       backerror () ; 
  459.     } 
  460.     j = first ; 
  461.     p = mem [ r ] .hh .v.RH ; 
  462.     while ( p != 0 ) {
  463.         
  464.       if ( j >= maxbufstack ) 
  465.       {
  466.         maxbufstack = j + 1 ; 
  467.         if ( maxbufstack == bufsize ) 
  468.         overflow ( 256 , bufsize ) ; 
  469.       } 
  470.       buffer [ j ] = mem [ p ] .hh .v.LH % 256 ; 
  471.       incr ( j ) ; 
  472.       p = mem [ p ] .hh .v.RH ; 
  473.     } 
  474.     if ( j > first + 1 ) 
  475.     {
  476.       nonewcontrolsequence = false ; 
  477.       curcs = idlookup ( first , j - first ) ; 
  478.       nonewcontrolsequence = true ; 
  479.     } 
  480.     else if ( j == first ) 
  481.     curcs = 513 ; 
  482.     else curcs = 257 + buffer [ first ] ; 
  483.     flushlist ( r ) ; 
  484.     if ( eqtb [ curcs ] .hh.b0 == 101 ) 
  485.     {
  486.       eqdefine ( curcs , 0 , 256 ) ; 
  487.     } 
  488.     curtok = curcs + 4095 ; 
  489.     backinput () ; 
  490.       } 
  491.       break ; 
  492.     case 108 : 
  493.       convtoks () ; 
  494.       break ; 
  495.     case 109 : 
  496.       insthetoks () ; 
  497.       break ; 
  498.     case 105 : 
  499.       conditional () ; 
  500.       break ; 
  501.     case 106 : 
  502.       if ( curchr > iflimit ) 
  503.       if ( iflimit == 1 ) 
  504.       insertrelax () ; 
  505.       else {
  506.       
  507.     {
  508.       if ( interaction == 3 ) 
  509.       wakeupterminal () ; 
  510.       printnl ( 262 ) ; 
  511.       print ( 772 ) ; 
  512.     } 
  513.     printcmdchr ( 106 , curchr ) ; 
  514.     {
  515.       helpptr = 1 ; 
  516.       helpline [ 0 ] = 773 ; 
  517.     } 
  518.     error () ; 
  519.       } 
  520.       else {
  521.       
  522.     while ( curchr != 2 ) passtext () ; 
  523.     {
  524.       p = condptr ; 
  525.       ifline = mem [ p + 1 ] .cint ; 
  526.       curif = mem [ p ] .hh.b1 ; 
  527.       iflimit = mem [ p ] .hh.b0 ; 
  528.       condptr = mem [ p ] .hh .v.RH ; 
  529.       freenode ( p , 2 ) ; 
  530.     } 
  531.       } 
  532.       break ; 
  533.     case 104 : 
  534.       if ( curchr > 0 ) 
  535.       forceeof = true ; 
  536.       else if ( nameinprogress ) 
  537.       insertrelax () ; 
  538.       else startinput () ; 
  539.       break ; 
  540.       default: 
  541.       {
  542.     {
  543.       if ( interaction == 3 ) 
  544.       wakeupterminal () ; 
  545.       printnl ( 262 ) ; 
  546.       print ( 615 ) ; 
  547.     } 
  548.     {
  549.       helpptr = 5 ; 
  550.       helpline [ 4 ] = 616 ; 
  551.       helpline [ 3 ] = 617 ; 
  552.       helpline [ 2 ] = 618 ; 
  553.       helpline [ 1 ] = 619 ; 
  554.       helpline [ 0 ] = 620 ; 
  555.     } 
  556.     error () ; 
  557.       } 
  558.       break ; 
  559.     } 
  560.   } 
  561.   else if ( curcmd < 115 ) 
  562.   macrocall () ; 
  563.   else {
  564.       
  565.     curtok = 7615 ; 
  566.     backinput () ; 
  567.   } 
  568.   curval = cvbackup ; 
  569.   curvallevel = cvlbackup ; 
  570.   radix = radixbackup ; 
  571.   curorder = cobackup ; 
  572.   mem [ memtop - 13 ] .hh .v.RH = backupbackup ; 
  573. } 
  574. void getxtoken ( ) 
  575. {/* 20 30 */ getxtoken_regmem 
  576.   lab20: getnext () ; 
  577.   if ( curcmd <= 100 ) 
  578.   goto lab30 ; 
  579.   if ( curcmd >= 111 ) 
  580.   if ( curcmd < 115 ) 
  581.   macrocall () ; 
  582.   else {
  583.       
  584.     curcs = 3520 ; 
  585.     curcmd = 9 ; 
  586.     goto lab30 ; 
  587.   } 
  588.   else expand () ; 
  589.   goto lab20 ; 
  590.   lab30: if ( curcs == 0 ) 
  591.   curtok = ( curcmd * 256 ) + curchr ; 
  592.   else curtok = 4095 + curcs ; 
  593. } 
  594. void xtoken ( ) 
  595. {xtoken_regmem 
  596.   while ( curcmd > 100 ) {
  597.       
  598.     expand () ; 
  599.     getnext () ; 
  600.   } 
  601.   if ( curcs == 0 ) 
  602.   curtok = ( curcmd * 256 ) + curchr ; 
  603.   else curtok = 4095 + curcs ; 
  604. } 
  605. void scanleftbrace ( ) 
  606. {scanleftbrace_regmem 
  607.   do {
  608.       getxtoken () ; 
  609.   } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  610.   if ( curcmd != 1 ) 
  611.   {
  612.     {
  613.       if ( interaction == 3 ) 
  614.       wakeupterminal () ; 
  615.       printnl ( 262 ) ; 
  616.       print ( 653 ) ; 
  617.     } 
  618.     {
  619.       helpptr = 4 ; 
  620.       helpline [ 3 ] = 654 ; 
  621.       helpline [ 2 ] = 655 ; 
  622.       helpline [ 1 ] = 656 ; 
  623.       helpline [ 0 ] = 657 ; 
  624.     } 
  625.     backerror () ; 
  626.     curtok = 379 ; 
  627.     curcmd = 1 ; 
  628.     curchr = 123 ; 
  629.     incr ( alignstate ) ; 
  630.   } 
  631. } 
  632. void scanoptionalequals ( ) 
  633. {scanoptionalequals_regmem 
  634.   do {
  635.       getxtoken () ; 
  636.   } while ( ! ( curcmd != 10 ) ) ; 
  637.   if ( curtok != 3133 ) 
  638.   backinput () ; 
  639. } 
  640. boolean zscankeyword ( s ) 
  641. strnumber s ; 
  642. {/* 10 */ register boolean Result; scankeyword_regmem 
  643.   halfword p  ; 
  644.   halfword q  ; 
  645.   poolpointer k  ; 
  646.   p = memtop - 13 ; 
  647.   mem [ p ] .hh .v.RH = 0 ; 
  648.   k = strstart [ s ] ; 
  649.   while ( k < strstart [ s + 1 ] ) {
  650.       
  651.     getxtoken () ; 
  652.     if ( ( curcs == 0 ) && ( ( curchr == strpool [ k ] ) || ( curchr == 
  653.     strpool [ k ] - 32 ) ) ) 
  654.     {
  655.       {
  656.     q = getavail () ; 
  657.     mem [ p ] .hh .v.RH = q ; 
  658.     mem [ q ] .hh .v.LH = curtok ; 
  659.     p = q ; 
  660.       } 
  661.       incr ( k ) ; 
  662.     } 
  663.     else if ( ( curcmd != 10 ) || ( p != memtop - 13 ) ) 
  664.     {
  665.       backinput () ; 
  666.       if ( p != memtop - 13 ) 
  667.       begintokenlist ( mem [ memtop - 13 ] .hh .v.RH , 3 ) ; 
  668.       Result = false ; 
  669.       return(Result) ; 
  670.     } 
  671.   } 
  672.   flushlist ( mem [ memtop - 13 ] .hh .v.RH ) ; 
  673.   Result = true ; 
  674.   return(Result) ; 
  675. } 
  676. void muerror ( ) 
  677. {muerror_regmem 
  678.   {
  679.     if ( interaction == 3 ) 
  680.     wakeupterminal () ; 
  681.     printnl ( 262 ) ; 
  682.     print ( 658 ) ; 
  683.   } 
  684.   {
  685.     helpptr = 1 ; 
  686.     helpline [ 0 ] = 659 ; 
  687.   } 
  688.   error () ; 
  689. } 
  690. void scaneightbitint ( ) 
  691. {scaneightbitint_regmem 
  692.   scanint () ; 
  693.   if ( ( curval < 0 ) || ( curval > 255 ) ) 
  694.   {
  695.     {
  696.       if ( interaction == 3 ) 
  697.       wakeupterminal () ; 
  698.       printnl ( 262 ) ; 
  699.       print ( 683 ) ; 
  700.     } 
  701.     {
  702.       helpptr = 2 ; 
  703.       helpline [ 1 ] = 684 ; 
  704.       helpline [ 0 ] = 685 ; 
  705.     } 
  706.     interror ( curval ) ; 
  707.     curval = 0 ; 
  708.   } 
  709. } 
  710. void scancharnum ( ) 
  711. {scancharnum_regmem 
  712.   scanint () ; 
  713.   if ( ( curval < 0 ) || ( curval > 255 ) ) 
  714.   {
  715.     {
  716.       if ( interaction == 3 ) 
  717.       wakeupterminal () ; 
  718.       printnl ( 262 ) ; 
  719.       print ( 686 ) ; 
  720.     } 
  721.     {
  722.       helpptr = 2 ; 
  723.       helpline [ 1 ] = 687 ; 
  724.       helpline [ 0 ] = 685 ; 
  725.     } 
  726.     interror ( curval ) ; 
  727.     curval = 0 ; 
  728.   } 
  729. } 
  730. void scanfourbitint ( ) 
  731. {scanfourbitint_regmem 
  732.   scanint () ; 
  733.   if ( ( curval < 0 ) || ( curval > 15 ) ) 
  734.   {
  735.     {
  736.       if ( interaction == 3 ) 
  737.       wakeupterminal () ; 
  738.       printnl ( 262 ) ; 
  739.       print ( 688 ) ; 
  740.     } 
  741.     {
  742.       helpptr = 2 ; 
  743.       helpline [ 1 ] = 689 ; 
  744.       helpline [ 0 ] = 685 ; 
  745.     } 
  746.     interror ( curval ) ; 
  747.     curval = 0 ; 
  748.   } 
  749. } 
  750. void scanfifteenbitint ( ) 
  751. {scanfifteenbitint_regmem 
  752.   scanint () ; 
  753.   if ( ( curval < 0 ) || ( curval > 32767 ) ) 
  754.   {
  755.     {
  756.       if ( interaction == 3 ) 
  757.       wakeupterminal () ; 
  758.       printnl ( 262 ) ; 
  759.       print ( 690 ) ; 
  760.     } 
  761.     {
  762.       helpptr = 2 ; 
  763.       helpline [ 1 ] = 691 ; 
  764.       helpline [ 0 ] = 685 ; 
  765.     } 
  766.     interror ( curval ) ; 
  767.     curval = 0 ; 
  768.   } 
  769. } 
  770. void scantwentysevenbitint ( ) 
  771. {scantwentysevenbitint_regmem 
  772.   scanint () ; 
  773.   if ( ( curval < 0 ) || ( curval > 134217727L ) ) 
  774.   {
  775.     {
  776.       if ( interaction == 3 ) 
  777.       wakeupterminal () ; 
  778.       printnl ( 262 ) ; 
  779.       print ( 692 ) ; 
  780.     } 
  781.     {
  782.       helpptr = 2 ; 
  783.       helpline [ 1 ] = 693 ; 
  784.       helpline [ 0 ] = 685 ; 
  785.     } 
  786.     interror ( curval ) ; 
  787.     curval = 0 ; 
  788.   } 
  789. } 
  790. void scanfontident ( ) 
  791. {scanfontident_regmem 
  792.   internalfontnumber f  ; 
  793.   halfword m  ; 
  794.   do {
  795.       getxtoken () ; 
  796.   } while ( ! ( curcmd != 10 ) ) ; 
  797.   if ( curcmd == 88 ) 
  798.   f = eqtb [ 4834 ] .hh .v.RH ; 
  799.   else if ( curcmd == 87 ) 
  800.   f = curchr ; 
  801.   else if ( curcmd == 86 ) 
  802.   {
  803.     m = curchr ; 
  804.     scanfourbitint () ; 
  805.     f = eqtb [ m + curval ] .hh .v.RH ; 
  806.   } 
  807.   else {
  808.       
  809.     {
  810.       if ( interaction == 3 ) 
  811.       wakeupterminal () ; 
  812.       printnl ( 262 ) ; 
  813.       print ( 810 ) ; 
  814.     } 
  815.     {
  816.       helpptr = 2 ; 
  817.       helpline [ 1 ] = 811 ; 
  818.       helpline [ 0 ] = 812 ; 
  819.     } 
  820.     backerror () ; 
  821.     f = 0 ; 
  822.   } 
  823.   curval = f ; 
  824. } 
  825. void zfindfontdimen ( writing ) 
  826. boolean writing ; 
  827. {findfontdimen_regmem 
  828.   internalfontnumber f  ; 
  829.   integer n  ; 
  830.   scanint () ; 
  831.   n = curval ; 
  832.   scanfontident () ; 
  833.   f = curval ; 
  834.   if ( n <= 0 ) 
  835.   curval = fmemptr ; 
  836.   else {
  837.       
  838.     if ( writing && ( n <= 4 ) && ( n >= 2 ) && ( fontglue [ f ] != 0 ) ) 
  839.     {
  840.       deleteglueref ( fontglue [ f ] ) ; 
  841.       fontglue [ f ] = 0 ; 
  842.     } 
  843.     if ( n > fontparams [ f ] ) 
  844.     if ( f < fontptr ) 
  845.     curval = fmemptr ; 
  846.     else {
  847.     
  848.       do {
  849.       if ( fmemptr == fontmemsize ) 
  850.     overflow ( 817 , fontmemsize ) ; 
  851.     fontinfo [ fmemptr ] .cint = 0 ; 
  852.     incr ( fmemptr ) ; 
  853.     incr ( fontparams [ f ] ) ; 
  854.       } while ( ! ( n == fontparams [ f ] ) ) ; 
  855.       curval = fmemptr - 1 ; 
  856.     } 
  857.     else curval = n + parambase [ f ] ; 
  858.   } 
  859.   if ( curval == fmemptr ) 
  860.   {
  861.     {
  862.       if ( interaction == 3 ) 
  863.       wakeupterminal () ; 
  864.       printnl ( 262 ) ; 
  865.       print ( 795 ) ; 
  866.     } 
  867.     printesc ( hash [ 3524 + f ] .v.RH ) ; 
  868.     print ( 813 ) ; 
  869.     printint ( fontparams [ f ] ) ; 
  870.     print ( 814 ) ; 
  871.     {
  872.       helpptr = 2 ; 
  873.       helpline [ 1 ] = 815 ; 
  874.       helpline [ 0 ] = 816 ; 
  875.     } 
  876.     error () ; 
  877.   } 
  878. } 
  879. void zscansomethinginternal ( level , negative ) 
  880. smallnumber level ; 
  881. boolean negative ; 
  882. {scansomethinginternal_regmem 
  883.   halfword m  ; 
  884.   integer p  ; 
  885.   m = curchr ; 
  886.   switch ( curcmd ) 
  887.   {case 85 : 
  888.     {
  889.       scancharnum () ; 
  890.       if ( m == 5907 ) 
  891.       {
  892.     curval = eqtb [ 5907 + curval ] .hh .v.RH ; 
  893.     curvallevel = 0 ; 
  894.       } 
  895.       else if ( m < 5907 ) 
  896.       {
  897.     curval = eqtb [ m + curval ] .hh .v.RH ; 
  898.     curvallevel = 0 ; 
  899.       } 
  900.       else {
  901.       
  902.     curval = eqtb [ m + curval ] .cint ; 
  903.     curvallevel = 0 ; 
  904.       } 
  905.     } 
  906.     break ; 
  907.   case 71 : 
  908.   case 72 : 
  909.   case 86 : 
  910.   case 87 : 
  911.   case 88 : 
  912.     if ( level != 5 ) 
  913.     {
  914.       {
  915.     if ( interaction == 3 ) 
  916.     wakeupterminal () ; 
  917.     printnl ( 262 ) ; 
  918.     print ( 660 ) ; 
  919.       } 
  920.       {
  921.     helpptr = 3 ; 
  922.     helpline [ 2 ] = 661 ; 
  923.     helpline [ 1 ] = 662 ; 
  924.     helpline [ 0 ] = 663 ; 
  925.       } 
  926.       backerror () ; 
  927.       {
  928.     curval = 0 ; 
  929.     curvallevel = 1 ; 
  930.       } 
  931.     } 
  932.     else if ( curcmd <= 72 ) 
  933.     {
  934.       if ( curcmd < 72 ) 
  935.       {
  936.     scaneightbitint () ; 
  937.     m = 4322 + curval ; 
  938.       } 
  939.       {
  940.     curval = eqtb [ m ] .hh .v.RH ; 
  941.     curvallevel = 5 ; 
  942.       } 
  943.     } 
  944.     else {
  945.     
  946.       backinput () ; 
  947.       scanfontident () ; 
  948.       {
  949.     curval = 3524 + curval ; 
  950.     curvallevel = 4 ; 
  951.       } 
  952.     } 
  953.     break ; 
  954.   case 73 : 
  955.     {
  956.       curval = eqtb [ m ] .cint ; 
  957.       curvallevel = 0 ; 
  958.     } 
  959.     break ; 
  960.   case 74 : 
  961.     {
  962.       curval = eqtb [ m ] .cint ; 
  963.       curvallevel = 1 ; 
  964.     } 
  965.     break ; 
  966.   case 75 : 
  967.     {
  968.       curval = eqtb [ m ] .hh .v.RH ; 
  969.       curvallevel = 2 ; 
  970.     } 
  971.     break ; 
  972.   case 76 : 
  973.     {
  974.       curval = eqtb [ m ] .hh .v.RH ; 
  975.       curvallevel = 3 ; 
  976.     } 
  977.     break ; 
  978.   case 79 : 
  979.     if ( abs ( curlist .modefield ) != m ) 
  980.     {
  981.       {
  982.     if ( interaction == 3 ) 
  983.     wakeupterminal () ; 
  984.     printnl ( 262 ) ; 
  985.     print ( 676 ) ; 
  986.       } 
  987.       printcmdchr ( 79 , m ) ; 
  988.       {
  989.     helpptr = 4 ; 
  990.     helpline [ 3 ] = 677 ; 
  991.     helpline [ 2 ] = 678 ; 
  992.     helpline [ 1 ] = 679 ; 
  993.     helpline [ 0 ] = 680 ; 
  994.       } 
  995.       error () ; 
  996.       if ( level != 5 ) 
  997.       {
  998.     curval = 0 ; 
  999.     curvallevel = 1 ; 
  1000.       } 
  1001.       else {
  1002.       
  1003.     curval = 0 ; 
  1004.     curvallevel = 0 ; 
  1005.       } 
  1006.     } 
  1007.     else if ( m == 1 ) 
  1008.     {
  1009.       curval = curlist .auxfield .cint ; 
  1010.       curvallevel = 1 ; 
  1011.     } 
  1012.     else {
  1013.     
  1014.       curval = curlist .auxfield .hh .v.LH ; 
  1015.       curvallevel = 0 ; 
  1016.     } 
  1017.     break ; 
  1018.   case 80 : 
  1019.     if ( curlist .modefield == 0 ) 
  1020.     {
  1021.       curval = 0 ; 
  1022.       curvallevel = 0 ; 
  1023.     } 
  1024.     else {
  1025.     
  1026.       nest [ nestptr ] = curlist ; 
  1027.       p = nestptr ; 
  1028.       while ( abs ( nest [ p ] .modefield ) != 1 ) decr ( p ) ; 
  1029.       {
  1030.     curval = nest [ p ] .pgfield ; 
  1031.     curvallevel = 0 ; 
  1032.       } 
  1033.     } 
  1034.     break ; 
  1035.   case 82 : 
  1036.     {
  1037.       if ( m == 0 ) 
  1038.       curval = deadcycles ; 
  1039.       else curval = insertpenalties ; 
  1040.       curvallevel = 0 ; 
  1041.     } 
  1042.     break ; 
  1043.   case 81 : 
  1044.     {
  1045.       if ( ( pagecontents == 0 ) && ( ! outputactive ) ) 
  1046.       if ( m == 0 ) 
  1047.       curval = 1073741823L ; 
  1048.       else curval = 0 ; 
  1049.       else curval = pagesofar [ m ] ; 
  1050.       curvallevel = 1 ; 
  1051.     } 
  1052.     break ; 
  1053.   case 84 : 
  1054.     {
  1055.       if ( eqtb [ 4312 ] .hh .v.RH == 0 ) 
  1056.       curval = 0 ; 
  1057.       else curval = mem [ eqtb [ 4312 ] .hh .v.RH ] .hh .v.LH ; 
  1058.       curvallevel = 0 ; 
  1059.     } 
  1060.     break ; 
  1061.   case 83 : 
  1062.     {
  1063.       scaneightbitint () ; 
  1064.       if ( eqtb [ 4578 + curval ] .hh .v.RH == 0 ) 
  1065.       curval = 0 ; 
  1066.       else curval = mem [ eqtb [ 4578 + curval ] .hh .v.RH + m ] .cint ; 
  1067.       curvallevel = 1 ; 
  1068.     } 
  1069.     break ; 
  1070.   case 68 : 
  1071.   case 69 : 
  1072.     {
  1073.       curval = curchr ; 
  1074.       curvallevel = 0 ; 
  1075.     } 
  1076.     break ; 
  1077.   case 77 : 
  1078.     {
  1079.       findfontdimen ( false ) ; 
  1080.       fontinfo [ fmemptr ] .cint = 0 ; 
  1081.       {
  1082.     curval = fontinfo [ curval ] .cint ; 
  1083.     curvallevel = 1 ; 
  1084.       } 
  1085.     } 
  1086.     break ; 
  1087.   case 78 : 
  1088.     {
  1089.       scanfontident () ; 
  1090.       if ( m == 0 ) 
  1091.       {
  1092.     curval = hyphenchar [ curval ] ; 
  1093.     curvallevel = 0 ; 
  1094.       } 
  1095.       else {
  1096.       
  1097.     curval = skewchar [ curval ] ; 
  1098.     curvallevel = 0 ; 
  1099.       } 
  1100.     } 
  1101.     break ; 
  1102.   case 89 : 
  1103.     {
  1104.       scaneightbitint () ; 
  1105.       switch ( m ) 
  1106.       {case 0 : 
  1107.     curval = eqtb [ 6218 + curval ] .cint ; 
  1108.     break ; 
  1109.       case 1 : 
  1110.     curval = eqtb [ 6751 + curval ] .cint ; 
  1111.     break ; 
  1112.       case 2 : 
  1113.     curval = eqtb [ 3800 + curval ] .hh .v.RH ; 
  1114.     break ; 
  1115.       case 3 : 
  1116.     curval = eqtb [ 4056 + curval ] .hh .v.RH ; 
  1117.     break ; 
  1118.       } 
  1119.       curvallevel = m ; 
  1120.     } 
  1121.     break ; 
  1122.   case 70 : 
  1123.     if ( curchr > 2 ) 
  1124.     {
  1125.       if ( curchr == 3 ) 
  1126.       curval = line ; 
  1127.       else curval = lastbadness ; 
  1128.       curvallevel = 0 ; 
  1129.     } 
  1130.     else {
  1131.     
  1132.       if ( curchr == 2 ) 
  1133.       curval = 0 ; 
  1134.       else curval = 0 ; 
  1135.       curvallevel = curchr ; 
  1136.       if ( ! ( curlist .tailfield >= himemmin ) && ( curlist .modefield != 0 ) 
  1137.       ) 
  1138.       switch ( curchr ) 
  1139.       {case 0 : 
  1140.     if ( mem [ curlist .tailfield ] .hh.b0 == 12 ) 
  1141.     curval = mem [ curlist .tailfield + 1 ] .cint ; 
  1142.     break ; 
  1143.       case 1 : 
  1144.     if ( mem [ curlist .tailfield ] .hh.b0 == 11 ) 
  1145.     curval = mem [ curlist .tailfield + 1 ] .cint ; 
  1146.     break ; 
  1147.       case 2 : 
  1148.     if ( mem [ curlist .tailfield ] .hh.b0 == 10 ) 
  1149.     {
  1150.       curval = mem [ curlist .tailfield + 1 ] .hh .v.LH ; 
  1151.       if ( mem [ curlist .tailfield ] .hh.b1 == 99 ) 
  1152.       curvallevel = 3 ; 
  1153.     } 
  1154.     break ; 
  1155.       } 
  1156.       else if ( ( curlist .modefield == 1 ) && ( curlist .tailfield == curlist 
  1157.       .headfield ) ) 
  1158.       switch ( curchr ) 
  1159.       {case 0 : 
  1160.     curval = lastpenalty ; 
  1161.     break ; 
  1162.       case 1 : 
  1163.     curval = lastkern ; 
  1164.     break ; 
  1165.       case 2 : 
  1166.     if ( lastglue != 65535L ) 
  1167.     curval = lastglue ; 
  1168.     break ; 
  1169.       } 
  1170.     } 
  1171.     break ; 
  1172.     default: 
  1173.     {
  1174.       {
  1175.     if ( interaction == 3 ) 
  1176.     wakeupterminal () ; 
  1177.     printnl ( 262 ) ; 
  1178.     print ( 681 ) ; 
  1179.       } 
  1180.       printcmdchr ( curcmd , curchr ) ; 
  1181.       print ( 682 ) ; 
  1182.       printesc ( 533 ) ; 
  1183.       {
  1184.     helpptr = 1 ; 
  1185.     helpline [ 0 ] = 680 ; 
  1186.       } 
  1187.       error () ; 
  1188.       if ( level != 5 ) 
  1189.       {
  1190.     curval = 0 ; 
  1191.     curvallevel = 1 ; 
  1192.       } 
  1193.       else {
  1194.       
  1195.     curval = 0 ; 
  1196.     curvallevel = 0 ; 
  1197.       } 
  1198.     } 
  1199.     break ; 
  1200.   } 
  1201.   while ( curvallevel > level ) {
  1202.       
  1203.     if ( curvallevel == 2 ) 
  1204.     curval = mem [ curval + 1 ] .cint ; 
  1205.     else if ( curvallevel == 3 ) 
  1206.     muerror () ; 
  1207.     decr ( curvallevel ) ; 
  1208.   } 
  1209.   if ( negative ) 
  1210.   if ( curvallevel >= 2 ) 
  1211.   {
  1212.     curval = newspec ( curval ) ; 
  1213.     {
  1214.       mem [ curval + 1 ] .cint = - (integer) mem [ curval + 1 ] .cint ; 
  1215.       mem [ curval + 2 ] .cint = - (integer) mem [ curval + 2 ] .cint ; 
  1216.       mem [ curval + 3 ] .cint = - (integer) mem [ curval + 3 ] .cint ; 
  1217.     } 
  1218.   } 
  1219.   else curval = - (integer) curval ; 
  1220.   else if ( ( curvallevel >= 2 ) && ( curvallevel <= 3 ) ) 
  1221.   incr ( mem [ curval ] .hh .v.RH ) ; 
  1222. } 
  1223.