home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / tex0.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-31  |  42.6 KB  |  2,140 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. #ifdef AMIGA
  5. extern int do_rexx;    /* defined in arexx.c, used in error() */
  6. #endif
  7.  
  8.  
  9. void println ( void )
  10. { println_regmem
  11.  
  12.   switch ( selector ) {
  13.   case termandlog:
  14.     (void) putc('\n', stdout);
  15.     termoffset = 0;
  16.     /* fall throught */
  17.   case logonly:
  18.     (void) putc('\n', logfile);
  19.     fileoffset = 0;
  20.     break;
  21.   case termonly:
  22.     (void) putc('\n', stdout);
  23.     termoffset = 0;
  24.     break;
  25.   case noprint:
  26.   case pseudo:
  27.   case newstring:
  28.     break;
  29.   default:
  30.     (void) putc('\n', writefile[selector]);
  31.     break;
  32.   }
  33. }
  34.  
  35.   
  36. #ifdef ERW_CODEPAGE
  37.   static
  38. void print_representable_char ( ASCIIcode s )
  39. #else
  40. void printchar ( ASCIIcode s )
  41. #endif
  42. { printchar_regmem
  43.  
  44. #ifndef ERW_CODEPAGE
  45.   if ( s == newlinechar && selector < pseudo ) {
  46.     println ();
  47.     return;
  48.   }
  49. #endif
  50.  
  51.   switch ( selector ) {
  52.   case termandlog :
  53.     (void) putc( Xchr ( s ) ,  stdout );
  54.     incr ( termoffset ) ;
  55.     if ( termoffset == maxprintline ) {
  56.        (void) putc('\n',  stdout );
  57.        termoffset = 0;
  58.     }
  59.     /* fall throught */
  60.   case logonly :
  61.     (void) putc( Xchr ( s ) ,  logfile );
  62.     incr ( fileoffset ) ;
  63.     if ( fileoffset == maxprintline ) {
  64.        (void) putc('\n',  logfile );
  65.        fileoffset = 0 ;
  66.     }
  67.     break;
  68.   case termonly :
  69.     (void) putc( Xchr ( s ) ,  stdout );
  70.     incr ( termoffset ) ;
  71.     if ( termoffset == maxprintline ) {
  72.        (void) putc('\n',  stdout );
  73.        termoffset = 0;
  74.     }
  75.     break ;
  76.   case noprint :
  77.     break ;
  78.   case pseudo :
  79.     if ( tally < trickcount )
  80.       trickbuf [ tally % errorline ] = s ;
  81.     break ;
  82.   case newstring :
  83.     if ( poolptr < poolsize )
  84.        appendchar ( s ) ;
  85.     break ;
  86.   default:
  87.     (void) putc( Xchr ( s ) ,  writefile [ selector ] );
  88.     break ;
  89.   }
  90.   incr ( tally ) ;
  91. }
  92.  
  93.  
  94. #ifdef ERW_CODEPAGE
  95. void printchar ( ASCIIcode s)
  96. { printchar_regmem
  97.  
  98.   if ( s == newlinechar && selector < pseudo ) {
  99.     println ();
  100.     return;
  101.   }
  102.  
  103.   if (printable[s] || (selector > pseudo) ) {
  104.     print_representable_char(s);
  105.     return;
  106.   }
  107.  
  108.   print_representable_char('^');
  109.   print_representable_char('^');
  110.   if ( s < 64 ) {
  111.     print_representable_char(s + 64);
  112.   } else if ( s < 128 ) {
  113.     print_representable_char(s - 64);
  114.   } else {
  115.     register short l;
  116.  
  117.     l = s / 16;
  118.     print_representable_char( l + ( ( l < 10 ) ? '0' : ('a'-10) ) );
  119.     l = s % 16;
  120.     print_representable_char( l + ( ( l < 10 ) ? '0' : ('a'-10) ) );
  121.   }
  122. }
  123. #endif
  124.  
  125.  
  126. void print ( integer s )
  127. { print_regmem
  128.   register packedASCIIcode *cur, *ende;
  129. #ifndef ERW_CODEPAGE
  130.   register integer nl;
  131. #endif
  132.  
  133.   if ( s >= strptr ) {
  134.     c_print("???");
  135.     return;
  136.   } else if ( s < 256 ) {
  137.     if ( s < 0 ) {
  138.       c_print("???");
  139.       return;
  140.     } else {
  141. #ifdef ERW_CODEPAGE
  142.       printchar(s);
  143. #else
  144.       if ( selector > pseudo ) {
  145.     printchar( s );
  146.     return;
  147.       }
  148.       if ( s == newlinechar ) {
  149.     if ( selector < pseudo ) {
  150.       println ();
  151.       return;
  152.     }
  153.       }
  154.       nl = newlinechar;  newlinechar = (integer) -1;
  155.       cur = &strpool[strstart[s]];  ende = &strpool[strstart[s+1]];
  156.       while ( cur < ende ) {
  157.     printchar ( *cur );
  158.     incr ( cur );
  159.       }
  160.       newlinechar = nl;
  161. #endif
  162.       return;
  163.     }
  164.   }
  165.  
  166.   cur = &strpool[strstart[s]];  ende = &strpool[strstart[s+1]];
  167.   while ( cur < ende ) {
  168.     printchar ( *cur );
  169.     incr ( cur );
  170.   }
  171. }
  172.  
  173.  
  174. /* wie `print'
  175.  * nur dass direkt ein null-terminierender String uebergeben wird.
  176.  * (Und fuer diesen gelte "s >= 256", so dass die Abfrage zu
  177.  * Beginn weggelassen werden kann)
  178.  */
  179. void c_print ( char *s )
  180. { print_regmem
  181.  
  182.   while( *s != '\0' )
  183.     printchar ( *s++ );
  184. }
  185.  
  186.  
  187. #ifndef ERW_CODEPAGE
  188. void slowprint ( integer s )
  189. { slowprint_regmem
  190.   register packedASCIIcode *cur, *ende;
  191.  
  192.   if( (s >= strptr) || (s < 256) ) {
  193.     print(s);
  194.   } else {
  195.     cur = &strpool[strstart[s]];  ende = &strpool[strstart[s+1]];
  196.     while ( cur < ende ) {
  197.       print ( *cur );
  198.       incr ( cur );
  199.     }
  200.   }
  201. }
  202. #endif
  203.  
  204.  
  205. void c_printnl ( char *s )
  206. { printnl_regmem
  207.  
  208.   if ( ( termoffset > 0 && odd(selector) )
  209.     || ( fileoffset > 0 && selector >= logonly ) )
  210.     println ();
  211.   c_print ( s );
  212. }
  213.  
  214. void printnl ( strnumber s )
  215. { printnl_regmem
  216.  
  217.   if ( ( termoffset > 0 && odd(selector) )
  218.     || ( fileoffset > 0 && selector >= logonly ) )
  219.     println ();
  220.   print ( s );
  221. }
  222.  
  223.     /* Note that c_printesc() should only be used on internal strings! */
  224.     /* Because we don't call c_slowprint() !! ;-) */
  225. void c_printesc ( char *s )
  226. { printesc_regmem
  227.   register integer c;
  228.  
  229.   c = escapechar;
  230.   if ( c >= 0 && c < 256 )
  231.     print ( c );
  232.   c_print(s);
  233. }
  234.  
  235. void printesc ( strnumber s )
  236. { printesc_regmem
  237.   register integer c;
  238.  
  239.   c = escapechar;
  240.   if ( c >= 0 && c < 256 )
  241.     print ( c );
  242.   slowprint ( s );  /* TeX 3.14 2.update:  print ( s ); */
  243. }
  244.  
  245. void printthedigs ( eightbits k )
  246. { printthedigs_regmem
  247.  
  248.   while ( k > 0 ) {
  249.     decr ( k ) ;
  250.     if ( dig [ k ] < 10 )
  251.     printchar ( 48 + dig[k] );
  252.     else
  253.     printchar ( 55 + dig[k] );
  254.   }
  255. }
  256.  
  257. void printint ( integer n )
  258. { printint_regmem
  259.   register schar k  ;
  260.   register integer m  ;
  261.   ldiv_t result;
  262.  
  263.   k = 0 ;
  264.   if ( n < 0 ) {
  265.     printchar ( 45 ) ;
  266.     if ( n > -100000000L )
  267.     n = - (integer) n ;
  268.     else {
  269.     m = -1 - n ;
  270.         result = ldiv(m, 10);
  271.     n = result.quot;    /* n = m / 10 ; */
  272.     m = result.rem + 1;    /* m = ( m % 10 ) + 1 ; */
  273.     k = 1;
  274.     if ( m < 10 )
  275.        dig [ 0 ] = m ;
  276.     else {
  277.        dig [ 0 ] = 0 ;
  278.        incr ( n ) ;
  279.     }
  280.     }
  281.   }
  282.  
  283.   do {
  284.     result = ldiv(n, 10);
  285.     dig[k] = result.rem;    /* dig [ k ] = n % 10 ; */
  286.     n = result.quot;        /* n = n / 10 ; */
  287.     incr ( k );
  288.   } while ( n != 0 );
  289.  
  290.   printthedigs ( k );
  291. }
  292.  
  293. void printcs ( integer p )
  294. { printcs_regmem
  295.  
  296.   if ( p < hashbase )
  297.     if ( p >= singlebase )
  298.     if ( p == nullcs ) {
  299.        printesc ( 500 );
  300.        printesc( STR_ENDCSNAME );
  301.     } else {
  302.        printesc ( p - singlebase );
  303.        if ( catcode ( p - singlebase ) == 11 )
  304.           printchar ( 32 );
  305.     }
  306.     else if ( p < activebase )
  307.     c_printesc("IMPOSSIBLE.");
  308.     else
  309.      print ( p - activebase );
  310.   else if ( p >= undefinedcontrolsequence )
  311.     c_printesc("IMPOSSIBLE.");
  312.   else if ( ( ztext ( p ) >= strptr ) )
  313.     c_printesc("NONEXISTENT.");
  314.   else {
  315.     printesc ( ztext(p) );  /* TeX 3.14 2.update */
  316.     printchar ( 32 );
  317.   }
  318. }
  319.  
  320. void sprintcs ( halfword p )
  321. { sprintcs_regmem
  322.  
  323.   if ( p < hashbase )
  324.     if ( p < singlebase )
  325.     print ( p - activebase );
  326.     else if ( p < nullcs )
  327.     printesc ( p - singlebase );
  328.     else {
  329.     printesc( 500 );
  330.     printesc( STR_ENDCSNAME );
  331.     }
  332.   else {
  333.     printesc ( ztext(p) );    /* TeX 3.14 2.update */
  334.   }
  335. }
  336.  
  337.  
  338. void printfilename ( integer n, integer a, integer e )
  339. { printfilename_regmem
  340.  
  341.   slowprint ( a );  slowprint ( n );  slowprint ( e ); /* TeX 3.141 */
  342. }
  343.  
  344.  
  345. void printsize ( integer s )
  346. { printsize_regmem
  347.  
  348.   if ( s == 0 )
  349.     printesc ( 408 );
  350.   else if ( s == scriptsize )
  351.     printesc ( 409 );
  352.   else
  353.     printesc ( 410 );
  354. }
  355.  
  356.  
  357. void printwritewhatsit ( strnumber s, halfword p )
  358. { printwritewhatsit_regmem
  359.  
  360.   printesc ( s );
  361.   if ( writestream(p) < 16 )
  362.     printint ( writestream(p) );
  363.   else if ( writestream(p) == 16 )
  364.     printchar ( 42 );
  365.   else
  366.     printchar ( 45 );
  367. }
  368.  
  369.  
  370. VOLATILE void jumpout ( void )
  371. { jumpout_regmem
  372.  
  373.   closefilesandterminate ();
  374.   flush ( stdout );
  375.   readyalready = 0;
  376.   if ( ( history != spotless ) && ( history != warningissued ) )
  377.     uexit ( 1 );
  378.   else
  379.     uexit ( 0 );
  380. }
  381.  
  382.  
  383. void print_err(char *s)
  384. { printerr_regmem
  385.  
  386.   if ( interaction >= errorstopmode )
  387.     wakeupterminal ();
  388.   c_printnl("! ");
  389.   c_print(s);
  390. }
  391.  
  392.  
  393. void p_print_err( strnumber s )
  394. { printerr_regmem
  395.  
  396.   if ( interaction >= errorstopmode )
  397.     wakeupterminal ();
  398.   c_printnl("! ");
  399.   print(s);
  400. }
  401.  
  402.  
  403. #ifdef STRINGBUG_FIX
  404. void slow_print_err( strnumber s )
  405. { printerr_regmem
  406.  
  407.   if ( interaction >= errorstopmode )
  408.     wakeupterminal();
  409.   c_printnl("! ");
  410.   slowprint(s);
  411. }
  412. #endif
  413.  
  414.  
  415. /* wie `print'
  416.  * nur dass direkt ein null-terminierender String uebergeben wird.
  417.  * Ausserdem koennen auch '\n' Zeichen im String vorhanden sein.
  418.  */
  419. static void c_err_print ( char *s )
  420. { c_print_regmem
  421.  
  422.   while( *s != '\0' ) {
  423.     if( *s == '\n' ) {
  424.       println ();
  425.     } else {
  426.       printchar ( *s );
  427.     }
  428.     s++;
  429.   }
  430. }
  431.  
  432.  
  433. void error ( void )
  434. { error_regmem
  435.   register ASCIIcode c;
  436.   register integer s1, s2, s3, s4;
  437.  
  438.   if ( history < errormessageissued )
  439.     history = errormessageissued;
  440.   printchar( 46 );
  441.   showcontext ();
  442.  
  443.   if ( interaction >= errorstopmode ) {
  444.     while ( true ) {
  445. lab22:
  446.     clearforerrorprompt ();
  447. #ifdef AMIGA
  448.     if (do_rexx == 2) {
  449.       /* gegen Endlosschleife, wenn 'e' nicht verfuegbar ist */
  450.       do_rexx = 3;
  451.       /* es wird ein 'e' probiert und dann ein 'x' gemacht */
  452.       last = first;
  453.       buffer[last++] = 69;        /* e : simulate typed 'E' command */
  454.     } else {
  455.       if (do_rexx == 3) {
  456.         last = first;
  457.         buffer[last++] = 88;    /* x : simulate typed 'X' command */
  458.       } else {
  459.         terminput("? ");
  460.       }
  461.     }
  462. #else
  463.     terminput("? ");
  464. #endif
  465.     if ( last == first )
  466.       return;
  467.     c = buffer[first];
  468.     if ( c >= 97 )
  469.       c -= 32;
  470.  
  471.     switch ( c ) {
  472.     case 48:  case 49:  case 50:  case 51:  case 52:
  473.     case 53:  case 54:  case 55:  case 56:  case 57:
  474.       if ( deletionsallowed ) {
  475.         s1 = curtok;
  476.         s2 = curcmd;
  477.         s3 = curchr;
  478.         s4 = alignstate;
  479.         alignstate = 1000000L;
  480.         OKtointerrupt = false;
  481.         if ( ( last > first + 1 )
  482.         && ( buffer [ first + 1 ] >= 48 )
  483.         && ( buffer [ first + 1 ] <= 57 ) )
  484.           c = TEN_MULT(c) + buffer [ first + 1 ] - 48 * 11;
  485.         else
  486.           c = c - 48;
  487.         while ( c > 0 ) {
  488.           gettoken ();  
  489.           decr ( c );
  490.         }
  491.         curtok = s1;
  492.         curcmd = s2;
  493.         curchr = s3;
  494.         alignstate = s4;
  495.         OKtointerrupt = true;
  496.  
  497.         zhelp1( STR_H_IHAVEJUSTDELETED );
  498.         showcontext();
  499.         goto lab22;
  500.       }
  501.       break;
  502. #ifdef DEBUG
  503.     case 68:    /* D */
  504.       debughelp();
  505.       goto lab22; 
  506. #endif /* DEBUG */
  507.     case 69:    /* E */
  508.       if ( baseptr > 0 ) {
  509.         editnamestart = strstart [ inputstack[baseptr].namefield ];
  510.         editnamelength = strstart [ inputstack[baseptr].namefield + 1 ]
  511.                - strstart [ inputstack[baseptr].namefield ];
  512.         editline = line;
  513.         jumpout ();
  514.       }
  515.       break;
  516.     case 72:    /* H */
  517.       if ( useerrhelp ) {
  518.         giveerrhelp();
  519.         useerrhelp = false;
  520.       } else {
  521. #ifdef NEW_HELP
  522.         if ( *helpptr == 0 )
  523.           zhelp2( STR_H_SORRY_DONTKNOWHELP, STR_H_MAYBE_ASK_HUMAN );
  524.  
  525.         do {
  526.           if( (int) *helpptr < (int)256 ) {
  527.         c_err_print ( help_messages[(int) *helpptr++] );
  528.           } else {
  529.             print ( (int) *helpptr++ );
  530.           }
  531.           println ();
  532.         } while ( *helpptr != 0 );
  533. #else
  534.         if ( helpptr == 0 )
  535.           zhelp2( STR_H_SORRY_DONTKNOWHELP, STR_H_MAYBE_ASK_HUMAN );
  536.         do {
  537.           decr ( helpptr );
  538.           if( helpline[helpptr] < (int)256 ) {
  539.         c_err_print ( help_messages[helpline[helpptr]] );
  540.           } else {
  541.         print ( helpline[helpptr] );
  542.           }
  543.           println ();
  544.         } while ( helpptr != 0 );
  545. #endif
  546.       }
  547.       zhelp3( STR_H_SORRY_GAVEHELP, STR_H_MAYBE_ASK_HUMAN,
  548.           STR_H_ANERRORMIGHT );
  549.       goto lab22;
  550.     case 73:    /* I */
  551.       beginfilereading ();
  552.       if ( last > first + 1 ) {
  553.         curinput .locfield = first + 1;
  554.         buffer [ first ] = 32;
  555.       } else {
  556.         terminput("insert>");
  557.         curinput .locfield = first;
  558.       }
  559.       first = last;
  560.       curinput.limitfield = last - 1;
  561.       return;
  562.  
  563.     case 81:    /* Q, R, S */
  564.     case 82:
  565.     case 83:
  566.       errorcount = 0;
  567. #ifdef ERW_INTERACTION
  568.       geqworddefine(intbase + interactionmodecode, batchmode + c - 81);
  569. #else
  570.       interaction = batchmode + c - 81;
  571. #endif
  572.       c_print("OK, entering ");
  573.       switch ( c ) {
  574.       case 81:
  575.         printesc ( 272 );
  576.         decr ( selector );
  577.         break;
  578.       case 82:
  579.         printesc ( 273 );
  580.         break;
  581.       case 83:
  582.         printesc ( 274 );
  583.         break;
  584.       }
  585.       print ( 275 );
  586.       println ();
  587.       flush ( stdout );
  588.       return;
  589.      case 88:    /* X */
  590. #ifdef ERW_INTERACTION
  591.       geqworddefine(intbase + interactionmodecode, scrollmode);
  592. #else
  593.       interaction = scrollmode;
  594. #endif
  595.       jumpout();
  596.       break;
  597.     default:
  598.       break;
  599.     }
  600.  
  601.     c_print("Type <return> to proceed, S to scroll future error messages,");
  602.     c_printnl("R to run without stopping, Q to run quietly,");
  603.     c_printnl("I to insert something, ");
  604.     if ( baseptr > 0 )
  605.       c_print("E to edit your file,");
  606.     if ( deletionsallowed )
  607.       c_printnl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,");
  608.     c_printnl("H for help, X to quit.");
  609.     }
  610.   }
  611.   incr ( errorcount );
  612.   if ( errorcount == 100 ) {
  613.     c_printnl("(That makes 100 errors; please try again.)");
  614.     history = fatalerrorstop;
  615.     jumpout ();
  616.   }
  617.   if ( interaction > batchmode )
  618.     decr ( selector );
  619.   if ( useerrhelp ) {
  620.     println ();
  621.     giveerrhelp ();
  622.   } else {
  623. #ifdef NEW_HELP
  624.     while ( *helpptr > 0 ) {
  625.       c_printnl("");
  626.       if( (int) *helpptr < (int)256 ) {
  627.     c_err_print ( help_messages[(int) *helpptr++] );
  628.       } else {
  629.     print( (int) *helpptr++ );
  630.       }
  631.     }
  632. #else
  633.     while ( helpptr > 0 ) {
  634.       decr ( helpptr );
  635.       c_printnl("");
  636.       if( helpline[helpptr] < (int)256 ) {
  637.     c_err_print ( help_messages[helpline[helpptr]] );
  638.       } else {
  639.     print ( helpline[helpptr] );
  640.       }
  641.     }
  642. #endif
  643.   }
  644.   println ();
  645.   if ( interaction > batchmode )
  646.     incr ( selector );
  647.   println ();
  648. }
  649.  
  650.  
  651. VOLATILE void fatalerror ( strnumber s )
  652. { fatalerror_regmem
  653.  
  654.   normalizeselector();
  655.  
  656.   print_err("Emergency stop");
  657. #ifdef NEW_HELP
  658.   { static short tmp[] = { 0, 0 };
  659.     tmp[0] = s;        /* zhelp1(s); */
  660.     helpptr = tmp;
  661.   }
  662. #else
  663.   zhelp1( s );
  664. #endif
  665.   succumb();
  666. }
  667.  
  668.  
  669. #if 0        /* verschoben nach `overflow.c' */
  670. VOLATILE void overflow ( strnumber s, integer n )
  671. #endif
  672.  
  673.  
  674. VOLATILE void confusion ( char *s )
  675. { confusion_regmem
  676.  
  677.   normalizeselector ();
  678.   if ( history < errormessageissued ) {
  679.     print_err("This can't happen (");
  680.     c_print ( s );
  681.     printchar ( 41 );
  682.     zhelp1( STR_H_IMBROKEN_FIX );
  683.   } else {
  684.     print_err("I can't go on meeting you like this");
  685.     zhelp1( STR_H_ONEOFYOURFAUXPAS );
  686.   }
  687.   succumb ();
  688. }
  689.  
  690.  
  691. boolean initterminal ( void )
  692. { initterminal_regmem
  693.  
  694.   topenin ();
  695.   if ( last > first ) {
  696.     curinput .locfield = first;
  697.     while ( curinput.locfield < last && buffer[curinput.locfield] == ' ' )
  698.     incr ( curinput .locfield );
  699.     if ( curinput .locfield < last )
  700.       return(true);
  701.   }
  702.   while ( true ) {
  703.     wakeupterminal ();
  704.     (void) Fputs( stdout, "**" );
  705.     flush ( stdout );
  706.     if ( ! inputln ( stdin, true ) ) {
  707.       (void) Fputs( stdout, "\n! End of file on the terminal... why?" );
  708.       return(false);
  709.     }
  710.     curinput .locfield = first;
  711.     while ( curinput.locfield < last && buffer[curinput.locfield] == 32 )
  712.     incr ( curinput .locfield );
  713.     if ( curinput .locfield < last )
  714.       return(true);
  715.     (void) printf("Please type the name of your input file.\n");
  716.   }
  717. }
  718.  
  719.  
  720. strnumber makestring ( void )
  721. { makestring_regmem
  722.  
  723.   if ( strptr == maxstrings )
  724.     overflow(2, maxstrings - initstrptr); 
  725.   incr ( strptr );
  726.   strstart [ strptr ] = poolptr;
  727.   return(strptr - 1);
  728. }
  729.  
  730.  
  731. #if 0      /* (br) both replaced by strncmp() */
  732. boolean zstreqbuf ( strnumber s, integer k );
  733. boolean zstreqstr ( strnumber s, strnumber t );
  734. #endif
  735.  
  736.  
  737. void printtwo ( integer n )
  738. { printtwo_regmem
  739.   ldiv_t result;
  740.  
  741.   /* n = abs ( n ) % 100 ; */
  742.   if( n < 0 )  n = -n;
  743.   while( n > 100 )
  744.     n -= 100;
  745.   result = ldiv(n, 10);
  746.   printchar ( 48 + result.quot );    /* ( n / 10 ) */
  747.   printchar ( 48 + result.rem );    /* ( n % 10 ) */
  748. }
  749.  
  750. void printhex ( integer n )
  751. { printhex_regmem
  752.   register schar k;
  753.  
  754.   k = 0;
  755.   printchar ( 34 );
  756.   do {
  757.     dig [ k ] = n % 16;
  758.     n = n / 16;
  759.     incr ( k );
  760.   } while ( ! ( n == 0 ) );
  761.   printthedigs ( k );
  762. }
  763.  
  764. #if 0
  765. void printromanint ( integer n )
  766. { printromanint_regmem
  767.   register poolpointer j, k;
  768.   register nonnegativeinteger u, v;
  769.  
  770.   j = strstart [ 260 ];
  771.   v = 1000;
  772.   while ( true ) {
  773.     while ( n >= v ) {
  774.       printchar( strpool[j] );
  775.       n -= v;
  776.     }
  777.     if ( n <= 0 )
  778.       return;
  779.     k = j + 2;
  780.     u = v / ( strpool [ k - 1 ] - 48 );
  781.     if ( strpool [ k - 1 ] == 50 ) {
  782.       k += 2;
  783.       u /= ( strpool [ k - 1 ] - 48 );
  784.     }
  785.     if ( n + u >= v ) {
  786.       printchar ( strpool [ k ] );
  787.       n += u;
  788.     } else {
  789.       j += 2;
  790.       v /= ( strpool [ j - 1 ] - 48 );
  791.     }
  792.   }
  793. }
  794.  
  795. #else
  796.  
  797. void printromanint ( integer n )
  798. { printromanint_regmem
  799.   register unsigned char *k, *j;
  800.   register nonnegativeinteger u, v;
  801.   unsigned char roman[] =
  802.     { 'm', 2, 'd', 5, 'c', 2, 'l', 5, 'x', 2, 'v', 5, 'i', 0 };
  803.  
  804.   /* j = "m2d5c2l5x2v5i"; */
  805.   j = roman;
  806.  
  807.   v = 1000;
  808.   while ( true ) {
  809.     while ( n >= v ) {
  810.       printchar( *j );
  811.       n -= v;
  812.     }
  813.     if ( n <= 0 )
  814.       return;
  815.  
  816.     k = j + 1;
  817.     u = v / *k;
  818.     if( *k == 2 ) {
  819.     k += 2;
  820.     u /= *k;
  821.     }
  822.     k++;
  823.  
  824.     if ( n + u >= v ) {
  825.       printchar( *k );
  826.       n += u;
  827.     } else {
  828.       j++;
  829.       v /= *j;
  830.       j++;
  831.     }
  832.   }
  833. }
  834. #endif
  835.  
  836.  
  837. void printcurrentstring ( void )
  838. { printcurrentstring_regmem
  839.   register poolpointer j;
  840.  
  841.   j = strstart [ strptr ];
  842.   while ( j < poolptr ) {
  843.     printchar ( strpool [ j ] );
  844.     incr ( j );
  845.   }
  846. }
  847.  
  848.  
  849. void terminput ( char *s )
  850. { terminput_regmem
  851.   register integer k;
  852.  
  853.   wakeupterminal(); 
  854.   c_print( s );
  855.   flush ( stdout );
  856.   if ( ! inputln ( stdin , true ) )
  857.     fatalerror( STR_H_FE_ENDOFFILE );
  858.   termoffset = 0;
  859.   decr ( selector );
  860.   if ( last != first )
  861.     for( k = first ; k <= last - 1 ; k++ ) {
  862.     print ( buffer [ k ] );
  863.     }
  864.   println ();
  865.   incr ( selector );
  866. }
  867.  
  868.  
  869. void interror ( integer n )
  870. { interror_regmem
  871.  
  872.   c_print(" (");
  873.   printint ( n );
  874.   printchar( 41 );
  875.   error () ;
  876. }
  877.  
  878. void normalizeselector ( void )
  879. { normalizeselector_regmem
  880.  
  881.   selector = (logopened) ? termandlog : termonly;
  882.   if ( jobname == 0 )
  883.     openlogfile ();
  884.   if ( interaction <= batchmode )
  885.     decr ( selector );
  886. }
  887.  
  888. VOLATILE void succumb ( void )
  889. { succumb_regmem
  890.  
  891.   if ( interaction >= errorstopmode ) {
  892. #ifdef ERW_INTERACTION
  893.     geqworddefine(intbase + interactionmodecode, scrollmode);
  894. #else
  895.     interaction = scrollmode;
  896. #endif
  897.   }
  898.   if ( logopened )
  899.     error ();
  900. #ifdef DEBUG
  901.   if ( interaction > batchmode )
  902.     debughelp ();
  903. #endif /* DEBUG */
  904.   history = fatalerrorstop;
  905.   jumpout ();
  906. }
  907.  
  908. void pauseforinstructions ( void )
  909. { pauseforinstructions_regmem
  910.  
  911.   if ( OKtointerrupt ) {
  912. #ifdef ERW_INTERACTION
  913.     geqworddefine(intbase + interactionmodecode, errorstopmode);
  914. #else
  915.     interaction = errorstopmode;
  916. #endif
  917.     if ( ( selector == logonly ) || ( selector == noprint ) )
  918.       incr ( selector );
  919.  
  920.     print_err("Interruption");
  921.     zhelp1( STR_H_YOURANG );
  922.     deletionsallowed = false;
  923.     error();
  924.     deletionsallowed = true ;
  925.     interrupt = 0;
  926.   }
  927. }
  928.  
  929.  
  930.  
  931. #ifdef DEBUG
  932. void zprintword ( memoryword w )
  933. { printword_regmem
  934.  
  935.   printint ( w .cint ) ;
  936.   printchar ( 32 ) ;
  937.   printscaled ( w .cint ) ;
  938.   printchar ( 32 ) ;
  939.   printscaled ( round ( unity * w .gr ) ) ;
  940.   println () ;
  941.   printint ( w .hh .v.LH ) ;
  942.   printchar ( 61 ) ;
  943.   printint ( w .hh.b0 ) ;
  944.   printchar ( 58 ) ;
  945.   printint ( w .hh.b1 ) ;
  946.   printchar ( 59 ) ;
  947.   printint ( w .hh .v.RH ) ;
  948.   printchar ( 32 ) ;
  949.   printint ( w .qqqq .b0 ) ;
  950.   printchar ( 58 ) ;
  951.   printint ( w .qqqq .b1 ) ;
  952.   printchar ( 58 ) ;
  953.   printint ( w .qqqq .b2 ) ;
  954.   printchar ( 58 ) ;
  955.   printint ( w .qqqq .b3 ) ;
  956. }
  957. #endif /* DEBUG */
  958.  
  959.  
  960. void showtokenlist ( integer p, integer q, integer l )
  961. { showtokenlist_regmem
  962.   register integer m, c;
  963.   register ASCIIcode matchchr;
  964.   register ASCIIcode n;
  965.  
  966.   matchchr = 35;
  967.   n = 48;
  968.   tally = 0;
  969.   while ( ( p != 0 ) && ( tally < l ) ) {
  970.     if ( p == q ) {
  971.       firstcount = tally;
  972.       trickcount = tally + 1 + errorline - halferrorline;
  973.       if ( trickcount < errorline )
  974.     trickcount = errorline;
  975.     }
  976.     if ( ( p < himemmin ) || ( p > memend ) ) {
  977.       c_printesc("CLOBBERED.");
  978.       return;
  979.     }
  980.     if ( info ( p ) >= cstokenflag )
  981.       printcs ( info ( p ) - cstokenflag );
  982.     else {
  983.       m = info ( p ) / 256;
  984.       c = info ( p ) % 256;
  985.       if ( info ( p ) < 0 )
  986.     c_printesc("BAD.");
  987.       else switch ( m ) {
  988.       case left_brace:    case right_brace:    case math_shift:
  989.       case tab_mark:    case sup_mark:        case sub_mark:
  990.       case spacer:    case letter:        case otherchar:
  991.     print ( c );
  992.     break;
  993.       case mac_param:
  994.     print ( c );  print ( c );
  995.     break;
  996.       case out_param:
  997.     print ( matchchr );
  998.     if ( c <= 9 )
  999.       printchar ( c + 48 );
  1000.     else {
  1001.       printchar ( 33 );
  1002.       return;
  1003.     }
  1004.     break;
  1005.       case begin_match:
  1006.     matchchr = c;
  1007.     print ( c );
  1008.     incr ( n );
  1009.     printchar ( n );
  1010.     if ( n > 57 )
  1011.       return;
  1012.     break;
  1013.       case end_match:
  1014.     c_print("->");
  1015.     break;
  1016.       default:
  1017.     c_printesc("BAD.");
  1018.     break;
  1019.       }
  1020.     }
  1021.     p = link ( p );
  1022.   }
  1023.   if ( p != 0 )
  1024.     c_printesc("ETC.");
  1025. }
  1026.  
  1027.  
  1028. void STDARGS runaway ( void )
  1029. { runaway_regmem
  1030.   register halfword p;
  1031.  
  1032.   if ( scannerstatus > skipping ) {
  1033.     c_printnl("Runaway ");
  1034.     switch ( scannerstatus ) {
  1035.     case defining:
  1036.     c_print("definition");
  1037.     p = defref;
  1038.     break;
  1039.     case matching:
  1040.     c_print("argument");
  1041.     p = temphead;
  1042.     break;
  1043.     case aligning:
  1044.     c_print("preamble");
  1045.     p = holdhead;
  1046.     break;
  1047.     case absorbing:
  1048.     c_print("text");
  1049.     p = defref;
  1050.     break;
  1051.     }
  1052.     printchar ( 63 );
  1053.     println ();
  1054.     showtokenlist ( link(p), 0, errorline - 10 );
  1055.   }
  1056. }
  1057.  
  1058.  
  1059. /* memory management routines -> getmem.c */
  1060.  
  1061.  
  1062. long_halfword newnullbox ( void )
  1063. { register long_halfword p;
  1064.  
  1065.   p = getnode ( boxnodesize );
  1066.  
  1067.   { newnullbox_regmem
  1068.  
  1069. /* ztype ( p ) = hlistnode ;  subtype ( p ) = 0 ; */
  1070.   set_type_subtype(p, hlistnode, 0);
  1071.  
  1072.   width ( p ) = 0;
  1073.   depth ( p ) = 0;
  1074.   height ( p ) = 0;
  1075.   shiftamount ( p ) = 0;
  1076.   listptr ( p ) = 0;
  1077.  
  1078. /* gluesign ( p ) = normal ;  glueorder ( p ) = normal ; */
  1079.   set_gluesign_order(p, normal, normal);
  1080.  
  1081.   glueset ( p ) = 0.0;
  1082.  
  1083.   }
  1084.   return(p);
  1085. }
  1086.  
  1087. long_halfword newrule ( void )
  1088. { register long_halfword p;
  1089.  
  1090.   p = getnode ( rulenodesize );
  1091.  
  1092.   { newrule_regmem
  1093.  
  1094. /* ztype ( p ) = rulenode ;  subtype ( p ) = 0 ; */
  1095.   set_type_subtype(p, rulenode, 0);
  1096.  
  1097.   width ( p ) = nullflag;
  1098.   depth ( p ) = nullflag;
  1099.   height ( p ) = nullflag;
  1100.   }
  1101.  
  1102.   return(p);
  1103. }
  1104.  
  1105. long_halfword newligature ( quarterword f, quarterword c, halfword q )
  1106. { register long_halfword p;
  1107.  
  1108.   p = getnode ( smallnodesize );
  1109.  
  1110.   { newligature_regmem
  1111.  
  1112. /* ztype ( p ) = ligaturenode ;  subtype ( p ) = 0 ; */
  1113.   set_type_subtype(p, ligaturenode, 0);
  1114.  
  1115.   font ( ligchar(p) ) = f;  character ( ligchar(p) ) = c;
  1116.   /* ist besser als: */
  1117.   /* set_font_character(ligchar(p), f, c); */
  1118.  
  1119.   ligptr ( p ) = q;
  1120.   }
  1121.   return(p);
  1122. }
  1123.  
  1124. long_halfword newligitem ( quarterword c )
  1125. { register long_halfword p;
  1126.  
  1127.   p = getnode ( smallnodesize );
  1128.  
  1129.   { newligitem_regmem
  1130.  
  1131.   character ( p ) = c;
  1132.   ligptr ( p ) = 0;
  1133.   }
  1134.   return(p);
  1135. }
  1136.  
  1137. long_halfword newdisc ( void )
  1138. { register long_halfword p;
  1139.  
  1140.   p = getnode ( smallnodesize );
  1141.  
  1142.   { newdisc_regmem
  1143.  
  1144. /* ztype ( p ) = discnode ;  replacecount ( p ) = 0 ; */
  1145.   set_type_replacecount(p, discnode, 0);
  1146.   prebreak ( p ) = 0;
  1147.   postbreak ( p ) = 0;
  1148.   }
  1149.   return(p);
  1150. }
  1151.  
  1152. long_halfword newmath ( scaled w, smallnumber s )
  1153. { register long_halfword p;
  1154.  
  1155.   p = getnode ( smallnodesize );
  1156.  
  1157.   { newmath_regmem
  1158.  
  1159. /* ztype ( p ) = mathnode ;  subtype ( p ) = s ; */
  1160.   set_type_subtype(p, mathnode, s);
  1161.  
  1162.   width ( p ) = w;
  1163.   }
  1164.   return(p);
  1165. }
  1166.  
  1167. long_halfword newspec ( halfword p )
  1168. { register long_halfword q;
  1169.  
  1170.   q = getnode ( gluespecsize );
  1171.  
  1172.   { newspec_regmem
  1173.  
  1174.   mem [ q ] = mem [ p ];
  1175.   gluerefcount ( q ) = 0;
  1176.   width ( q ) = width ( p );
  1177.   stretch ( q ) = stretch ( p );
  1178.   shrink ( q ) = shrink ( p );
  1179.   }
  1180.   return(q);
  1181. }
  1182.  
  1183. long_halfword newparamglue ( smallnumber n )
  1184. { register long_halfword p;
  1185.  
  1186.   p = getnode ( smallnodesize );
  1187.  
  1188.   { newparamglue_regmem
  1189.     register halfword q;
  1190.  
  1191. /* ztype ( p ) = gluenode ;  subtype ( p ) = n + 1 ; */
  1192.   set_type_subtype(p, gluenode, n+1);
  1193.  
  1194.   leaderptr ( p ) = 0;
  1195.   q = gluepar ( n );
  1196.   glueptr ( p ) = q;
  1197.   incr ( gluerefcount(q) );
  1198.   }
  1199.   return(p);
  1200. }
  1201.  
  1202. long_halfword newglue ( halfword q )
  1203. { register long_halfword p;
  1204.  
  1205.   p = getnode ( smallnodesize );
  1206.  
  1207.   { newglue_regmem
  1208.  
  1209. /* ztype ( p ) = gluenode ;  subtype ( p ) = normal ; */
  1210.   set_type_subtype(p, gluenode, normal);
  1211.  
  1212.   leaderptr ( p ) = 0;
  1213.   glueptr ( p ) = q;
  1214.   incr ( gluerefcount(q) );
  1215.   }
  1216.   return(p);
  1217. }
  1218.  
  1219. long_halfword newskipparam ( smallnumber n )
  1220. { newskipparam_regmem
  1221.  
  1222.   tempptr = newspec ( gluepar ( n ) );
  1223.  
  1224.   { register long_halfword p;
  1225.  
  1226.   p = newglue ( tempptr );
  1227.   gluerefcount ( tempptr ) = 0;
  1228.   subtype ( p ) = n + 1;
  1229.  
  1230.   return(p);
  1231.   }
  1232. }
  1233.  
  1234. long_halfword newkern ( scaled w )
  1235. { register long_halfword p;
  1236.  
  1237.   p = getnode ( smallnodesize );
  1238.  
  1239.   { newkern_regmem
  1240.  
  1241. /* ztype ( p ) = kernnode ;  subtype ( p ) = normal ; */
  1242.   set_type_subtype(p, kernnode, normal);
  1243.  
  1244.   width ( p ) = w;
  1245.   }
  1246.   return(p);
  1247. }
  1248.  
  1249. long_halfword newpenalty ( integer m )
  1250. { register long_halfword p;
  1251.  
  1252.   p = getnode ( smallnodesize );
  1253.  
  1254.   { newpenalty_regmem
  1255.  
  1256. /* ztype ( p ) = penaltynode ;  subtype ( p ) = 0 ; */
  1257.   set_type_subtype(p, penaltynode, 0);
  1258.  
  1259.   mem [ p + 1 ] .cint = m;
  1260.   }
  1261.   return(p);
  1262. }
  1263.  
  1264.  
  1265. #ifdef TEXXET
  1266. long_halfword new_edge( smallnumber s, scaled w )
  1267. { register long_halfword p;
  1268.  
  1269.   p = getnode(edge_node_size);
  1270.  
  1271.   { new_edge_regmem
  1272.  
  1273.   ztype(p) = edge_node; subtype(p) = s;
  1274.   width(p) = w;
  1275.   }
  1276.   return(p);
  1277. }
  1278. #endif
  1279.  
  1280.  
  1281. #ifdef DEBUG
  1282. void zcheckmem ( boolean printlocs )
  1283. {/* 31 32 */ checkmem_regmem
  1284.   register halfword p, q;
  1285.   boolean clobbered;
  1286.  
  1287.   {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <=
  1288.   for_end) do
  1289.     freearr [ p ] = false ;
  1290.   while ( p++ < for_end ) ; }
  1291.  
  1292.   {register integer for_end; p = himemmin ; for_end = memend ; if ( p <=
  1293.   for_end) do
  1294.     freearr [ p ] = false ;
  1295.   while ( p++ < for_end ) ; }
  1296.  
  1297.   p = avail ;
  1298.   q = 0 ;
  1299.   clobbered = false ;
  1300.   while ( p != 0 ) {
  1301.     if ( ( p > memend ) || ( p < himemmin ) )
  1302.     clobbered = true ;
  1303.     else if ( freearr [ p ] )
  1304.     clobbered = true ;
  1305.     if ( clobbered ) {
  1306.       c_printnl("VAIL list clobbered at ");
  1307.       printint ( q ) ;
  1308.       goto lab31 ;
  1309.     }
  1310.     freearr [ p ] = true ;
  1311.     q = p ;
  1312.     p = link ( q ) ;
  1313.   }
  1314. lab31:
  1315.   p = rover ;
  1316.   q = 0 ;
  1317.   clobbered = false ;
  1318.   do {
  1319.     if ( ( p >= lomemmax ) || ( p < memmin ) )
  1320.       clobbered = true ;
  1321.     else if ( ( rlink ( p ) >= lomemmax ) || ( rlink ( p ) < memmin ) )
  1322.       clobbered = true ;
  1323.     else if ( ! ( isempty ( p ) ) || ( nodesize ( p ) < 2 ) || ( p + nodesize
  1324.     ( p ) > lomemmax ) || ( llink ( rlink ( p ) ) != p ) )
  1325.       clobbered = true ;
  1326.     if ( clobbered ) {
  1327.       c_printnl("Double-AVAIL list clobbered at ");
  1328.       printint ( q ) ;
  1329.       goto lab32 ;
  1330.     }
  1331.     {register integer for_end; q = p ; for_end = p + nodesize ( p ) - 1
  1332.     ; if ( q <= for_end) do
  1333.       {
  1334.     if ( freearr [ q ] ) {
  1335.       c_printnl("Doubly free location at ");
  1336.       printint ( q ) ;
  1337.       goto lab32 ;
  1338.     }
  1339.     freearr [ q ] = true ;
  1340.       }
  1341.     while ( q++ < for_end ) ; }
  1342.     q = p ;
  1343.     p = rlink ( p ) ;
  1344.   } while ( ! ( p == rover ) ) ;
  1345. lab32:
  1346.   p = memmin ;
  1347.   while ( p <= lomemmax ) {
  1348.     if ( isempty ( p ) ) {
  1349.       c_printnl("Bad flag at ");
  1350.       printint ( p ) ;
  1351.     }
  1352.     while ( ( p <= lomemmax ) && ! freearr [ p ] ) incr ( p ) ;
  1353.     while ( ( p <= lomemmax ) && freearr [ p ] ) incr ( p ) ;
  1354.   }
  1355.   if ( printlocs ) {
  1356.     c_printnl("New busy locs:");
  1357.     {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <=
  1358.     for_end) do
  1359.       if ( ! freearr [ p ] && ( ( p > waslomax ) || wasfree [ p ] ) ) {
  1360.     printchar ( 32 ) ;
  1361.     printint ( p ) ;
  1362.       }
  1363.     while ( p++ < for_end ) ; }
  1364.     {register integer for_end; p = himemmin ; for_end = memend ; if ( p <=
  1365.     for_end) do
  1366.       if ( ! freearr [ p ] && ( ( p < washimin ) || ( p > wasmemend ) ||
  1367.       wasfree [ p ] ) )
  1368.       {
  1369.     printchar ( 32 ) ;
  1370.     printint ( p ) ;
  1371.       }
  1372.     while ( p++ < for_end ) ; }
  1373.   }
  1374.   {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <=
  1375.   for_end) do
  1376.     wasfree [ p ] = freearr [ p ] ;
  1377.   while ( p++ < for_end ) ; }
  1378.   {register integer for_end; p = himemmin ; for_end = memend ; if ( p <=
  1379.   for_end) do
  1380.     wasfree [ p ] = freearr [ p ] ;
  1381.   while ( p++ < for_end ) ; }
  1382.   wasmemend = memend ;
  1383.   waslomax = lomemmax ;
  1384.   washimin = himemmin ;
  1385. }
  1386. #endif /* DEBUG */
  1387.  
  1388. #ifdef DEBUG
  1389. void searchmem ( halfword p )
  1390. halfword p ;
  1391. {searchmem_regmem
  1392.   register integer q  ;
  1393.  
  1394.   {register integer for_end; q = memmin ; for_end = lomemmax ; if ( q <=
  1395.   for_end) do
  1396.     {
  1397.       if ( link ( q ) == p ) {
  1398.     c_printnl("LINK(");
  1399.     printint ( q ) ;
  1400.     printchar ( 41 ) ;
  1401.       }
  1402.       if ( info ( q ) == p ) {
  1403.     c_printnl("INFO(");
  1404.     printint ( q ) ;
  1405.     printchar ( 41 ) ;
  1406.       }
  1407.     }
  1408.   while ( q++ < for_end ) ; }
  1409.   {register integer for_end; q = himemmin ; for_end = memend ; if ( q <=
  1410.   for_end) do
  1411.     {
  1412.       if ( link ( q ) == p ) {
  1413.     c_printnl("LINK(");
  1414.     printint ( q ) ;
  1415.     printchar ( 41 ) ;
  1416.       }
  1417.       if ( info ( q ) == p ) {
  1418.     c_printnl("INFO(");
  1419.     printint ( q ) ;
  1420.     printchar ( 41 ) ;
  1421.       }
  1422.     }
  1423.   while ( q++ < for_end ) ; }
  1424.   {register integer for_end; q = activebase ; for_end = boxbase + 255 ; if (
  1425.   q <= for_end) do
  1426.     {
  1427.       if ( equiv ( q ) == p ) {
  1428.     c_printnl("EQUIV(");
  1429.     printint ( q ) ;
  1430.     printchar ( 41 ) ;
  1431.       }
  1432.     }
  1433.   while ( q++ < for_end ) ; }
  1434.   if ( saveptr > 0 )
  1435.   {register integer for_end; q = 0 ; for_end = saveptr - 1 ; if ( q <=
  1436.   for_end) do
  1437.     {
  1438.       if ( equivfield ( savestack [ q ] ) == p ) {
  1439.     c_printnl("SAVE(");
  1440.     printint ( q ) ;
  1441.     printchar ( 41 ) ;
  1442.       }
  1443.     }
  1444.   while ( q++ < for_end ) ; }
  1445.   {register integer for_end; q = 0 ; for_end = hyphsize ; if ( q <= for_end)
  1446.   do
  1447.     {
  1448.       if ( hyphlist(q) == p ) {
  1449.     c_printnl("HYPH(");
  1450.     printint ( q ) ;
  1451.     printchar ( 41 ) ;
  1452.       }
  1453.     }
  1454.   while ( q++ < for_end ) ; }
  1455. }
  1456. #endif /* DEBUG */
  1457.  
  1458. void shortdisplay ( integer p )
  1459. { shortdisplay_regmem
  1460.  
  1461.   while ( p > memmin ) {
  1462.     if ( ischarnode ( p ) ) {
  1463.       if ( p <= memend ) {
  1464.     if ( font ( p ) != fontinshortdisplay ) {
  1465.       if ( ( font(p) > fontmax ) )
  1466.       printchar ( 42 );
  1467.       else printesc ( fontidtext ( font(p) ) );
  1468.       printchar ( 32 );
  1469.       fontinshortdisplay = font ( p );
  1470.     }
  1471.     print ( character(p) );
  1472.       }
  1473.     }
  1474.     else switch ( ztype ( p ) )
  1475.     {case hlistnode:
  1476.     case vlistnode:
  1477.     case insnode:
  1478.     case whatsitnode:
  1479.     case marknode:
  1480.     case adjustnode:
  1481.     case unsetnode:
  1482.       c_print("[]");
  1483.       break;
  1484.     case rulenode:
  1485.       printchar ( 124 );
  1486.       break;
  1487.     case gluenode:
  1488.       if ( glueptr ( p ) != zeroglue )
  1489.       printchar ( 32 );
  1490.       break;
  1491.     case mathnode:
  1492. #ifdef TEXXET
  1493.       if( subtype(p) > after )
  1494.     c_print("[]");
  1495.       else
  1496. #endif
  1497.         printchar ( 36 );  /* "$" */
  1498.       break;
  1499.     case ligaturenode:
  1500.       shortdisplay ( ligptr(p) );
  1501.       break;
  1502.     case discnode:
  1503.       shortdisplay ( prebreak(p) );
  1504.       shortdisplay ( postbreak(p) );
  1505.       { register integer n;
  1506.  
  1507.     n = replacecount ( p );
  1508.     while ( n > 0 ) {
  1509.       if ( link ( p ) != 0 )
  1510.         p = link ( p );
  1511.       decr ( n );
  1512.     }
  1513.       }
  1514.       break;
  1515.     default:
  1516.       break;
  1517.     }
  1518.     p = link ( p );
  1519.   }
  1520. }
  1521.  
  1522. void printfontandchar ( integer p )
  1523. { printfontandchar_regmem
  1524.  
  1525.   if ( p > memend )
  1526.     c_printesc("CLOBBERED.");
  1527.   else {
  1528.     if ( ( font ( p ) > fontmax ) )
  1529.       printchar ( 42 );
  1530.     else
  1531.       printesc ( fontidtext ( font ( p ) ) );
  1532.     printchar ( 32 );
  1533.     print ( character ( p ) );
  1534.   }
  1535. }
  1536.  
  1537. void printmark ( integer p )
  1538. { printmark_regmem
  1539.  
  1540.   printchar ( 123 );
  1541.   if ( ( p < himemmin ) || ( p > memend ) )
  1542.     c_printesc("CLOBBERED.");
  1543.   else
  1544.     showtokenlist ( link(p), 0, maxprintline - 10 );
  1545.   printchar ( 125 );
  1546. }
  1547.  
  1548. void printruledimen ( scaled d )
  1549. { printruledimen_regmem
  1550.  
  1551.   if ( isrunning ( d ) )
  1552.     printchar ( 42 );
  1553.   else
  1554.     printscaled ( d );
  1555. }
  1556.  
  1557. void printglue ( scaled d, integer order, strnumber s )
  1558. { printglue_regmem
  1559.  
  1560.   printscaled ( d );
  1561.   if ( ( order < normal ) || ( order > filll ) )
  1562.     c_print("foul");
  1563.   else if ( order > normal ) {
  1564.     print( STR_FIL );
  1565.     while ( order > fil ) {
  1566.       printchar ( 108 );
  1567.       decr ( order );
  1568.     }
  1569.   } else if ( s != 0 )
  1570.     print ( s );
  1571. }
  1572.  
  1573. void printspec ( integer p, strnumber s )
  1574. { printspec_regmem
  1575.  
  1576.   if ( ( p < memmin ) || ( p >= lomemmax ) )
  1577.     printchar ( 42 );
  1578.   else {
  1579.     printscaled ( width ( p ) );
  1580.     if ( s != 0 )
  1581.       print ( s );
  1582.     if ( stretch ( p ) != 0 ) {
  1583.       print( STR_PLUS_ );
  1584.       printglue ( stretch ( p ), stretchorder ( p ), s );
  1585.     }
  1586.     if ( shrink ( p ) != 0 ) {
  1587.       print( STR_MINUS_ );
  1588.       printglue ( shrink ( p ), shrinkorder ( p ), s );
  1589.     }
  1590.   }
  1591. }
  1592.  
  1593. void printfamandchar ( halfword p )
  1594. { printfamandchar_regmem
  1595.  
  1596.   printesc ( 460 );
  1597.   printint ( fam ( p ) );
  1598.   printchar ( 32 );
  1599.   print ( character ( p ) );
  1600. }
  1601.  
  1602. void printdelimiter ( halfword p )
  1603. { printdelimiter_regmem
  1604.   register integer a;
  1605.  
  1606.   a = smallfam ( p ) * 256 + smallchar ( p );
  1607.   a = a * 4096 + largefam ( p ) * 256 + largechar ( p );
  1608.   if ( a < 0 )
  1609.     printint ( a );
  1610.   else
  1611.     printhex ( a );
  1612. }
  1613.  
  1614. void printsubsidiarydata ( halfword p, ASCIIcode c )
  1615. { printsubsidiarydata_regmem
  1616.  
  1617.   if ( curlength >= depththreshold ) {
  1618.     if ( mathtype ( p ) != 0 )
  1619.     c_print(" []");
  1620.   } else {
  1621.     appendchar ( c ) ;
  1622.     /* tempptr = p ; */
  1623.     switch ( mathtype ( p ) ) {
  1624.     case mathchar:
  1625.     println ();
  1626.     printcurrentstring ();
  1627.     printfamandchar ( p );
  1628.     break;
  1629.     case subbox:
  1630.       /* showinfo () ; */   shownodelist( info (p) );
  1631.       break;
  1632.     case submlist:
  1633.       if ( info ( p ) == 0 ) {
  1634.     println ();
  1635.     printcurrentstring ();
  1636.     c_print("{}");
  1637.       } else {
  1638.     /* showinfo () ; */   shownodelist( info (p) );
  1639.       }
  1640.       break;
  1641.     default:
  1642.       break;
  1643.     }
  1644.     flushchar;
  1645.   }
  1646. }
  1647.  
  1648. void printstyle ( integer c )
  1649. { printstyle_regmem
  1650.  
  1651.   switch ( c / 2 ) {
  1652.   case 0:
  1653.     printesc( STR_DISPLAYSTYLE ); 
  1654.     break;
  1655.   case 1:
  1656.     printesc( STR_TEXTSTYLE );
  1657.     break;
  1658.   case 2:
  1659.     printesc( STR_SCRIPTSTYLE );
  1660.     break;
  1661.   case 3:
  1662.     printesc( STR_SCRIPTSCRIPTSTYLE );
  1663.     break;
  1664.   default:
  1665.     c_print("Unknown style!");
  1666.     break;
  1667.   }
  1668. }
  1669.  
  1670. void printskipparam ( integer n )
  1671. { printskipparam_regmem
  1672.  
  1673.   switch ( n ) {
  1674.   case lineskipcode :
  1675.     printesc ( 372 ) ;
  1676.     break ;
  1677.   case baselineskipcode :
  1678.     printesc ( 373 ) ;
  1679.     break ;
  1680.   case parskipcode :
  1681.     printesc ( 374 ) ;
  1682.     break ;
  1683.   case abovedisplayskipcode :
  1684.     printesc ( 375 ) ;
  1685.     break ;
  1686.   case belowdisplayskipcode :
  1687.     printesc ( 376 ) ;
  1688.     break ;
  1689.   case abovedisplayshortskipcode :
  1690.     printesc ( 377 ) ;
  1691.     break ;
  1692.   case belowdisplayshortskipcode :
  1693.     printesc ( 378 ) ;
  1694.     break ;
  1695.   case leftskipcode :
  1696.     printesc ( 379 ) ;
  1697.     break ;
  1698.   case rightskipcode :
  1699.     printesc ( 380 ) ;
  1700.     break ;
  1701.   case topskipcode :
  1702.     printesc ( 381 ) ;
  1703.     break ;
  1704.   case splittopskipcode :
  1705.     printesc ( 382 ) ;
  1706.     break ;
  1707.   case tabskipcode :
  1708.     printesc ( 383 ) ;
  1709.     break ;
  1710.   case spaceskipcode :
  1711.     printesc ( 384 ) ;
  1712.     break ;
  1713.   case xspaceskipcode :
  1714.     printesc ( 385 ) ;
  1715.     break ;
  1716.   case parfillskipcode :
  1717.     printesc ( 386 ) ;
  1718.     break ;
  1719.   case thinmuskipcode :
  1720.     printesc ( 387 ) ;
  1721.     break ;
  1722.   case medmuskipcode :
  1723.     printesc ( 388 ) ;
  1724.     break ;
  1725.   case thickmuskipcode :
  1726.     printesc ( 389 ) ;
  1727.     break ;
  1728.   default:
  1729.     print ( 390 ) ;
  1730.     break ;
  1731.   }
  1732. }
  1733.  
  1734. void shownodelist ( integer p )
  1735. { shownodelist_regmem
  1736.   register integer n  ;
  1737.   real g  ;
  1738.  
  1739.   if ( curlength > depththreshold ) {
  1740.     if ( p > 0 )
  1741.     c_print(" []");
  1742.     return ;
  1743.   }
  1744.   n = 0 ;
  1745.   while ( p > memmin ) {
  1746.     println () ;
  1747.     printcurrentstring () ;
  1748.     if ( p > memend ) {
  1749.       c_print("Bad link, display aborted.");
  1750.       return ;
  1751.     }
  1752.     incr ( n ) ;
  1753.     if ( n > breadthmax ) {
  1754.       c_print("etc.");
  1755.       return ;
  1756.     }
  1757.     if ( ischarnode ( p ) )
  1758.       printfontandchar ( p ) ;
  1759.     else switch ( ztype ( p ) ) {
  1760.     case hlistnode :
  1761.     case vlistnode :
  1762.     case unsetnode :
  1763.       {
  1764.     if ( ztype ( p ) == hlistnode )
  1765.       printesc ( 104 ) ;
  1766.     else if ( ztype ( p ) == vlistnode )
  1767.       printesc ( 118 ) ;
  1768.     else
  1769.       c_printesc("unset");
  1770.     c_print("box(");
  1771.     printscaled ( height ( p ) ) ;
  1772.     printchar ( 43 ) ;
  1773.     printscaled ( depth ( p ) ) ;
  1774.     c_print(")x");
  1775.     printscaled ( width ( p ) ) ;
  1776.     if ( ztype ( p ) == unsetnode ) {
  1777.       if ( spancount ( p ) != 0 ) {
  1778.         c_print(" (");
  1779.         printint ( spancount ( p ) + 1 ) ;
  1780.         c_print(" columns)");
  1781.       }
  1782.       if ( gluestretch ( p ) != 0 ) {
  1783.         c_print(", stretch ");
  1784.         printglue ( gluestretch ( p ) , glueorder ( p ) , 0 ) ;
  1785.       }
  1786.       if ( glueshrink ( p ) != 0 ) {
  1787.         c_print(", shrink ");
  1788.         printglue ( glueshrink ( p ) , gluesign ( p ) , 0 ) ;
  1789.       }
  1790.     } else {
  1791.       g = glueset ( p ) ;
  1792.       if ( ( g != 0.0 ) && ( gluesign ( p ) != normal ) ) {
  1793.         c_print(", glue set ");
  1794.         if ( gluesign ( p ) == shrinking )
  1795.           c_print("- ");
  1796.         if ( fabs ( g ) > 20000.0 ) {
  1797.           if ( g > 0.0 )
  1798.         printchar ( 62 ) ;
  1799.           else
  1800.         c_print("< -");
  1801.           printglue ( 20000 * unity , glueorder ( p ) , 0 ) ;
  1802.         } else
  1803.           printglue ( round ( unity * g ) , glueorder ( p ) , 0 ) ;
  1804.       }
  1805.       if ( shiftamount ( p ) != 0 ) {
  1806.         c_print(", shifted ");
  1807.         printscaled ( shiftamount ( p ) ) ;
  1808.       }
  1809.     }
  1810.     {
  1811.       appendchar ( 46 ) ;
  1812.       shownodelist ( listptr ( p ) ) ;
  1813.       flushchar ;
  1814.     }
  1815.       }
  1816.       break ;
  1817.     case rulenode :
  1818.       {
  1819.     c_printesc("rule(");
  1820.     printruledimen ( height ( p ) ) ;
  1821.     printchar ( 43 ) ;
  1822.     printruledimen ( depth ( p ) ) ;
  1823.     c_print(")x");
  1824.     printruledimen ( width ( p ) ) ;
  1825.       }
  1826.       break ;
  1827.     case insnode :
  1828.       {
  1829.     printesc( STR_INSERT );
  1830.     printint ( subtype ( p ) ) ;
  1831.     c_print(", natural size ");
  1832.     printscaled ( height ( p ) ) ;
  1833.     c_print("; split(");
  1834.     printspec ( splittopptr ( p ) , 0 ) ;
  1835.     printchar ( 44 ) ;
  1836.     printscaled ( depth ( p ) ) ;
  1837.     c_print("); float cost ");
  1838.     printint ( floatcost ( p ) ) ;
  1839.     {
  1840.       appendchar ( 46 ) ;
  1841.       shownodelist ( insptr ( p ) ) ;
  1842.       flushchar ;
  1843.     }
  1844.       }
  1845.       break ;
  1846.     case whatsitnode :
  1847.       switch ( subtype ( p ) ) {
  1848.       case opennode :
  1849.     printwritewhatsit ( STR_OPENOUT , p ) ;
  1850.     printchar ( 61 ) ;
  1851.     printfilename ( openname ( p ) , openarea ( p ) , openext ( p ) ) ;
  1852.     break ;
  1853.       case writenode :
  1854.     printwritewhatsit ( STR_WRITE, p ) ;
  1855.     printmark ( writetokens ( p ) ) ;
  1856.     break ;
  1857.       case closenode :
  1858.     printwritewhatsit ( STR_CLOSEOUT , p ) ;
  1859.     break ;
  1860.       case specialnode :
  1861.     printesc ( STR_SPECIAL ) ;
  1862.     printmark ( writetokens ( p ) ) ;
  1863.     break ;
  1864.       case languagenode :
  1865.     printesc ( STR_SETLANGUAGE );
  1866.     printint ( whatlang ( p ) ) ;
  1867.     c_print(" (hyphenmin ");
  1868.     printint ( whatlhm ( p ) ) ;
  1869.     printchar ( 44 ) ;
  1870.     printint ( whatrhm ( p ) ) ;
  1871.     printchar ( 41 ) ;
  1872.     break ;
  1873.       default:
  1874.     c_print("whatsit?");
  1875.     break ;
  1876.       }
  1877.       break ;
  1878.     case gluenode :
  1879.       if ( subtype ( p ) >= aleaders ) {
  1880.     c_printesc(""); 
  1881.     if ( subtype ( p ) == cleaders )
  1882.       printchar ( 99 ) ;
  1883.     else if ( subtype ( p ) == xleaders )
  1884.       printchar ( 120 ) ;
  1885.     c_print("leaders ");
  1886.     printspec ( glueptr ( p ) , 0 ) ;
  1887.     {
  1888.       appendchar ( 46 ) ;
  1889.       shownodelist ( leaderptr ( p ) ) ;
  1890.       flushchar ;
  1891.     }
  1892.       } else {
  1893.     printesc ( 331 ) ;
  1894.     if ( subtype ( p ) != normal ) {
  1895.       printchar ( 40 ) ;
  1896.       if ( subtype ( p ) < condmathglue )
  1897.         printskipparam ( subtype ( p ) - 1 ) ;
  1898.       else if ( subtype ( p ) == condmathglue )
  1899.         printesc ( 332 ) ;
  1900.       else
  1901.         printesc ( 333 ) ;
  1902.       printchar ( 41 ) ;
  1903.     }
  1904.     if ( subtype ( p ) != condmathglue ) {
  1905.       printchar ( 32 ) ;
  1906.       if ( subtype ( p ) < condmathglue )
  1907.         printspec ( glueptr ( p ) , 0 ) ;
  1908.       else
  1909.         printspec( glueptr ( p ), STR_MU ); 
  1910.     }
  1911.       }
  1912.       break ;
  1913.     case kernnode :
  1914.       if ( subtype ( p ) != muglue ) {
  1915.     printesc ( 337 ) ;
  1916.     if ( subtype ( p ) != normal )
  1917.       printchar ( 32 ) ;
  1918.     printscaled ( width ( p ) ) ;
  1919.     if ( subtype ( p ) == acckern )
  1920.       c_print(" (for accent)");
  1921.       } else {
  1922.     printesc ( 339 ) ;
  1923.     printscaled ( width ( p ) ) ;
  1924.     print( STR_MU );
  1925.       }
  1926.       break ;
  1927.     case mathnode :
  1928. #ifdef TEXXET
  1929.       if( subtype(p) > after ) {
  1930.     c_printesc( end_LR(p) ? "end" : "begin" );
  1931.     printchar( (subtype(p) <= end_L_code) ? 'L' : 'R' );
  1932.       } else
  1933. #endif
  1934.       {
  1935.     printesc ( 340 ) ;  /* "math" */
  1936.     if ( subtype ( p ) == before )
  1937.       c_print("on");
  1938.     else
  1939.       c_print("off");
  1940.     if ( width ( p ) != 0 ) {
  1941.       c_print(", surrounded ");
  1942.       printscaled ( width ( p ) ) ;
  1943.     }
  1944.       }
  1945.       break ;
  1946.     case ligaturenode :
  1947.       {
  1948.     printfontandchar ( ligchar ( p ) ) ;
  1949.     c_print(" (ligature ");
  1950.     if ( subtype ( p ) > 1 )
  1951.       printchar ( 124 ) ;
  1952.     fontinshortdisplay = font ( ligchar ( p ) ) ;
  1953.     shortdisplay ( ligptr ( p ) ) ;
  1954.     if ( odd ( subtype ( p ) ) )
  1955.       printchar ( 124 ) ;
  1956.     printchar ( 41 ) ;
  1957.       }
  1958.       break ;
  1959.     case penaltynode :
  1960.       {
  1961.     printesc ( 345 ) ;
  1962.     printint ( mem [ p + 1 ] .cint ) ;
  1963.       }
  1964.       break ;
  1965.     case discnode :
  1966.       {
  1967.     printesc ( 346 ) ;
  1968.     if ( replacecount ( p ) > 0 ) {
  1969.       c_print(" replacing ");
  1970.       printint ( replacecount ( p ) ) ;
  1971.     }
  1972.     {
  1973.       appendchar ( 46 ) ;
  1974.       shownodelist ( prebreak ( p ) ) ;
  1975.       flushchar ;
  1976.     }
  1977.     appendchar ( 124 ) ;
  1978.     shownodelist ( postbreak ( p ) ) ;
  1979.     flushchar ;
  1980.       }
  1981.       break ;
  1982.     case marknode :
  1983.       {
  1984.     printesc ( 348 ) ;
  1985.     printmark ( markptr ( p ) ) ;
  1986.       }
  1987.       break ;
  1988.     case adjustnode :
  1989.       {
  1990.     printesc ( 349 ) ;
  1991.     {
  1992.       appendchar ( 46 ) ;
  1993.       shownodelist ( adjustptr ( p ) ) ;
  1994.       flushchar ;
  1995.     }
  1996.       }
  1997.       break ;
  1998.     case stylenode :
  1999.       printstyle ( subtype ( p ) ) ;
  2000.       break ;
  2001.     case choicenode :
  2002.       {
  2003.     printesc ( 521 ) ;
  2004.     appendchar ( 68 ) ;
  2005.     shownodelist ( displaymlist ( p ) ) ;
  2006.     flushchar ;
  2007.     appendchar ( 84 ) ;
  2008.     shownodelist ( textmlist ( p ) ) ;
  2009.     flushchar ;
  2010.     appendchar ( 83 ) ;
  2011.     shownodelist ( scriptmlist ( p ) ) ;
  2012.     flushchar ;
  2013.     appendchar ( 115 ) ;
  2014.     shownodelist ( scriptscriptmlist ( p ) ) ;
  2015.     flushchar ;
  2016.       }
  2017.       break ;
  2018.     case ordnoad :
  2019.     case opnoad :
  2020.     case binnoad :
  2021.     case relnoad :
  2022.     case opennoad :
  2023.     case closenoad :
  2024.     case punctnoad :
  2025.     case innernoad :
  2026.     case radicalnoad :
  2027.     case overnoad :
  2028.     case undernoad :
  2029.     case vcenternoad :
  2030.     case accentnoad :
  2031.     case leftnoad :
  2032.     case rightnoad :
  2033.       {
  2034.     switch ( ztype ( p ) ) {
  2035.     case ordnoad :
  2036.       printesc ( STR_MATHORD );
  2037.       break ;
  2038.     case opnoad :
  2039.       printesc ( STR_MATHOP ) ;
  2040.       break ;
  2041.     case binnoad :
  2042.       printesc ( STR_MATHBIN ) ;
  2043.       break ;
  2044.     case relnoad :
  2045.       printesc ( STR_MATHREL ) ;
  2046.       break ;
  2047.     case opennoad :
  2048.       printesc ( STR_MATHOPEN ) ;
  2049.       break ;
  2050.     case closenoad :
  2051.       printesc ( STR_MATHCLOSE ) ;
  2052.       break ;
  2053.     case punctnoad :
  2054.       printesc ( STR_MATHPUNCT ) ;
  2055.       break ;
  2056.     case innernoad :
  2057.       printesc ( STR_MATHINNER ) ;
  2058.       break ;
  2059.     case overnoad :
  2060.       printesc ( STR_OVERLINE ) ;
  2061.       break ;
  2062.     case undernoad :
  2063.       printesc ( STR_UNDERLINE ) ;
  2064.       break ;
  2065.     case vcenternoad :
  2066.       printesc ( 535 ) ;
  2067.       break ;
  2068.     case radicalnoad :
  2069.       {
  2070.         printesc ( 529 ) ;
  2071.         printdelimiter ( leftdelimiter ( p ) ) ;
  2072.       }
  2073.       break ;
  2074.     case accentnoad :
  2075.       {
  2076.         printesc ( 504 ) ;
  2077.         printfamandchar ( accentchr ( p ) ) ;
  2078.       }
  2079.       break ;
  2080.     case leftnoad :
  2081.       {
  2082.         printesc ( STR_LEFT ) ;
  2083.         printdelimiter ( nucleus ( p ) ) ;
  2084.       }
  2085.       break ;
  2086.     case rightnoad :
  2087.       {
  2088.         printesc( STR_RIGHT ); 
  2089.         printdelimiter ( nucleus ( p ) ) ;
  2090.       }
  2091.       break ;
  2092.     }
  2093.     if ( subtype ( p ) != normal )
  2094.     if ( subtype ( p ) == limits )
  2095.       printesc ( STR_LIMITS ) ;
  2096.     else
  2097.       printesc ( STR_NOLIMITS ) ;
  2098.     if ( ztype ( p ) < leftnoad )
  2099.       printsubsidiarydata ( nucleus ( p ) , 46 ) ;
  2100.     printsubsidiarydata ( supscr ( p ) , 94 ) ;
  2101.     printsubsidiarydata ( subscr ( p ) , 95 ) ;
  2102.       }
  2103.       break ;
  2104.     case fractionnoad :
  2105.       {
  2106.     c_printesc("fraction, thickness ");
  2107.     if ( thickness ( p ) == defaultcode )
  2108.       c_print("= default");
  2109.     else
  2110.       printscaled ( thickness ( p ) ) ;
  2111.     if ( ( smallfam ( leftdelimiter ( p ) ) != 0 )
  2112.       || ( smallchar ( leftdelimiter ( p ) ) != 0 )
  2113.       || ( largefam ( leftdelimiter ( p ) ) != 0 )
  2114.       || ( largechar ( leftdelimiter ( p ) ) != 0 ) )
  2115.     {
  2116.       c_print(", left-delimiter ");
  2117.       printdelimiter ( leftdelimiter ( p ) ) ;
  2118.     }
  2119.     if ( ( smallfam ( rightdelimiter ( p ) ) != 0 )
  2120.       || ( smallchar ( rightdelimiter ( p ) ) != 0 )
  2121.       || ( largefam ( rightdelimiter ( p ) ) != 0 )
  2122.       || ( largechar ( rightdelimiter ( p ) ) != 0 ) )
  2123.     {
  2124.       c_print(", right-delimiter ");
  2125.       printdelimiter ( rightdelimiter ( p ) ) ;
  2126.     }
  2127.     printsubsidiarydata ( numerator ( p ) , 92 ) ;
  2128.     printsubsidiarydata ( denominator ( p ) , 47 ) ;
  2129.       }
  2130.       break ;
  2131.     default:
  2132.       c_print("Unknown node type!");
  2133.       break ;
  2134.     }
  2135.     p = link ( p ) ;
  2136.   }
  2137. }
  2138.  
  2139. /* -- end -- */
  2140.