home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / tex1.c < prev    next >
C/C++ Source or Header  |  1993-10-12  |  45KB  |  2,029 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4.  
  5. void showbox ( halfword p )
  6. { showbox_regmem
  7.  
  8.   depththreshold = showboxdepth;
  9.   breadthmax = showboxbreadth;
  10.   if ( breadthmax <= 0 )
  11.     breadthmax = 5;
  12.   if ( poolptr + depththreshold >= poolsize )
  13.     depththreshold = poolsize - poolptr - 1;
  14.   shownodelist( p );
  15.   println();
  16. } 
  17.  
  18.  
  19. void deletetokenref ( halfword p )
  20. { deletetokenref_regmem
  21.  
  22.   if ( tokenrefcount ( p ) == 0 )
  23.     flushlist( p );
  24.   else
  25.     decr( tokenrefcount(p) );
  26. }
  27.  
  28.  
  29. void deleteglueref ( halfword p )
  30. { deleteglueref_regmem
  31.  
  32.   fastdeleteglueref( p );
  33. }
  34.  
  35.  
  36. void flushnodelist ( halfword p )
  37. { flushnodelist_regmem
  38.   register halfword q;
  39.  
  40.   while ( p != 0 ) {
  41.     q = link ( p );
  42.     if ( ischarnode ( p ) ) {
  43.       register halfword tmp_avail = avail;
  44.  
  45.       do {
  46.     /* freeavail ( p ) ; */
  47.     link(p) = tmp_avail;  tmp_avail = p;
  48. #ifdef STAT
  49.     decr(dynused);
  50. #endif
  51.     p = q;
  52.         if( p == 0 ) {
  53.       avail = tmp_avail;
  54.       return;
  55.     }
  56.         q = link( p );
  57.       } while( ischarnode(p) );
  58.  
  59.       avail = tmp_avail;
  60.       /* continue; */ /* we know: p != null && !ischarnode(p) */
  61.     }
  62.  
  63.     switch ( ztype ( p ) ) {
  64.       case hlistnode :
  65.       case vlistnode :
  66.       case unsetnode :
  67.     flushnodelist ( listptr ( p ) );
  68.     freenode( p, boxnodesize );
  69.     goto lab30;
  70.     break;
  71.       case rulenode : 
  72.     freenode( p, rulenodesize );
  73.     goto lab30;
  74.     break;
  75.       case insnode :
  76.     {
  77.       flushnodelist ( insptr ( p ) ) ; 
  78.       deleteglueref ( splittopptr ( p ) ) ; 
  79.       freenode ( p , insnodesize ) ; 
  80.       goto lab30 ; 
  81.     } 
  82.     break ; 
  83.       case whatsitnode : 
  84.     {
  85.       switch ( subtype ( p ) ) {
  86.       case opennode : 
  87.         freenode ( p , opennodesize ) ; 
  88.         break ; 
  89.       case writenode : 
  90.       case specialnode : 
  91.         {
  92.           deletetokenref ( writetokens ( p ) ) ; 
  93.           freenode ( p , writenodesize ) ; 
  94.           goto lab30 ; 
  95.         } 
  96.         break ; 
  97.       case closenode : 
  98.       case languagenode : 
  99.         freenode ( p, smallnodesize );
  100.         break;
  101.       default: 
  102.         confusion("ext3");
  103.         break;
  104.       }
  105.       goto lab30;
  106.     }
  107.     break;
  108.       case gluenode :
  109.     {
  110.       fastdeleteglueref ( glueptr ( p ) ) ; 
  111.       if ( leaderptr ( p ) != 0 ) 
  112.         flushnodelist ( leaderptr ( p ) ) ; 
  113.     } 
  114.     break ; 
  115.       case kernnode : 
  116.       case mathnode : 
  117.       case penaltynode : 
  118.     break ; 
  119.       case ligaturenode : 
  120.     flushnodelist ( ligptr ( p ) ) ; 
  121.     break ; 
  122.       case marknode : 
  123.     deletetokenref ( markptr ( p ) ) ; 
  124.     break ; 
  125.       case discnode : 
  126.     flushnodelist ( prebreak ( p ) ) ; 
  127.     flushnodelist ( postbreak ( p ) ) ; 
  128.     break ; 
  129.       case adjustnode : 
  130.     flushnodelist ( adjustptr ( p ) ) ; 
  131.     break ; 
  132.       case stylenode : 
  133.     {
  134.       freenode ( p , stylenodesize ) ; 
  135.       goto lab30 ; 
  136.     } 
  137.     break ; 
  138.       case choicenode : 
  139.     {
  140.       flushnodelist ( displaymlist ( p ) ) ; 
  141.       flushnodelist ( textmlist ( p ) ) ; 
  142.       flushnodelist ( scriptmlist ( p ) ) ; 
  143.       flushnodelist ( scriptscriptmlist ( p ) ) ; 
  144.       freenode ( p , stylenodesize ) ; 
  145.       goto lab30 ; 
  146.     } 
  147.     break ; 
  148.       case ordnoad : 
  149.       case opnoad : 
  150.       case binnoad : 
  151.       case relnoad : 
  152.       case opennoad : 
  153.       case closenoad : 
  154.       case punctnoad : 
  155.       case innernoad : 
  156.       case radicalnoad : 
  157.       case overnoad : 
  158.       case undernoad : 
  159.       case vcenternoad : 
  160.       case accentnoad : 
  161.     if ( mathtype ( nucleus ( p ) ) >= subbox ) 
  162.       flushnodelist ( info ( nucleus ( p ) ) ) ; 
  163.     if ( mathtype ( supscr ( p ) ) >= subbox ) 
  164.       flushnodelist ( info ( supscr ( p ) ) ) ; 
  165.     if ( mathtype ( subscr ( p ) ) >= subbox ) 
  166.       flushnodelist ( info ( subscr ( p ) ) ) ; 
  167.     if ( ztype ( p ) == radicalnoad ) 
  168.       freenode ( p , radicalnoadsize ) ; 
  169.     else if ( ztype ( p ) == accentnoad ) 
  170.       freenode ( p , accentnoadsize ) ; 
  171.     else
  172.       freenode ( p , noadsize );
  173.     goto lab30;
  174.     break;
  175.       case leftnoad : 
  176.       case rightnoad : 
  177.     {
  178.       freenode ( p , noadsize ) ; 
  179.       goto lab30 ; 
  180.     } 
  181.     break ; 
  182.       case fractionnoad : 
  183.     {
  184.       flushnodelist ( info ( numerator ( p ) ) ) ; 
  185.       flushnodelist ( info ( denominator ( p ) ) ) ; 
  186.       freenode ( p , fractionnoadsize ) ; 
  187.       goto lab30 ; 
  188.     } 
  189.     break ; 
  190.       default: 
  191.     confusion("flushing"); /* 350 */
  192.     break ; 
  193.     }
  194.     freenode( p, smallnodesize );
  195. lab30:
  196.     p = q;
  197.   }
  198. }
  199.  
  200.  
  201. halfword copynodelist ( halfword p )
  202. { copynodelist_regmem 
  203.   register halfword q ; 
  204.   register long_halfword r ; 
  205.   /*register*/ long_halfword h; /* head of copied list, not used in loop! */
  206.  
  207.   h = q = getavail ();
  208.   /* q = h; */
  209.   while ( p != 0 ) {
  210.     if ( ischarnode ( p ) ) {
  211.       r = getavail () ;
  212.       /* we know:  words = 1 for this simple and often occuring case */
  213.       mem[r] = mem[p];
  214.     } else {
  215.       register schar words = 1;
  216.       /* half of remaining cases are gluenodes with length smallnodesize,
  217.          but only one word must be copied (see 202. flushnodelist) */
  218.  
  219.       switch ( ztype ( p ) ) {
  220.       case hlistnode : 
  221.       case vlistnode : 
  222.       case unsetnode : 
  223.     r = getnode ( boxnodesize ) ; 
  224.     mem [ r + 6 ] = mem [ p + 6 ] ; 
  225.     mem [ r + 5 ] = mem [ p + 5 ] ; 
  226.     listptr ( r ) = copynodelist ( listptr ( p ) ) ; 
  227.     words = 5 ; 
  228.     break ; 
  229.       case rulenode : 
  230.     r = getnode ( rulenodesize ) ; 
  231.     words = rulenodesize ; 
  232.     break ; 
  233.       case insnode : 
  234.     r = getnode ( insnodesize ) ; 
  235.     mem [ r + 4 ] = mem [ p + 4 ] ; 
  236.     addglueref ( splittopptr ( p ) ) ; 
  237.     insptr ( r ) = copynodelist ( insptr ( p ) ) ; 
  238.     words = insnodesize - 1 ; 
  239.     break ; 
  240.       case whatsitnode : 
  241.     switch ( subtype ( p ) ) {
  242.     case opennode : 
  243.         r = getnode ( opennodesize ) ; 
  244.         words = opennodesize ; 
  245.         break ; 
  246.     case writenode : 
  247.     case specialnode : 
  248.         r = getnode ( writenodesize ) ; 
  249.         addtokenref ( writetokens ( p ) ) ; 
  250.         words = writenodesize ; 
  251.         break ; 
  252.     case closenode : 
  253.     case languagenode : 
  254.         r = getnode ( smallnodesize ) ; 
  255.         words = smallnodesize ; 
  256.         break ; 
  257.     default: 
  258.         confusion("ext2");
  259.         break ; 
  260.     }
  261.     break ; 
  262.       case gluenode : 
  263.     r = getnode ( smallnodesize ) ; 
  264.     addglueref ( glueptr ( p ) ) ; 
  265.     glueptr ( r ) = glueptr ( p ) ; 
  266.     leaderptr ( r ) = copynodelist ( leaderptr ( p ) ) ; 
  267.     break ; 
  268.       case kernnode : 
  269.       case mathnode : 
  270.       case penaltynode : 
  271.     r = getnode ( smallnodesize ) ; 
  272.     words = smallnodesize ; 
  273.     break ; 
  274.       case ligaturenode : 
  275.     r = getnode ( smallnodesize ) ; 
  276.     mem [ ligchar ( r ) ] = mem [ ligchar ( p ) ] ; 
  277.     ligptr ( r ) = copynodelist ( ligptr ( p ) ) ; 
  278.     break ; 
  279.       case discnode : 
  280.     r = getnode ( smallnodesize ) ; 
  281.     prebreak ( r ) = copynodelist ( prebreak ( p ) ) ; 
  282.     postbreak ( r ) = copynodelist ( postbreak ( p ) ) ; 
  283.     break ; 
  284.       case marknode : 
  285.     r = getnode ( smallnodesize ) ; 
  286.     addtokenref ( markptr ( p ) ) ; 
  287.     words = smallnodesize ; 
  288.     break ; 
  289.       case adjustnode : 
  290.     r = getnode ( smallnodesize ) ; 
  291.     adjustptr ( r ) = copynodelist ( adjustptr ( p ) ) ; 
  292.     break ; 
  293.       default:
  294.     confusion("copying"); /* 351 */ /* --> jump_out() --> exit() */
  295.     break ; 
  296.       }
  297.       while ( words > 0 ) {
  298.     decr ( words ) ; 
  299.     mem [ r + words ] = mem [ p + words ] ; 
  300.       }
  301.     }
  302.     link ( q ) = r;
  303.     q = r;
  304.     p = link ( p );
  305.   }
  306.   link( q ) = 0;
  307.   q = link( h );
  308.   freeavail( h );
  309.  
  310.   return(q);
  311. }
  312.  
  313.  
  314. void printmode ( integer m )
  315. { printmode_regmem
  316.  
  317. #ifdef OLD_MODE
  318.   if ( m > 0 )
  319.   switch ( m / (maxcommand + 1) ) {
  320.   case 0 : 
  321.     c_print("vertical");
  322.     break ; 
  323.   case 1 : 
  324.     c_print("horizontal");
  325.     break ;
  326.   case 2 :
  327.     c_print("display math");
  328.     break ; 
  329.   } else if ( m == 0 ) 
  330.     c_print("no");
  331.   else switch ( (-(integer)m) / (maxcommand + 1) ) {
  332.   case 0 :
  333.     c_print("internal vertical");
  334.     break ;
  335.   case 1 : 
  336.     c_print("restricted horizontal");
  337.     break ; 
  338.   case 2 : 
  339.     c_print("math");
  340.     break ; 
  341.   }
  342. #else
  343.   char *s;
  344.  
  345.   if ( m > 0 ) {
  346.     switch ( m ) {
  347.     case vmode:  s = "vertical"; break;
  348.     case hmode:  s = "horizontal"; break;
  349.     case mmode:  s = "display math"; break;
  350.     }
  351.   } else if ( m == 0 ) {
  352.     s = "no";
  353.   } else {
  354.     switch ( -m ) {
  355.     case vmode:  s = "internal vertical"; break;
  356.     case hmode:  s = "restricted horizontal"; break;
  357.     case mmode:  s = "math"; break;
  358.     }
  359.   }
  360.   c_print(s);
  361. #endif
  362.   c_print(" mode");
  363. }
  364.  
  365.  
  366. void pushnest ( void )
  367. { pushnest_regmem 
  368.  
  369.   if ( nestptr > maxneststack ) {
  370.     maxneststack = nestptr;
  371.     if ( nestptr == nestsize )
  372.       overflow(4, nestsize);
  373.   } 
  374.   nest[nestptr] = curlist;
  375.   incr( nestptr );
  376.   curlist .headfield = getavail();
  377.   curlist .tailfield = curlist .headfield;
  378.   curlist .pgfield = 0;
  379.   curlist .mlfield = line;
  380. #ifdef TEXXET
  381.   LR_save = 0;
  382. #endif
  383. }
  384.  
  385.  
  386. void popnest ( void )
  387. { popnest_regmem
  388.  
  389.   freeavail( curlist .headfield );
  390.   decr ( nestptr );
  391.   curlist = nest[nestptr];
  392. }
  393.  
  394.  
  395. void showactivities ( void )
  396. { showactivities_regmem 
  397.   register integer p;
  398.   register short m;
  399.   memoryword a;
  400.   register halfword q, r;
  401.   register integer t;
  402.  
  403.   nest [ nestptr ] = curlist;
  404.   c_printnl("");
  405.   println();
  406.   for( p = nestptr ; p >= 0 ; --p ) {
  407.     m = nest [ p ] .modefield ; 
  408.     a = nest [ p ] .auxfield ; 
  409.     c_printnl("### ");
  410.     printmode ( m ) ; 
  411.     c_print(" entered at line ");
  412.     printint ( abs ( nest [ p ] .mlfield ) ) ; 
  413.     if ( m == hmode )
  414. #if 0  /* 3.1415 */
  415.       if ( ( nest [ p ] .lhmfield != 2 ) || ( nest [ p ] .rhmfield != 3 ) ) {
  416.     c_print(" (hyphenmin ");
  417.     printint ( nest [ p ] .lhmfield ) ; 
  418.     printchar ( 44 ) ; 
  419.     printint ( nest [ p ] .rhmfield ) ; 
  420.     printchar ( 41 ) ; 
  421.       } 
  422. #else
  423.       if ( nest [ p ] .pgfield != 0x830000L ) {
  424.     c_print(" (language");
  425.     printint ( ( nest [ p ] .pgfield % 0x010000L ) ) ;
  426.     c_print(":hyphenmin");
  427.     printint ( ( nest [ p ] .pgfield / 0x400000L ) ) ;
  428.     printchar ( 44 ) ; 
  429.     printint ( ( ( nest [ p ] .pgfield / 0x010000L ) % 0x40 ) ) ;
  430.     printchar ( 41 ) ; 
  431.       }
  432. #endif
  433.     if ( nest [ p ] .mlfield < 0 ) 
  434.       c_print(" (\\output routine)");
  435.     if ( p == 0 ) {
  436.     if ( pagehead != pagetail ) {
  437.       c_printnl("### current page:");
  438.       if ( outputactive ) 
  439.       c_print(" (held over for next output)");
  440.       showbox ( link ( pagehead ) ) ; 
  441.       if ( pagecontents > 0 ) {
  442.         c_printnl("total height ");
  443.         printtotals () ; 
  444.         c_printnl(" goal height ");
  445.         printscaled ( pagesofar [ 0 ] ) ; 
  446.         r = link ( pageinshead ) ; 
  447.         while ( r != pageinshead ) {
  448.           println () ; 
  449.           printesc( STR_INSERT );
  450.           t = subtype ( r ) ; 
  451.           printint ( t ) ; 
  452.           c_print(" adds ");
  453.           t = xovern ( height ( r ) , 1000 ) * count ( t ) ; 
  454.           printscaled ( t ) ; 
  455.           if ( ztype ( r ) == splitup ) {
  456.         q = pagehead ; 
  457.         t = 0 ; 
  458.         do {
  459.           q = link ( q ) ; 
  460.           if ( ( ztype ( q ) == insnode ) && ( subtype ( q ) == 
  461.           subtype ( r ) ) ) 
  462.           incr ( t ) ; 
  463.         } while ( ! ( q == brokenins ( r ) ) ) ; 
  464.         c_print(", #");
  465.         printint ( t ) ; 
  466.         c_print(" might split");
  467.           } 
  468.           r = link ( r ) ; 
  469.         } 
  470.       } 
  471.     } 
  472.     if ( link ( contribhead ) != 0 ) 
  473.       c_printnl("### recent contributions:");
  474.     }
  475.     showbox ( link ( nest [ p ] .headfield ) ) ; 
  476. #ifdef OLD_MODE
  477.     switch ( abs ( m ) / (maxcommand + 1) )
  478. #else
  479.     switch ( abs ( m ) )
  480. #endif
  481.       {
  482. #ifdef OLD_MODE
  483.       case 0 :
  484. #else
  485.       case vmode:
  486. #endif
  487.     {
  488.       c_printnl("prevdepth ");
  489.       if ( a .cint <= ignoredepth ) 
  490.         c_print("ignored");
  491.       else
  492.         printscaled ( a .cint ) ; 
  493.       if ( nest [ p ] .pgfield != 0 ) {
  494.         c_print(", prevgraf ");
  495.         printint ( nest [ p ] .pgfield ) ; 
  496.         c_print(" line");
  497.         if ( nest [ p ] .pgfield != 1 ) 
  498.           printchar ( 115 ) ; 
  499.       }
  500.     }
  501.     break ;
  502. #ifdef OLD_MODE
  503.       case 1 :
  504. #else
  505.       case hmode:
  506. #endif
  507.     {
  508.       c_printnl("spacefactor ");
  509.       printint ( a.hh.v.LH ) ; 
  510.       if ( m > 0 && a.hh.v.RH > 0 ) {
  511.         c_print(", current language ");
  512.         printint ( a.hh.v.RH );
  513.       }
  514.     }
  515.     break ; 
  516. #ifdef OLD_MODE
  517.       case 2:
  518. #else
  519.       case mmode:
  520. #endif
  521.     if ( a .cint != 0 ) {
  522.       c_print("this will be denominator of:");
  523.       showbox ( a .cint ) ; 
  524.     } 
  525.     break ; 
  526.       }
  527.   }
  528. }
  529.  
  530.  
  531. void printparam ( integer n )
  532. { printparam_regmem 
  533.  
  534.   switch ( n ) {
  535.   case pretolerancecode : 
  536.     printesc ( 416 ) ; 
  537.     break ; 
  538.   case tolerancecode : 
  539.     printesc ( 417 ) ; 
  540.     break ; 
  541.   case linepenaltycode : 
  542.     printesc ( 418 ) ; 
  543.     break ; 
  544.   case hyphenpenaltycode : 
  545.     printesc ( 419 ) ; 
  546.     break ; 
  547.   case exhyphenpenaltycode : 
  548.     printesc ( 420 ) ; 
  549.     break ; 
  550.   case clubpenaltycode : 
  551.     printesc ( 421 ) ; 
  552.     break ; 
  553.   case widowpenaltycode : 
  554.     printesc ( 422 ) ; 
  555.     break ; 
  556.   case displaywidowpenaltycode : 
  557.     printesc ( 423 ) ; 
  558.     break ; 
  559.   case brokenpenaltycode : 
  560.     printesc ( 424 ) ; 
  561.     break ; 
  562.   case binoppenaltycode : 
  563.     printesc ( 425 ) ; 
  564.     break ; 
  565.   case relpenaltycode : 
  566.     printesc ( 426 ) ; 
  567.     break ; 
  568.   case predisplaypenaltycode : 
  569.     printesc ( 427 ) ; 
  570.     break ; 
  571.   case postdisplaypenaltycode : 
  572.     printesc ( 428 ) ; 
  573.     break ; 
  574.   case interlinepenaltycode : 
  575.     printesc ( 429 ) ; 
  576.     break ; 
  577.   case doublehyphendemeritscode : 
  578.     printesc ( 430 ) ; 
  579.     break ; 
  580.   case finalhyphendemeritscode : 
  581.     printesc ( 431 ) ; 
  582.     break ; 
  583.   case adjdemeritscode : 
  584.     printesc ( 432 ) ; 
  585.     break ; 
  586.   case magcode : 
  587.     printesc ( 433 ) ; 
  588.     break ; 
  589.   case delimiterfactorcode : 
  590.     printesc ( 434 ) ; 
  591.     break ; 
  592.   case loosenesscode : 
  593.     printesc ( 435 ) ; 
  594.     break ; 
  595.   case timecode : 
  596.     printesc ( 436 ) ; 
  597.     break ; 
  598.   case daycode : 
  599.     printesc ( 437 ) ; 
  600.     break ; 
  601.   case monthcode : 
  602.     printesc ( 438 ) ; 
  603.     break ; 
  604.   case yearcode : 
  605.     printesc ( 439 ) ; 
  606.     break ; 
  607.   case showboxbreadthcode : 
  608.     printesc ( 440 ) ; 
  609.     break ; 
  610.   case showboxdepthcode : 
  611.     printesc ( 441 ) ; 
  612.     break ; 
  613.   case hbadnesscode : 
  614.     printesc ( 442 ) ; 
  615.     break ; 
  616.   case vbadnesscode : 
  617.     printesc ( 443 ) ; 
  618.     break ; 
  619.   case pausingcode : 
  620.     printesc ( 444 ) ; 
  621.     break ; 
  622.   case tracingonlinecode : 
  623.     printesc ( 445 ) ; 
  624.     break ; 
  625.   case tracingmacroscode : 
  626.     printesc ( 446 ) ; 
  627.     break ; 
  628.   case tracingstatscode : 
  629.     printesc ( 447 ) ; 
  630.     break ; 
  631.   case tracingparagraphscode : 
  632.     printesc ( 448 ) ; 
  633.     break ; 
  634.   case tracingpagescode : 
  635.     printesc ( 449 ) ; 
  636.     break ; 
  637.   case tracingoutputcode : 
  638.     printesc ( 450 ) ; 
  639.     break ; 
  640.   case tracinglostcharscode : 
  641.     printesc ( 451 ) ; 
  642.     break ; 
  643.   case tracingcommandscode : 
  644.     printesc ( 452 ) ; 
  645.     break ; 
  646.   case tracingrestorescode : 
  647.     printesc ( 453 ) ; 
  648.     break ; 
  649.   case uchyphcode : 
  650.     printesc ( 454 ) ; 
  651.     break ; 
  652.   case outputpenaltycode : 
  653.     printesc ( 455 ) ; 
  654.     break ; 
  655.   case maxdeadcyclescode : 
  656.     printesc ( 456 ) ; 
  657.     break ; 
  658.   case hangaftercode : 
  659.     printesc ( 457 ) ; 
  660.     break ; 
  661.   case floatingpenaltycode : 
  662.     printesc ( 458 ) ; 
  663.     break ; 
  664.   case globaldefscode : 
  665.     printesc ( 459 ) ; 
  666.     break ; 
  667.   case curfamcode : 
  668.     printesc ( 460 ) ; 
  669.     break ; 
  670.   case escapecharcode : 
  671.     printesc ( 461 ) ; 
  672.     break ; 
  673.   case defaulthyphencharcode : 
  674.     printesc ( 462 ) ; 
  675.     break ; 
  676.   case defaultskewcharcode : 
  677.     printesc ( 463 ) ; 
  678.     break ; 
  679.   case endlinecharcode : 
  680.     printesc ( 464 ) ; 
  681.     break ; 
  682.   case newlinecharcode : 
  683.     printesc ( 465 ) ; 
  684.     break ; 
  685.   case languagecode : 
  686.     printesc ( 466 ) ; 
  687.     break ; 
  688.   case lefthyphenmincode : 
  689.     printesc ( 467 ) ; 
  690.     break ; 
  691.   case righthyphenmincode : 
  692.     printesc ( 468 ) ; 
  693.     break ; 
  694.   case holdinginsertscode : 
  695.     printesc ( 469 ) ; 
  696.     break ; 
  697.   case errorcontextlinescode : 
  698.     printesc ( 470 ) ; 
  699.     break ;
  700. #ifdef MLTEX
  701.   case char_sub_def_max_code :
  702.     printesc( STR_CHARSUBDEFMAX );
  703.     break;
  704.   case tracing_char_sub_def_code :
  705.     printesc( STR_TRACING_CHARSUBDEF );
  706.     break;
  707. #endif
  708. #ifdef ERW_INTERACTION
  709.   case interactionmodecode :
  710.     printesc( STR_INTERACTION_MODE );
  711.     break;
  712. #endif
  713.   default: 
  714.     c_print("[unknown integer parameter!]");
  715.     break ; 
  716.   }
  717. } 
  718.  
  719.  
  720. void begindiagnostic ( void )
  721. { begindiagnostic_regmem
  722.  
  723.   oldsetting = selector;
  724.   if ( ( tracingonline <= 0 ) && ( selector == termandlog ) ) {
  725.     decr ( selector );
  726.     if ( history == spotless )
  727.       history = warningissued;
  728.   }
  729. }
  730.  
  731.  
  732. void enddiagnostic ( boolean blankline )
  733. { enddiagnostic_regmem
  734.  
  735.   c_printnl("");
  736.   if ( blankline )
  737.     println();
  738.   selector = oldsetting;
  739. }
  740.  
  741.  
  742. void printlengthparam ( integer n )
  743. { printlengthparam_regmem 
  744.  
  745.   switch ( n ) {
  746.   case parindentcode : 
  747.     printesc ( 474 ) ; 
  748.     break ; 
  749.   case mathsurroundcode : 
  750.     printesc ( 475 ) ; 
  751.     break ; 
  752.   case lineskiplimitcode : 
  753.     printesc ( 476 ) ; 
  754.     break ; 
  755.   case hsizecode : 
  756.     printesc ( 477 ) ; 
  757.     break ; 
  758.   case vsizecode : 
  759.     printesc ( 478 ) ; 
  760.     break ; 
  761.   case maxdepthcode : 
  762.     printesc ( 479 ) ; 
  763.     break ; 
  764.   case splitmaxdepthcode : 
  765.     printesc ( 480 ) ; 
  766.     break ; 
  767.   case boxmaxdepthcode : 
  768.     printesc ( 481 ) ; 
  769.     break ; 
  770.   case hfuzzcode : 
  771.     printesc ( 482 ) ; 
  772.     break ; 
  773.   case vfuzzcode : 
  774.     printesc ( 483 ) ; 
  775.     break ; 
  776.   case delimitershortfallcode : 
  777.     printesc ( 484 ) ; 
  778.     break ; 
  779.   case nulldelimiterspacecode : 
  780.     printesc ( 485 ) ; 
  781.     break ; 
  782.   case scriptspacecode : 
  783.     printesc ( 486 ) ; 
  784.     break ; 
  785.   case predisplaysizecode : 
  786.     printesc ( 487 ) ; 
  787.     break ; 
  788.   case displaywidthcode : 
  789.     printesc ( 488 ) ; 
  790.     break ; 
  791.   case displayindentcode : 
  792.     printesc ( 489 ) ; 
  793.     break ; 
  794.   case overfullrulecode : 
  795.     printesc ( 490 ) ; 
  796.     break ; 
  797.   case hangindentcode : 
  798.     printesc ( 491 ) ; 
  799.     break ; 
  800.   case hoffsetcode : 
  801.     printesc ( 492 ) ; 
  802.     break ; 
  803.   case voffsetcode : 
  804.     printesc ( 493 ) ; 
  805.     break ; 
  806.   case emergencystretchcode : 
  807.     printesc ( 494 ) ; 
  808.     break ; 
  809.   default: 
  810.     c_print("[unknown dimen parameter!]");
  811.     break ; 
  812.   } 
  813. } 
  814.  
  815.  
  816. void printcmdchr ( quarterword cmd, halfword chrcode )
  817. { printcmdchr_regmem 
  818.  
  819.   switch ( cmd ) {
  820.   case left_brace : 
  821.       c_print("begin-group character ");
  822.       print ( chrcode ) ; 
  823.     break ; 
  824.   case right_brace : 
  825.       c_print("end-group character ");
  826.       print ( chrcode ) ; 
  827.     break ; 
  828.   case math_shift : 
  829.       c_print("math shift character ");
  830.       print ( chrcode ) ; 
  831.     break ; 
  832.   case mac_param : 
  833.       c_print("macro parameter character ");
  834.       print ( chrcode ) ; 
  835.     break ; 
  836.   case sup_mark : 
  837.       c_print("superscript character ");
  838.       print ( chrcode ) ; 
  839.     break ; 
  840.   case sub_mark : 
  841.       c_print("subscript character ");
  842.       print ( chrcode ) ; 
  843.     break ; 
  844.   case endv : 
  845.     c_print("end of alignment template");
  846.     break ; 
  847.   case spacer : 
  848.       c_print("blank space ");
  849.       print ( chrcode ) ; 
  850.     break ; 
  851.   case letter : 
  852.       c_print("the letter ");
  853.       print ( chrcode ) ; 
  854.     break ; 
  855.   case otherchar : 
  856.       c_print("the character ");
  857.       print ( chrcode ) ; 
  858.     break ; 
  859.  
  860.   case assign_glue : 
  861.   case assign_mu_glue : 
  862.     if ( chrcode < skipbase ) 
  863.       printskipparam ( chrcode - gluebase ) ; 
  864.     else if ( chrcode < muskipbase ) {
  865.       printesc( STR_SKIP );
  866.       printint ( chrcode - skipbase ) ; 
  867.     } else {
  868.       printesc ( 392 ) ; 
  869.       printint ( chrcode - muskipbase ) ; 
  870.     } 
  871.     break ; 
  872.   case assign_toks : 
  873.     if ( chrcode >= toksbase ) {
  874.       printesc ( 403 ) ; 
  875.       printint ( chrcode - toksbase ) ; 
  876.     } else switch ( chrcode ) {
  877.     case outputroutineloc : 
  878.       printesc ( 394 ) ; 
  879.       break ; 
  880.     case everyparloc : 
  881.       printesc ( 395 ) ; 
  882.       break ; 
  883.     case everymathloc : 
  884.       printesc ( 396 ) ; 
  885.       break ; 
  886.     case everydisplayloc : 
  887.       printesc ( 397 ) ; 
  888.       break ; 
  889.     case everyhboxloc : 
  890.       printesc ( 398 ) ; 
  891.       break ; 
  892.     case everyvboxloc : 
  893.       printesc ( 399 ) ; 
  894.       break ; 
  895.     case everyjobloc : 
  896.       printesc ( 400 ) ; 
  897.       break ; 
  898.     case everycrloc : 
  899.       printesc ( 401 ) ; 
  900.       break ; 
  901.     default: 
  902.       printesc ( 402 ) ; 
  903.       break ; 
  904.     } 
  905.     break ; 
  906.   case assign_int : 
  907.     if ( chrcode < countbase ) 
  908.       printparam ( chrcode - intbase ) ; 
  909.     else {
  910.       printesc ( 472 ) ; 
  911.       printint ( chrcode - countbase ) ; 
  912.     } 
  913.     break ; 
  914.   case assign_dimen : 
  915.     if ( chrcode < scaledbase ) 
  916.       printlengthparam ( chrcode - dimenbase ) ; 
  917.     else {
  918.       printesc ( 496 ) ; 
  919.       printint ( chrcode - scaledbase ) ; 
  920.     } 
  921.     break ; 
  922.   case accent : 
  923.     printesc ( 504 ) ; 
  924.     break ; 
  925.   case advance : 
  926.     printesc ( 505 ) ; 
  927.     break ; 
  928.   case afterassignment : 
  929.     printesc ( 506 ) ; 
  930.     break ; 
  931.   case aftergroup : 
  932.     printesc ( 507 ) ; 
  933.     break ; 
  934.   case assign_font_dimen : 
  935.     printesc ( 515 ) ; 
  936.     break ; 
  937.   case begin_group : 
  938.     printesc ( 508 ) ; 
  939.     break ; 
  940.   case break_penalty : 
  941.     printesc ( 527 ) ; 
  942.     break ; 
  943.   case charnum : 
  944.     printesc ( 509 ) ; 
  945.     break ; 
  946.   case csname : 
  947.     printesc ( 500 ) ; 
  948.     break ; 
  949.   case def_font : 
  950.     printesc ( 514 ) ; 
  951.     break ; 
  952.   case delim_num : 
  953.     printesc ( 510 ) ; 
  954.     break ; 
  955.   case divide : 
  956.     printesc ( 511 ) ; 
  957.     break ; 
  958.   case end_cs_name : 
  959.     printesc ( STR_ENDCSNAME );
  960.     break ; 
  961.   case end_group : 
  962.     printesc( STR_ENDGROUP );
  963.     break ; 
  964.   case exspace : 
  965.     printesc ( 32 ) ; 
  966.     break ; 
  967.   case expandafter : 
  968.     printesc ( 513 ) ; 
  969.     break ; 
  970.   case halign : 
  971.     printesc ( 516 ) ; 
  972.     break ; 
  973.   case hrule : 
  974.     printesc ( 517 ) ; 
  975.     break ; 
  976.   case ignorespaces : 
  977.     printesc ( 518 ) ; 
  978.     break ; 
  979.   case insert : 
  980.     printesc( STR_INSERT );
  981.     break ; 
  982.   case ital_corr : 
  983.     printesc ( 47 ) ; 
  984.     break ; 
  985.   case mark : 
  986.     printesc ( 348 ) ; 
  987.     break ; 
  988.   case math_accent : 
  989.     printesc ( 519 ) ; 
  990.     break ; 
  991.   case math_char_num : 
  992.     printesc ( 520 ) ; 
  993.     break ; 
  994.   case math_choice : 
  995.     printesc ( 521 ) ; 
  996.     break ; 
  997.   case multiply : 
  998.     printesc ( 522 ) ; 
  999.     break ; 
  1000.   case no_align : 
  1001.     printesc ( 523 ) ; 
  1002.     break ; 
  1003.   case noboundary : 
  1004.     printesc ( 524 ) ; 
  1005.     break ; 
  1006.   case noexpand : 
  1007.     printesc ( 525 ) ; 
  1008.     break ; 
  1009.   case non_script : 
  1010.     printesc ( 332 ) ; 
  1011.     break ; 
  1012.   case omit : 
  1013.     printesc ( 526 ) ; 
  1014.     break ; 
  1015.   case radical : 
  1016.     printesc ( 529 ) ; 
  1017.     break ; 
  1018.   case read_to_cs : 
  1019.     printesc ( STR_READ );
  1020.     break ; 
  1021.   case relax : 
  1022.     printesc ( 531 ) ; 
  1023.     break ; 
  1024.   case set_box : 
  1025.     printesc ( 532 ) ; 
  1026.     break ; 
  1027.   case set_prev_graf : 
  1028.     printesc ( 528 ) ; 
  1029.     break ; 
  1030.   case set_shape : 
  1031.     printesc ( 404 ) ; 
  1032.     break ; 
  1033.   case the : 
  1034.     printesc ( 533 ) ; 
  1035.     break ; 
  1036.   case toks_register : 
  1037.     printesc ( 403 ) ; 
  1038.     break ; 
  1039.   case vadjust : 
  1040.     printesc ( 349 ) ; 
  1041.     break ; 
  1042.   case valign : 
  1043. #ifdef TEXXET
  1044.     if( chrcode != 0 ) {
  1045.       switch( chrcode ) {
  1046.     case begin_L_code:    print_esc(STR_BEGINL); break;
  1047.     case end_L_code:    print_esc(STR_ENDL); break;
  1048.     case begin_R_code:    print_esc(STR_BEGINR); break;
  1049.     default:        print_esc(STR_ENDR); break;
  1050.       }
  1051.     } else
  1052. #endif
  1053.       printesc ( 534 ) ; 
  1054.     break ; 
  1055.   case vcenter : 
  1056.     printesc ( 535 ) ; 
  1057.     break ; 
  1058.   case vrule : 
  1059.     printesc ( 536 ) ; 
  1060.     break ; 
  1061. #ifdef MLTEX
  1062.   case char_sub_def :
  1063.     printesc(STR_CHARSUBDEF);
  1064.     break;
  1065. #endif
  1066.   case par_end : 
  1067.     printesc( STR_PAR );
  1068.     break ; 
  1069.   case input : 
  1070.     printesc( (chrcode == 0) ? 625 : 626 );
  1071.     break ; 
  1072.   case topbotmark : 
  1073.     switch ( chrcode ) {
  1074.     case firstmarkcode : 
  1075.       printesc ( 628 ) ; 
  1076.       break ; 
  1077.     case botmarkcode : 
  1078.       printesc ( 629 ) ; 
  1079.       break ; 
  1080.     case splitfirstmarkcode : 
  1081.       printesc ( 630 ) ; 
  1082.       break ; 
  1083.     case splitbotmarkcode : 
  1084.       printesc ( 631 ) ; 
  1085.       break ; 
  1086.       default: 
  1087.       printesc ( 627 ) ; 
  1088.       break ; 
  1089.     } 
  1090.     break ; 
  1091.   case register_cmd : 
  1092.     if ( chrcode == intval ) 
  1093.       printesc ( 472 ) ; 
  1094.     else if ( chrcode == dimenval ) 
  1095.       printesc ( 496 ) ; 
  1096.     else if ( chrcode == glueval ) 
  1097.       printesc( STR_SKIP );
  1098.     else
  1099.       printesc ( 392 ) ; 
  1100.     break ; 
  1101.   case set_aux:
  1102.     printesc( (chrcode == vmode) ? STR_PREVDEPTH : STR_SPACEFACTOR );
  1103.     break;
  1104.   case set_page_int : 
  1105.     printesc( (chrcode == 0) ? STR_DEADCYCLES : STR_INSERTPENALTIES );
  1106.     break;
  1107.   case set_box_dimen : 
  1108.     if ( chrcode == widthoffset ) 
  1109.       printesc ( STR_WD ) ; 
  1110.     else if ( chrcode == heightoffset ) 
  1111.       printesc ( STR_HT ) ; 
  1112.     else
  1113.       printesc ( STR_DP ) ; 
  1114.     break ; 
  1115.   case last_item : 
  1116.     switch ( chrcode ) {
  1117.     case intval : 
  1118.       printesc ( STR_LASTPENALTY ) ; 
  1119.       break ; 
  1120.     case dimenval : 
  1121.       printesc ( STR_LASTKERN ) ; 
  1122.       break ; 
  1123.     case glueval : 
  1124.       printesc ( STR_LASTSKIP ) ; 
  1125.       break ; 
  1126.     case inputlinenocode : 
  1127.       printesc ( STR_INPUTLINENO ) ; 
  1128.       break ; 
  1129.     default: 
  1130.       printesc ( STR_BADNESS ) ; 
  1131.       break ; 
  1132.     } 
  1133.     break ; 
  1134.   case convert : 
  1135.     switch ( chrcode ) {
  1136.     case numbercode : 
  1137.       printesc ( STR_NUMBER );
  1138.       break ; 
  1139.     case romannumeralcode : 
  1140.       printesc ( STR_ROMANNUMERAL );
  1141.       break ; 
  1142.     case stringcode : 
  1143.       printesc ( STR_STRING );
  1144.       break ; 
  1145.     case meaningcode : 
  1146.       printesc ( STR_MEANING );
  1147.       break ; 
  1148.     case fontnamecode : 
  1149.       printesc ( STR_FONTNAME );
  1150.       break ; 
  1151.     default: 
  1152.       printesc ( STR_JOBNAME );
  1153.       break;
  1154.     }
  1155.     break;
  1156.   case iftest : 
  1157.     switch ( chrcode ) {
  1158.     case ifcatcode : 
  1159.       printesc ( STR_IFCAT ) ; 
  1160.       break ; 
  1161.     case ifintcode : 
  1162.       printesc ( STR_IFNUM ) ; 
  1163.       break ; 
  1164.     case ifdimcode : 
  1165.       printesc ( STR_IFDIM ) ; 
  1166.       break ; 
  1167.     case ifoddcode : 
  1168.       printesc ( STR_IFODD ) ; 
  1169.       break ; 
  1170.     case ifvmodecode : 
  1171.       printesc ( STR_IFVMODE ) ; 
  1172.       break ; 
  1173.     case ifhmodecode : 
  1174.       printesc ( STR_IFHMODE ) ; 
  1175.       break ; 
  1176.     case ifmmodecode : 
  1177.       printesc ( STR_IFMMODE ) ; 
  1178.       break ; 
  1179.     case ifinnercode : 
  1180.       printesc ( STR_IFINNER ) ; 
  1181.       break ; 
  1182.     case ifvoidcode : 
  1183.       printesc ( STR_IFVOID ) ; 
  1184.       break ; 
  1185.     case ifhboxcode : 
  1186.       printesc ( STR_IFHBOX ) ; 
  1187.       break ; 
  1188.     case ifvboxcode : 
  1189.       printesc ( STR_IFVBOX ) ; 
  1190.       break ; 
  1191.     case ifxcode : 
  1192.       printesc ( STR_IFX ) ; 
  1193.       break ; 
  1194.     case ifeofcode : 
  1195.       printesc ( STR_IFEOF ) ; 
  1196.       break ; 
  1197.     case iftruecode : 
  1198.       printesc ( STR_IFTRUE ) ; 
  1199.       break ; 
  1200.     case iffalsecode : 
  1201.       printesc ( STR_IFFALSE ) ; 
  1202.       break ; 
  1203.     case ifcasecode : 
  1204.       printesc ( STR_IFCASE ) ; 
  1205.       break ; 
  1206.     default: 
  1207.       printesc( STR_IF );
  1208.       break ; 
  1209.     } 
  1210.     break ; 
  1211.   case fiorelse : 
  1212.     if ( chrcode == ficode ) 
  1213.       printesc ( STR_FI ) ; 
  1214.     else if ( chrcode == orcode ) 
  1215.       printesc ( STR_OR ) ; 
  1216.     else printesc ( STR_ELSE );
  1217.     break ; 
  1218.   case tab_mark : 
  1219.     if ( chrcode == spancode ) 
  1220.       printesc( STR_SPAN );
  1221.     else {
  1222.       c_print("alignment tab character ");
  1223.       print ( chrcode ) ; 
  1224.     } 
  1225.     break ; 
  1226.   case car_ret : 
  1227.     printesc( (chrcode == crcode) ? STR_CR : STR_CRCR );
  1228.     break;
  1229.   case set_page_dimen : 
  1230.     switch ( chrcode ) {
  1231.     case 0 : 
  1232.       printesc( STR_PAGEGOAL );
  1233.       break ; 
  1234.     case 1 : 
  1235.       printesc( STR_PAGETOTAL );
  1236.       break ; 
  1237.     case 2 : 
  1238.       printesc( STR_PAGESTRETCH );
  1239.       break ; 
  1240.     case 3 : 
  1241.       printesc( STR_PAGEFILSTRETCH );
  1242.       break ; 
  1243.     case 4 : 
  1244.       printesc( STR_PAGEFILLSTRETCH );
  1245.       break ; 
  1246.     case 5 : 
  1247.       printesc( STR_PAGEFILLLSTRETCH );
  1248.       break ; 
  1249.     case 6 : 
  1250.       printesc( STR_PAGESHRINK );
  1251.       break ; 
  1252.     default: 
  1253.       printesc( STR_PAGEDEPTH );
  1254.       break ; 
  1255.     } 
  1256.     break ; 
  1257.   case stop : 
  1258.     printesc( (chrcode == 1) ? STR_DUMP : STR_END );
  1259.     break ; 
  1260.   case hskip : 
  1261.     switch ( chrcode ) {
  1262.     case 4 : 
  1263.       printesc( STR_HSKIP );
  1264.       break ; 
  1265.     case 0 : 
  1266.       printesc( STR_HFIL );
  1267.       break ; 
  1268.     case 1 : 
  1269.       printesc( STR_HFILL );
  1270.       break ; 
  1271.     case 2 : 
  1272.       printesc( STR_HSS );
  1273.       break ; 
  1274.     default: 
  1275.       printesc( STR_HFILNEG );
  1276.       break;
  1277.     }
  1278.     break ; 
  1279.   case vskip : 
  1280.     switch ( chrcode ) {
  1281.     case 4 : 
  1282.       printesc( STR_VSKIP );
  1283.       break ; 
  1284.     case 0 : 
  1285.       printesc( STR_VFIL ) ; 
  1286.       break ; 
  1287.     case 1 : 
  1288.       printesc( STR_VFILL ) ; 
  1289.       break ; 
  1290.     case 2 : 
  1291.       printesc( STR_VSS ) ; 
  1292.       break ; 
  1293.     default: 
  1294.       printesc( STR_VFILNEG ) ; 
  1295.       break ; 
  1296.     } 
  1297.     break ; 
  1298.   case mskip : 
  1299.     printesc ( 333 ) ; 
  1300.     break ; 
  1301.   case kern : 
  1302.     printesc ( 337 ) ; 
  1303.     break ; 
  1304.   case mkern : 
  1305.     printesc ( 339 ) ; 
  1306.     break ; 
  1307.   case hmove : 
  1308.     printesc( (chrcode == 1) ? STR_MOVELEFT : STR_MOVERIGHT );
  1309.     break ; 
  1310.   case vmove : 
  1311.     printesc( (chrcode == 1) ? STR_RAISE : STR_LOWER );
  1312.     break ; 
  1313.   case make_box : 
  1314.     switch ( chrcode ) {
  1315.     case 0 : 
  1316.       printesc( STR_BOX );
  1317.       break ; 
  1318.     case 1 : 
  1319.       printesc( STR_COPY );
  1320.       break ; 
  1321.     case 2 : 
  1322.       printesc( STR_LASTBOX );
  1323.       break ; 
  1324.     case 3 : 
  1325.       printesc( STR_VSPLIT );
  1326.       break ; 
  1327. #ifdef OLD_MODE
  1328.     case 4 :
  1329.       printesc( STR_VTOP );
  1330.       break ; 
  1331.     case 5 : 
  1332.       printesc( STR_VBOX );
  1333.       break ; 
  1334.     default: 
  1335.       printesc( STR_HBOX );
  1336.       break ; 
  1337. #else
  1338.     default:
  1339.       if( chrcode == 4 )
  1340.     printesc( STR_VTOP );
  1341.       else if( chrcode == (4 + vmode) )
  1342.     printesc( STR_VBOX );
  1343.       else
  1344.     printesc( STR_HBOX ); 
  1345.       break;
  1346. #endif
  1347.     }
  1348.     break;
  1349.   case leader_ship :
  1350.     if ( chrcode == aleaders ) 
  1351.       printesc( STR_LEADERS );
  1352.     else if ( chrcode == cleaders ) 
  1353.       printesc( STR_CLEADERS );
  1354.     else if ( chrcode == xleaders ) 
  1355.       printesc( STR_XLEADERS );
  1356.     else
  1357.       printesc( STR_SHIPOUT );
  1358.     break ; 
  1359.   case start_par : 
  1360.     printesc( (chrcode == 0) ? STR_NOINDENT : STR_INDENT );
  1361.     break;
  1362.   case remove_item : 
  1363.     if ( chrcode == gluenode ) 
  1364.       printesc( STR_UNSKIP );
  1365.     else if ( chrcode == kernnode ) 
  1366.       printesc( STR_UNKERN );
  1367.     else
  1368.       printesc( STR_UNPENALTY );
  1369.     break;
  1370.   case un_hbox : 
  1371.     printesc( (chrcode == 1) ? STR_UNHCOPY : STR_UNHBOX );
  1372.     break;
  1373.   case un_vbox : 
  1374.     printesc( (chrcode == 1) ? STR_UNVCOPY : STR_UNVBOX );
  1375.     break;
  1376.   case discretionary : 
  1377.     printesc( (chrcode == 1) ? 45 : 346 );
  1378.     break ; 
  1379.   case eq_no : 
  1380.     printesc( (chrcode == 1) ? STR_LEQNO : STR_EQNO );
  1381.     break ; 
  1382.   case math_comp : 
  1383.     switch ( chrcode ) {
  1384.     case ordnoad : 
  1385.       printesc ( STR_MATHORD ) ; 
  1386.       break ; 
  1387.     case opnoad : 
  1388.       printesc ( STR_MATHOP ) ; 
  1389.       break ; 
  1390.     case binnoad : 
  1391.       printesc ( STR_MATHBIN ) ; 
  1392.       break ; 
  1393.     case relnoad : 
  1394.       printesc ( STR_MATHREL ) ; 
  1395.       break ; 
  1396.     case opennoad : 
  1397.       printesc ( STR_MATHOPEN ) ; 
  1398.       break ; 
  1399.     case closenoad : 
  1400.       printesc ( STR_MATHCLOSE ) ; 
  1401.       break ; 
  1402.     case punctnoad : 
  1403.       printesc ( STR_MATHPUNCT ) ; 
  1404.       break ; 
  1405.     case innernoad : 
  1406.       printesc ( STR_MATHINNER ) ; 
  1407.       break ; 
  1408.     case undernoad : 
  1409.       printesc ( STR_UNDERLINE ) ; 
  1410.       break ; 
  1411.     default: 
  1412.       printesc ( STR_OVERLINE );
  1413.       break ; 
  1414.     } 
  1415.     break ; 
  1416.   case limit_switch : 
  1417.     if ( chrcode == limits ) 
  1418.       printesc ( STR_LIMITS ) ; 
  1419.     else if ( chrcode == nolimits ) 
  1420.       printesc ( STR_NOLIMITS ) ; 
  1421.     else
  1422.       printesc( STR_DISPLAYLIMITS );
  1423.     break ; 
  1424.   case math_style :
  1425.     printstyle ( chrcode ) ; 
  1426.     break ; 
  1427.   case above :
  1428.     { strnumber s;
  1429.  
  1430.       switch ( chrcode ) {
  1431.     case 1:  s = STR_OVER;  break;
  1432.     case 2:  s = STR_ATOP;  break;
  1433.     case 3:  s = STR_ABOVEWITHDELIMS; break;
  1434.     case 4:  s = STR_OVERWITHDELIMS;  break;
  1435.     case 5:  s = STR_ATOPWITHDELIMS;  break;
  1436.     default: s = STR_ABOVE; break;
  1437.       }
  1438.       printesc(s);
  1439.     }
  1440.     break;
  1441.   case left_right : 
  1442.     printesc( (chrcode == leftnoad) ? STR_LEFT : STR_RIGHT );
  1443.     break ; 
  1444.   case prefix : 
  1445.     if ( chrcode == 1 ) 
  1446.       printesc ( STR_LONG );
  1447.     else if ( chrcode == 2 ) 
  1448.       printesc ( STR_OUTER );
  1449.     else
  1450.       printesc ( STR_GLOBAL );
  1451.     break ; 
  1452.   case def : 
  1453.     if ( chrcode == 0 ) 
  1454.       printesc ( STR_DEF );
  1455.     else if ( chrcode == 1 ) 
  1456.       printesc ( STR_GDEF );
  1457.     else if ( chrcode == 2 ) 
  1458.       printesc ( STR_EDEF );
  1459.     else
  1460.       printesc ( STR_XDEF );
  1461.     break ; 
  1462.   case let : 
  1463.     printesc( (chrcode != normal) ? STR_FUTURELET : STR_LET );
  1464.     break ; 
  1465.   case shorthand_def : 
  1466.     switch ( chrcode ) {
  1467.     case 0 : 
  1468.       printesc ( STR_CHARDEF );
  1469.       break ; 
  1470.     case 1 : 
  1471.       printesc ( STR_MATHCHARDEF );
  1472.       break ; 
  1473.     case 2 : 
  1474.       printesc ( STR_COUNTDEF );
  1475.       break ; 
  1476.     case 3 : 
  1477.       printesc ( STR_DIMENDEF );
  1478.       break ; 
  1479.     case 4 : 
  1480.       printesc ( STR_SKIPDEF );
  1481.       break ; 
  1482.     case 5 : 
  1483.       printesc ( STR_MUSKIPDEF );
  1484.       break ; 
  1485.     default: 
  1486.       printesc ( STR_TOKSDEF );
  1487.       break ; 
  1488.     } 
  1489.     break ; 
  1490.   case chargiven : 
  1491.     printesc ( 509 ) ; 
  1492.     printhex ( chrcode ) ; 
  1493.     break ; 
  1494.   case math_given :
  1495.     printesc ( 520 ) ; 
  1496.     printhex ( chrcode ) ; 
  1497.     break ; 
  1498.   case def_code : 
  1499.     if ( chrcode == catcodebase ) 
  1500.       printesc ( 411 ) ; 
  1501.     else if ( chrcode == mathcodebase ) 
  1502.       printesc ( 415 ) ; 
  1503.     else if ( chrcode == lccodebase ) 
  1504.       printesc ( 412 ) ; 
  1505.     else if ( chrcode == uccodebase ) 
  1506.       printesc ( 413 ) ; 
  1507.     else if ( chrcode == sfcodebase ) 
  1508.       printesc ( 414 ) ; 
  1509.     else printesc ( 473 ) ; 
  1510.     break ; 
  1511.   case def_family : 
  1512.     printsize ( chrcode - mathfontbase );
  1513.     break ; 
  1514.   case hyph_data : 
  1515.     printesc( (chrcode == 1) ? STR_PATTERNS : STR_HYPHENATION );
  1516.     break ; 
  1517.   case assign_font_int : 
  1518.     printesc( (chrcode == 0) ? STR_HYPHENCHAR : STR_SKEWCHAR );
  1519.     break ; 
  1520.   case set_font :
  1521.     {
  1522.       c_print("select font ");
  1523. #if 0  /* TeX 3.141 */
  1524.       print ( fontname(chrcode) );
  1525. #else
  1526.       slowprint ( fontname(chrcode) );
  1527. #endif
  1528.       if ( fontsize(chrcode) != fontdsize(chrcode) ) {
  1529.     print( STR_AT_ );
  1530.     printscaled ( fontsize(chrcode) );
  1531.     print( STR_PT );
  1532.       } 
  1533.     } 
  1534.     break ; 
  1535.   case set_interaction : 
  1536.     switch ( chrcode ) {
  1537.     case batchmode : 
  1538.       printesc ( 272 ) ; 
  1539.       break ; 
  1540.     case nonstopmode : 
  1541.       printesc ( 273 ) ; 
  1542.       break ; 
  1543.     case scrollmode : 
  1544.       printesc ( 274 ) ; 
  1545.       break ; 
  1546.     default: 
  1547.       printesc ( STR_ERRORSTOPMODE );
  1548.       break ; 
  1549.     } 
  1550.     break ; 
  1551.   case instream : 
  1552.     printesc( (chrcode == 0) ? STR_CLOSEIN : STR_OPENIN );
  1553.     break ; 
  1554.   case message : 
  1555.     printesc( (chrcode == 0) ? STR_MESSAGE : STR_ERRMESSAGE );
  1556.     break ; 
  1557.   case caseshift : 
  1558.     printesc( (chrcode == lccodebase) ? STR_LOWERCASE : STR_UPPERCASE );
  1559.     break ; 
  1560.   case xray : 
  1561.     switch ( chrcode ) {
  1562.     case 1 : 
  1563.       printesc ( STR_SHOWBOX );
  1564.       break;
  1565.     case 2 : 
  1566.       printesc ( STR_SHOWTHE );
  1567.       break;
  1568.     case 3 : 
  1569.       printesc ( STR_SHOWLISTS );
  1570.       break;
  1571.     default: 
  1572.       printesc ( STR_SHOW );
  1573.       break;
  1574.     }
  1575.     break ; 
  1576.   case undefinedcs : 
  1577.     c_print("undefined");
  1578.     break ; 
  1579.   case call : 
  1580.     c_print("macro");
  1581.     break ; 
  1582.   case longcall : 
  1583.     c_printesc("long macro");
  1584.     break ; 
  1585.   case longoutercall : 
  1586.     printesc ( STR_LONG );
  1587.     /* Fall through */
  1588.   case outercall : 
  1589.     c_printesc("outer macro");
  1590.     break ;
  1591.   case endtemplate : 
  1592.     c_printesc("outer endtemplate");
  1593.     break ;
  1594.   case extension: 
  1595.     switch ( chrcode ) {
  1596.     case opennode : 
  1597.       printesc ( STR_OPENOUT );
  1598.       break ; 
  1599.     case writenode : 
  1600.       printesc ( STR_WRITE );
  1601.       break ; 
  1602.     case closenode : 
  1603.       printesc ( STR_CLOSEOUT );
  1604.       break ; 
  1605.     case specialnode : 
  1606.       printesc ( STR_SPECIAL );
  1607.       break ; 
  1608.     case 4 : 
  1609.       printesc ( STR_IMMEDIATE );
  1610.       break ; 
  1611.     case 5 : 
  1612.       printesc( STR_SETLANGUAGE );
  1613.       break ; 
  1614.     default: 
  1615.       c_print("[unknown extension!]");
  1616.       break ; 
  1617.     } 
  1618.     break ; 
  1619.   default:
  1620.     c_print("[unknown command code!]");
  1621.     break;
  1622.   } 
  1623. } 
  1624.  
  1625.  
  1626. #ifdef STAT
  1627. void showeqtb ( halfword n )
  1628. { showeqtb_regmem 
  1629.  
  1630.   if ( n < activebase ) 
  1631.     printchar ( 63 ) ; 
  1632.   else if ( n < gluebase ) {
  1633.     sprintcs ( n ) ; 
  1634.     printchar ( 61 ) ; 
  1635.     printcmdchr ( eqtype ( n ) , equiv ( n ) ) ; 
  1636.     if ( eqtype ( n ) >= call ) {
  1637.       printchar ( 58 ) ; 
  1638.       showtokenlist ( link ( equiv ( n ) ) , 0 , 32 ) ; 
  1639.     } 
  1640.   } else if ( n < localbase ) {
  1641.     if ( n < skipbase ) {
  1642.       printskipparam ( n - gluebase ) ; 
  1643.       printchar ( 61 ) ; 
  1644.       if ( n < gluebase + thinmuskipcode ) 
  1645.     printspec( equiv(n), STR_PT );
  1646.       else
  1647.     printspec( equiv(n), STR_MU );
  1648.     } else if ( n < muskipbase ) {
  1649.       printesc( STR_SKIP );
  1650.       printint ( n - skipbase ) ; 
  1651.       printchar ( 61 ) ; 
  1652.       printspec ( equiv ( n ) , STR_PT ) ; 
  1653.     } else {
  1654.       printesc ( 392 ) ; 
  1655.       printint ( n - muskipbase ) ; 
  1656.       printchar ( 61 ) ; 
  1657.       printspec ( equiv ( n ), STR_MU );
  1658.     }
  1659.   } else if ( n < intbase ) 
  1660.  
  1661.   if ( n == parshapeloc ) {
  1662.     printesc ( 404 ) ; 
  1663.     printchar ( 61 ) ; 
  1664.     if ( parshapeptr == 0 ) 
  1665.       printchar ( 48 ) ; 
  1666.     else printint ( info ( parshapeptr ) ) ; 
  1667.   } else if ( n < toksbase ) {
  1668.     printcmdchr( assign_toks, n );
  1669.     printchar ( 61 ) ; 
  1670.     if ( equiv ( n ) != 0 )
  1671.       showtokenlist ( link ( equiv ( n ) ) , 0 , 32 ) ; 
  1672.   } else if ( n < boxbase ) {
  1673.     printesc ( 403 ) ; 
  1674.     printint ( n - toksbase ) ; 
  1675.     printchar ( 61 ) ; 
  1676.     if ( equiv ( n ) != 0 )
  1677.       showtokenlist ( link ( equiv ( n ) ) , 0 , 32 ) ; 
  1678.   } else if ( n < curfontloc ) {
  1679.     printesc( STR_BOX );
  1680.     printint ( n - boxbase ) ; 
  1681.     printchar ( 61 ) ;
  1682.     if ( equiv ( n ) == 0 ) 
  1683.       c_print("void");
  1684.     else {
  1685.       depththreshold = 0 ; 
  1686.       breadthmax = 1 ; 
  1687.       shownodelist ( equiv ( n ) ) ; 
  1688.     } 
  1689.   } else if ( n < catcodebase ) {
  1690.     if ( n == curfontloc )
  1691.       c_print("current font");
  1692.     else if ( n < mathfontbase + 16 ) {
  1693.       printesc ( 408 ) ; 
  1694.       printint ( n - mathfontbase ) ; 
  1695.     } else if ( n < mathfontbase + 32 ) {
  1696.       printesc ( 409 ) ; 
  1697.       printint ( n - mathfontbase - 16 ) ; 
  1698.     } else {
  1699.       printesc ( 410 ) ; 
  1700.       printint ( n - mathfontbase - 32 ) ; 
  1701.     } 
  1702.     printchar ( 61 ) ; 
  1703.     printesc ( hash [ fontidbase + equiv ( n ) ] .v.RH ) ; 
  1704.   } else if ( n < mathcodebase ) {
  1705.     if ( n < lccodebase ) {
  1706.       printesc ( 411 ) ; 
  1707.       printint ( n - catcodebase ) ; 
  1708.     } else if ( n < uccodebase ) {
  1709.       printesc ( 412 ) ; 
  1710.       printint ( n - lccodebase ) ; 
  1711.     } else if ( n < sfcodebase ) {
  1712.       printesc ( 413 ) ; 
  1713.       printint ( n - uccodebase ) ; 
  1714.     } else {
  1715.       printesc ( 414 ) ; 
  1716.       printint ( n - sfcodebase ) ; 
  1717.     } 
  1718.     printchar ( 61 ) ; 
  1719.     printint ( equiv ( n ) ) ; 
  1720.   } else {
  1721.     printesc ( 415 ) ; 
  1722.     printint ( n - mathcodebase ) ; 
  1723.     printchar ( 61 ) ; 
  1724.     printint ( equiv ( n ) ) ; 
  1725.   }
  1726.  
  1727.   else if ( n < dimenbase ) {
  1728.     if ( n < countbase ) 
  1729.       printparam ( n - intbase ) ; 
  1730.     else if ( n < delcodebase ) {
  1731.       printesc ( 472 ) ; 
  1732.       printint ( n - countbase ) ; 
  1733.     } else {
  1734.       printesc ( 473 ) ; 
  1735.       printint ( n - delcodebase ) ; 
  1736.     } 
  1737.     printchar ( 61 ) ; 
  1738.     printint ( eqtb [ n ] .cint ) ; 
  1739.   } else if ( n <= eqtbsize ) {
  1740.     if ( n < scaledbase )
  1741.       printlengthparam ( n - dimenbase ) ; 
  1742.     else {
  1743.       printesc ( 496 ) ; 
  1744.       printint ( n - scaledbase ) ; 
  1745.     } 
  1746.     printchar ( 61 ) ; 
  1747.     printscaled ( eqtb [ n ] .cint ) ; 
  1748.     print ( STR_PT );
  1749.   } else
  1750.     printchar ( 63 );
  1751. }
  1752. #endif /* STAT */
  1753.  
  1754.  
  1755. halfword idlookup ( integer j, integer l )
  1756. { idlookup_regmem
  1757.   register unsigned short h;    /* ==> hashprime < (65536/2-256) */
  1758.   register integer d; 
  1759.   register halfword p;
  1760.   register long k;
  1761.  
  1762.   ASCIIcode *cp = &buffer[j];
  1763.  
  1764.   /* 261. */
  1765.   h = *cp++;    /* h = buffer [ j ] ; */
  1766.   for( k = 2 ; k <= l ; k++ ) {
  1767.       h = h + h + *cp++;    /* buffer[k] */
  1768.       while ( h >= hashprime )
  1769.     h -= hashprime;
  1770.   }
  1771.   /* 261. end */
  1772.  
  1773.   p = h + hashbase;
  1774.  
  1775.   while ( true ) {
  1776.     if( ( ztext(p) > 0 )
  1777.     &&  ( length( ztext(p) ) == l )
  1778.     && !strncmp( (char *) &strpool[strstart[ztext(p)]],
  1779.              (char *) &buffer[j],
  1780.              l ) )
  1781.       return(p);
  1782.  
  1783.     if ( next ( p ) == 0 ) {
  1784.       if ( nonewcontrolsequence )
  1785.     return( undefinedcontrolsequence );
  1786.       else {
  1787.     /* 260. */
  1788.     if ( ztext ( p ) > 0 ) {
  1789.       do {
  1790.         if ( hashisfull )
  1791.         overflow(5, hashsize);
  1792.         decr ( hashused );
  1793.       } while ( ztext ( hashused ) != 0 );
  1794.       next ( p ) = hashused;
  1795.       p = hashused;
  1796.     }
  1797.     strroom ( l );
  1798.     d = curlength;
  1799.     while ( poolptr > strstart [ strptr ] ) {
  1800.       decr ( poolptr );
  1801.       strpool [ poolptr + l ] = strpool [ poolptr ];
  1802.     }
  1803.     for( k = j ; k <= j + l - 1 ; k++ ) {
  1804.       appendchar ( buffer [ k ] );
  1805.     }
  1806.     ztext ( p ) = makestring();
  1807.     poolptr += d;
  1808. #ifdef STAT
  1809.     incr ( cscount );
  1810. #endif /* STAT */
  1811.       }
  1812.       return(p);
  1813.     }
  1814.     p = next ( p );
  1815.   }
  1816. }
  1817.  
  1818.  
  1819. void newsavelevel ( groupcode c )
  1820. { newsavelevel_regmem
  1821.  
  1822.   if ( saveptr > maxsavestack ) {
  1823.     maxsavestack = saveptr;
  1824.     if ( maxsavestack > savesize - 6 )
  1825.     overflow(6, savesize);
  1826.   }
  1827.   savetype ( saveptr ) = levelboundary;
  1828.   savelevel ( saveptr ) = curgroup;
  1829.   saveindex ( saveptr ) = curboundary;
  1830.   if ( curlevel == maxquarterword )
  1831.     overflow(7, maxquarterword - 0);
  1832.   curboundary = saveptr;
  1833.   incr ( curlevel );
  1834.   incr ( saveptr );
  1835.   curgroup = c;
  1836. }
  1837.  
  1838.  
  1839. static    /* (hes) */
  1840. void eqdestroy ( MEDmemoryword w )
  1841. { eqdestroy_regmem
  1842.  
  1843.   switch ( eqtypefield ( w ) ) {
  1844.   case call :
  1845.   case longcall :
  1846.   case outercall :
  1847.   case longoutercall :
  1848.     deletetokenref ( equivfield ( w ) );
  1849.     break;
  1850.   case glueref :
  1851.     deleteglueref ( equivfield ( w ) );
  1852.     break;
  1853.   case shaperef :
  1854.     { register halfword q;
  1855.  
  1856.       q = equivfield( w );
  1857.       if ( q != 0 )
  1858.     freenode( q, info(q) + info(q) + 1 ); 
  1859.     }
  1860.     break;
  1861.   case boxref :
  1862.     flushnodelist ( equivfield ( w ) );
  1863.     break;
  1864.   default:
  1865.     break;
  1866.   }
  1867. }
  1868.  
  1869.  
  1870. void eqsave ( halfword p, quarterword l )
  1871. { eqsave_regmem
  1872.  
  1873.   if ( saveptr > maxsavestack ) {
  1874.     maxsavestack = saveptr ; 
  1875.     if ( maxsavestack > savesize - 6 ) 
  1876.       overflow(6, savesize);
  1877.   } 
  1878.   if ( l == levelzero ) 
  1879.     savetype ( saveptr ) = restorezero ; 
  1880.   else {
  1881.     savestack [ saveptr ] = eqtb [ p ] ; 
  1882.     incr ( saveptr ) ; 
  1883.     savetype ( saveptr ) = restoreoldvalue ; 
  1884.   } 
  1885.   savelevel ( saveptr ) = l ; 
  1886.   saveindex ( saveptr ) = p ; 
  1887.   incr ( saveptr ) ; 
  1888. }
  1889.  
  1890.  
  1891. void eqdefine ( halfword p, quarterword t, halfword e )
  1892. { eqdefine_regmem
  1893.  
  1894.   if ( eqlevel ( p ) == curlevel ) 
  1895.     eqdestroy ( eqtb [ p ] ) ; 
  1896.   else if ( curlevel > levelone ) 
  1897.     eqsave ( p , eqlevel ( p ) ) ; 
  1898.   eqlevel ( p ) = curlevel ; 
  1899.   eqtype ( p ) = t ; 
  1900.   equiv ( p ) = e ; 
  1901. }
  1902.  
  1903.  
  1904. void eqworddefine ( halfword p, integer w )
  1905. { eqworddefine_regmem 
  1906.  
  1907.   if ( xeqlevel [ p ] != curlevel ) {
  1908.     eqsave( p, xeqlevel[p] );
  1909.     xeqlevel[p] = curlevel;
  1910.   }
  1911.   eqtb [ p ] .cint = w;
  1912. }
  1913.  
  1914.  
  1915. void geqdefine ( halfword p, quarterword t, halfword e )
  1916. { geqdefine_regmem
  1917.  
  1918.   eqdestroy ( eqtb [ p ] );
  1919.   eqlevel ( p ) = levelone;
  1920.   eqtype ( p ) = t;
  1921.   equiv ( p ) = e;
  1922. }
  1923.  
  1924.  
  1925. void geqworddefine ( halfword p, integer w )
  1926. { geqworddefine_regmem
  1927.  
  1928.   eqtb [ p ] .cint = w;
  1929.   xeqlevel [ p ] = levelone;
  1930. } 
  1931.  
  1932.  
  1933. void saveforafter ( halfword t )
  1934. { saveforafter_regmem
  1935.  
  1936.   if ( curlevel > levelone ) {
  1937.     if ( saveptr > maxsavestack ) {
  1938.       maxsavestack = saveptr ; 
  1939.       if ( maxsavestack > savesize - 6 ) 
  1940.     overflow(6, savesize);
  1941.     }
  1942.     savetype ( saveptr ) = inserttoken;
  1943.     savelevel ( saveptr ) = levelzero;
  1944.     saveindex ( saveptr ) = t;
  1945.     incr ( saveptr );
  1946.   }
  1947. }
  1948.  
  1949.  
  1950. #ifdef STAT
  1951. void restoretrace ( halfword p, char *s )
  1952. { restoretrace_regmem
  1953.  
  1954.   begindiagnostic () ; 
  1955.   printchar ( 123 ) ; 
  1956.   c_print(s);
  1957.   printchar ( 32 ) ; 
  1958.   showeqtb ( p ) ; 
  1959.   printchar ( 125 ) ; 
  1960.   enddiagnostic ( false ) ; 
  1961. } 
  1962. #endif /* STAT */
  1963.  
  1964.  
  1965. void unsave ( void )
  1966. {/* 30 */ unsave_regmem 
  1967.   register halfword p  ; 
  1968.   register quarterword l  ; 
  1969.  
  1970.   if ( curlevel > levelone ) {
  1971.     decr ( curlevel ) ; 
  1972.     while ( true ) {
  1973.       decr ( saveptr ) ; 
  1974.       if ( savetype ( saveptr ) == levelboundary ) 
  1975.     goto lab30 ; 
  1976.       p = saveindex ( saveptr ) ; 
  1977.       if ( savetype ( saveptr ) == inserttoken ) {
  1978.     register halfword t;
  1979.  
  1980.     t = curtok ; 
  1981.     curtok = p ; 
  1982.     backinput () ; 
  1983.     curtok = t ; 
  1984.       } else {
  1985.     if ( savetype ( saveptr ) == restoreoldvalue ) {
  1986.       l = savelevel ( saveptr ) ; 
  1987.       decr ( saveptr ) ; 
  1988.     } else
  1989.       savestack [ saveptr ] = eqtb [ undefinedcontrolsequence ] ; 
  1990.     if ( p < intbase ) 
  1991.     if ( eqlevel ( p ) == levelone ) {
  1992.       eqdestroy ( savestack [ saveptr ] ) ; 
  1993. #ifdef STAT
  1994.       if ( tracingrestores > 0 ) 
  1995.         restoretrace(p, "retaining");
  1996. #endif /* STAT */
  1997.     } else {
  1998.       eqdestroy ( eqtb [ p ] ) ; 
  1999.       eqtb [ p ] = savestack [ saveptr ] ; 
  2000. #ifdef STAT
  2001.       if ( tracingrestores > 0 ) 
  2002.         restoretrace(p, "restoring");
  2003. #endif /* STAT */
  2004.     }
  2005.     else if ( xeqlevel [ p ] != levelone ) {
  2006.       eqtb [ p ] = savestack [ saveptr ] ; 
  2007.       xeqlevel [ p ] = l ; 
  2008. #ifdef STAT
  2009.       if ( tracingrestores > 0 ) 
  2010.         restoretrace(p, "restoring");
  2011. #endif /* STAT */
  2012.     }
  2013.     else {
  2014. #ifdef STAT
  2015.       if ( tracingrestores > 0 ) 
  2016.         restoretrace(p, "retaining");
  2017. #endif /* STAT */
  2018.     }
  2019.       }
  2020.     }
  2021. lab30:
  2022.     curgroup = savelevel ( saveptr ) ; 
  2023.     curboundary = saveindex ( saveptr ) ; 
  2024.   } else
  2025.     confusion("curlevel");
  2026. }
  2027.  
  2028. /* -- end -- */
  2029.