home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / tex2.c < prev    next >
C/C++ Source or Header  |  1991-08-24  |  22KB  |  1,008 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. /* preparemag() nach tex7.c */
  5.  
  6. void tokenshow ( halfword p )
  7. { tokenshow_regmem 
  8.  
  9.   if ( p != 0 ) 
  10.     showtokenlist ( link ( p ) , 0 , 10000000L ) ; 
  11. }
  12.  
  13. void printmeaning ( void )
  14. { printmeaning_regmem 
  15.  
  16.   printcmdchr ( curcmd , curchr ) ; 
  17.   if ( curcmd >= call ) {
  18.     printchar ( 58 ) ; 
  19.     println () ; 
  20.     tokenshow ( curchr ) ; 
  21.   } else if ( curcmd == topbotmark ) {
  22.     printchar ( 58 ) ; 
  23.     println () ; 
  24.     tokenshow ( curmark [ curchr ] ) ; 
  25.   } 
  26. }
  27.  
  28.  
  29. void showcurcmdchr ( void )
  30. { showcurcmdchr_regmem 
  31.  
  32.   begindiagnostic () ; 
  33.   printnl ( 123 ) ; 
  34.   if ( curlist .modefield != shownmode ) {
  35.     printmode ( curlist .modefield ) ; 
  36.     c_print(": "); /* 564 */
  37.     shownmode = curlist .modefield ; 
  38.   }
  39.   printcmdchr ( curcmd , curchr ) ; 
  40.   printchar ( 125 ) ; 
  41.   enddiagnostic ( false ) ; 
  42. }
  43.  
  44.  
  45. void showcontext ( void )
  46. {/* 30 */ showcontext_regmem 
  47.   register integer oldsetting  ; 
  48.   register integer nn  ; 
  49.   boolean bottomline  ; 
  50.   register integer i  ; 
  51.   register integer j  ; 
  52.   register integer l  ; 
  53.   register integer m  ; 
  54.   register integer n  ; 
  55.   register integer p  ; 
  56.   register integer q  ; 
  57.  
  58.   baseptr = inputptr ; 
  59. #ifndef INP_PTR
  60.   inputstack [ baseptr ] = curinput ; 
  61. #endif
  62.   nn = -1 ; 
  63.   bottomline = false ; 
  64.   while ( true ) {
  65. #ifdef INP_PTR
  66.     curinput_ptr = &inputstack [ baseptr ] ; 
  67. #else
  68.     curinput = inputstack [ baseptr ] ;
  69. #endif
  70.     if ( ( curinput .statefield != tokenlist ) ) 
  71.       if ( ( curinput .namefield > 17 ) || ( baseptr == 0 ) ) 
  72.     bottomline = true ; 
  73.     if ( baseptr == inputptr || bottomline || nn < errorcontextlines ) {
  74.       if ( ( baseptr == inputptr ) || ( curinput .statefield != tokenlist )
  75.        || ( tokentype != backedup ) || ( curinput .locfield != 0 ) ) {
  76.     tally = 0 ; 
  77.     oldsetting = selector ; 
  78.     if ( curinput .statefield != tokenlist ) {
  79.       if ( curinput .namefield <= 17 )
  80.         if ( ( curinput .namefield == 0 ) ) 
  81.           if ( baseptr == 0 ) 
  82.         c_printnl("<*>");
  83.           else
  84.         c_printnl("<insert> ");
  85.         else {
  86.           c_printnl("<read ");
  87.           if ( curinput .namefield == 17 ) 
  88.         printchar ( 42 ) ; 
  89.           else
  90.         printint ( curinput .namefield - 1 ) ; 
  91.           printchar ( 62 ) ; 
  92.         }
  93.       else {
  94.         c_printnl("l.");
  95.         printint ( line ) ; 
  96.       } 
  97.       printchar ( 32 ) ; 
  98.       {
  99.         l = tally ; 
  100.         tally = 0 ; 
  101.         selector = pseudo ; 
  102.         trickcount = 1000000L ; 
  103.       } 
  104.       if ( buffer [ curinput .limitfield ] == endlinechar ) 
  105.         j = curinput .limitfield ; 
  106.       else
  107.         j = curinput .limitfield + 1 ; 
  108.       if ( j > 0 ) 
  109.         for ( i = curinput .startfield ; i <= j - 1 ; i++ ) {
  110.           if ( i == curinput .locfield ) {
  111.         firstcount = tally ; 
  112.         trickcount = tally + 1 + errorline - halferrorline ; 
  113.         if ( trickcount < errorline ) 
  114.         trickcount = errorline ; 
  115.           }
  116.           print ( buffer [ i ] ) ; 
  117.         }
  118.     } else {
  119.       switch ( tokentype ) {
  120.       case parameter : 
  121.         c_printnl("<argument> ");
  122.         break ; 
  123.       case utemplate : 
  124.       case vtemplate : 
  125.         c_printnl("<template> ");
  126.         break ; 
  127.       case backedup : 
  128.         if ( curinput .locfield == 0 ) 
  129.           c_printnl("<recently read> ");
  130.         else
  131.           c_printnl("<to be read again> ");
  132.         break ; 
  133.       case inserted : 
  134.         c_printnl("<inserted text> ");
  135.         break ; 
  136.       case macro : 
  137.         println () ; 
  138.         printcs ( curinput .namefield ) ; 
  139.         break ; 
  140.       case outputtext : 
  141.         c_printnl("<output> ");
  142.         break ; 
  143.       case everypartext : 
  144.         c_printnl("<everypar> ");
  145.         break ; 
  146.       case everymathtext : 
  147.         c_printnl("<everymath> ");
  148.         break ; 
  149.       case everydisplaytext : 
  150.         c_printnl("<everydisplay> ");
  151.         break ; 
  152.       case everyhboxtext : 
  153.         c_printnl("<everyhbox> ");
  154.         break ; 
  155.       case everyvboxtext : 
  156.         c_printnl("<everyvbox> ");
  157.         break ; 
  158.       case everyjobtext : 
  159.         c_printnl("<everyjob> ");
  160.         break ; 
  161.       case everycrtext : 
  162.         c_printnl("<everycr> ");
  163.         break ; 
  164.       case marktext : 
  165.         c_printnl("<mark> ");
  166.         break ; 
  167.       case writetext : 
  168.         c_printnl("<write> ");
  169.         break ; 
  170.       default: 
  171.         printnl ( 63 );
  172.         break ; 
  173.       }
  174.       {
  175.         l = tally ; 
  176.         tally = 0 ; 
  177.         selector = pseudo ; 
  178.         trickcount = 1000000L ; 
  179.       }
  180.       if ( tokentype < macro ) 
  181.         showtokenlist (curinput .startfield, curinput .locfield, 100000L);
  182.       else
  183.         showtokenlist ( link ( curinput .startfield ),
  184.                 curinput .locfield, 100000L );
  185.     }
  186.     selector = oldsetting ; 
  187.     if ( trickcount == 1000000L ) {
  188.       firstcount = tally ; 
  189.       trickcount = tally + 1 + errorline - halferrorline ; 
  190.       if ( trickcount < errorline ) 
  191.         trickcount = errorline ;
  192.     }
  193.     m = ( (tally < trickcount) ? tally : trickcount ) - firstcount;
  194.     if ( l + firstcount <= halferrorline ) {
  195.       p = 0 ; 
  196.       n = l + firstcount ; 
  197.     } else {
  198.       print ( 275 ) ; 
  199.       p = l + firstcount - halferrorline + 3 ; 
  200.       n = halferrorline ; 
  201.     } 
  202.     for( q = p ; q <= firstcount - 1 ; q++ ) {
  203.       printchar ( trickbuf [ q % errorline ] ) ;
  204.     }
  205.     println () ; 
  206.     for( q = n ; q >= 1 ; --q ) {
  207.       printchar ( 32 ) ;
  208.     }
  209.     if ( m + n <= errorline ) 
  210.       p = firstcount + m ; 
  211.     else
  212.       p = firstcount + ( errorline - n - 3 ) ; 
  213.     for( q = firstcount ; q <= p - 1 ; q++ ) {
  214.       printchar ( trickbuf [ q % errorline ] ) ;
  215.     }
  216.     if ( m + n > errorline ) 
  217.       print ( 275 ) ;
  218.     incr ( nn ) ; 
  219.       }
  220.     } else if ( nn == errorcontextlines ) {
  221.       printnl ( 275 ) ; 
  222.       incr ( nn ) ; 
  223.     }
  224.     if ( bottomline ) 
  225.       goto lab30 ; 
  226.     decr ( baseptr ) ; 
  227.   }
  228. lab30:
  229. #ifdef INP_PTR
  230.   curinput_ptr = &inputstack [ inputptr ] ; 
  231. #else
  232.   curinput = inputstack [ inputptr ] ; 
  233. #endif
  234. }
  235.  
  236.  
  237. void begintokenlist ( halfword p, quarterword t )
  238. { begintokenlist_regmem
  239.  
  240.   {
  241.     if ( inputptr > maxinstack ) {
  242.       maxinstack = inputptr ; 
  243.       if ( inputptr == stacksize )        /* hier evtl. noch aendern */
  244.         overflow(8, stacksize);
  245.     }
  246. #ifdef INP_PTR
  247.     incr ( inputptr ) ;
  248.     curinput_ptr++;
  249. #else
  250.     inputstack [ inputptr ] = curinput ; 
  251.     incr ( inputptr ) ; 
  252. #endif
  253.   } 
  254.  
  255.   {
  256. #ifndef INP_PTR
  257.     register instaterecord *curinputPTR = &curinput;
  258. #   define curinput (*curinputPTR)
  259. #endif
  260.  
  261.   curinput .statefield = tokenlist ; 
  262.   tokentype = t ; 
  263.   curinput .startfield = p ; 
  264.   if ( t >= macro ) {
  265.     addtokenref ( p ) ; 
  266.     if ( t == macro ) 
  267.       paramstart = paramptr ; 
  268.     else {
  269.       curinput .locfield = link ( p ) ; 
  270.       if ( tracingmacros > 1 ) {
  271.     begindiagnostic () ; 
  272.     c_printnl("");
  273.     switch ( t ) {
  274.     case marktext : 
  275.       printesc ( 348 ) ; 
  276.       break ; 
  277.     case writetext : 
  278.       printesc ( STR_WRITE );
  279.       break ; 
  280.     default: 
  281.       printcmdchr( assign_toks, t - outputtext + outputroutineloc );
  282.       break ; 
  283.     }
  284.     c_print("->");
  285.     tokenshow ( p ) ; 
  286.     enddiagnostic ( false ) ; 
  287.       } 
  288.     }
  289.   } else
  290.     curinput .locfield = p ;
  291.  
  292. #ifndef INP_PTR
  293. # undef curinput
  294. #endif
  295.   }
  296. }
  297.  
  298.  
  299. void endtokenlist ( void )
  300. { endtokenlist_regmem 
  301.  
  302. #ifndef INP_PTR
  303.   register instaterecord *curinputPTR = &curinput;
  304. # define curinput (*curinputPTR)
  305. #endif
  306.  
  307.   if ( tokentype >= backedup ) {
  308.     if ( tokentype <= inserted ) 
  309.       flushlist ( curinput.startfield ) ; 
  310.     else {
  311.       deletetokenref ( curinput.startfield ) ; 
  312.       if ( tokentype == macro ) {
  313. #if 0 /* def PARAM_PTR */
  314.     long anzahl = paramptr - paramstart;
  315.     halfword *psp = ¶mstack[paramptr];
  316.  
  317.     while ( anzahl-- > 0 ) {
  318.       flushlist( *psp );
  319.       psp--;
  320.     }
  321.     paramptr = paramstart;
  322. #else
  323.     while ( paramptr > paramstart ) {
  324.       decr ( paramptr ) ; 
  325.       flushlist ( paramstack [ paramptr ] ) ; 
  326.     } 
  327. #endif
  328.       }
  329.     }
  330.   } else if ( tokentype == utemplate ) 
  331.     if ( alignstate > 500000L ) 
  332.       alignstate = 0 ; 
  333.     else fatalerror( STR_H_FE_INTERWOVEN );
  334.  
  335.   {
  336.     decr ( inputptr ) ; 
  337. #ifdef INP_PTR
  338.     --curinput_ptr;
  339. #else
  340.     curinput = inputstack [ inputptr ] ; 
  341. #endif
  342.   } 
  343.   {
  344.     if ( interrupt != 0 ) 
  345.     pauseforinstructions () ; 
  346.   }
  347. #ifndef INP_PTR
  348. # undef curinput
  349. #endif
  350. }
  351.  
  352.  
  353. void backinput ( void )
  354. {
  355. #ifndef INP_PTR
  356.   register instaterecord *curinputPTR = &curinput;
  357. # define curinput (*curinputPTR)
  358. #endif
  359.  
  360.   while ( curinput .statefield == tokenlist && curinput .locfield == 0 )
  361.     endtokenlist();
  362.  
  363.   { register long_halfword p;
  364.  
  365.   p = getavail();
  366.  
  367.   { backinput_regmem 
  368.     register halfword r_curtok = curtok;
  369.  
  370.   info ( p ) = r_curtok ; 
  371.   if ( r_curtok < rightbracelimit )
  372.     if ( r_curtok < leftbracelimit )
  373.       decr ( alignstate ) ;
  374.     else
  375.       incr ( alignstate ) ;
  376.   }
  377.  
  378.   { register integer r_inputptr = inputptr;
  379.  
  380.     if ( r_inputptr > maxinstack ) {
  381.       maxinstack = r_inputptr ; 
  382.       if ( r_inputptr == stacksize ) 
  383.         overflow(8, stacksize); 
  384.     }
  385. #ifdef INP_PTR
  386.     incr ( r_inputptr ) ;
  387.     curinput_ptr++;
  388. #else
  389.     inputstack [ r_inputptr ] = curinput ; 
  390.     incr ( r_inputptr ) ;
  391. #endif
  392.  
  393.     inputptr = r_inputptr;
  394.   }
  395.   curinput .statefield = tokenlist ; 
  396.   tokentype = backedup ; 
  397.   curinput .startfield = p ; 
  398.   curinput .locfield = p ; 
  399.   }
  400. #ifndef INP_PTR
  401. # undef curinput
  402. #endif
  403. }
  404.  
  405.  
  406. void backerror ( void )
  407. { backerror_regmem 
  408.  
  409.   OKtointerrupt = false ; 
  410.   backinput () ; 
  411.   OKtointerrupt = true ; 
  412.   error () ; 
  413. } 
  414.  
  415.  
  416. void inserror ( void )
  417. { inserror_regmem
  418.  
  419.   OKtointerrupt = false ; 
  420.   backinput () ; 
  421.   tokentype = inserted ; 
  422.   OKtointerrupt = true ; 
  423.   error () ; 
  424. } 
  425.  
  426.  
  427. void beginfilereading ( void )
  428. { beginfilereading_regmem 
  429.  
  430.   if ( inopen == maxinopen ) 
  431.     overflow(9, maxinopen);
  432.   if ( first == bufsize ) 
  433.     overflow(1, bufsize);
  434.   incr ( inopen ) ; 
  435.   {
  436.     if ( inputptr > maxinstack ) {
  437.       maxinstack = inputptr ; 
  438.       if ( inputptr == stacksize ) 
  439.     overflow(8, stacksize);
  440.     } 
  441. #ifdef INP_PTR
  442.     incr ( inputptr ) ; 
  443.     curinput_ptr++;
  444.     curinput.locfield = (*(curinput_ptr-1)).locfield;
  445.     curinput.limitfield = (*(curinput_ptr-1)).limitfield;
  446. #else
  447.     inputstack [ inputptr ] = curinput ; 
  448.     incr ( inputptr ) ; 
  449. #endif
  450.   } 
  451.   curinput .indexfield = inopen ; 
  452.   linestack [ curinput .indexfield ] = line ; 
  453.   curinput .startfield = first ; 
  454.   curinput .statefield = 1 ; 
  455.   curinput .namefield = 0 ; 
  456. }
  457.  
  458.  
  459. void endfilereading ( void )
  460. { endfilereading_regmem 
  461.  
  462.   first = curinput .startfield ; 
  463.   line = linestack [ curinput .indexfield ] ; 
  464.   if ( curinput .namefield > 17 ) 
  465.     aclose ( inputfile [ curinput .indexfield ] ) ; 
  466.   {
  467.     decr ( inputptr ) ; 
  468. #ifdef INP_PTR
  469.     --curinput_ptr;
  470. #else
  471.     curinput = inputstack [ inputptr ] ; 
  472. #endif
  473.   } 
  474.   decr ( inopen ) ; 
  475. }
  476.  
  477.  
  478. void clearforerrorprompt ( void )
  479. { clearforerrorprompt_regmem 
  480.  
  481.   while ( ( curinput .statefield != tokenlist )
  482.     && ( curinput .namefield == 0 )
  483.     && ( inputptr > 0 )
  484.     && ( curinput .locfield > curinput .limitfield ) )
  485.     endfilereading () ;
  486.   println () ; 
  487.   clearterminal () ; 
  488. } 
  489.  
  490.  
  491. void checkoutervalidity ( void )
  492. { checkoutervalidity_regmem 
  493.  
  494.   if ( scannerstatus != normal ) {
  495.     deletionsallowed = false ; 
  496.     if ( curcs != 0 ) {
  497.       if ( ( curinput .statefield == tokenlist )
  498.         || ( curinput .namefield < 1 )
  499.         || ( curinput .namefield > 17 ) ) {
  500.     register long_halfword p;
  501.  
  502.     p = getavail();
  503.     info ( p ) = cstokenflag + curcs;
  504.     begintokenlist( p, backedup );
  505.       }
  506.       curcmd = 10 ; 
  507.       curchr = 32 ; 
  508.     }
  509.     if ( scannerstatus > skipping ) {
  510.       runaway () ; 
  511.       if ( curcs == 0 ) {
  512.     print_err("File ended");
  513.       } else {
  514.     curcs = 0 ; 
  515.     print_err("Forbidden control sequence found");
  516.       }
  517.       c_print(" while scanning ");
  518.  
  519.      { register halfword p;
  520.  
  521.       p = getavail () ; 
  522.       switch ( scannerstatus ) {
  523.       case defining : 
  524.     {
  525.       c_print("definition");
  526.       info ( p ) = rightbracetoken + 125 ; 
  527.     } 
  528.     break ; 
  529.       case matching : 
  530.     {
  531.       c_print("use");
  532.       info ( p ) = partoken ; 
  533.       longstate = outercall ; 
  534.     } 
  535.     break ; 
  536.       case aligning : 
  537.     { register halfword q;
  538.  
  539.       c_print("preamble");
  540.       info ( p ) = rightbracetoken + 125 ; 
  541.       q = p ; 
  542.       p = getavail () ; 
  543.       link ( p ) = q ; 
  544.       info ( p ) = cstokenflag + frozencr ; 
  545.       alignstate = -1000000L ; 
  546.     }
  547.     break ; 
  548.       case absorbing :
  549.     {
  550.       c_print("text");
  551.       info ( p ) = rightbracetoken + 125;
  552.     }
  553.     break;
  554.       }
  555.       begintokenlist( p, inserted);
  556.      }
  557.       c_print(" of ");
  558.       sprintcs( warningindex );
  559.       zhelp1( STR_H_ISUSPECT_FORGOTTEN );
  560.       error();
  561.     } else {
  562.       print_err("Incomplete ");
  563.       printcmdchr( iftest, curif );
  564.       c_print("; all text was ignored after line ");
  565.       printint ( skipline );
  566.       if ( curcs != 0 ) {
  567.     zhelp2( STR_H_AFORBIDDEN_SKIPPED, STR_H_THISKIND_HAPPENS_IF );
  568.     curcs = 0;
  569.       } else {
  570.     zhelp2( STR_H_THEFILEENDEDWHILE, STR_H_THISKIND_HAPPENS_IF );
  571.       }
  572.       curtok = cstokenflag + frozenfi;
  573.       inserror();
  574.     }
  575.     deletionsallowed = true;
  576.   }
  577. }
  578.  
  579.  
  580. void firmuptheline ( void )
  581. { firmuptheline_regmem 
  582.   register integer k  ;
  583.  
  584. #if 0            /* (br) deleted */
  585.   curinput .limitfield = last ; 
  586.   if ( pausing > 0 )
  587. #endif
  588.   if ( interaction > nonstopmode ) {
  589.     wakeupterminal () ; 
  590.     println () ; 
  591.     if ( curinput .startfield < curinput .limitfield ) 
  592.     {register integer for_end; k = curinput .startfield ; for_end = curinput 
  593.     .limitfield - 1 ; if ( k <= for_end) do 
  594.       print ( buffer [ k ] ) ; 
  595.     while ( k++ < for_end ) ; } 
  596.     first = curinput .limitfield;
  597.     terminput("=>");
  598.     if ( last > first ) {
  599.       {register integer for_end; k = first ; for_end = last - 1 ; if ( k <= 
  600.       for_end) do 
  601.     buffer [ k + curinput .startfield - first ] = buffer [ k ] ; 
  602.       while ( k++ < for_end ) ; } 
  603.       curinput .limitfield = curinput .startfield + last - first ; 
  604.     }
  605.   }
  606. }
  607.  
  608.  
  609.  
  610. void macrocall ( void )
  611. { macrocall_regmem 
  612.   register halfword r;
  613.   halfword p;
  614.   register halfword s;
  615.   halfword rbraceptr; 
  616.   register smallnumber n;
  617.   register halfword unbalance;
  618.   register halfword m;
  619.   halfword refcount;
  620.   smallnumber savescannerstatus;
  621.   halfword savewarningindex;
  622.   ASCIIcode matchchr;
  623.  
  624.   savescannerstatus = scannerstatus ; 
  625.   savewarningindex = warningindex ; 
  626.   warningindex = curcs ; 
  627.   refcount = curchr;
  628.   r = link ( refcount ) ; 
  629.   n = 0 ; 
  630.   if ( tracingmacros > 0 ) {
  631.     begindiagnostic () ; 
  632.     println () ; 
  633.     printcs ( warningindex ) ; 
  634.     tokenshow ( refcount ) ; 
  635.     enddiagnostic ( false ) ; 
  636.   } 
  637.   if ( info ( r ) != endmatchtoken ) {
  638.     scannerstatus = matching ; 
  639.     unbalance = 0 ; 
  640.     longstate = eqtype ( curcs ) ; 
  641.     if ( longstate >= outercall ) 
  642.       longstate = longstate - 2 ; 
  643.     do {
  644.       link ( temphead ) = 0 ; 
  645.       if ( ( info ( r ) > matchtoken + 255 ) || ( info ( r ) < matchtoken ) ) 
  646.         s = 0 ; 
  647.       else {
  648.     matchchr = info ( r ) - matchtoken ; 
  649.     s = link ( r ) ; 
  650.     r = s ; 
  651.     p = temphead ; 
  652.     m = 0 ; 
  653.       }
  654. lab22: gettoken () ;
  655.       { register halfword r_curtok = curtok;
  656.  
  657.     if ( r_curtok == info ( r ) ) {
  658.       r = link ( r ) ; 
  659.       if ( ( info(r) >= matchtoken ) && ( info(r) <= endmatchtoken ) ) {
  660.         if ( r_curtok < leftbracelimit ) 
  661.           decr ( alignstate ) ; 
  662.         goto lab40 ; 
  663.       } else
  664.         goto lab22 ; 
  665.     }
  666.     if ( s != r ) 
  667.     if ( s == 0 ) {
  668.       print_err("Use of ");
  669.       sprintcs ( warningindex ) ; 
  670.       c_print(" doesn't match its definition");
  671.       zhelp1( STR_H_IFYOUSAY_DEFA );
  672.       error();
  673.       goto lab10 ; 
  674.     } else {
  675.       register halfword t;
  676.  
  677.       t = s ; 
  678.       do {
  679.         register halfword u, v;
  680.  
  681.         storenewtoken( info ( t ) );
  682.         incr ( m ) ; 
  683.         u = link ( t ) ; 
  684.         v = s;
  685.         while ( true ) {
  686.           if ( u == r ) 
  687.           if ( r_curtok != info ( v ) ) 
  688.             goto lab30 ; 
  689.           else {
  690.             r = link ( v ) ; 
  691.             goto lab22 ; 
  692.           }
  693.           if ( info ( u ) != info ( v ) ) 
  694.             goto lab30 ; 
  695.           u = link ( u ) ; 
  696.           v = link ( v ) ; 
  697.         }
  698. lab30:      t = link ( t ) ; 
  699.       } while ( ! ( t == r ) ) ; 
  700.       r = s ; 
  701.     }
  702.  
  703.     if ( r_curtok == partoken ) 
  704.     if ( longstate != longcall ) {
  705.       if ( longstate == call ) {
  706.         runaway () ; 
  707.         print_err("Paragraph ended before ");
  708.         sprintcs ( warningindex ) ; 
  709.         c_print(" was complete");
  710.         zhelp1( STR_H_ISUSPECT_CAUSING );
  711.         backerror () ; 
  712.       }
  713.       pstack [ n ] = link ( temphead ) ; 
  714.       alignstate = alignstate - unbalance ; 
  715.       for( m = 0 ; m <= n ; m++ ) {
  716.         flushlist ( pstack [ m ] ) ;
  717.       }
  718.       goto lab10 ; 
  719.     }
  720.  
  721.     if ( r_curtok < rightbracelimit ) 
  722.  
  723.     if ( r_curtok < leftbracelimit ) {
  724.       /* register halfword r_curtok = curtok; */
  725.  
  726.       unbalance = 1 ; 
  727.       while ( true ) {
  728.         faststorenewtoken ( r_curtok );
  729.         gettoken () ;
  730.         r_curtok = curtok;
  731.         if ( r_curtok == partoken ) 
  732.         if ( longstate != longcall ) {
  733.           if ( longstate == call ) {
  734.         runaway () ; 
  735.         print_err("Paragraph ended before ");
  736.         sprintcs ( warningindex ) ; 
  737.         c_print(" was complete");
  738.         zhelp1( STR_H_ISUSPECT_CAUSING );
  739.         backerror () ; 
  740.           }
  741.           pstack [ n ] = link ( temphead ) ; 
  742.           alignstate = alignstate - unbalance ; 
  743.           for( m = 0 ; m <= n ; m++ ) {
  744.         flushlist ( pstack [ m ] ) ;
  745.           }
  746.           goto lab10 ; 
  747.         }
  748.         if ( r_curtok < rightbracelimit ) 
  749.         if ( r_curtok < leftbracelimit ) 
  750.           incr ( unbalance ) ; 
  751.         else {
  752.           decr ( unbalance ) ; 
  753.           if ( unbalance == 0 ) 
  754.         goto lab31 ; 
  755.         }
  756.       }
  757. lab31:      rbraceptr = p ;
  758.       storenewtoken ( r_curtok );
  759.  
  760.     } else {
  761.       
  762.       backinput () ; 
  763.       print_err("Argument of ");
  764.       sprintcs ( warningindex ) ; 
  765.       c_print(" has an extra }");
  766.       zhelp1( STR_H_IVERUNACROSS );
  767.       incr ( alignstate ) ; 
  768.       longstate = call ; 
  769.       curtok = partoken ; 
  770.       inserror () ; 
  771.         }
  772.  
  773.         else {        /* (curtok >= rightbracelimit) */
  774.  
  775.       if ( r_curtok == spacetoken ) 
  776.       if ( info ( r ) <= endmatchtoken &&  info ( r ) >= matchtoken )
  777.         goto lab22 ; 
  778.  
  779.       storenewtoken ( r_curtok );
  780.     }
  781.       }
  782.  
  783.       incr ( m ) ; 
  784.       if ( info ( r ) > endmatchtoken ) 
  785.         goto lab22 ; 
  786.       if ( info ( r ) < matchtoken ) 
  787.         goto lab22 ;
  788. lab40:
  789.       if ( s != 0 ) {
  790.     if ( (m == 1) && ( info(p) < rightbracelimit ) && ( p != temphead ) ) {
  791.       link ( rbraceptr ) = 0 ; 
  792.       freeavail ( p ) ; 
  793.       p = link ( temphead ) ; 
  794.       pstack [ n ] = link ( p ) ; 
  795.       freeavail ( p ) ; 
  796.     } else
  797.       pstack [ n ] = link ( temphead ) ; 
  798.     incr ( n ) ; 
  799.     if ( tracingmacros > 0 ) {
  800.       begindiagnostic () ; 
  801.       printnl ( matchchr ) ; 
  802.       printint ( n ) ; 
  803.       c_print("<-");
  804.       showtokenlist ( pstack [ n - 1 ] , 0 , 1000 ) ; 
  805.       enddiagnostic ( false ) ; 
  806.     }
  807.       }
  808.     } while ( ! ( info ( r ) == endmatchtoken ) ) ; 
  809.   }
  810.  
  811.   while ( ( curinput.statefield == tokenlist ) && ( curinput.locfield == 0 ) )
  812.     endtokenlist ();
  813.  
  814.   begintokenlist ( refcount , macro ) ; 
  815.   curinput .namefield = warningindex ; 
  816.   curinput .locfield = link ( r ) ; 
  817.   if ( n > 0 ) {
  818.     if ( paramptr + n > maxparamstack ) {
  819.       maxparamstack = paramptr + n ; 
  820.       if ( maxparamstack > paramsize ) 
  821.       overflow(10, paramsize);
  822.     }
  823.     for( m = 0 ; m <= n - 1 ; m++ ) {
  824.       paramstack [ paramptr + m ] = pstack [ m ] ;
  825.     }
  826.     paramptr += n ;
  827.   } 
  828. lab10:
  829.   scannerstatus = savescannerstatus ; 
  830.   warningindex = savewarningindex ; 
  831. }
  832.  
  833.  
  834. void insertrelax ( void )
  835. { insertrelax_regmem 
  836.  
  837.   curtok = cstokenflag + curcs ; 
  838.   backinput () ; 
  839.   curtok = cstokenflag + frozenrelax ; 
  840.   backinput () ; 
  841.   tokentype = inserted ; 
  842. }
  843.  
  844.  
  845. void expand ( void )
  846. { expand_regmem 
  847.   integer cvbackup  ; 
  848.   smallnumber cvlbackup, radixbackup, cobackup  ; 
  849.   halfword backupbackup  ; 
  850.  
  851.   cvbackup = curval;
  852.   cvlbackup = curvallevel;
  853.   radixbackup = radix ; 
  854.   cobackup = curorder ; 
  855.   backupbackup = link ( backuphead ) ; 
  856.   if ( curcmd < call ) {
  857.     if ( tracingcommands > 1 ) 
  858.       showcurcmdchr () ; 
  859.     switch ( curcmd ) {
  860.     case topbotmark : 
  861.       if ( curmark [ curchr ] != 0 ) 
  862.     begintokenlist ( curmark [ curchr ] , marktext ) ; 
  863.       break ; 
  864.     case expandafter : 
  865.       { register halfword t;
  866.  
  867.     gettoken () ; 
  868.     t = curtok ; 
  869.     if( (halfword)gettoken() > maxcommand )
  870.       expand();
  871.     else
  872.       backinput();
  873.     curtok = t ; 
  874.     backinput();
  875.       } 
  876.       break ; 
  877.     case noexpand : 
  878.       { register halfword t;
  879.     register smallnumber savescannerstatus;
  880.  
  881.     savescannerstatus = scannerstatus ; 
  882.     scannerstatus = normal ; 
  883.     gettoken () ; 
  884.     scannerstatus = savescannerstatus ; 
  885.     t = curtok ; 
  886.     backinput () ; 
  887.     if ( t >= cstokenflag ) {
  888.       register halfword p;
  889.  
  890.       p = getavail () ; 
  891.       info ( p ) = cstokenflag + frozendontexpand ; 
  892.       link ( p ) = curinput .locfield ; 
  893.       curinput .startfield = p ; 
  894.       curinput .locfield = p ; 
  895.     }
  896.       }
  897.       break ; 
  898.     case csname : 
  899.       { register halfword p, r;
  900.     register integer j;
  901.  
  902.     r = getavail () ; 
  903.     p = r ; 
  904.     do {
  905.       getxtoken () ; 
  906.       if ( curcs == 0 )
  907.         storenewtoken ( curtok );
  908.     } while( curcs == 0 );
  909.  
  910.     if ( curcmd != 67 ) {
  911.       print_err("Missing ");
  912.       printesc( STR_ENDCSNAME );
  913.       c_print(" inserted");
  914.       zhelp1( STR_H_THECSMARKED );
  915.       backerror();
  916.     }
  917.     j = first ; 
  918.     p = link ( r ) ; 
  919.     while ( p != 0 ) {
  920.       if ( j >= maxbufstack ) {
  921.         maxbufstack = j + 1 ; 
  922.         if ( maxbufstack == bufsize ) 
  923.           overflow(1, bufsize);
  924.       } 
  925.       buffer [ j ] = info ( p ) % 256 ; 
  926.       incr ( j ) ; 
  927.       p = link ( p ) ; 
  928.     } 
  929.     if ( j > first + 1 ) {
  930.       nonewcontrolsequence = false ; 
  931.       curcs = idlookup ( first , j - first ) ; 
  932.       nonewcontrolsequence = true ; 
  933.     } else if ( j == first ) 
  934.       curcs = nullcs ; 
  935.     else
  936.       curcs = singlebase + buffer [ first ] ; 
  937.     flushlist ( r ) ; 
  938.     if ( eqtype ( curcs ) == undefinedcs ) {
  939.       eqdefine ( curcs , 0 , 256 ) ; 
  940.     } 
  941.     curtok = curcs + cstokenflag ; 
  942.     backinput () ; 
  943.       } 
  944.       break ; 
  945.     case convert : 
  946.       convtoks () ; 
  947.       break ; 
  948.     case the : 
  949.       insthetoks () ; 
  950.       break ; 
  951.     case iftest : 
  952.       conditional () ; 
  953.       break ; 
  954.     case fiorelse : 
  955.       if ( curchr > iflimit ) 
  956.       if ( iflimit == ifcode ) 
  957.     insertrelax () ; 
  958.       else {
  959.     print_err("Extra ");
  960.     printcmdchr ( fiorelse , curchr ) ; 
  961.     zhelp1( STR_H_IMIGNORING_IF );
  962.     error () ; 
  963.       } else {
  964.     while ( curchr != ficode )
  965.       passtext () ;
  966.  
  967.     { register halfword p;
  968.  
  969.       p = condptr ; 
  970.       ifline = iflinefield ( p ) ; 
  971.       curif = subtype ( p ) ; 
  972.       iflimit = ztype ( p ) ; 
  973.       condptr = link ( p ) ; 
  974.       freenode ( p , ifnodesize ) ; 
  975.     }
  976.       }
  977.       break ; 
  978.     case input : 
  979.       if ( curchr > 0 ) 
  980.     forceeof = true ; 
  981.       else if ( nameinprogress ) 
  982.     insertrelax () ; 
  983.       else startinput () ; 
  984.       break ; 
  985.     default: 
  986.       {
  987.     print_err("Undefined control sequence");
  988.     zhelp1( STR_H_THECSATTHEEND );
  989.     error();
  990.       }
  991.       break;
  992.     }
  993.   } else if ( curcmd < endtemplate ) 
  994.     macrocall () ; 
  995.   else {
  996.     curtok = cstokenflag + frozenendv ; 
  997.     backinput () ; 
  998.   } 
  999.   curval = cvbackup;
  1000.   curvallevel = cvlbackup;
  1001.   radix = radixbackup ; 
  1002.   curorder = cobackup ; 
  1003.   link ( backuphead ) = backupbackup ; 
  1004. }
  1005.  
  1006.  
  1007. /* -- end -- */
  1008.