home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / tex7.c < prev    next >
C/C++ Source or Header  |  1994-04-18  |  37KB  |  1,626 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4.  
  5. smallnumber normmin ( integer h )
  6. { normmin_regmem
  7.  
  8.   if ( h <= 0 ) 
  9.     return(1);
  10.  
  11.   if ( h >= 63 )
  12.    return(63);
  13.  
  14.   return(h);
  15. } 
  16.  
  17.  
  18. void newgraf ( boolean indented )
  19. { newgraf_regmem 
  20.  
  21.   curlist .pgfield = 0;
  22.   if ( curlist.modefield == vmode || curlist .headfield != curlist .tailfield )
  23.     tailappend ( newparamglue ( parskipcode ) ) ; 
  24. #if 0  /* 3.1415 */
  25.   curlist .lhmfield = normmin ( lefthyphenmin ) ; 
  26.   curlist .rhmfield = normmin ( righthyphenmin ) ; 
  27. #endif
  28.   pushnest ();
  29.   curlist .modefield = hmode;
  30.   curlist .auxfield .hh .v.LH = 1000;
  31. #if 0  /* 3.1415 */
  32.   curlist .auxfield .hh .v.RH = 0;
  33. #else
  34.   if ( language <= 0 || language > 255 )
  35.     curlang = 0;
  36.   else
  37.     curlang = language ; 
  38.   curlist .auxfield .hh .v.RH = curlang;
  39.   curlist .pgfield = ( normmin ( lefthyphenmin ) * 0x40
  40.             + normmin ( righthyphenmin ) ) * 0x10000L + curlang;
  41. #endif
  42.   if ( indented ) {
  43.     curlist .tailfield = newnullbox () ; 
  44.     link ( curlist .headfield ) = curlist .tailfield ; 
  45.     width ( curlist .tailfield ) = parindent ; 
  46.   }
  47.   if ( everypar != 0 )
  48.     begintokenlist( everypar, everypartext );
  49.   if ( nestptr == 1 )
  50.     buildpage();
  51. }
  52.  
  53.  
  54. void indentinhmode (  boolean indented /* void */ )
  55. { indentinhmode_regmem 
  56.   register long_halfword p;
  57.  
  58.   if ( indented /* curchr > 0 */ ) {
  59.     p = newnullbox ();
  60.     width ( p ) = parindent;
  61.     if ( abs ( curlist .modefield ) == hmode )
  62.       curlist .auxfield .hh .v.LH = 1000;
  63.     else {
  64.       register long_halfword q;
  65.  
  66.       q = newnoad ();
  67.       mathtype ( nucleus ( q ) ) = subbox;
  68.       info ( nucleus ( q ) ) = p;
  69.       p = q;
  70.     }
  71.     tailappend ( p );
  72.   }
  73. }
  74.  
  75.  
  76. void headforvmode ( void )
  77. { headforvmode_regmem 
  78.  
  79.   if ( curlist .modefield < 0 ) {
  80.     if ( curcmd != 36 )
  81.       offsave();
  82.     else {
  83.       p_print_err( STR_H_YOUCANTUSE );
  84.       printesc( STR_HRULE );
  85.       c_print("' here except with leaders");
  86.       zhelp1( STR_H_TOPUTAHORIZONTAL );
  87.       error ();
  88.     }
  89.   } else {
  90.     backinput ();
  91.     curtok = partoken;
  92.     backinput ();
  93.     tokentype = inserted;
  94.   }
  95. }
  96.  
  97.  
  98. void endgraf ( void )
  99. { endgraf_regmem 
  100.  
  101.   if ( curlist .modefield == hmode ) {
  102.     if ( curlist .headfield == curlist .tailfield ) 
  103.       popnest ();
  104.     else
  105.       linebreak ( widowpenalty );
  106. #ifdef TEXXET
  107.     if( LR_save != 0 ) {
  108.     flushlist(LR_save);
  109.     LR_save = 0;
  110.     }
  111. #endif
  112.     normalparagraph();
  113.     errorcount = 0;
  114.   }
  115. }
  116.  
  117.  
  118. void begininsertoradjust ( void )
  119. { begininsertoradjust_regmem 
  120.   register integer r_curval;
  121.  
  122.   if ( curcmd == 38 ) 
  123.     curval = r_curval = 255;
  124.   else {
  125.     r_curval = scaneightbitint ();
  126.     if ( r_curval == 255 ) {
  127.       print_err("You can't ");
  128.       printesc( STR_INSERT );
  129.       printint ( 255 ) ; 
  130.       zhelp1( STR_H_IMCHANGINGTOINSERT );
  131.       error () ; 
  132.       curval = r_curval = 0;
  133.     }
  134.   }
  135.   saved ( 0 ) = r_curval;
  136.   incr ( saveptr );
  137.   newsavelevel( insertgroup );
  138.   scanleftbrace();
  139.   normalparagraph();
  140.   pushnest();
  141.   curlist .modefield = -vmode;
  142.   curlist .auxfield .cint = ignoredepth;
  143. }
  144.  
  145.  
  146. void makemark ( void )
  147. {
  148.   scantoks( false, true );
  149.  
  150.  {makemark_regmem 
  151.   register long_halfword p;
  152.  
  153.   p = getnode ( smallnodesize );
  154.   /* ztype ( p ) = marknode ; subtype ( p ) = 0 ; */
  155.   set_type_subtype(p, marknode, 0);
  156.  
  157.   markptr ( p ) = defref;
  158.   link ( curlist .tailfield ) = p;
  159.   curlist .tailfield = p;
  160.  }
  161. }
  162.  
  163.  
  164. void appendpenalty ( void )
  165. { appendpenalty_regmem 
  166.   register integer r_curval;
  167.  
  168.   r_curval = scanint ();
  169.   tailappend ( newpenalty ( r_curval ) );
  170.   if ( curlist .modefield == vmode )
  171.     buildpage ();
  172. }
  173.  
  174.  
  175. void deletelast ( void )
  176. { deletelast_regmem
  177.  
  178.   if ( curlist.modefield == vmode && curlist.tailfield == curlist.headfield ) {
  179.     if ( ( curchr != gluenode ) || ( lastglue != maxhalfword ) ) {
  180.       youcant();
  181. #ifdef NEW_HELP
  182.       if ( curchr == kernnode )
  183.     zhelp2( STR_H_SORRY_CANTTAKETHINGS, STR_H_TRY_KERNLASTSKIP );
  184.       else if ( curchr != gluenode ) 
  185.     zhelp2( STR_H_SORRY_CANTTAKETHINGS, STR_H_PERHAPSYOUCAN_OUTPUT );
  186.       else
  187.     zhelp2( STR_H_SORRY_CANTTAKETHINGS, STR_H_TRY_VSKIPLASTSKIP );
  188. #else
  189.       zhelp2 ( STR_H_SORRY_CANTTAKETHINGS, STR_H_TRY_VSKIPLASTSKIP );
  190.       if ( curchr == kernnode ) 
  191.         helpline [ 0 ] = ( STR_H_TRY_KERNLASTSKIP );
  192.       else if ( curchr != gluenode ) 
  193.         helpline [ 0 ] = ( STR_H_PERHAPSYOUCAN_OUTPUT );
  194. #endif
  195.       error () ; 
  196.     }
  197.   } else {
  198.     if ( ! ischarnode ( curlist .tailfield ) ) 
  199.     if ( ztype ( curlist .tailfield ) == curchr ) {
  200.       register halfword p, q;
  201.  
  202.       q = curlist .headfield ; 
  203.       do {
  204.     p = q;
  205.     if ( ! ischarnode ( q ) ) 
  206.     if ( ztype ( q ) == discnode ) {
  207.       register quarterword m;
  208.  
  209.       for( m = replacecount ( q ) ; m >= 1 ; --m ) {
  210.         p = link ( p );
  211.       }
  212.       if ( p == curlist .tailfield ) 
  213.         return;
  214.     }
  215.     q = link ( p ) ; 
  216.       } while( q != curlist.tailfield );
  217.       link ( p ) = 0;
  218.       flushnodelist ( curlist .tailfield );
  219.       curlist .tailfield = p;
  220.     }
  221.   }
  222. }
  223.  
  224.  
  225. void unpackage ( void )
  226. { unpackage_regmem
  227.   register long_halfword p;
  228.   register schar c;
  229.  
  230.   c = curchr;
  231.   p = box( scaneightbitint() );
  232.   if ( p == 0 )
  233.     return;
  234.  
  235.   if ( ( abs ( curlist .modefield ) == mmode )
  236.   || ( ( abs ( curlist .modefield ) == vmode )
  237.     && ( ztype ( p ) != vlistnode ) )
  238.   || ( ( abs ( curlist .modefield ) == hmode )
  239.     && ( ztype ( p ) != hlistnode ) ) )
  240.   {
  241.     print_err("Incompatible list can't be unboxed");
  242.     zhelp1( STR_H_SORRYPANDORA );
  243.     error();
  244.     return;
  245.   }
  246.  
  247. #if 0
  248.   if ( c == 1 ) 
  249.     link ( curlist .tailfield ) = copynodelist ( listptr ( p ) ) ; 
  250.   else {
  251.     link ( curlist .tailfield ) = listptr ( p ) ; 
  252.     box ( curval ) = 0 ; 
  253.     freenode ( p , boxnodesize ) ; 
  254.   }
  255. #ifdef ERW_LANGUAGE
  256.   if ( abs( curlist .modefield ) == hmode ) {
  257.     register halfword p = 0;
  258.     while ( link ( curlist .tailfield ) != 0 ) {
  259.       curlist .tailfield = link ( curlist .tailfield ) ;
  260.       if (ischarnode(curlist .tailfield))
  261.     ;
  262.       else {
  263.     if (ztype(curlist .tailfield) == whatsitnode &&
  264.         subtype(curlist .tailfield) == languagenode) {
  265.       p = curlist .tailfield;
  266.     }
  267.       }
  268.     }
  269.     /* Abpruefen, ob language node in Box war... */
  270.     if( p != 0 ) {
  271.       if( whatlang(p) != curlist .auxfield .hh .v.RH ) {
  272.         /* Update `clang' */
  273.     curlist .auxfield .hh .v.RH = whatlang(p);
  274.     /* Insert additional languagenode, if \language != clang */
  275.     fixlanguage();
  276.       }
  277.     }
  278.   } else {
  279.     while ( link ( curlist .tailfield ) != 0 )
  280.       curlist .tailfield = link ( curlist .tailfield ) ;
  281.   }
  282. #else
  283.   while ( link ( curlist .tailfield ) != 0 )
  284.     curlist .tailfield = link ( curlist .tailfield ) ;
  285. #endif
  286.  
  287.  
  288. #else
  289.  
  290.   /* schneller geht die while-Schleife zum Schluss, wenn man `tail' in
  291.    * einer lokalen Variable haelt...
  292.    */
  293.   { register halfword ctf = curlist.tailfield;
  294.  
  295.     if ( c == 1 ) 
  296.       link(ctf) = copynodelist ( listptr(p) );
  297.     else {
  298.       link(ctf) = listptr(p);
  299.       box ( curval ) = 0;
  300.       freenode ( p, boxnodesize );
  301.     }
  302. #ifdef ERW_LANGUAGE
  303.     if ( abs( curlist .modefield ) == hmode ) {
  304.       if( link(ctf) != 0 ) {
  305.     register halfword p = 0;
  306.     do {
  307.       ctf = link( ctf );
  308.       if (ischarnode(ctf))
  309.         ;
  310.       else {
  311.         if (ztype(ctf) == whatsitnode && subtype(ctf) == languagenode) {
  312.           p = ctf;
  313.         }
  314.       }
  315.     } while( link(ctf) != 0 );
  316.     curlist.tailfield = ctf;
  317.     /* Abpruefen, ob... */
  318.     if( p != 0 ) {
  319.       if( whatlang(p) != curlist .auxfield .hh .v.RH ) {
  320.         /* Update `clang' */
  321.         curlist .auxfield .hh .v.RH = whatlang(p);
  322.         /* Insert additional languagenode, if \language != clang */
  323.         fixlanguage();
  324.       }
  325.     }
  326.       }
  327.     } else {
  328.       if( link(ctf) != 0 ) {
  329.     do {
  330.       ctf = link( ctf );
  331.     } while( link(ctf) != 0 );
  332.     curlist.tailfield = ctf;
  333.       }
  334.     }
  335. #else
  336.     if( link(ctf) != 0 ) {
  337.       do {
  338.     ctf = link( ctf );
  339.       } while( link(ctf) != 0 );
  340.       curlist.tailfield = ctf;
  341.     }
  342. #endif  /* ERW_LANGUAGE */
  343.   }
  344. #endif
  345. }
  346.  
  347.  
  348. void appenditaliccorrection ( void )
  349. { appenditaliccorrection_regmem
  350.   register halfword p;
  351.   register internalfontnumber f;
  352.  
  353.   if ( curlist .tailfield != curlist .headfield ) {
  354.     if ( ischarnode ( curlist .tailfield ) )
  355.     p = curlist .tailfield ; 
  356.     else if ( ztype ( curlist .tailfield ) == ligaturenode ) 
  357.     p = ligchar ( curlist .tailfield ) ; 
  358.     else
  359.     return;
  360.     f = font ( p );
  361.     tailappend ( newkern ( zcharitalic ( f, zcharinfo(f, character(p)) ) ) );
  362.     subtype ( curlist .tailfield ) = explicit ; 
  363.   }
  364. }
  365.  
  366.  
  367. void appenddiscretionary ( void )
  368. { appenddiscretionary_regmem
  369.   register integer c;
  370.  
  371.   tailappend ( newdisc () );
  372.   if ( curchr == 1 ) {
  373.     c = hyphenchar(curfont);
  374.     if ( c >= 0 && c < 256 )
  375.       prebreak ( curlist .tailfield ) = newcharacter( curfont, c );
  376.   } else {
  377.     incr ( saveptr );
  378.     saved ( -1 ) = 0;
  379.     newsavelevel ( discgroup );
  380.     scanleftbrace ();
  381.     pushnest();
  382.     curlist .modefield = -hmode;
  383.     curlist .auxfield .hh .v.LH = 1000;
  384.   }
  385. }
  386.  
  387.  
  388. void builddiscretionary ( void )
  389. { builddiscretionary_regmem 
  390.   register halfword p, q;
  391.   register integer n;
  392.  
  393.   unsave ();
  394.  
  395.   n = 0;
  396.   q = curlist .headfield;
  397.   p = link ( q );
  398.   while ( p != 0 ) {
  399.     if( !ischarnode(p) && ( ztype(p) > rulenode )
  400.     && ( ztype(p) != kernnode ) && ( ztype(p) != ligaturenode ) ) {
  401.       print_err("Improper discretionary list");
  402.       zhelp1( STR_H_DISCLISTS_MUST );
  403.       error();
  404.       begindiagnostic();
  405.       c_printnl("The following discretionary sublist has been deleted:");
  406.       showbox ( p );
  407.       enddiagnostic ( true );
  408.       flushnodelist ( p );
  409.       link ( q ) = 0;
  410.       goto lab30;
  411.     }
  412.     q = p;
  413.     p = link ( q );
  414.     incr ( n );
  415.   }
  416.  
  417. lab30:
  418.   p = link ( curlist .headfield );
  419.   popnest ();
  420.   switch ( saved ( -1 ) ) {
  421.   case 0:
  422.     prebreak ( curlist .tailfield ) = p;
  423.     break;
  424.   case 1:
  425.     postbreak ( curlist .tailfield ) = p;
  426.     break;
  427.   case 2:
  428.     {
  429.       if ( ( n > 0 ) && ( abs ( curlist .modefield ) == mmode ) ) {
  430.     print_err("Illegal math ");
  431.     printesc( STR_DISCRETIONARY );
  432.     zhelp1( STR_H_SORRY_THIRDPARTOFDISC );
  433.     flushnodelist ( p );
  434.     n = 0;
  435.     error();
  436.       } else
  437.     link ( curlist .tailfield ) = p;
  438.       if ( n <= maxquarterword )
  439.     replacecount ( curlist .tailfield ) = n;
  440.       else {
  441.     print_err("Discretionary list is too long");
  442.     zhelp1( STR_H_WOW_INEVERTHOUGHT );
  443.     error();
  444.       }
  445.       if ( n > 0 )
  446.     curlist .tailfield = q;
  447.       decr( saveptr );
  448.       return;
  449.     }
  450.     break ; 
  451.   }
  452.  
  453.   incr ( saved ( -1 ) );
  454.   newsavelevel ( discgroup );
  455.   scanleftbrace();
  456.   pushnest();
  457.   curlist .modefield = -hmode;
  458.   curlist .auxfield .hh .v.LH = 1000;
  459. }
  460.  
  461.  
  462. void makeaccent ( void )
  463. { makeaccent_regmem
  464.   real s, t;
  465.   register halfword p, q;
  466.   register internalfontnumber f;
  467.   register scaled a, h, x, w, delta;
  468.   fourquarters i;
  469.  
  470.   { register integer r_curval;
  471.  
  472.     r_curval = scancharnum ();
  473.     f = curfont;
  474.     p = newcharacter( f, r_curval );
  475.   }
  476.  
  477.   if ( p != 0 ) {
  478.     x = xheight ( f ) ; 
  479.     s = slant ( f ) / ((double) 65536.0 ) ; 
  480.     a = zcharwidth ( f ,  zcharinfo ( f ,  character ( p ) ) ) ; 
  481.  
  482.     doassignments();
  483.  
  484.     f = curfont ; 
  485.     if ( curcmd == 11 || curcmd == 12 || curcmd == 68 ) {
  486.       q = newcharacter ( f , curchr );
  487.     } else if ( curcmd == 16 ) {
  488.       q = newcharacter( f, scancharnum() );
  489.     } else {
  490.       q = 0;
  491.       backinput();
  492.     }
  493.  
  494.     if ( q != 0 ) {
  495.       t = slant ( f ) / ((double) 65536.0 );
  496.       i = zcharinfo( f, character ( q ) );
  497.       w = zcharwidth( f, i ) ; 
  498.       h = zcharheight( f, heightdepth ( i ) );
  499.       if ( h != x ) {
  500.     p = hpack( p, 0, 1 );
  501.     shiftamount ( p ) = x - h;
  502.       }
  503.       delta = round ( ( w - a ) / ((double) 2.0 ) + h * t - x * s ) ; 
  504.       { register long_halfword r;
  505.     r = newkern ( delta );
  506.     subtype ( r ) = acckern;
  507.     link ( curlist .tailfield ) = r;
  508.     link ( r ) = p;
  509.       }
  510.       curlist .tailfield = newkern ( - (integer) a - delta );
  511.       subtype ( curlist .tailfield ) = acckern;
  512.       link ( p ) = curlist .tailfield;
  513.       p = q;
  514.     }
  515.     link ( curlist .tailfield ) = p;
  516.     curlist .tailfield = p;
  517.     curlist .auxfield .hh .v.LH = 1000;
  518.   }
  519. }
  520.  
  521.  
  522. static char err_misplaced[] = "Misplaced "; /* 1107 */
  523.  
  524. void alignerror ( void )
  525. { alignerror_regmem 
  526.  
  527.   if ( abs ( alignstate ) > 2 ) {
  528.     print_err( err_misplaced );
  529.     printcmdchr ( curcmd , curchr ) ; 
  530.     if ( curtok == tabtoken + 38 ) {
  531.       zhelp3( STR_H_ICANTFIGURE_TABMARK, STR_H_HERE_AMPERSAND,
  532.         STR_H_UPABOVE_PREVALIGN );
  533.     } else {
  534.       zhelp3( STR_H_ICANTFIGURE_TABMARK, STR_H_ORCRORSPAN,
  535.         STR_H_UPABOVE_PREVALIGN );
  536.     }
  537.     error();
  538.   } else {
  539.     backinput();
  540.     if ( alignstate < 0 ) {
  541.       p_print_err( STR_H_MISSING_LEFTBRACE );
  542.       incr ( alignstate );
  543.       curtok = leftbracetoken + 123;
  544.     } else {
  545.       print_err("Missing } inserted");
  546.       decr ( alignstate );
  547.       curtok = rightbracetoken + 125;
  548.     }
  549.     zhelp1( STR_H_IVEPUTIN_TOFIX );
  550.     inserror();
  551.   }
  552. }
  553.  
  554.  
  555. void noalignerror ( void )
  556. { noalignerror_regmem 
  557.  
  558.   print_err( err_misplaced );
  559.   printesc( STR_NOALIGN );
  560.   zhelp2( STR_H_IEXPECT_NOALIGN, STR_H_AN_ALIGNMENT );
  561.   error();
  562. }
  563.  
  564.  
  565. void omiterror ( void )
  566. { omiterror_regmem 
  567.  
  568.   print_err( err_misplaced );
  569.   printesc( STR_OMIT );
  570.   zhelp2( STR_H_IEXPECT_OMIT, STR_H_AN_ALIGNMENT );
  571.   error();
  572. }
  573.  
  574.  
  575. void doendv ( void )
  576. { doendv_regmem 
  577.  
  578.   if ( curgroup == aligngroup ) {
  579.     endgraf ();
  580.     if ( fincol () )
  581.       finrow();
  582.   } else {
  583.     offsave();
  584.   }
  585. }
  586.  
  587.  
  588. void cserror ( void )
  589. { cserror_regmem 
  590.  
  591.   print_err("Extra ");
  592.   printesc( STR_ENDCSNAME );
  593.   zhelp1( STR_H_IMIGNORING_CSNAME );
  594.   error();
  595. }
  596.  
  597.  
  598. void pushmath ( groupcode c )
  599. { pushmath_regmem 
  600.  
  601.   pushnest();
  602.   curlist .modefield = -mmode;
  603.   curlist .auxfield .cint = 0;
  604.   newsavelevel ( c );
  605. }
  606.  
  607.  
  608.   static void
  609. go_into_ordinary_math(void)        /* added (br) */
  610. { gointoordinarymath_regmem
  611.  
  612.   pushmath ( mathshiftgroup );
  613.   eqworddefine ( intbase + curfamcode, -1 );
  614.   if ( everymath != 0 )
  615.     begintokenlist ( everymath, everymathtext );
  616. }
  617.  
  618.  
  619. void initmath ( void )
  620. {/* 21 40 45 30 */ initmath_regmem 
  621.   register scaled w  ; 
  622.   register scaled l  ; 
  623.   register scaled s  ; 
  624.   register halfword p  ; 
  625.   register halfword q  ; 
  626.   register internalfontnumber f  ; 
  627.   register integer n  ; 
  628.   register scaled v  ; 
  629.   register scaled d  ; 
  630.  
  631.   gettoken ();
  632.   if ( ( curcmd == 3 ) && ( curlist .modefield > 0 ) ) {
  633.     if ( curlist .headfield == curlist .tailfield ) {
  634.       popnest ();
  635.       w = - (integer) maxdimen;
  636.     } else {
  637.       linebreak ( displaywidowpenalty ) ; 
  638.       v = shiftamount ( justbox ) + 2 * quad ( curfont ) ; 
  639.       w = - (integer) maxdimen ; 
  640.       p = listptr ( justbox ) ; 
  641.       while ( p != 0 ) {
  642. lab21:
  643.     if ( ischarnode ( p ) ) {
  644.       f = font ( p ) ; 
  645.       d = zcharwidth ( f ,  zcharinfo ( f ,  character ( p ) ) ) ; 
  646.       goto lab40 ; 
  647.     } 
  648.     switch ( ztype ( p ) ) {
  649.     case hlistnode : 
  650.     case vlistnode : 
  651.     case rulenode : 
  652.         d = width ( p ) ; 
  653.         goto lab40 ; 
  654.       break ; 
  655.     case ligaturenode : 
  656.         mem [ ligtrick ] = mem [ ligchar ( p ) ] ; 
  657.         link ( ligtrick ) = link ( p ) ; 
  658.         p = ligtrick ; 
  659.         goto lab21 ; 
  660.       break ; 
  661.     case kernnode : 
  662.     case mathnode : 
  663.       d = width ( p ) ; 
  664.       break ; 
  665.     case gluenode : 
  666.         q = glueptr ( p ) ; 
  667.         d = width ( q ) ; 
  668.         if ( gluesign ( justbox ) == stretching ) {
  669.           if ( ( glueorder ( justbox ) == stretchorder ( q ) ) && ( 
  670.           stretch ( q ) != 0 ) ) 
  671.           v = maxdimen ; 
  672.         } else if ( gluesign ( justbox ) == shrinking ) {
  673.           if ( ( glueorder ( justbox ) == shrinkorder ( q ) ) && ( shrink 
  674.           ( q ) != 0 ) ) 
  675.           v = maxdimen ; 
  676.         } 
  677.         if ( subtype ( p ) >= aleaders ) 
  678.           goto lab40;
  679.       break ; 
  680.     case whatsitnode : 
  681.     default: 
  682.       d = 0 ; 
  683.       break ; 
  684.     }
  685.     if ( v < maxdimen ) 
  686.       v = v + d ; 
  687.     goto lab45 ; 
  688.  
  689. lab40:    if ( v < maxdimen ) {
  690.       v = v + d ; 
  691.       w = v ; 
  692.     } else {
  693.       w = maxdimen ; 
  694.       goto lab30 ; 
  695.     } 
  696. lab45:
  697.     p = link ( p ) ; 
  698.       }
  699. lab30: ; 
  700.     }
  701.  
  702.     if ( parshapeptr == 0 ) {
  703.     if ( ( hangindent != 0 )
  704.     && ( ( hangafter >= 0 && ( curlist .pgfield + 2 > hangafter ) )
  705.       || ( curlist .pgfield + 1 < - (integer) hangafter ) ) )
  706.       {
  707.     l = hsize - abs ( hangindent ) ; 
  708.     if ( hangindent > 0 ) 
  709.       s = hangindent ; 
  710.     else
  711.       s = 0 ; 
  712.       } else {
  713.     l = hsize ; 
  714.     s = 0 ; 
  715.       }
  716.     } else {
  717.       n = info ( parshapeptr ) ; 
  718.       if ( curlist .pgfield + 2 >= n ) 
  719.     p = parshapeptr + 2 * n ; 
  720.       else
  721.     p = parshapeptr + 2 * ( curlist .pgfield + 2 ) ; 
  722.       s = mem [ p - 1 ] .cint ; 
  723.       l = mem [ p ] .cint ; 
  724.     } 
  725.     pushmath ( mathshiftgroup ) ; 
  726.     curlist .modefield = mmode;
  727.     eqworddefine ( intbase + curfamcode , -1 ) ; 
  728.     eqworddefine ( dimenbase + predisplaysizecode , w ) ; 
  729.     eqworddefine ( dimenbase + displaywidthcode , l ) ; 
  730.     eqworddefine ( dimenbase + displayindentcode , s ) ; 
  731.     if ( everydisplay != 0 ) 
  732.       begintokenlist ( everydisplay , everydisplaytext ) ; 
  733.     if ( nestptr == 1 ) 
  734.       buildpage () ; 
  735.   } else {
  736.     backinput () ; 
  737.     go_into_ordinary_math();
  738.   }
  739. }
  740.  
  741.  
  742. void starteqno ( void )
  743. { starteqno_regmem 
  744.  
  745.   saved ( 0 ) = curchr;
  746.   incr ( saveptr );
  747.   go_into_ordinary_math();
  748. }
  749.  
  750.  
  751. void scanmath ( halfword p )
  752. { scanmath_regmem 
  753.   register integer c;
  754.   register eightbits r_curcmd;
  755.  
  756. lab20:
  757.   r_curcmd = getxnbtoken(1);
  758.  
  759. /*lab21:*/
  760.   switch ( r_curcmd ) {
  761.   case 16 :
  762.     curchr = scancharnum ();    /* curchr = curval; */
  763.     curcmd = 68;
  764. #if 0
  765.     r_curcmd = 68;
  766.     goto lab21 ;
  767.     break ;
  768. #else
  769.     /* Fall through */
  770. #endif
  771.   case 11 : 
  772.   case 12 : 
  773.   case 68 : 
  774.       c = mathcode ( curchr ) ; 
  775.       if ( c == 32768L ) {
  776.     {
  777.       curcs = curchr + activebase ; 
  778.       curcmd = eqtype ( curcs ) ; 
  779.       curchr = equiv ( curcs ) ; 
  780.       xtoken () ; 
  781.       backinput () ; 
  782.     } 
  783.     goto lab20 ; 
  784.       }
  785.     break ; 
  786.   case 17 : 
  787.     c = scanfifteenbitint ();        /* c = curval; */
  788.     break ; 
  789.   case 69 : 
  790.     c = curchr ; 
  791.     break ; 
  792.   case 15 : 
  793.     c = scantwentysevenbitint() / 4096;    /* c = curval / 4096; */
  794.     break ; 
  795.   default: 
  796.     {
  797.       backinput () ; 
  798.       scanleftbrace () ; 
  799.       saved ( 0 ) = p ; 
  800.       incr ( saveptr ) ; 
  801.       pushmath ( mathgroup ) ; 
  802.       return ; 
  803.     }
  804.     break ; 
  805.   }
  806.   mathtype ( p ) = mathchar ; 
  807.   character ( p ) = c % 256 ; 
  808.   if ( ( c >= varcode ) && ( ( curfam >= 0 ) && ( curfam < 16 ) ) ) 
  809.     fam ( p ) = curfam ; 
  810.   else
  811.     fam ( p ) = ( c / 256 ) % 16 ; 
  812. }
  813.  
  814.  
  815. void setmathchar ( integer c )
  816. { setmathchar_regmem 
  817.  
  818.   if ( c >= 32768L ) {
  819.     curcs = curchr + activebase ; 
  820.     curcmd = eqtype ( curcs ) ; 
  821.     curchr = equiv ( curcs ) ; 
  822.     xtoken () ; 
  823.     backinput () ; 
  824.   } else {
  825.     register long_halfword p;
  826.  
  827.     p = newnoad () ; 
  828.     mathtype ( nucleus ( p ) ) = mathchar ; 
  829.     character ( nucleus ( p ) ) = c % 256 ; 
  830.     fam ( nucleus ( p ) ) = ( c / 256 ) % 16 ; 
  831.     if ( c >= varcode ) {
  832.       if ( ( ( curfam >= 0 ) && ( curfam < 16 ) ) ) 
  833.     fam ( nucleus ( p ) ) = curfam ; 
  834.       ztype ( p ) = ordnoad ; 
  835.     } else
  836.       ztype ( p ) = ordnoad + ( c / 4096 ) ; 
  837.     link ( curlist .tailfield ) = p ; 
  838.     curlist .tailfield = p ; 
  839.   }
  840. }
  841.  
  842.  
  843. void mathlimitswitch ( void )
  844. { mathlimitswitch_regmem 
  845.  
  846.   if ( curlist .headfield != curlist .tailfield ) 
  847.   if ( ztype ( curlist .tailfield ) == opnoad ) {
  848.     subtype ( curlist .tailfield ) = curchr ; 
  849.     return ; 
  850.   }
  851.   print_err("Limit controls must follow a math operator");
  852.   zhelp1( STR_H_IMIGNORING_LIMITS );
  853.   error () ; 
  854. }
  855.  
  856.  
  857. void scandelimiter ( halfword p, boolean r )
  858. { scandelimiter_regmem 
  859.   register integer r_curval;
  860.  
  861.   if ( r ) 
  862.     r_curval = scantwentysevenbitint ();
  863.   else {
  864.     register eightbits r_curcmd;
  865.  
  866.     r_curcmd = getxnbtoken(1);
  867.     switch ( r_curcmd ) {
  868.     case 11 : 
  869.     case 12 : 
  870.       r_curval = delcode ( curchr );
  871.       break ; 
  872.     case 15 : 
  873.       r_curval = scantwentysevenbitint ();
  874.       break ;
  875.     default: 
  876.       r_curval = -1;
  877.       break ;
  878.     }
  879.     curval = r_curval;
  880.   }
  881.  
  882.   if ( r_curval < 0 ) {
  883.     print_err("Missing delimiter (. inserted)");
  884.     zhelp1( STR_H_IWASEXP_BRACE );
  885.     backerror();
  886.     curval = r_curval = 0;
  887.   }
  888.   smallfam ( p ) = ( r_curval / 1048576L ) % 16;
  889.   smallchar ( p ) = ( r_curval / 4096 ) % 256;
  890.   largefam ( p ) = ( r_curval / 256 ) % 16;
  891.   largechar ( p ) = r_curval % 256;
  892. }
  893.  
  894.  
  895. void mathradical ( void )
  896. { mathradical_regmem
  897.  
  898.   tailappend ( getnode ( radicalnoadsize ) ) ; 
  899.   ztype ( curlist .tailfield ) = radicalnoad ; 
  900.   subtype ( curlist .tailfield ) = normal ; 
  901.   mem [ nucleus ( curlist .tailfield ) ] .hh = emptyfield ; 
  902.   mem [ subscr ( curlist .tailfield ) ] .hh = emptyfield ; 
  903.   mem [ supscr ( curlist .tailfield ) ] .hh = emptyfield ; 
  904.   scandelimiter ( leftdelimiter ( curlist .tailfield ) , true ) ; 
  905.   scanmath ( nucleus ( curlist .tailfield ) ) ; 
  906. }
  907.  
  908.  
  909. void mathac ( void )
  910. { mathac_regmem 
  911.  
  912.   if ( curcmd == 45 ) {
  913.     print_err("Please use ");
  914.     printesc( STR_MATHACCENT );
  915.     c_print(" for accents in math mode");
  916.     zhelp1( STR_H_IMCHANGING_ACCENT );
  917.     error();
  918.   }
  919.   tailappend ( getnode ( accentnoadsize ) ) ; 
  920.   ztype ( curlist .tailfield ) = accentnoad ; 
  921.   subtype ( curlist .tailfield ) = normal ; 
  922.   mem [ nucleus ( curlist .tailfield ) ] .hh = emptyfield ; 
  923.   mem [ subscr ( curlist .tailfield ) ] .hh = emptyfield ; 
  924.   mem [ supscr ( curlist .tailfield ) ] .hh = emptyfield ; 
  925.   mathtype ( accentchr ( curlist .tailfield ) ) = mathchar ; 
  926.   { register integer r_curval;
  927.  
  928.     r_curval = scanfifteenbitint ();
  929.     character ( accentchr ( curlist .tailfield ) ) = r_curval % 256;
  930.     if ( r_curval >= varcode && ( curfam >= 0 && curfam < 16 ) )
  931.       fam ( accentchr ( curlist .tailfield ) ) = curfam;
  932.     else
  933.       fam ( accentchr ( curlist .tailfield ) ) = ( r_curval / 256 ) % 16 ;
  934.   }
  935.   scanmath ( nucleus ( curlist .tailfield ) ) ;
  936. }
  937.  
  938.  
  939. void appendchoices ( void )
  940. { appendchoices_regmem 
  941.  
  942.   tailappend ( newchoice () ) ; 
  943.   incr ( saveptr ) ; 
  944.   saved ( -1 ) = 0 ; 
  945.   pushmath ( mathchoicegroup ) ; 
  946.   scanleftbrace () ; 
  947. }
  948.  
  949.  
  950. halfword finmlist ( halfword p )
  951. { finmlist_regmem
  952.   register halfword q ;
  953.  
  954.   if ( curlist .auxfield .cint != 0 ) {
  955.     mathtype ( denominator ( curlist .auxfield .cint ) ) = submlist ; 
  956.     info ( denominator( curlist.auxfield.cint ) ) = link( curlist.headfield );
  957.     if ( p == 0 )
  958.       q = curlist .auxfield .cint ; 
  959.     else {
  960.       q = info ( numerator ( curlist .auxfield .cint ) ) ; 
  961.       if ( ztype ( q ) != leftnoad ) 
  962.     confusion("right");
  963.       info ( numerator ( curlist .auxfield .cint ) ) = link ( q ) ; 
  964.       link ( q ) = curlist .auxfield .cint ; 
  965.       link ( curlist .auxfield .cint ) = p ; 
  966.     } 
  967.   } else {
  968.     link ( curlist .tailfield ) = p ; 
  969.     q = link ( curlist .headfield ) ; 
  970.   } 
  971.   popnest () ; 
  972.  
  973.   return(q);
  974. }
  975.  
  976.  
  977. void buildchoices ( void )
  978. {/* 10 */ buildchoices_regmem 
  979.   register halfword p  ; 
  980.  
  981.   unsave () ; 
  982.   p = finmlist ( 0 ) ; 
  983.   switch ( saved ( -1 ) ) {
  984.   case 0 : 
  985.     displaymlist ( curlist .tailfield ) = p ; 
  986.     break ; 
  987.   case 1 : 
  988.     textmlist ( curlist .tailfield ) = p ; 
  989.     break ; 
  990.   case 2 : 
  991.     scriptmlist ( curlist .tailfield ) = p ; 
  992.     break ; 
  993.   case 3 : 
  994.     {
  995.       scriptscriptmlist ( curlist .tailfield ) = p ; 
  996.       decr ( saveptr ) ; 
  997.       return ; 
  998.     } 
  999.     break ; 
  1000.   } 
  1001.   incr ( saved ( -1 ) ) ; 
  1002.   pushmath ( mathchoicegroup ) ; 
  1003.   scanleftbrace () ; 
  1004. } 
  1005.  
  1006.  
  1007. void subsup ( void )
  1008. { subsup_regmem 
  1009.   register smallnumber t  ; 
  1010.   register halfword p  ; 
  1011.  
  1012.   t = 0 ; 
  1013.   p = 0 ; 
  1014.   if ( curlist .tailfield != curlist .headfield ) 
  1015.   if ( scriptsallowed ( curlist .tailfield ) ) {
  1016.     p = supscr ( curlist .tailfield ) + curcmd - 7 ; 
  1017.     t = mathtype ( p ) ; 
  1018.   } 
  1019.   if ( ( p == 0 ) || ( t != 0 ) ) {
  1020.     tailappend ( newnoad () ) ; 
  1021.     p = supscr ( curlist .tailfield ) + curcmd - 7 ; 
  1022.     if ( t != 0 ) {
  1023.       if ( curcmd == 7 ) {
  1024.     print_err("Double superscript");
  1025.     zhelp1( STR_H_ITREAT_XUP1UP2 );
  1026.       } else {
  1027.     print_err("Double subscript");
  1028.     zhelp1( STR_H_ITREAT_XDOWN1DOWN2 );
  1029.       } 
  1030.       error () ; 
  1031.     } 
  1032.   }
  1033.   scanmath ( p ) ; 
  1034. }
  1035.  
  1036.  
  1037. void mathfraction ( void )
  1038. { mathfraction_regmem 
  1039.   register smallnumber c  ; 
  1040.  
  1041.   c = curchr ; 
  1042.   if ( curlist .auxfield .cint != 0 ) {
  1043.     if ( c >= 3 ) {
  1044.       scandelimiter ( garbage , false ) ; 
  1045.       scandelimiter ( garbage , false ) ; 
  1046.     } 
  1047.     if ( c % 3 == 0 ) 
  1048.       scandimen( false, false, false );
  1049.     print_err("Ambiguous; you need another { and }");
  1050.     zhelp1( STR_H_IM_IGNORING_FRACTION );
  1051.     error();
  1052.   } else {
  1053.     curlist .auxfield .cint = getnode ( fractionnoadsize ) ; 
  1054.     ztype ( curlist .auxfield .cint ) = fractionnoad ; 
  1055.     subtype ( curlist .auxfield .cint ) = normal ; 
  1056.     mathtype ( numerator ( curlist .auxfield .cint ) ) = submlist ; 
  1057.     info ( numerator ( curlist.auxfield.cint ) ) = link ( curlist.headfield );
  1058.     mem [ denominator ( curlist .auxfield .cint ) ] .hh = emptyfield ; 
  1059.     mem [ leftdelimiter ( curlist .auxfield .cint ) ] .qqqq = nulldelimiter ; 
  1060.     mem [ rightdelimiter ( curlist .auxfield .cint ) ] .qqqq = nulldelimiter ; 
  1061.     link ( curlist .headfield ) = 0 ; 
  1062.     curlist .tailfield = curlist .headfield ; 
  1063.     if ( c >= 3 ) {
  1064.       scandelimiter ( leftdelimiter ( curlist .auxfield .cint ) , false ) ; 
  1065.       scandelimiter ( rightdelimiter ( curlist .auxfield .cint ) , false ) ; 
  1066.     }
  1067.     switch ( c % 3 ) {
  1068.     case 0 : 
  1069.       thickness( curlist.auxfield.cint ) = scandimen( false, false, false );
  1070.       break ; 
  1071.     case 1 : 
  1072.       thickness ( curlist .auxfield .cint ) = defaultcode ; 
  1073.       break ; 
  1074.     case 2 : 
  1075.       thickness ( curlist .auxfield .cint ) = 0 ; 
  1076.       break ; 
  1077.     } 
  1078.   }
  1079. }
  1080.  
  1081.  
  1082. void mathleftright ( void )
  1083. { mathleftright_regmem 
  1084.   register smallnumber t;
  1085.  
  1086.   t = curchr ; 
  1087.   if ( ( t == rightnoad ) && ( curgroup != mathleftgroup ) ) {
  1088.     if ( curgroup == mathshiftgroup ) {
  1089.       scandelimiter ( garbage , false ) ; 
  1090.       print_err("Extra ");
  1091.       printesc( STR_RIGHT );
  1092.       zhelp1( STR_H_IM_IGNORING_RIGHT );
  1093.       error();
  1094.     } else
  1095.       offsave ();
  1096.   } else {
  1097.     register halfword p;
  1098.  
  1099.     p = newnoad () ; 
  1100.     ztype ( p ) = t ; 
  1101.     scandelimiter ( delimiter ( p ) , false ) ; 
  1102.     if ( t == leftnoad ) {
  1103.       pushmath ( mathleftgroup ) ; 
  1104.       link ( curlist .headfield ) = p ; 
  1105.       curlist .tailfield = p ; 
  1106.     } else {
  1107.       p = finmlist ( p ) ; 
  1108.       unsave () ; 
  1109.       tailappend ( newnoad () ) ; 
  1110.       ztype ( curlist .tailfield ) = innernoad ; 
  1111.       mathtype ( nucleus ( curlist .tailfield ) ) = submlist ; 
  1112.       info ( nucleus ( curlist .tailfield ) ) = p ; 
  1113.     }
  1114.   }
  1115. }
  1116.  
  1117.  
  1118. void resumeafterdisplay ( void )
  1119. { resumeafterdisplay_regmem 
  1120.  
  1121.   if ( curgroup != mathshiftgroup ) 
  1122.     confusion("display");
  1123.   unsave () ; 
  1124.   curlist .pgfield = curlist .pgfield + 3 ; 
  1125.   pushnest () ; 
  1126.   curlist .modefield = hmode ;
  1127.   curlist .auxfield .hh .v.LH = 1000 ; 
  1128. #if 0  /* 3.1415 */
  1129.   curlist .auxfield .hh .v.RH = 0 ; 
  1130. #else
  1131.   if ( language <= 0 || language > 255 )
  1132.     curlang = 0;
  1133.   else
  1134.     curlang = language ; 
  1135.   curlist .auxfield .hh .v.RH = curlang;
  1136.   curlist .pgfield = ( normmin ( lefthyphenmin ) * 0x40
  1137.             + normmin ( righthyphenmin ) ) * 0x10000L + curlang;
  1138. #endif
  1139.  
  1140.   if ( (eightbits)getxtoken() != 10 )
  1141.     backinput();
  1142.  
  1143.   if ( nestptr == 1 ) 
  1144.     buildpage();
  1145. }
  1146.  
  1147.  
  1148. void getrtoken ( void )
  1149. { getrtoken_regmem 
  1150.  
  1151. lab20:
  1152.   do {
  1153.     gettoken();
  1154.   } while ( curtok == spacetoken );
  1155.  
  1156.   if ( ( curcs == 0 ) || ( curcs > frozencontrolsequence ) ) {
  1157.     print_err("Missing control sequence inserted");
  1158.     zhelp1( STR_H_PLEASEDONTSAYDEF );
  1159.     if ( curcs == 0 )
  1160.       backinput();
  1161.     curtok = cstokenflag + frozenprotection;
  1162.     inserror();
  1163.     goto lab20;
  1164.   }
  1165. }
  1166.  
  1167.  
  1168.   long_halfword
  1169. trapzeroglue ( long_halfword r_curval )
  1170. { trapzeroglue_regmem 
  1171.  
  1172.   if( width(r_curval) == 0 && stretch(r_curval) == 0 && shrink(r_curval) == 0 ) {
  1173.     addglueref ( zeroglue );
  1174.     deleteglueref ( r_curval );
  1175.     curval = r_curval = zeroglue;
  1176.   }
  1177.   return r_curval;
  1178. }
  1179.  
  1180.  
  1181. void doregistercommand ( smallnumber a )
  1182. { doregistercommand_regmem 
  1183.   register halfword l, q;
  1184.   register integer p;
  1185.   register integer r_curval;
  1186.  
  1187.   q = curcmd ; 
  1188.   if ( q != register_cmd ) {
  1189.     register eightbits r_curcmd;
  1190.  
  1191.     r_curcmd = getxtoken();
  1192.     if ( r_curcmd >= assign_int && r_curcmd <= assign_mu_glue ) {
  1193.     p = r_curcmd - assign_int;
  1194.     l = curchr ; 
  1195.     goto lab40 ; 
  1196.     } 
  1197.     if ( r_curcmd != register_cmd ) {
  1198.     p_print_err(  STR_H_YOUCANTUSE );
  1199.     printcmdchr ( r_curcmd , curchr );
  1200.     print( STR_H_AFTER );
  1201.     printcmdchr ( q , 0 );
  1202.     zhelp1( STR_H_IMFORGETTING );
  1203.     error () ; 
  1204.     return;
  1205.     }
  1206.   }
  1207.  
  1208.   p = curchr ; 
  1209.   r_curval = scaneightbitint ();
  1210.   switch ( p ) {
  1211.     case intval : 
  1212.       l = r_curval + countbase;
  1213.       break ; 
  1214.     case dimenval : 
  1215.       l = r_curval + scaledbase ; 
  1216.       break ; 
  1217.     case glueval : 
  1218.       l = r_curval + skipbase ; 
  1219.       break ; 
  1220.     case muval : 
  1221.       l = r_curval + muskipbase ; 
  1222.       break ; 
  1223.   }
  1224.  
  1225. lab40: ; 
  1226.   if ( q == register_cmd )
  1227.     scanoptionalequals () ; 
  1228.   else if ( scankeyword ( STR_BY ) )
  1229.     ;
  1230.  
  1231.   aritherror = false ; 
  1232.   if ( q < multiply ) {
  1233.  
  1234.   if ( p < glueval ) {
  1235.     if ( p == intval ) 
  1236.       r_curval = scanint ();
  1237.     else
  1238.       r_curval = scandimen ( false, false, false );
  1239.     if ( q == advance )
  1240.       r_curval = r_curval + eqtb [ l ] .cint;
  1241.   } else {
  1242.     r_curval = scanglue ( p );
  1243.     if ( q == advance ) {
  1244.       register long_halfword r;
  1245.  
  1246.       q = newspec ( r_curval ) ; 
  1247.       r = equiv ( l ) ; 
  1248.       deleteglueref ( r_curval ) ; 
  1249.       width ( q ) += width ( r );
  1250.       if ( stretch ( q ) == 0 ) 
  1251.     stretchorder ( q ) = normal ; 
  1252.       if ( stretchorder ( q ) == stretchorder ( r ) ) 
  1253.     stretch ( q ) += stretch ( r );
  1254.       else if ( ( stretchorder ( q ) < stretchorder ( r ) )
  1255.          && ( stretch ( r ) != 0 ) ) {
  1256.     stretch ( q ) = stretch ( r ) ; 
  1257.     stretchorder ( q ) = stretchorder ( r ) ; 
  1258.       }
  1259.       if ( shrink ( q ) == 0 )
  1260.     shrinkorder ( q ) = normal ; 
  1261.       if ( shrinkorder ( q ) == shrinkorder ( r ) ) 
  1262.     shrink ( q ) += shrink ( r );
  1263.       else if ( ( shrinkorder ( q ) < shrinkorder ( r ) )
  1264.          && ( shrink ( r ) != 0 ) ) {
  1265.     shrink ( q ) = shrink ( r ) ; 
  1266.     shrinkorder ( q ) = shrinkorder ( r ) ; 
  1267.       }
  1268.       r_curval = q ; 
  1269.     }
  1270.   }
  1271.  
  1272.   } else {
  1273.  
  1274.     r_curval = scanint ();
  1275.     if ( p < glueval ) {
  1276.       if ( q == multiply ) 
  1277.     if ( p == intval ) 
  1278.       r_curval = multandadd( eqtb[l].cint, r_curval, 0, 2147483647L );
  1279.     else
  1280.       r_curval = multandadd( eqtb[l].cint , r_curval, 0, 1073741823L );
  1281.       else
  1282.     r_curval = xovern( eqtb[l].cint, r_curval );
  1283.     } else {
  1284.       register long_halfword r, s;
  1285.  
  1286.       s = equiv ( l );
  1287.       r = newspec ( s );
  1288.       if ( q == multiply ) {
  1289.     width(r) = multandadd( width(s), r_curval, 0, 1073741823L ) ; 
  1290.     stretch(r) = multandadd( stretch(s), r_curval, 0, 1073741823L );
  1291.     shrink(r) = multandadd( shrink(s), r_curval, 0, 1073741823L );
  1292.       } else {
  1293.     width(r) = xovern( width(s), r_curval );
  1294.     stretch(r) = xovern( stretch(s), r_curval );
  1295.     shrink(r) = xovern( shrink(s), r_curval );
  1296.       }
  1297.       r_curval = r;
  1298.     }
  1299.   }
  1300.  
  1301.   if ( aritherror ) {
  1302.     print_err("Arithmetic overflow");
  1303.     zhelp1( STR_H_ICANTCARRYOUT );
  1304.     error ();
  1305.     return;
  1306.   }
  1307.  
  1308.   if ( p < glueval ) {
  1309.     if ( ( a >= 4 ) ) 
  1310.       geqworddefine( l, r_curval );
  1311.     else
  1312.       eqworddefine( l, r_curval );
  1313.   } else {
  1314.     r_curval = trapzeroglue(r_curval);
  1315.     if ( a >= 4 )
  1316.       geqdefine( l, glueref, r_curval );
  1317.     else
  1318.       eqdefine( l, glueref, r_curval );
  1319.   }
  1320. }
  1321.  
  1322.  
  1323. void alteraux ( void )
  1324. { alteraux_regmem
  1325.  
  1326.   if ( curchr != abs ( curlist .modefield ) )
  1327.     reportillegalcase ();
  1328.   else {
  1329.     register halfword c;
  1330.  
  1331.     c = curchr ; 
  1332.     scanoptionalequals();
  1333.     if ( c == vmode ) {
  1334.       curlist.auxfield.cint = scandimen( false, false, false );
  1335.     } else {
  1336.       register integer r_curval;
  1337.  
  1338.       r_curval = scanint ();
  1339.       if ( r_curval <= 0 || r_curval > 32767 ) {
  1340.     print_err("Bad space factor");
  1341.     zhelp1( STR_H_IALLOWONLYVALUES );
  1342.     interror ( r_curval );
  1343.       } else
  1344.     curlist .auxfield .hh .v.LH = r_curval;
  1345.     }
  1346.   }
  1347. }
  1348.  
  1349.  
  1350. void alterprevgraf ( void )
  1351. { alterprevgraf_regmem 
  1352.   register integer p;
  1353.   
  1354.   nest [ nestptr ] = curlist ; 
  1355.   p = nestptr ; 
  1356.   while ( abs ( nest [ p ] .modefield ) != vmode )
  1357.     decr ( p );
  1358.  
  1359.   scanoptionalequals ();
  1360.  
  1361.  { register integer r_curval;
  1362.  
  1363.   r_curval = scanint ();
  1364.   if ( r_curval < 0 ) {
  1365.     print_err("Bad ");
  1366.     printesc( STR_PREVGRAF );
  1367.     zhelp1( STR_H_IALLOWONLYNONNEG );
  1368.     interror ( r_curval ) ; 
  1369.   } else {
  1370.     nest[p].pgfield = r_curval;
  1371.     curlist = nest[nestptr];
  1372.   }
  1373.  }
  1374. }
  1375.  
  1376.  
  1377. void alterpagesofar ( void )
  1378. { alterpagesofar_regmem
  1379.   register schar c;
  1380.  
  1381.   c = curchr;
  1382.   scanoptionalequals ();
  1383.   pagesofar[c] = scandimen( false, false, false );
  1384. }
  1385.  
  1386.  
  1387. void alterinteger ( void )
  1388. { alterinteger_regmem
  1389.   register schar c;
  1390.  
  1391.   c = curchr;
  1392.   scanoptionalequals();
  1393.   if ( c == 0 ) 
  1394.     deadcycles = scanint();
  1395.   else
  1396.     insertpenalties = scanint();
  1397. }
  1398.  
  1399.  
  1400. void alterboxdimen ( void )
  1401. { alterboxdimen_regmem 
  1402.   register smallnumber c  ; 
  1403.   register eightbits b  ; 
  1404.  
  1405.   c = curchr ; 
  1406.   b = scaneightbitint ();    /* b = curval; */
  1407.   scanoptionalequals ();
  1408.   { register integer r_curval;
  1409.  
  1410.     r_curval = scandimen( false, false, false );
  1411.     if ( box ( b ) != 0 )
  1412.       mem [ box ( b ) + c ] .cint = r_curval;
  1413.   }
  1414. }
  1415.  
  1416.  
  1417.  
  1418. /* preparemag() & newfont() => filename.c */
  1419.  
  1420.  
  1421. void newinteraction ( void )
  1422. { newinteraction_regmem 
  1423.  
  1424.   println();
  1425. #ifdef ERW_INTERACTION
  1426.   geqworddefine ( intbase + interactionmodecode, curchr );
  1427. #else
  1428.   interaction = curchr;
  1429. #endif
  1430.   if ( interaction <= batchmode )
  1431.     selector = noprint;
  1432.   else selector = termonly;
  1433.   if ( logopened )
  1434.     selector = selector + 2;
  1435. }
  1436.  
  1437.  
  1438. void doassignments ( void )
  1439. { doassignments_regmem 
  1440.   register eightbits r_curcmd;
  1441.  
  1442.   while ( true ) {
  1443.     r_curcmd = getxnbtoken(1);
  1444.     if ( r_curcmd <= max_non_prefixed_command )
  1445.       return;
  1446.     setboxallowed = false;  /* TeX 3.141 */
  1447.     prefixedcommand();
  1448.     setboxallowed = true;   /* TeX 3.141 */
  1449.   }
  1450. }
  1451.  
  1452.  
  1453. void openorclosein ( void )
  1454. { openorclosein_regmem 
  1455.   register schar c;
  1456.   register schar n;
  1457.  
  1458.   c = curchr ; 
  1459.   n = scanfourbitint ();
  1460.   if ( readopen [ n ] != closed ) {
  1461.     aclose ( readfile [ n ] );
  1462.     readopen [ n ] = closed;
  1463.   }
  1464.   if ( c != 0 ) {
  1465.     scanoptionalequals ();
  1466.     scanfilename ();
  1467.     if ( curext == 335 )
  1468.       curext = STR_DOT_TEX;
  1469.     packfilename ( curname , curarea , curext );
  1470.     if ( aopenin ( readfile [ n ] , TEXINPUTPATH ) ) 
  1471.       readopen [ n ] = justopen;
  1472.   }
  1473. }
  1474.  
  1475.  
  1476. void issuemessage ( void )
  1477. { issuemessage_regmem
  1478.   register integer oldsetting;
  1479.   schar c;
  1480.   register strnumber s;
  1481.  
  1482.   c = curchr ; 
  1483.   link ( garbage ) = scantoks ( false , true ) ; 
  1484.  
  1485.   oldsetting = selector ; 
  1486.   selector = newstring ; 
  1487.   tokenshow ( defref ) ; 
  1488.   selector = oldsetting ; 
  1489.   flushlist ( defref ) ; 
  1490.  
  1491.   strroom ( 1 );
  1492.   s = makestring ();
  1493.   if ( c == 0 ) {
  1494.     if ( termoffset + length ( s ) > maxprintline - 2 )
  1495.       println ();
  1496.     else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
  1497.       printchar( 32 );
  1498. #if 0 /* TeX 3.141 */
  1499.     print ( s );
  1500. #else
  1501.     slowprint( s );
  1502. #endif
  1503.     flush ( stdout );
  1504.   } else {
  1505. #if 0 /* TeX 3.141 */
  1506.     p_print_err ( s );
  1507. #else
  1508.     p_print_err ( 335 ); /* "" */  slowprint( s );
  1509. #endif
  1510.     if ( errhelp != 0 )
  1511.       useerrhelp = true;
  1512.     else if ( longhelpseen )
  1513.       zhelp1( STR_H_THATWASANOTHER );
  1514.     else {
  1515.       if ( interaction < errorstopmode )
  1516.     longhelpseen = true;
  1517.       zhelp1( STR_H_THISERRORMESSAGE );
  1518.     }
  1519.     error();
  1520.     useerrhelp = false;
  1521.   }
  1522.   flushstring;
  1523. }
  1524.  
  1525.  
  1526. void shiftcase ( void )
  1527. { shiftcase_regmem 
  1528.   register halfword b;
  1529.  
  1530.   b = curchr;
  1531.  
  1532.  { register halfword p;
  1533.  
  1534.   p = scantoks ( false , false );
  1535.   p = link ( defref );
  1536.   while ( p != 0 ) {
  1537.     register halfword t;
  1538.  
  1539.     t = info ( p ) ; 
  1540.     if ( t < cstokenflag + singlebase ) {
  1541.       register eightbits c;
  1542.  
  1543.       c = t % 256;
  1544.       if ( equiv ( b + c ) != 0 )
  1545.     info ( p ) = t - c + equiv ( b + c );
  1546.     }
  1547.     p = link ( p );
  1548.   }
  1549.  }
  1550.   begintokenlist ( link ( defref ) , backedup );
  1551.   freeavail ( defref );
  1552. }
  1553.  
  1554.  
  1555. void showwhatever ( void )
  1556. { showwhatever_regmem
  1557.   /* register halfword p; */
  1558.  
  1559.   switch ( curchr ) {
  1560.   case 3:
  1561.     begindiagnostic ();
  1562.     showactivities ();
  1563.     break;
  1564.   case 1:
  1565.     { register integer r_curval;
  1566.  
  1567.       r_curval = scaneightbitint();
  1568.       begindiagnostic();
  1569.       c_printnl("> \\box");
  1570.       printint ( r_curval );
  1571.       printchar( 61 );
  1572.       if ( box ( r_curval ) == 0 )
  1573.     c_print("void");
  1574.       else
  1575.     showbox( box(r_curval) );
  1576.     }
  1577.     break;
  1578.   case 0:
  1579.     {
  1580.       gettoken ();
  1581.       if ( interaction >= errorstopmode ) 
  1582.     wakeupterminal ();
  1583.       c_printnl("> ");
  1584.       if ( curcs != 0 ) {
  1585.     sprintcs ( curcs );
  1586.     printchar ( 61 );
  1587.       }
  1588.       printmeaning ();
  1589.       goto lab50;
  1590.     }
  1591.     break;
  1592.   default:
  1593.     {
  1594.       /* p = */ (void) thetoks ();
  1595.       if ( interaction >= errorstopmode ) 
  1596.     wakeupterminal ();
  1597.       c_printnl("> ");
  1598.       tokenshow ( temphead );
  1599.       flushlist ( link ( temphead ) );
  1600.       goto lab50 ; 
  1601.     } 
  1602.     break ; 
  1603.   } 
  1604.   enddiagnostic ( true );
  1605.   print_err("OK");
  1606.  
  1607.   if ( selector == termandlog ) 
  1608.   if ( tracingonline <= 0 ) {
  1609.     selector = termonly ; 
  1610.     c_print(" (see the transcript file)");
  1611.     selector = termandlog;
  1612.   }
  1613. lab50:
  1614.   if ( interaction < errorstopmode ) {
  1615.     help0;
  1616.     decr ( errorcount );
  1617.   } else if ( tracingonline > 0 ) {
  1618.     zhelp1( STR_H_THISISNTERR );
  1619.   } else {
  1620.     zhelp2( STR_H_THISISNTERR, STR_H_ANDTYPEITRACING );
  1621.   }
  1622.   error();
  1623. }
  1624.  
  1625. /* -- end -- */
  1626.