home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex15.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  35.2 KB  |  1,704 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void alterprevgraf ( ) 
  5. {alterprevgraf_regmem 
  6.   integer p  ; 
  7.   nest [ nestptr ] = curlist ; 
  8.   p = nestptr ; 
  9.   while ( abs ( nest [ p ] .modefield ) != 1 ) decr ( p ) ; 
  10.   scanoptionalequals () ; 
  11.   scanint () ; 
  12.   if ( curval < 0 ) 
  13.   {
  14.     {
  15.       if ( interaction == 3 ) 
  16.       wakeupterminal () ; 
  17.       printnl ( 262 ) ; 
  18.       print ( 948 ) ; 
  19.     } 
  20.     printesc ( 528 ) ; 
  21.     {
  22.       helpptr = 1 ; 
  23.       helpline [ 0 ] = 1206 ; 
  24.     } 
  25.     interror ( curval ) ; 
  26.   } 
  27.   else {
  28.       
  29.     nest [ p ] .pgfield = curval ; 
  30.     curlist = nest [ nestptr ] ; 
  31.   } 
  32. } 
  33. void alterpagesofar ( ) 
  34. {alterpagesofar_regmem 
  35.   schar c  ; 
  36.   c = curchr ; 
  37.   scanoptionalequals () ; 
  38.   scandimen ( false , false , false ) ; 
  39.   pagesofar [ c ] = curval ; 
  40. } 
  41. void alterinteger ( ) 
  42. {alterinteger_regmem 
  43.   schar c  ; 
  44.   c = curchr ; 
  45.   scanoptionalequals () ; 
  46.   scanint () ; 
  47.   if ( c == 0 ) 
  48.   deadcycles = curval ; 
  49.   else insertpenalties = curval ; 
  50. } 
  51. void alterboxdimen ( ) 
  52. {alterboxdimen_regmem 
  53.   smallnumber c  ; 
  54.   eightbits b  ; 
  55.   c = curchr ; 
  56.   scaneightbitint () ; 
  57.   b = curval ; 
  58.   scanoptionalequals () ; 
  59.   scandimen ( false , false , false ) ; 
  60.   if ( eqtb [ 4578 + b ] .hh .v.RH != 0 ) 
  61.   mem [ eqtb [ 4578 + b ] .hh .v.RH + c ] .cint = curval ; 
  62. } 
  63. void znewfont ( a ) 
  64. smallnumber a ; 
  65. {/* 50 */ newfont_regmem 
  66.   halfword u  ; 
  67.   scaled s  ; 
  68.   internalfontnumber f  ; 
  69.   strnumber t  ; 
  70.   schar oldsetting  ; 
  71.   if ( jobname == 0 ) 
  72.   openlogfile () ; 
  73.   getrtoken () ; 
  74.   u = curcs ; 
  75.   if ( u >= 514 ) 
  76.   t = hash [ u ] .v.RH ; 
  77.   else if ( u >= 257 ) 
  78.   if ( u == 513 ) 
  79.   t = 1210 ; 
  80.   else t = u - 257 ; 
  81.   else {
  82.       
  83.     oldsetting = selector ; 
  84.     selector = 21 ; 
  85.     print ( 1210 ) ; 
  86.     print ( u - 1 ) ; 
  87.     selector = oldsetting ; 
  88.     {
  89.       if ( poolptr + 1 > poolsize ) 
  90.       overflow ( 257 , poolsize - initpoolptr ) ; 
  91.     } 
  92.     t = makestring () ; 
  93.   } 
  94.   if ( ( a >= 4 ) ) 
  95.   geqdefine ( u , 87 , 0 ) ; 
  96.   else eqdefine ( u , 87 , 0 ) ; 
  97.   scanoptionalequals () ; 
  98.   scanfilename () ; 
  99.   nameinprogress = true ; 
  100.   if ( scankeyword ( 1211 ) ) 
  101.   {
  102.     scandimen ( false , false , false ) ; 
  103.     s = curval ; 
  104.     if ( ( s <= 0 ) || ( s >= 134217728L ) ) 
  105.     {
  106.       {
  107.     if ( interaction == 3 ) 
  108.     wakeupterminal () ; 
  109.     printnl ( 262 ) ; 
  110.     print ( 1213 ) ; 
  111.       } 
  112.       printscaled ( s ) ; 
  113.       print ( 1214 ) ; 
  114.       {
  115.     helpptr = 2 ; 
  116.     helpline [ 1 ] = 1215 ; 
  117.     helpline [ 0 ] = 1216 ; 
  118.       } 
  119.       error () ; 
  120.       s = 10 * 65536L ; 
  121.     } 
  122.   } 
  123.   else if ( scankeyword ( 1212 ) ) 
  124.   {
  125.     scanint () ; 
  126.     s = - (integer) curval ; 
  127.     if ( ( curval <= 0 ) || ( curval > 32768L ) ) 
  128.     {
  129.       {
  130.     if ( interaction == 3 ) 
  131.     wakeupterminal () ; 
  132.     printnl ( 262 ) ; 
  133.     print ( 548 ) ; 
  134.       } 
  135.       {
  136.     helpptr = 1 ; 
  137.     helpline [ 0 ] = 549 ; 
  138.       } 
  139.       interror ( curval ) ; 
  140.       s = -1000 ; 
  141.     } 
  142.   } 
  143.   else s = -1000 ; 
  144.   nameinprogress = false ; 
  145.   {register integer for_end; f = 1 ; for_end = fontptr ; if ( f <= for_end) 
  146.   do 
  147.     if ( streqstr ( fontname [ f ] , curname ) && streqstr ( fontarea [ f ] , 
  148.     curarea ) ) 
  149.     {
  150.       if ( s > 0 ) 
  151.       {
  152.     if ( s == fontsize [ f ] ) 
  153.     goto lab50 ; 
  154.       } 
  155.       else if ( fontsize [ f ] == xnoverd ( fontdsize [ f ] , - (integer) s , 
  156.       1000 ) ) 
  157.       goto lab50 ; 
  158.     } 
  159.   while ( f++ < for_end ) ; } 
  160.   f = readfontinfo ( u , curname , curarea , s ) ; 
  161.   lab50: eqtb [ u ] .hh .v.RH = f ; 
  162.   eqtb [ 3524 + f ] = eqtb [ u ] ; 
  163.   hash [ 3524 + f ] .v.RH = t ; 
  164. } 
  165. void newinteraction ( ) 
  166. {newinteraction_regmem 
  167.   println () ; 
  168.   interaction = curchr ; 
  169.   if ( interaction == 0 ) 
  170.   selector = 16 ; 
  171.   else selector = 17 ; 
  172.   if ( logopened ) 
  173.   selector = selector + 2 ; 
  174. } 
  175. void doassignments ( ) 
  176. {/* 10 */ doassignments_regmem 
  177.   while ( true ) {
  178.       
  179.     do {
  180.     getxtoken () ; 
  181.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  182.     if ( curcmd <= 70 ) 
  183.     return ; 
  184.     prefixedcommand () ; 
  185.   } 
  186. } 
  187. void openorclosein ( ) 
  188. {openorclosein_regmem 
  189.   schar c  ; 
  190.   schar n  ; 
  191.   c = curchr ; 
  192.   scanfourbitint () ; 
  193.   n = curval ; 
  194.   if ( readopen [ n ] != 2 ) 
  195.   {
  196.     aclose ( readfile [ n ] ) ; 
  197.     readopen [ n ] = 2 ; 
  198.   } 
  199.   if ( c != 0 ) 
  200.   {
  201.     scanoptionalequals () ; 
  202.     scanfilename () ; 
  203.     if ( curext == 335 ) 
  204.     curext = 784 ; 
  205.     packfilename ( curname , curarea , curext ) ; 
  206.     if ( aopenin ( readfile [ n ] , TEXINPUTPATH ) ) 
  207.     readopen [ n ] = 1 ; 
  208.   } 
  209. } 
  210. void issuemessage ( ) 
  211. {issuemessage_regmem 
  212.   schar oldsetting  ; 
  213.   schar c  ; 
  214.   strnumber s  ; 
  215.   c = curchr ; 
  216.   mem [ memtop - 12 ] .hh .v.RH = scantoks ( false , true ) ; 
  217.   oldsetting = selector ; 
  218.   selector = 21 ; 
  219.   tokenshow ( defref ) ; 
  220.   selector = oldsetting ; 
  221.   flushlist ( defref ) ; 
  222.   {
  223.     if ( poolptr + 1 > poolsize ) 
  224.     overflow ( 257 , poolsize - initpoolptr ) ; 
  225.   } 
  226.   s = makestring () ; 
  227.   if ( c == 0 ) 
  228.   {
  229.     if ( termoffset + ( strstart [ s + 1 ] - strstart [ s ] ) > maxprintline - 
  230.     2 ) 
  231.     println () ; 
  232.     else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  233.     printchar ( 32 ) ; 
  234.     print ( s ) ; 
  235.     flush ( stdout ) ; 
  236.   } 
  237.   else {
  238.       
  239.     {
  240.       if ( interaction == 3 ) 
  241.       wakeupterminal () ; 
  242.       printnl ( 262 ) ; 
  243.       print ( s ) ; 
  244.     } 
  245.     if ( eqtb [ 4321 ] .hh .v.RH != 0 ) 
  246.     useerrhelp = true ; 
  247.     else if ( longhelpseen ) 
  248.     {
  249.       helpptr = 1 ; 
  250.       helpline [ 0 ] = 1223 ; 
  251.     } 
  252.     else {
  253.     
  254.       if ( interaction < 3 ) 
  255.       longhelpseen = true ; 
  256.       {
  257.     helpptr = 4 ; 
  258.     helpline [ 3 ] = 1224 ; 
  259.     helpline [ 2 ] = 1225 ; 
  260.     helpline [ 1 ] = 1226 ; 
  261.     helpline [ 0 ] = 1227 ; 
  262.       } 
  263.     } 
  264.     error () ; 
  265.     useerrhelp = false ; 
  266.   } 
  267.   {
  268.     decr ( strptr ) ; 
  269.     poolptr = strstart [ strptr ] ; 
  270.   } 
  271. } 
  272. void shiftcase ( ) 
  273. {shiftcase_regmem 
  274.   halfword b  ; 
  275.   halfword p  ; 
  276.   halfword t  ; 
  277.   eightbits c  ; 
  278.   b = curchr ; 
  279.   p = scantoks ( false , false ) ; 
  280.   p = mem [ defref ] .hh .v.RH ; 
  281.   while ( p != 0 ) {
  282.       
  283.     t = mem [ p ] .hh .v.LH ; 
  284.     if ( t < 4352 ) 
  285.     {
  286.       c = t % 256 ; 
  287.       if ( eqtb [ b + c ] .hh .v.RH != 0 ) 
  288.       mem [ p ] .hh .v.LH = t - c + eqtb [ b + c ] .hh .v.RH ; 
  289.     } 
  290.     p = mem [ p ] .hh .v.RH ; 
  291.   } 
  292.   begintokenlist ( mem [ defref ] .hh .v.RH , 3 ) ; 
  293.   {
  294.     mem [ defref ] .hh .v.RH = avail ; 
  295.     avail = defref ; 
  296.     ;
  297. #ifdef STAT
  298.     decr ( dynused ) ; 
  299. #endif /* STAT */
  300.   } 
  301. } 
  302. void showwhatever ( ) 
  303. {/* 50 */ showwhatever_regmem 
  304.   halfword p  ; 
  305.   switch ( curchr ) 
  306.   {case 3 : 
  307.     {
  308.       begindiagnostic () ; 
  309.       showactivities () ; 
  310.     } 
  311.     break ; 
  312.   case 1 : 
  313.     {
  314.       scaneightbitint () ; 
  315.       begindiagnostic () ; 
  316.       printnl ( 1245 ) ; 
  317.       printint ( curval ) ; 
  318.       printchar ( 61 ) ; 
  319.       if ( eqtb [ 4578 + curval ] .hh .v.RH == 0 ) 
  320.       print ( 406 ) ; 
  321.       else showbox ( eqtb [ 4578 + curval ] .hh .v.RH ) ; 
  322.     } 
  323.     break ; 
  324.   case 0 : 
  325.     {
  326.       gettoken () ; 
  327.       if ( interaction == 3 ) 
  328.       wakeupterminal () ; 
  329.       printnl ( 1239 ) ; 
  330.       if ( curcs != 0 ) 
  331.       {
  332.     sprintcs ( curcs ) ; 
  333.     printchar ( 61 ) ; 
  334.       } 
  335.       printmeaning () ; 
  336.       goto lab50 ; 
  337.     } 
  338.     break ; 
  339.     default: 
  340.     {
  341.       p = thetoks () ; 
  342.       if ( interaction == 3 ) 
  343.       wakeupterminal () ; 
  344.       printnl ( 1239 ) ; 
  345.       tokenshow ( memtop - 3 ) ; 
  346.       flushlist ( mem [ memtop - 3 ] .hh .v.RH ) ; 
  347.       goto lab50 ; 
  348.     } 
  349.     break ; 
  350.   } 
  351.   enddiagnostic ( true ) ; 
  352.   {
  353.     if ( interaction == 3 ) 
  354.     wakeupterminal () ; 
  355.     printnl ( 262 ) ; 
  356.     print ( 1246 ) ; 
  357.   } 
  358.   if ( selector == 19 ) 
  359.   if ( eqtb [ 6192 ] .cint <= 0 ) 
  360.   {
  361.     selector = 17 ; 
  362.     print ( 1247 ) ; 
  363.     selector = 19 ; 
  364.   } 
  365.   lab50: if ( interaction < 3 ) 
  366.   {
  367.     helpptr = 0 ; 
  368.     decr ( errorcount ) ; 
  369.   } 
  370.   else if ( eqtb [ 6192 ] .cint > 0 ) 
  371.   {
  372.     {
  373.       helpptr = 3 ; 
  374.       helpline [ 2 ] = 1234 ; 
  375.       helpline [ 1 ] = 1235 ; 
  376.       helpline [ 0 ] = 1236 ; 
  377.     } 
  378.   } 
  379.   else {
  380.       
  381.     {
  382.       helpptr = 5 ; 
  383.       helpline [ 4 ] = 1234 ; 
  384.       helpline [ 3 ] = 1235 ; 
  385.       helpline [ 2 ] = 1236 ; 
  386.       helpline [ 1 ] = 1237 ; 
  387.       helpline [ 0 ] = 1238 ; 
  388.     } 
  389.   } 
  390.   error () ; 
  391. } 
  392. void znewwhatsit ( s , w ) 
  393. smallnumber s ; 
  394. smallnumber w ; 
  395. {newwhatsit_regmem 
  396.   halfword p  ; 
  397.   p = getnode ( w ) ; 
  398.   mem [ p ] .hh.b0 = 8 ; 
  399.   mem [ p ] .hh.b1 = s ; 
  400.   mem [ curlist .tailfield ] .hh .v.RH = p ; 
  401.   curlist .tailfield = p ; 
  402. } 
  403. void znewwritewhatsit ( w ) 
  404. smallnumber w ; 
  405. {newwritewhatsit_regmem 
  406.   newwhatsit ( curchr , w ) ; 
  407.   if ( w != 2 ) 
  408.   scanfourbitint () ; 
  409.   else {
  410.       
  411.     scanint () ; 
  412.     if ( curval < 0 ) 
  413.     curval = 17 ; 
  414.     else if ( curval > 15 ) 
  415.     curval = 16 ; 
  416.   } 
  417.   mem [ curlist .tailfield + 1 ] .hh .v.LH = curval ; 
  418. } 
  419. void doextension ( ) 
  420. {doextension_regmem 
  421.   integer i, j, k  ; 
  422.   halfword p, q, r  ; 
  423.   switch ( curchr ) 
  424.   {case 0 : 
  425.     {
  426.       newwritewhatsit ( 3 ) ; 
  427.       scanoptionalequals () ; 
  428.       scanfilename () ; 
  429.       mem [ curlist .tailfield + 1 ] .hh .v.RH = curname ; 
  430.       mem [ curlist .tailfield + 2 ] .hh .v.LH = curarea ; 
  431.       mem [ curlist .tailfield + 2 ] .hh .v.RH = curext ; 
  432.     } 
  433.     break ; 
  434.   case 1 : 
  435.     {
  436.       k = curcs ; 
  437.       newwritewhatsit ( 2 ) ; 
  438.       curcs = k ; 
  439.       p = scantoks ( false , false ) ; 
  440.       mem [ curlist .tailfield + 1 ] .hh .v.RH = defref ; 
  441.     } 
  442.     break ; 
  443.   case 2 : 
  444.     {
  445.       newwritewhatsit ( 2 ) ; 
  446.       mem [ curlist .tailfield + 1 ] .hh .v.RH = 0 ; 
  447.     } 
  448.     break ; 
  449.   case 3 : 
  450.     {
  451.       newwhatsit ( 3 , 2 ) ; 
  452.       mem [ curlist .tailfield + 1 ] .hh .v.LH = 0 ; 
  453.       p = scantoks ( false , true ) ; 
  454.       mem [ curlist .tailfield + 1 ] .hh .v.RH = defref ; 
  455.     } 
  456.     break ; 
  457.   case 4 : 
  458.     {
  459.       getxtoken () ; 
  460.       if ( ( curcmd == 59 ) && ( curchr <= 2 ) ) 
  461.       {
  462.     p = curlist .tailfield ; 
  463.     doextension () ; 
  464.     outwhat ( curlist .tailfield ) ; 
  465.     flushnodelist ( curlist .tailfield ) ; 
  466.     curlist .tailfield = p ; 
  467.     mem [ p ] .hh .v.RH = 0 ; 
  468.       } 
  469.       else backinput () ; 
  470.     } 
  471.     break ; 
  472.   case 5 : 
  473.     if ( abs ( curlist .modefield ) != 102 ) 
  474.     reportillegalcase () ; 
  475.     else {
  476.     
  477.       newwhatsit ( 4 , 2 ) ; 
  478.       scanint () ; 
  479.       if ( curval <= 0 ) 
  480.       curlist .auxfield .hh .v.RH = 0 ; 
  481.       else if ( curval > 255 ) 
  482.       curlist .auxfield .hh .v.RH = 0 ; 
  483.       else curlist .auxfield .hh .v.RH = curval ; 
  484.       mem [ curlist .tailfield + 1 ] .hh .v.RH = curlist .auxfield .hh .v.RH ; 
  485.       mem [ curlist .tailfield + 1 ] .hh.b0 = normmin ( eqtb [ 6214 ] .cint ) 
  486.       ; 
  487.       mem [ curlist .tailfield + 1 ] .hh.b1 = normmin ( eqtb [ 6215 ] .cint ) 
  488.       ; 
  489.     } 
  490.     break ; 
  491.     default: 
  492.     confusion ( 1282 ) ; 
  493.     break ; 
  494.   } 
  495. } 
  496. void fixlanguage ( ) 
  497. {fixlanguage_regmem 
  498.   ASCIIcode l  ; 
  499.   if ( eqtb [ 6213 ] .cint <= 0 ) 
  500.   l = 0 ; 
  501.   else if ( eqtb [ 6213 ] .cint > 255 ) 
  502.   l = 0 ; 
  503.   else l = eqtb [ 6213 ] .cint ; 
  504.   if ( l != curlist .auxfield .hh .v.RH ) 
  505.   {
  506.     newwhatsit ( 4 , 2 ) ; 
  507.     mem [ curlist .tailfield + 1 ] .hh .v.RH = l ; 
  508.     curlist .auxfield .hh .v.RH = l ; 
  509.     mem [ curlist .tailfield + 1 ] .hh.b0 = normmin ( eqtb [ 6214 ] .cint ) ; 
  510.     mem [ curlist .tailfield + 1 ] .hh.b1 = normmin ( eqtb [ 6215 ] .cint ) ; 
  511.   } 
  512. } 
  513. void handlerightbrace ( ) 
  514. {handlerightbrace_regmem 
  515.   halfword p, q  ; 
  516.   scaled d  ; 
  517.   integer f  ; 
  518.   switch ( curgroup ) 
  519.   {case 1 : 
  520.     unsave () ; 
  521.     break ; 
  522.   case 0 : 
  523.     {
  524.       {
  525.     if ( interaction == 3 ) 
  526.     wakeupterminal () ; 
  527.     printnl ( 262 ) ; 
  528.     print ( 1037 ) ; 
  529.       } 
  530.       {
  531.     helpptr = 2 ; 
  532.     helpline [ 1 ] = 1038 ; 
  533.     helpline [ 0 ] = 1039 ; 
  534.       } 
  535.       error () ; 
  536.     } 
  537.     break ; 
  538.   case 14 : 
  539.   case 15 : 
  540.   case 16 : 
  541.     extrarightbrace () ; 
  542.     break ; 
  543.   case 2 : 
  544.     package ( 0 ) ; 
  545.     break ; 
  546.   case 3 : 
  547.     {
  548.       adjusttail = memtop - 5 ; 
  549.       package ( 0 ) ; 
  550.     } 
  551.     break ; 
  552.   case 4 : 
  553.     {
  554.       endgraf () ; 
  555.       package ( 0 ) ; 
  556.     } 
  557.     break ; 
  558.   case 5 : 
  559.     {
  560.       endgraf () ; 
  561.       package ( 4 ) ; 
  562.     } 
  563.     break ; 
  564.   case 11 : 
  565.     {
  566.       endgraf () ; 
  567.       q = eqtb [ 3792 ] .hh .v.RH ; 
  568.       incr ( mem [ q ] .hh .v.RH ) ; 
  569.       d = eqtb [ 6736 ] .cint ; 
  570.       f = eqtb [ 6205 ] .cint ; 
  571.       unsave () ; 
  572.       decr ( saveptr ) ; 
  573.       p = vpackage ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 , 
  574.       1073741823L ) ; 
  575.       popnest () ; 
  576.       if ( savestack [ saveptr + 0 ] .cint < 255 ) 
  577.       {
  578.     {
  579.       mem [ curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  580.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  581.     } 
  582.     mem [ curlist .tailfield ] .hh.b0 = 3 ; 
  583.     mem [ curlist .tailfield ] .hh.b1 = savestack [ saveptr + 0 ] .cint ; 
  584.     mem [ curlist .tailfield + 3 ] .cint = mem [ p + 3 ] .cint + mem [ p + 
  585.     2 ] .cint ; 
  586.     mem [ curlist .tailfield + 4 ] .hh .v.LH = mem [ p + 5 ] .hh .v.RH ; 
  587.     mem [ curlist .tailfield + 4 ] .hh .v.RH = q ; 
  588.     mem [ curlist .tailfield + 2 ] .cint = d ; 
  589.     mem [ curlist .tailfield + 1 ] .cint = f ; 
  590.       } 
  591.       else {
  592.       
  593.     {
  594.       mem [ curlist .tailfield ] .hh .v.RH = getnode ( 2 ) ; 
  595.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  596.     } 
  597.     mem [ curlist .tailfield ] .hh.b0 = 5 ; 
  598.     mem [ curlist .tailfield ] .hh.b1 = 0 ; 
  599.     mem [ curlist .tailfield + 1 ] .cint = mem [ p + 5 ] .hh .v.RH ; 
  600.     deleteglueref ( q ) ; 
  601.       } 
  602.       freenode ( p , 7 ) ; 
  603.       if ( nestptr == 0 ) 
  604.       buildpage () ; 
  605.     } 
  606.     break ; 
  607.   case 8 : 
  608.     {
  609.       if ( ( curinput .locfield != 0 ) || ( ( curinput .indexfield != 6 ) && ( 
  610.       curinput .indexfield != 3 ) ) ) 
  611.       {
  612.     {
  613.       if ( interaction == 3 ) 
  614.       wakeupterminal () ; 
  615.       printnl ( 262 ) ; 
  616.       print ( 1003 ) ; 
  617.     } 
  618.     {
  619.       helpptr = 2 ; 
  620.       helpline [ 1 ] = 1004 ; 
  621.       helpline [ 0 ] = 1005 ; 
  622.     } 
  623.     error () ; 
  624.     do {
  625.         gettoken () ; 
  626.     } while ( ! ( curinput .locfield == 0 ) ) ; 
  627.       } 
  628.       endtokenlist () ; 
  629.       endgraf () ; 
  630.       unsave () ; 
  631.       outputactive = false ; 
  632.       insertpenalties = 0 ; 
  633.       if ( eqtb [ 4833 ] .hh .v.RH != 0 ) 
  634.       {
  635.     {
  636.       if ( interaction == 3 ) 
  637.       wakeupterminal () ; 
  638.       printnl ( 262 ) ; 
  639.       print ( 1006 ) ; 
  640.     } 
  641.     printesc ( 405 ) ; 
  642.     printint ( 255 ) ; 
  643.     {
  644.       helpptr = 3 ; 
  645.       helpline [ 2 ] = 1007 ; 
  646.       helpline [ 1 ] = 1008 ; 
  647.       helpline [ 0 ] = 1009 ; 
  648.     } 
  649.     boxerror ( 255 ) ; 
  650.       } 
  651.       if ( curlist .tailfield != curlist .headfield ) 
  652.       {
  653.     mem [ pagetail ] .hh .v.RH = mem [ curlist .headfield ] .hh .v.RH ; 
  654.     pagetail = curlist .tailfield ; 
  655.       } 
  656.       if ( mem [ memtop - 2 ] .hh .v.RH != 0 ) 
  657.       {
  658.     if ( mem [ memtop - 1 ] .hh .v.RH == 0 ) 
  659.     nest [ 0 ] .tailfield = pagetail ; 
  660.     mem [ pagetail ] .hh .v.RH = mem [ memtop - 1 ] .hh .v.RH ; 
  661.     mem [ memtop - 1 ] .hh .v.RH = mem [ memtop - 2 ] .hh .v.RH ; 
  662.     mem [ memtop - 2 ] .hh .v.RH = 0 ; 
  663.     pagetail = memtop - 2 ; 
  664.       } 
  665.       popnest () ; 
  666.       buildpage () ; 
  667.     } 
  668.     break ; 
  669.   case 10 : 
  670.     builddiscretionary () ; 
  671.     break ; 
  672.   case 6 : 
  673.     {
  674.       backinput () ; 
  675.       curtok = 7610 ; 
  676.       {
  677.     if ( interaction == 3 ) 
  678.     wakeupterminal () ; 
  679.     printnl ( 262 ) ; 
  680.     print ( 621 ) ; 
  681.       } 
  682.       printesc ( 892 ) ; 
  683.       print ( 622 ) ; 
  684.       {
  685.     helpptr = 1 ; 
  686.     helpline [ 0 ] = 1118 ; 
  687.       } 
  688.       inserror () ; 
  689.     } 
  690.     break ; 
  691.   case 7 : 
  692.     {
  693.       endgraf () ; 
  694.       unsave () ; 
  695.       alignpeek () ; 
  696.     } 
  697.     break ; 
  698.   case 12 : 
  699.     {
  700.       endgraf () ; 
  701.       unsave () ; 
  702.       saveptr = saveptr - 2 ; 
  703.       p = vpackage ( mem [ curlist .headfield ] .hh .v.RH , savestack [ 
  704.       saveptr + 1 ] .cint , savestack [ saveptr + 0 ] .cint , 1073741823L ) ; 
  705.       popnest () ; 
  706.       {
  707.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  708.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  709.       } 
  710.       mem [ curlist .tailfield ] .hh.b0 = 29 ; 
  711.       mem [ curlist .tailfield + 1 ] .hh .v.RH = 2 ; 
  712.       mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  713.     } 
  714.     break ; 
  715.   case 13 : 
  716.     buildchoices () ; 
  717.     break ; 
  718.   case 9 : 
  719.     {
  720.       unsave () ; 
  721.       decr ( saveptr ) ; 
  722.       mem [ savestack [ saveptr + 0 ] .cint ] .hh .v.RH = 3 ; 
  723.       p = finmlist ( 0 ) ; 
  724.       mem [ savestack [ saveptr + 0 ] .cint ] .hh .v.LH = p ; 
  725.       if ( p != 0 ) 
  726.       if ( mem [ p ] .hh .v.RH == 0 ) 
  727.       if ( mem [ p ] .hh.b0 == 16 ) 
  728.       {
  729.     if ( mem [ p + 3 ] .hh .v.RH == 0 ) 
  730.     if ( mem [ p + 2 ] .hh .v.RH == 0 ) 
  731.     {
  732.       mem [ savestack [ saveptr + 0 ] .cint ] .hh = mem [ p + 1 ] .hh ; 
  733.       freenode ( p , 4 ) ; 
  734.     } 
  735.       } 
  736.       else if ( mem [ p ] .hh.b0 == 28 ) 
  737.       if ( savestack [ saveptr + 0 ] .cint == curlist .tailfield + 1 ) 
  738.       if ( mem [ curlist .tailfield ] .hh.b0 == 16 ) 
  739.       {
  740.     q = curlist .headfield ; 
  741.     while ( mem [ q ] .hh .v.RH != curlist .tailfield ) q = mem [ q ] .hh 
  742.     .v.RH ; 
  743.     mem [ q ] .hh .v.RH = p ; 
  744.     freenode ( curlist .tailfield , 4 ) ; 
  745.     curlist .tailfield = p ; 
  746.       } 
  747.     } 
  748.     break ; 
  749.     default: 
  750.     confusion ( 1040 ) ; 
  751.     break ; 
  752.   } 
  753. } 
  754. void maincontrol ( ) 
  755. {/* 60 21 70 80 90 91 92 95 100 101 110 111 112 120 10 */ maincontrol_regmem 
  756.   integer t  ; 
  757.   if ( eqtb [ 4319 ] .hh .v.RH != 0 ) 
  758.   begintokenlist ( eqtb [ 4319 ] .hh .v.RH , 12 ) ; 
  759.   lab60: getxtoken () ; 
  760.   lab21: if ( interrupt != 0 ) 
  761.   if ( OKtointerrupt ) 
  762.   {
  763.     backinput () ; 
  764.     {
  765.       if ( interrupt != 0 ) 
  766.       pauseforinstructions () ; 
  767.     } 
  768.     goto lab60 ; 
  769.   } 
  770.     ;
  771. #ifdef DEBUG
  772.   if ( panicking ) 
  773.   checkmem ( false ) ; 
  774. #endif /* DEBUG */
  775.   if ( eqtb [ 6199 ] .cint > 0 ) 
  776.   showcurcmdchr () ; 
  777.   switch ( abs ( curlist .modefield ) + curcmd ) 
  778.   {case 113 : 
  779.   case 114 : 
  780.   case 170 : 
  781.     goto lab70 ; 
  782.     break ; 
  783.   case 118 : 
  784.     {
  785.       scancharnum () ; 
  786.       curchr = curval ; 
  787.       goto lab70 ; 
  788.     } 
  789.     break ; 
  790.   case 167 : 
  791.     {
  792.       getxtoken () ; 
  793.       if ( ( curcmd == 11 ) || ( curcmd == 12 ) || ( curcmd == 68 ) || ( 
  794.       curcmd == 16 ) ) 
  795.       cancelboundary = true ; 
  796.       goto lab21 ; 
  797.     } 
  798.     break ; 
  799.   case 112 : 
  800.     if ( curlist .auxfield .hh .v.LH == 1000 ) 
  801.     goto lab120 ; 
  802.     else appspace () ; 
  803.     break ; 
  804.   case 166 : 
  805.   case 267 : 
  806.     goto lab120 ; 
  807.     break ; 
  808.   case 1 : 
  809.   case 102 : 
  810.   case 203 : 
  811.   case 11 : 
  812.   case 213 : 
  813.   case 268 : 
  814.     ; 
  815.     break ; 
  816.   case 40 : 
  817.   case 141 : 
  818.   case 242 : 
  819.     {
  820.       do {
  821.       getxtoken () ; 
  822.       } while ( ! ( curcmd != 10 ) ) ; 
  823.       goto lab21 ; 
  824.     } 
  825.     break ; 
  826.   case 15 : 
  827.     if ( itsallover () ) 
  828.     return ; 
  829.     break ; 
  830.   case 23 : 
  831.   case 123 : 
  832.   case 224 : 
  833.   case 71 : 
  834.   case 172 : 
  835.   case 273 : 
  836.   case 39 : 
  837.   case 45 : 
  838.   case 49 : 
  839.   case 150 : 
  840.   case 7 : 
  841.   case 108 : 
  842.   case 209 : 
  843.     reportillegalcase () ; 
  844.     break ; 
  845.   case 8 : 
  846.   case 109 : 
  847.   case 9 : 
  848.   case 110 : 
  849.   case 18 : 
  850.   case 119 : 
  851.   case 70 : 
  852.   case 171 : 
  853.   case 51 : 
  854.   case 152 : 
  855.   case 16 : 
  856.   case 117 : 
  857.   case 50 : 
  858.   case 151 : 
  859.   case 53 : 
  860.   case 154 : 
  861.   case 67 : 
  862.   case 168 : 
  863.   case 54 : 
  864.   case 155 : 
  865.   case 55 : 
  866.   case 156 : 
  867.   case 57 : 
  868.   case 158 : 
  869.   case 56 : 
  870.   case 157 : 
  871.   case 31 : 
  872.   case 132 : 
  873.   case 52 : 
  874.   case 153 : 
  875.   case 29 : 
  876.   case 130 : 
  877.   case 47 : 
  878.   case 148 : 
  879.   case 212 : 
  880.   case 216 : 
  881.   case 217 : 
  882.   case 230 : 
  883.   case 227 : 
  884.   case 236 : 
  885.   case 239 : 
  886.     insertdollarsign () ; 
  887.     break ; 
  888.   case 37 : 
  889.   case 137 : 
  890.   case 238 : 
  891.     {
  892.       {
  893.     mem [ curlist .tailfield ] .hh .v.RH = scanrulespec () ; 
  894.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  895.       } 
  896.       if ( abs ( curlist .modefield ) == 1 ) 
  897.       curlist .auxfield .cint = -65536000L ; 
  898.       else if ( abs ( curlist .modefield ) == 102 ) 
  899.       curlist .auxfield .hh .v.LH = 1000 ; 
  900.     } 
  901.     break ; 
  902.   case 28 : 
  903.   case 128 : 
  904.   case 229 : 
  905.   case 231 : 
  906.     appendglue () ; 
  907.     break ; 
  908.   case 30 : 
  909.   case 131 : 
  910.   case 232 : 
  911.   case 233 : 
  912.     appendkern () ; 
  913.     break ; 
  914.   case 2 : 
  915.   case 103 : 
  916.     newsavelevel ( 1 ) ; 
  917.     break ; 
  918.   case 62 : 
  919.   case 163 : 
  920.   case 264 : 
  921.     newsavelevel ( 14 ) ; 
  922.     break ; 
  923.   case 63 : 
  924.   case 164 : 
  925.   case 265 : 
  926.     if ( curgroup == 14 ) 
  927.     unsave () ; 
  928.     else offsave () ; 
  929.     break ; 
  930.   case 3 : 
  931.   case 104 : 
  932.   case 205 : 
  933.     handlerightbrace () ; 
  934.     break ; 
  935.   case 22 : 
  936.   case 124 : 
  937.   case 225 : 
  938.     {
  939.       t = curchr ; 
  940.       scandimen ( false , false , false ) ; 
  941.       if ( t == 0 ) 
  942.       scanbox ( curval ) ; 
  943.       else scanbox ( - (integer) curval ) ; 
  944.     } 
  945.     break ; 
  946.   case 32 : 
  947.   case 133 : 
  948.   case 234 : 
  949.     scanbox ( 1073742237L + curchr ) ; 
  950.     break ; 
  951.   case 21 : 
  952.   case 122 : 
  953.   case 223 : 
  954.     beginbox ( 0 ) ; 
  955.     break ; 
  956.   case 44 : 
  957.     newgraf ( curchr > 0 ) ; 
  958.     break ; 
  959.   case 12 : 
  960.   case 13 : 
  961.   case 17 : 
  962.   case 69 : 
  963.   case 4 : 
  964.   case 24 : 
  965.   case 36 : 
  966.   case 46 : 
  967.   case 48 : 
  968.   case 27 : 
  969.   case 34 : 
  970.   case 65 : 
  971.   case 66 : 
  972.     {
  973.       backinput () ; 
  974.       newgraf ( true ) ; 
  975.     } 
  976.     break ; 
  977.   case 145 : 
  978.   case 246 : 
  979.     indentinhmode () ; 
  980.     break ; 
  981.   case 14 : 
  982.     {
  983.       normalparagraph () ; 
  984.       if ( curlist .modefield > 0 ) 
  985.       buildpage () ; 
  986.     } 
  987.     break ; 
  988.   case 115 : 
  989.     {
  990.       if ( alignstate < 0 ) 
  991.       offsave () ; 
  992.       endgraf () ; 
  993.       if ( curlist .modefield == 1 ) 
  994.       buildpage () ; 
  995.     } 
  996.     break ; 
  997.   case 116 : 
  998.   case 129 : 
  999.   case 138 : 
  1000.   case 126 : 
  1001.   case 134 : 
  1002.     headforvmode () ; 
  1003.     break ; 
  1004.   case 38 : 
  1005.   case 139 : 
  1006.   case 240 : 
  1007.   case 140 : 
  1008.   case 241 : 
  1009.     begininsertoradjust () ; 
  1010.     break ; 
  1011.   case 19 : 
  1012.   case 120 : 
  1013.   case 221 : 
  1014.     makemark () ; 
  1015.     break ; 
  1016.   case 43 : 
  1017.   case 144 : 
  1018.   case 245 : 
  1019.     appendpenalty () ; 
  1020.     break ; 
  1021.   case 26 : 
  1022.   case 127 : 
  1023.   case 228 : 
  1024.     deletelast () ; 
  1025.     break ; 
  1026.   case 25 : 
  1027.   case 125 : 
  1028.   case 226 : 
  1029.     unpackage () ; 
  1030.     break ; 
  1031.   case 146 : 
  1032.     appenditaliccorrection () ; 
  1033.     break ; 
  1034.   case 247 : 
  1035.     {
  1036.       mem [ curlist .tailfield ] .hh .v.RH = newkern ( 0 ) ; 
  1037.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1038.     } 
  1039.     break ; 
  1040.   case 149 : 
  1041.   case 250 : 
  1042.     appenddiscretionary () ; 
  1043.     break ; 
  1044.   case 147 : 
  1045.     makeaccent () ; 
  1046.     break ; 
  1047.   case 6 : 
  1048.   case 107 : 
  1049.   case 208 : 
  1050.   case 5 : 
  1051.   case 106 : 
  1052.   case 207 : 
  1053.     alignerror () ; 
  1054.     break ; 
  1055.   case 35 : 
  1056.   case 136 : 
  1057.   case 237 : 
  1058.     noalignerror () ; 
  1059.     break ; 
  1060.   case 64 : 
  1061.   case 165 : 
  1062.   case 266 : 
  1063.     omiterror () ; 
  1064.     break ; 
  1065.   case 33 : 
  1066.   case 135 : 
  1067.     initalign () ; 
  1068.     break ; 
  1069.   case 235 : 
  1070.     if ( privileged () ) 
  1071.     if ( curgroup == 15 ) 
  1072.     initalign () ; 
  1073.     else offsave () ; 
  1074.     break ; 
  1075.   case 10 : 
  1076.   case 111 : 
  1077.     doendv () ; 
  1078.     break ; 
  1079.   case 68 : 
  1080.   case 169 : 
  1081.   case 270 : 
  1082.     cserror () ; 
  1083.     break ; 
  1084.   case 105 : 
  1085.     initmath () ; 
  1086.     break ; 
  1087.   case 251 : 
  1088.     if ( privileged () ) 
  1089.     if ( curgroup == 15 ) 
  1090.     starteqno () ; 
  1091.     else offsave () ; 
  1092.     break ; 
  1093.   case 204 : 
  1094.     {
  1095.       {
  1096.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  1097.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1098.       } 
  1099.       backinput () ; 
  1100.       scanmath ( curlist .tailfield + 1 ) ; 
  1101.     } 
  1102.     break ; 
  1103.   case 214 : 
  1104.   case 215 : 
  1105.   case 271 : 
  1106.     setmathchar ( eqtb [ 5907 + curchr ] .hh .v.RH ) ; 
  1107.     break ; 
  1108.   case 219 : 
  1109.     {
  1110.       scancharnum () ; 
  1111.       curchr = curval ; 
  1112.       setmathchar ( eqtb [ 5907 + curchr ] .hh .v.RH ) ; 
  1113.     } 
  1114.     break ; 
  1115.   case 220 : 
  1116.     {
  1117.       scanfifteenbitint () ; 
  1118.       setmathchar ( curval ) ; 
  1119.     } 
  1120.     break ; 
  1121.   case 272 : 
  1122.     setmathchar ( curchr ) ; 
  1123.     break ; 
  1124.   case 218 : 
  1125.     {
  1126.       scantwentysevenbitint () ; 
  1127.       setmathchar ( curval / 4096 ) ; 
  1128.     } 
  1129.     break ; 
  1130.   case 253 : 
  1131.     {
  1132.       {
  1133.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  1134.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1135.       } 
  1136.       mem [ curlist .tailfield ] .hh.b0 = curchr ; 
  1137.       scanmath ( curlist .tailfield + 1 ) ; 
  1138.     } 
  1139.     break ; 
  1140.   case 254 : 
  1141.     mathlimitswitch () ; 
  1142.     break ; 
  1143.   case 269 : 
  1144.     mathradical () ; 
  1145.     break ; 
  1146.   case 248 : 
  1147.   case 249 : 
  1148.     mathac () ; 
  1149.     break ; 
  1150.   case 259 : 
  1151.     {
  1152.       scanspec ( 12 , false ) ; 
  1153.       normalparagraph () ; 
  1154.       pushnest () ; 
  1155.       curlist .modefield = -1 ; 
  1156.       curlist .auxfield .cint = -65536000L ; 
  1157.       if ( eqtb [ 4318 ] .hh .v.RH != 0 ) 
  1158.       begintokenlist ( eqtb [ 4318 ] .hh .v.RH , 11 ) ; 
  1159.     } 
  1160.     break ; 
  1161.   case 256 : 
  1162.     {
  1163.       mem [ curlist .tailfield ] .hh .v.RH = newstyle ( curchr ) ; 
  1164.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1165.     } 
  1166.     break ; 
  1167.   case 258 : 
  1168.     {
  1169.       {
  1170.     mem [ curlist .tailfield ] .hh .v.RH = newglue ( 0 ) ; 
  1171.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1172.       } 
  1173.       mem [ curlist .tailfield ] .hh.b1 = 98 ; 
  1174.     } 
  1175.     break ; 
  1176.   case 257 : 
  1177.     appendchoices () ; 
  1178.     break ; 
  1179.   case 211 : 
  1180.   case 210 : 
  1181.     subsup () ; 
  1182.     break ; 
  1183.   case 255 : 
  1184.     mathfraction () ; 
  1185.     break ; 
  1186.   case 252 : 
  1187.     mathleftright () ; 
  1188.     break ; 
  1189.   case 206 : 
  1190.     if ( curgroup == 15 ) 
  1191.     aftermath () ; 
  1192.     else offsave () ; 
  1193.     break ; 
  1194.   case 72 : 
  1195.   case 173 : 
  1196.   case 274 : 
  1197.   case 73 : 
  1198.   case 174 : 
  1199.   case 275 : 
  1200.   case 74 : 
  1201.   case 175 : 
  1202.   case 276 : 
  1203.   case 75 : 
  1204.   case 176 : 
  1205.   case 277 : 
  1206.   case 76 : 
  1207.   case 177 : 
  1208.   case 278 : 
  1209.   case 77 : 
  1210.   case 178 : 
  1211.   case 279 : 
  1212.   case 78 : 
  1213.   case 179 : 
  1214.   case 280 : 
  1215.   case 79 : 
  1216.   case 180 : 
  1217.   case 281 : 
  1218.   case 80 : 
  1219.   case 181 : 
  1220.   case 282 : 
  1221.   case 81 : 
  1222.   case 182 : 
  1223.   case 283 : 
  1224.   case 82 : 
  1225.   case 183 : 
  1226.   case 284 : 
  1227.   case 83 : 
  1228.   case 184 : 
  1229.   case 285 : 
  1230.   case 84 : 
  1231.   case 185 : 
  1232.   case 286 : 
  1233.   case 85 : 
  1234.   case 186 : 
  1235.   case 287 : 
  1236.   case 86 : 
  1237.   case 187 : 
  1238.   case 288 : 
  1239.   case 87 : 
  1240.   case 188 : 
  1241.   case 289 : 
  1242.   case 88 : 
  1243.   case 189 : 
  1244.   case 290 : 
  1245.   case 89 : 
  1246.   case 190 : 
  1247.   case 291 : 
  1248.   case 90 : 
  1249.   case 191 : 
  1250.   case 292 : 
  1251.   case 91 : 
  1252.   case 192 : 
  1253.   case 293 : 
  1254.   case 92 : 
  1255.   case 193 : 
  1256.   case 294 : 
  1257.   case 93 : 
  1258.   case 194 : 
  1259.   case 295 : 
  1260.   case 94 : 
  1261.   case 195 : 
  1262.   case 296 : 
  1263.   case 95 : 
  1264.   case 196 : 
  1265.   case 297 : 
  1266.   case 96 : 
  1267.   case 197 : 
  1268.   case 298 : 
  1269.   case 97 : 
  1270.   case 198 : 
  1271.   case 299 : 
  1272.   case 98 : 
  1273.   case 199 : 
  1274.   case 300 : 
  1275.   case 99 : 
  1276.   case 200 : 
  1277.   case 301 : 
  1278.   case 100 : 
  1279.   case 201 : 
  1280.   case 302 : 
  1281.   case 101 : 
  1282.   case 202 : 
  1283.   case 303 : 
  1284.     prefixedcommand () ; 
  1285.     break ; 
  1286.   case 41 : 
  1287.   case 142 : 
  1288.   case 243 : 
  1289.     {
  1290.       gettoken () ; 
  1291.       aftertoken = curtok ; 
  1292.     } 
  1293.     break ; 
  1294.   case 42 : 
  1295.   case 143 : 
  1296.   case 244 : 
  1297.     {
  1298.       gettoken () ; 
  1299.       saveforafter ( curtok ) ; 
  1300.     } 
  1301.     break ; 
  1302.   case 61 : 
  1303.   case 162 : 
  1304.   case 263 : 
  1305.     openorclosein () ; 
  1306.     break ; 
  1307.   case 59 : 
  1308.   case 160 : 
  1309.   case 261 : 
  1310.     issuemessage () ; 
  1311.     break ; 
  1312.   case 58 : 
  1313.   case 159 : 
  1314.   case 260 : 
  1315.     shiftcase () ; 
  1316.     break ; 
  1317.   case 20 : 
  1318.   case 121 : 
  1319.   case 222 : 
  1320.     showwhatever () ; 
  1321.     break ; 
  1322.   case 60 : 
  1323.   case 161 : 
  1324.   case 262 : 
  1325.     doextension () ; 
  1326.     break ; 
  1327.   } 
  1328.   goto lab60 ; 
  1329.   lab70: mains = eqtb [ 5651 + curchr ] .hh .v.RH ; 
  1330.   if ( mains == 1000 ) 
  1331.   curlist .auxfield .hh .v.LH = 1000 ; 
  1332.   else if ( mains < 1000 ) 
  1333.   {
  1334.     if ( mains > 0 ) 
  1335.     curlist .auxfield .hh .v.LH = mains ; 
  1336.   } 
  1337.   else if ( curlist .auxfield .hh .v.LH < 1000 ) 
  1338.   curlist .auxfield .hh .v.LH = 1000 ; 
  1339.   else curlist .auxfield .hh .v.LH = mains ; 
  1340.   mainf = eqtb [ 4834 ] .hh .v.RH ; 
  1341.   bchar = fontbchar [ mainf ] ; 
  1342.   falsebchar = fontfalsebchar [ mainf ] ; 
  1343.   if ( curlist .modefield > 0 ) 
  1344.   if ( eqtb [ 6213 ] .cint != curlist .auxfield .hh .v.RH ) 
  1345.   fixlanguage () ; 
  1346.   {
  1347.     ligstack = avail ; 
  1348.     if ( ligstack == 0 ) 
  1349.     ligstack = getavail () ; 
  1350.     else {
  1351.     
  1352.       avail = mem [ ligstack ] .hh .v.RH ; 
  1353.       mem [ ligstack ] .hh .v.RH = 0 ; 
  1354.     ;
  1355. #ifdef STAT
  1356.       incr ( dynused ) ; 
  1357. #endif /* STAT */
  1358.     } 
  1359.   } 
  1360.   mem [ ligstack ] .hh.b0 = mainf ; 
  1361.   curl = curchr ; 
  1362.   mem [ ligstack ] .hh.b1 = curl ; 
  1363.   curq = curlist .tailfield ; 
  1364.   if ( cancelboundary ) 
  1365.   {
  1366.     cancelboundary = false ; 
  1367.     maink = fontmemsize ; 
  1368.   } 
  1369.   else maink = bcharlabel [ mainf ] ; 
  1370.   if ( maink == fontmemsize ) 
  1371.   goto lab92 ; 
  1372.   curr = curl ; 
  1373.   curl = 256 ; 
  1374.   goto lab111 ; 
  1375.   lab80: if ( curl < 256 ) 
  1376.   {
  1377.     if ( mem [ curlist .tailfield ] .hh.b1 == hyphenchar [ mainf ] ) 
  1378.     if ( mem [ curq ] .hh .v.RH > 0 ) 
  1379.     insdisc = true ; 
  1380.     if ( ligaturepresent ) 
  1381.     {
  1382.       mainp = newligature ( mainf , curl , mem [ curq ] .hh .v.RH ) ; 
  1383.       if ( lfthit ) 
  1384.       {
  1385.     mem [ mainp ] .hh.b1 = 2 ; 
  1386.     lfthit = false ; 
  1387.       } 
  1388.       if ( rthit ) 
  1389.       if ( ligstack == 0 ) 
  1390.       {
  1391.     incr ( mem [ mainp ] .hh.b1 ) ; 
  1392.     rthit = false ; 
  1393.       } 
  1394.       mem [ curq ] .hh .v.RH = mainp ; 
  1395.       curlist .tailfield = mainp ; 
  1396.       ligaturepresent = false ; 
  1397.     } 
  1398.     if ( insdisc ) 
  1399.     {
  1400.       insdisc = false ; 
  1401.       if ( curlist .modefield > 0 ) 
  1402.       {
  1403.     mem [ curlist .tailfield ] .hh .v.RH = newdisc () ; 
  1404.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1405.       } 
  1406.     } 
  1407.   } 
  1408.   lab90: if ( ligstack == 0 ) 
  1409.   goto lab21 ; 
  1410.   curq = curlist .tailfield ; 
  1411.   curl = curr ; 
  1412.   lab91: if ( ! ( ligstack >= himemmin ) ) 
  1413.   goto lab95 ; 
  1414.   lab92: if ( ( curchr < fontbc [ mainf ] ) || ( curchr > fontec [ mainf ] ) ) 
  1415.   {
  1416.     charwarning ( mainf , curchr ) ; 
  1417.     {
  1418.       mem [ ligstack ] .hh .v.RH = avail ; 
  1419.       avail = ligstack ; 
  1420.     ;
  1421. #ifdef STAT
  1422.       decr ( dynused ) ; 
  1423. #endif /* STAT */
  1424.     } 
  1425.     goto lab60 ; 
  1426.   } 
  1427.   maini = fontinfo [ charbase [ mainf ] + curl ] .qqqq ; 
  1428.   if ( ! ( maini .b0 > 0 ) ) 
  1429.   {
  1430.     charwarning ( mainf , curchr ) ; 
  1431.     {
  1432.       mem [ ligstack ] .hh .v.RH = avail ; 
  1433.       avail = ligstack ; 
  1434.     ;
  1435. #ifdef STAT
  1436.       decr ( dynused ) ; 
  1437. #endif /* STAT */
  1438.     } 
  1439.     goto lab60 ; 
  1440.   } 
  1441.   {
  1442.     mem [ curlist .tailfield ] .hh .v.RH = ligstack ; 
  1443.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1444.   } 
  1445.   lab100: getnext () ; 
  1446.   if ( curcmd == 11 ) 
  1447.   goto lab101 ; 
  1448.   if ( curcmd == 12 ) 
  1449.   goto lab101 ; 
  1450.   if ( curcmd == 68 ) 
  1451.   goto lab101 ; 
  1452.   xtoken () ; 
  1453.   if ( curcmd == 11 ) 
  1454.   goto lab101 ; 
  1455.   if ( curcmd == 12 ) 
  1456.   goto lab101 ; 
  1457.   if ( curcmd == 68 ) 
  1458.   goto lab101 ; 
  1459.   if ( curcmd == 16 ) 
  1460.   {
  1461.     scancharnum () ; 
  1462.     curchr = curval ; 
  1463.     goto lab101 ; 
  1464.   } 
  1465.   if ( curcmd == 65 ) 
  1466.   bchar = 256 ; 
  1467.   curr = bchar ; 
  1468.   ligstack = 0 ; 
  1469.   goto lab110 ; 
  1470.   lab101: mains = eqtb [ 5651 + curchr ] .hh .v.RH ; 
  1471.   if ( mains == 1000 ) 
  1472.   curlist .auxfield .hh .v.LH = 1000 ; 
  1473.   else if ( mains < 1000 ) 
  1474.   {
  1475.     if ( mains > 0 ) 
  1476.     curlist .auxfield .hh .v.LH = mains ; 
  1477.   } 
  1478.   else if ( curlist .auxfield .hh .v.LH < 1000 ) 
  1479.   curlist .auxfield .hh .v.LH = 1000 ; 
  1480.   else curlist .auxfield .hh .v.LH = mains ; 
  1481.   {
  1482.     ligstack = avail ; 
  1483.     if ( ligstack == 0 ) 
  1484.     ligstack = getavail () ; 
  1485.     else {
  1486.     
  1487.       avail = mem [ ligstack ] .hh .v.RH ; 
  1488.       mem [ ligstack ] .hh .v.RH = 0 ; 
  1489.     ;
  1490. #ifdef STAT
  1491.       incr ( dynused ) ; 
  1492. #endif /* STAT */
  1493.     } 
  1494.   } 
  1495.   mem [ ligstack ] .hh.b0 = mainf ; 
  1496.   curr = curchr ; 
  1497.   mem [ ligstack ] .hh.b1 = curr ; 
  1498.   if ( curr == falsebchar ) 
  1499.   curr = 256 ; 
  1500.   lab110: if ( ( ( maini .b2 ) % 4 ) != 1 ) 
  1501.   goto lab80 ; 
  1502.   maink = ligkernbase [ mainf ] + maini .b3 ; 
  1503.   mainj = fontinfo [ maink ] .qqqq ; 
  1504.   if ( mainj .b0 <= 128 ) 
  1505.   goto lab112 ; 
  1506.   maink = ligkernbase [ mainf ] + 256 * mainj .b2 + mainj .b3 + 32768L - 256 * 
  1507.   ( 128 ) ; 
  1508.   lab111: mainj = fontinfo [ maink ] .qqqq ; 
  1509.   lab112: if ( mainj .b1 == curr ) 
  1510.   if ( mainj .b0 <= 128 ) 
  1511.   {
  1512.     if ( mainj .b2 >= 128 ) 
  1513.     {
  1514.       if ( curl < 256 ) 
  1515.       {
  1516.     if ( mem [ curlist .tailfield ] .hh.b1 == hyphenchar [ mainf ] ) 
  1517.     if ( mem [ curq ] .hh .v.RH > 0 ) 
  1518.     insdisc = true ; 
  1519.     if ( ligaturepresent ) 
  1520.     {
  1521.       mainp = newligature ( mainf , curl , mem [ curq ] .hh .v.RH ) ; 
  1522.       if ( lfthit ) 
  1523.       {
  1524.         mem [ mainp ] .hh.b1 = 2 ; 
  1525.         lfthit = false ; 
  1526.       } 
  1527.       if ( rthit ) 
  1528.       if ( ligstack == 0 ) 
  1529.       {
  1530.         incr ( mem [ mainp ] .hh.b1 ) ; 
  1531.         rthit = false ; 
  1532.       } 
  1533.       mem [ curq ] .hh .v.RH = mainp ; 
  1534.       curlist .tailfield = mainp ; 
  1535.       ligaturepresent = false ; 
  1536.     } 
  1537.     if ( insdisc ) 
  1538.     {
  1539.       insdisc = false ; 
  1540.       if ( curlist .modefield > 0 ) 
  1541.       {
  1542.         mem [ curlist .tailfield ] .hh .v.RH = newdisc () ; 
  1543.         curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1544.       } 
  1545.     } 
  1546.       } 
  1547.       {
  1548.     mem [ curlist .tailfield ] .hh .v.RH = newkern ( fontinfo [ kernbase [ 
  1549.     mainf ] + 256 * mainj .b2 + mainj .b3 ] .cint ) ; 
  1550.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1551.       } 
  1552.       goto lab90 ; 
  1553.     } 
  1554.     if ( curl == 256 ) 
  1555.     lfthit = true ; 
  1556.     else if ( ligstack == 0 ) 
  1557.     rthit = true ; 
  1558.     {
  1559.       if ( interrupt != 0 ) 
  1560.       pauseforinstructions () ; 
  1561.     } 
  1562.     switch ( mainj .b2 ) 
  1563.     {case 1 : 
  1564.     case 5 : 
  1565.       {
  1566.     curl = mainj .b3 ; 
  1567.     maini = fontinfo [ charbase [ mainf ] + curl ] .qqqq ; 
  1568.     ligaturepresent = true ; 
  1569.       } 
  1570.       break ; 
  1571.     case 2 : 
  1572.     case 6 : 
  1573.       {
  1574.     curr = mainj .b3 ; 
  1575.     if ( ligstack == 0 ) 
  1576.     {
  1577.       ligstack = newligitem ( curr ) ; 
  1578.       bchar = 256 ; 
  1579.     } 
  1580.     else if ( ( ligstack >= himemmin ) ) 
  1581.     {
  1582.       mainp = ligstack ; 
  1583.       ligstack = newligitem ( curr ) ; 
  1584.       mem [ ligstack + 1 ] .hh .v.RH = mainp ; 
  1585.     } 
  1586.     else mem [ ligstack ] .hh.b1 = curr ; 
  1587.       } 
  1588.       break ; 
  1589.     case 3 : 
  1590.       {
  1591.     curr = mainj .b3 ; 
  1592.     mainp = ligstack ; 
  1593.     ligstack = newligitem ( curr ) ; 
  1594.     mem [ ligstack ] .hh .v.RH = mainp ; 
  1595.       } 
  1596.       break ; 
  1597.     case 7 : 
  1598.     case 11 : 
  1599.       {
  1600.     if ( curl < 256 ) 
  1601.     {
  1602.       if ( mem [ curlist .tailfield ] .hh.b1 == hyphenchar [ mainf ] ) 
  1603.       if ( mem [ curq ] .hh .v.RH > 0 ) 
  1604.       insdisc = true ; 
  1605.       if ( ligaturepresent ) 
  1606.       {
  1607.         mainp = newligature ( mainf , curl , mem [ curq ] .hh .v.RH ) ; 
  1608.         if ( lfthit ) 
  1609.         {
  1610.           mem [ mainp ] .hh.b1 = 2 ; 
  1611.           lfthit = false ; 
  1612.         } 
  1613.         if ( false ) 
  1614.         if ( ligstack == 0 ) 
  1615.         {
  1616.           incr ( mem [ mainp ] .hh.b1 ) ; 
  1617.           rthit = false ; 
  1618.         } 
  1619.         mem [ curq ] .hh .v.RH = mainp ; 
  1620.         curlist .tailfield = mainp ; 
  1621.         ligaturepresent = false ; 
  1622.       } 
  1623.       if ( insdisc ) 
  1624.       {
  1625.         insdisc = false ; 
  1626.         if ( curlist .modefield > 0 ) 
  1627.         {
  1628.           mem [ curlist .tailfield ] .hh .v.RH = newdisc () ; 
  1629.           curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1630.         } 
  1631.       } 
  1632.     } 
  1633.     curq = curlist .tailfield ; 
  1634.     curl = mainj .b3 ; 
  1635.     maini = fontinfo [ charbase [ mainf ] + curl ] .qqqq ; 
  1636.     ligaturepresent = true ; 
  1637.       } 
  1638.       break ; 
  1639.       default: 
  1640.       {
  1641.     curl = mainj .b3 ; 
  1642.     ligaturepresent = true ; 
  1643.     if ( ligstack == 0 ) 
  1644.     goto lab80 ; 
  1645.     else goto lab91 ; 
  1646.       } 
  1647.       break ; 
  1648.     } 
  1649.     if ( mainj .b2 > 4 ) 
  1650.     if ( mainj .b2 != 7 ) 
  1651.     goto lab80 ; 
  1652.     if ( curl < 256 ) 
  1653.     goto lab110 ; 
  1654.     maink = bcharlabel [ mainf ] ; 
  1655.     goto lab111 ; 
  1656.   } 
  1657.   if ( mainj .b0 == 0 ) 
  1658.   incr ( maink ) ; 
  1659.   else {
  1660.       
  1661.     if ( mainj .b0 >= 128 ) 
  1662.     goto lab80 ; 
  1663.     maink = maink + mainj .b0 + 1 ; 
  1664.   } 
  1665.   goto lab111 ; 
  1666.   lab95: mainp = mem [ ligstack + 1 ] .hh .v.RH ; 
  1667.   if ( mainp > 0 ) 
  1668.   {
  1669.     mem [ curlist .tailfield ] .hh .v.RH = mainp ; 
  1670.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1671.   } 
  1672.   tempptr = ligstack ; 
  1673.   ligstack = mem [ tempptr ] .hh .v.RH ; 
  1674.   freenode ( tempptr , 2 ) ; 
  1675.   maini = fontinfo [ charbase [ mainf ] + curl ] .qqqq ; 
  1676.   ligaturepresent = true ; 
  1677.   if ( ligstack == 0 ) 
  1678.   if ( mainp > 0 ) 
  1679.   goto lab100 ; 
  1680.   else curr = bchar ; 
  1681.   else curr = mem [ ligstack ] .hh.b1 ; 
  1682.   goto lab110 ; 
  1683.   lab120: if ( eqtb [ 3794 ] .hh .v.RH == 0 ) 
  1684.   {
  1685.     {
  1686.       mainp = fontglue [ eqtb [ 4834 ] .hh .v.RH ] ; 
  1687.       if ( mainp == 0 ) 
  1688.       {
  1689.     mainp = newspec ( 0 ) ; 
  1690.     maink = parambase [ eqtb [ 4834 ] .hh .v.RH ] + 2 ; 
  1691.     mem [ mainp + 1 ] .cint = fontinfo [ maink ] .cint ; 
  1692.     mem [ mainp + 2 ] .cint = fontinfo [ maink + 1 ] .cint ; 
  1693.     mem [ mainp + 3 ] .cint = fontinfo [ maink + 2 ] .cint ; 
  1694.     fontglue [ eqtb [ 4834 ] .hh .v.RH ] = mainp ; 
  1695.       } 
  1696.     } 
  1697.     tempptr = newglue ( mainp ) ; 
  1698.   } 
  1699.   else tempptr = newparamglue ( 12 ) ; 
  1700.   mem [ curlist .tailfield ] .hh .v.RH = tempptr ; 
  1701.   curlist .tailfield = tempptr ; 
  1702.   goto lab60 ; 
  1703. } 
  1704.