home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / tex6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-11  |  45.0 KB  |  1,987 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4.  
  5. void postlinebreak ( integer finalwidowpenalty )
  6. { postlinebreak_regmem 
  7.   register halfword q, r;
  8.   boolean discbreak;
  9.   boolean postdiscbreak;
  10.   register halfword curline;
  11. #ifdef TEXXET
  12.   halfword LR_ptr = LR_save;
  13. #endif
  14.  
  15.   /* 878. Reverse the link ... */
  16.   q = breaknode ( bestbet ) ; 
  17.   curp = 0 ;
  18.   do {
  19.     r = q ; 
  20.     q = prevbreak ( q ) ; 
  21.     prevbreak ( r ) = curp ; 
  22.     curp = r ; 
  23.   } while ( q != 0 );
  24.  
  25.  
  26.   curline = curlist .pgfield + 1 ; 
  27.  
  28.   do {
  29.     /* Justify the line ending... 880. */
  30.  
  31. #ifdef TEXXET
  32.     /* 1381. Insert LR nodes at the beginning... */
  33.     q = link(temphead);
  34.     if( LR_ptr != 0 ) {
  35.       tempptr = LR_ptr;  r = q;
  36.       do {
  37.         register long_halfword s;
  38.  
  39.     s = newmath(0, begin_LR_type(tempptr));
  40.     link(s) = r;  r = s;
  41.     tempptr = link(tempptr);
  42.       } while( tempptr != 0 );
  43.     }
  44.     while( q != curbreak(curp) ) {
  45.       if( ! ischarnode(q) ) {
  46.     /* 1382. Adjust the LR stack.... */
  47.     if( ztype(q) == mathnode ) {
  48.       if( end_LR(q) ) {
  49.         if( LR_ptr != 0 )
  50.           if( info(LR_ptr) == subtype(q) )
  51.         pop_LR;
  52.       } else {
  53.         push_LR(q);
  54.       }
  55.     }
  56.       }
  57.       q = link(q);
  58.     }
  59. #endif
  60.  
  61.     /* Modify the end of the line ... 881. */
  62.     q = curbreak ( curp ) ; 
  63.     discbreak = false ; 
  64.     postdiscbreak = false ; 
  65.  
  66.     if ( q != 0 ) 
  67.     if ( ztype ( q ) == gluenode ) {
  68.       deleteglueref ( glueptr ( q ) ) ; 
  69.       glueptr ( q ) = rightskip ; 
  70.       subtype ( q ) = rightskipcode + 1 ; 
  71.       addglueref ( rightskip ) ; 
  72.       goto lab30 ; 
  73.     } else {
  74.       if ( ztype ( q ) == discnode ) {
  75.     register quarterword t;
  76.  
  77.     t = replacecount( q );
  78.     if ( t == 0 )
  79.       r = link ( q ) ; 
  80.     else {
  81.       r = q ; 
  82.       while ( t > 1 ) {
  83.         r = link ( r ) ; 
  84.         decr ( t ) ; 
  85.       } 
  86.           { register halfword s;
  87.  
  88.       s = link ( r ) ; 
  89. #if 0                    /* TeX 3.1->3.14 Update */
  90.       if ( ! ischarnode ( s ) ) 
  91.       if ( prevbreak ( curp ) != 0 ) 
  92.       if ( curbreak ( prevbreak ( curp ) ) == s ) 
  93.         s = r ;
  94. #endif
  95.       r = link ( s ) ; 
  96.       link ( s ) = 0 ; 
  97.           }
  98.       flushnodelist ( link ( q ) ) ; 
  99.       replacecount ( q ) = 0 ; 
  100.     }
  101.     if ( postbreak ( q ) != 0 ) {
  102.           register halfword s;
  103.  
  104.       s = postbreak ( q ) ; 
  105.       while ( link ( s ) != 0 )
  106.         s = link ( s ) ; 
  107.       link ( s ) = r ; 
  108.       r = postbreak ( q ) ; 
  109.       postbreak ( q ) = 0 ; 
  110.       postdiscbreak = true ; 
  111.     } 
  112.     if ( prebreak ( q ) != 0 ) {
  113.           register halfword s;
  114.  
  115.       s = prebreak ( q ) ; 
  116.       link ( q ) = s ; 
  117.       while ( link ( s ) != 0 )
  118.         s = link ( s ) ; 
  119.       prebreak ( q ) = 0 ; 
  120.       q = s ; 
  121.     } 
  122.     link ( q ) = r ; 
  123.     discbreak = true ; 
  124.       } else if ( ( ztype(q) == mathnode ) || ( ztype(q) == kernnode ) ) {
  125.     width ( q ) = 0 ;
  126. #ifdef TEXXET
  127.     if( ztype(q) == mathnode ) {
  128.       if( end_LR(q) ) {
  129.         if( LR_ptr != 0 )
  130.           if( info(LR_ptr) == subtype(q) )
  131.         pop_LR;
  132.       } else {
  133.         push_LR(q);
  134.       }
  135.     }
  136. #endif
  137.       }
  138.     }
  139.     else {
  140.       q = temphead ; 
  141.       while ( link ( q ) != 0 )
  142.     q = link ( q ) ; 
  143.     } 
  144.     r = newparamglue ( rightskipcode ) ; 
  145.     link ( r ) = link ( q ) ; 
  146.     link ( q ) = r ; 
  147.     q = r ; 
  148. lab30:        /* done: */
  149.  
  150. #ifdef TEXXET
  151.     /* 1383. Insert LR nodes ... */
  152.     if( LR_ptr != 0 ) {
  153.       register halfword s;
  154.  
  155.       s = temphead;  r = link(s);
  156.       while( r != q ) {
  157.     s = r;  r = link(s);
  158.       }
  159.       r = LR_ptr;
  160.       while( r != 0 ) {
  161.     tempptr = newmath(0, info(r));
  162.     link(s) = tempptr;
  163.     s = tempptr;
  164.     r = link(r);
  165.       }
  166.       link(s) = q;
  167.     }
  168. #endif
  169.  
  170.     /* Put the \leftskip glue ... 887. */
  171.     r = link ( q ) ; 
  172.     link ( q ) = 0 ; 
  173.     q = link ( temphead ) ; 
  174.     link ( temphead ) = r ; 
  175.     if ( leftskip != zeroglue ) {
  176.       r = newparamglue ( leftskipcode ) ; 
  177.       link ( r ) = q ; 
  178.       q = r ; 
  179.     }
  180.  
  181.     /* Call the packaging subroutine... 889. */
  182.     { register scaled curindent, curwidth;
  183.  
  184.       if ( curline > lastspecialline ) {
  185.     curwidth = secondwidth ; 
  186.     curindent = secondindent ; 
  187.       } else if ( parshapeptr == 0 ) {
  188.     curwidth = firstwidth ; 
  189.     curindent = firstindent ; 
  190.       } else {
  191.     curwidth = mem [ parshapeptr + 2 * curline ] .cint ; 
  192.     curindent = mem [ parshapeptr + 2 * curline - 1 ] .cint ; 
  193.       }
  194.       adjusttail = adjusthead ; 
  195.       justbox = hpack ( q , curwidth , 0 ) ; 
  196.       shiftamount ( justbox ) = curindent ;
  197.     }
  198.  
  199.     /* Append the new box to the current vertical list ... 888. */
  200.     appendtovlist ( justbox ) ; 
  201.     if ( adjusthead != adjusttail ) {
  202.       link ( curlist .tailfield ) = link ( adjusthead ) ; 
  203.       curlist .tailfield = adjusttail ; 
  204.     } 
  205.     adjusttail = 0 ;
  206.  
  207.     /* Append a penalty node.. 890. */
  208.     if ( curline + 1 != bestline ) {
  209.       register integer pen;
  210.  
  211.       pen = interlinepenalty ; 
  212.       if ( curline == curlist .pgfield + 1 ) 
  213.     pen = pen + clubpenalty ; 
  214.       if ( curline + 2 == bestline ) 
  215.     pen = pen + finalwidowpenalty ; 
  216.       if ( discbreak ) 
  217.     pen = pen + brokenpenalty ; 
  218.       if ( pen != 0 ) {
  219.     r = newpenalty ( pen ) ; 
  220.     link ( curlist .tailfield ) = r ; 
  221.     curlist .tailfield = r ; 
  222.       } 
  223.     } 
  224.  
  225.  
  226.     incr ( curline ) ; 
  227.     curp = prevbreak ( curp ) ; 
  228.     if ( curp != 0 ) 
  229.     if ( ! postdiscbreak ) {
  230.       /* 879. Prune unwanted ... */
  231.       r = temphead ; 
  232.       while ( true ) {
  233.     q = link ( r ) ; 
  234.     if ( q == curbreak ( curp ) ) 
  235.       goto lab31 ; 
  236.     if ( ischarnode ( q ) ) 
  237.       goto lab31 ; 
  238.     if ( nondiscardable ( q ) ) 
  239.       goto lab31 ; 
  240. #if 0  /* 3.1415 */
  241.     if ( subtype ( q ) == acckern ) 
  242.     if ( ztype ( q ) == kernnode ) 
  243.       goto lab31 ; 
  244. #else
  245.     if ( ztype ( q ) == kernnode )
  246.       if ( subtype ( q ) != explicit )
  247.         goto lab31 ; 
  248. #endif
  249.     r = q;
  250. #ifdef TEXXET
  251.     if( ztype(q) == mathnode ) {
  252.       if( end_LR(q) ) {
  253.         if( LR_ptr != 0 )
  254.           if( info(LR_ptr) == subtype(q) )
  255.         pop_LR;
  256.       } else {
  257.         push_LR(q);
  258.       }
  259.     }
  260. #endif
  261.       } 
  262. lab31:
  263.       if ( r != temphead ) {
  264.     link ( r ) = 0 ; 
  265.     flushnodelist ( link ( temphead ) ) ; 
  266.     link ( temphead ) = q ; 
  267.       }
  268.     }
  269.   } while ( curp != 0 );
  270.  
  271.   if ( ( curline != bestline ) || ( link ( temphead ) != 0 ) ) 
  272.     confusion("line breaking");
  273.   curlist .pgfield = bestline - 1 ;
  274.  
  275. #ifdef TEXXET
  276.   LR_save = LR_ptr;
  277. #endif
  278. }
  279.  
  280.  
  281.   smallnumber
  282. reconstitute ( smallnumber j, smallnumber n, halfword bchar, halfword hchar )
  283. { reconstitute_regmem 
  284.   register halfword p  ; 
  285.   register halfword t  ; 
  286.   fourquarters q  ; 
  287.   register halfword currh  ; 
  288.   register halfword testchar  ; 
  289.   register scaled w  ; 
  290. #ifdef FONTPTR
  291.   SMALLmemoryword *ligp;    /* (br) ptr in lig/kern program */
  292. #else
  293.   fontindex k  ; 
  294. #endif
  295.   register halfword ligstack, curl, curr, curq;
  296.  
  297.   hyphenpassed = 0 ; 
  298.   t = holdhead ; 
  299.   w = 0 ; 
  300.   link ( holdhead ) = 0 ; 
  301.   curl = hu [ j ] ; 
  302.   curq = t ; 
  303.   if ( j == 0 ) {
  304.     ligaturepresent = initlig ; 
  305.     p = initlist ; 
  306.     if ( ligaturepresent ) 
  307.       lfthit = initlft ; 
  308.     while ( p > 0 ) {
  309.       {
  310.     link ( t ) = getavail () ; 
  311.     t = link ( t ) ; 
  312.     font ( t ) = hf ; 
  313.     character ( t ) = character ( p ) ; 
  314.       } 
  315.       p = link ( p ) ; 
  316.     } 
  317.   } else if ( curl < nonchar ) {
  318.     link ( t ) = getavail () ; 
  319.     t = link ( t ) ; 
  320.     font ( t ) = hf ; 
  321.     character ( t ) = curl ; 
  322.   } 
  323.   ligstack = 0 ; 
  324.   {
  325.     if ( j < n )
  326.       curr = hu [ j + 1 ] ; 
  327.     else curr = bchar ; 
  328.     if ( odd ( hyf [ j ] ) ) 
  329.       currh = hchar ; 
  330.     else currh = nonchar ; 
  331.   }
  332.  
  333. lab22:
  334.   if ( curl == nonchar ) {
  335. #ifdef FONTPTR
  336.     if( bcharlabel(hf) == nonaddress )
  337.     goto lab30;
  338.     ligp = &fontinfo[bcharlabel(hf)];
  339.     q = ligp->qqqq;
  340. #else
  341.     k = bcharlabel(hf); 
  342.     if ( k == nonaddress ) 
  343.       goto lab30 ; 
  344.     else
  345.       q = fontinfo [ k ] .qqqq ; 
  346. #endif
  347.   } else {
  348.     q = zcharinfo ( hf ,  curl ) ; 
  349.     if ( chartag ( q ) != ligtag ) 
  350.       goto lab30 ; 
  351. #ifdef FONTPTR
  352.     ligp = zligkernstart ( hf ,  q ) ; 
  353.     q = ligp->qqqq ; 
  354.     if ( skipbyte ( q ) > stopflag ) {
  355.       ligp = zligkernrestart ( hf ,  q ) ; 
  356.       q = ligp->qqqq ; 
  357.     }
  358. #else
  359.     k = zligkernstart ( hf ,  q ) ; 
  360.     q = fontinfo [ k ] .qqqq ; 
  361.     if ( skipbyte ( q ) > stopflag ) {
  362.       k = zligkernrestart ( hf ,  q ) ; 
  363.       q = fontinfo [ k ] .qqqq ; 
  364.     }
  365. #endif
  366.   }
  367.   if ( currh < nonchar ) 
  368.     testchar = currh ; 
  369.   else
  370.     testchar = curr ;
  371.  
  372.   while ( true ) {
  373.     if ( nextchar ( q ) == testchar ) 
  374.     if ( skipbyte ( q ) <= stopflag ) 
  375.     if ( currh < nonchar ) {
  376.       hyphenpassed = j ; 
  377.       hchar = nonchar ; 
  378.       currh = nonchar ; 
  379.       goto lab22 ; 
  380.     } else {
  381.       if ( hchar < nonchar ) 
  382.       if ( odd ( hyf [ j ] ) ) {
  383.     hyphenpassed = j ; 
  384.     hchar = nonchar ; 
  385.       } 
  386.       if ( opbyte ( q ) < kernflag ) {
  387.     if ( curl == nonchar ) 
  388.     lfthit = true ; 
  389.     if ( j == n ) 
  390.     if ( ligstack == 0 ) 
  391.     rthit = true ; 
  392.     {
  393.       if ( interrupt != 0 ) 
  394.       pauseforinstructions () ; 
  395.     } 
  396.     switch ( opbyte ( q ) ) 
  397.     {case 1 : 
  398.     case 5 : 
  399.       {
  400.         curl = rembyte ( q ) ; 
  401.         ligaturepresent = true ; 
  402.       } 
  403.       break ; 
  404.     case 2 : 
  405.     case 6 : 
  406.       {
  407.         curr = rembyte ( q ) ; 
  408.         if ( ligstack > 0 ) 
  409.           character ( ligstack ) = curr ; 
  410.         else {
  411.           ligstack = newligitem ( curr ) ; 
  412.           if ( j == n ) 
  413.         bchar = nonchar ; 
  414.           else {
  415.         p = getavail () ; 
  416.         ligptr ( ligstack ) = p ; 
  417.         character ( p ) = hu [ j + 1 ] ; 
  418.         font ( p ) = hf ; 
  419.           } 
  420.         } 
  421.       } 
  422.       break ; 
  423.     case 3 : 
  424.       {
  425.         curr = rembyte ( q ) ; 
  426.         p = ligstack ; 
  427.         ligstack = newligitem ( curr ) ; 
  428.         link ( ligstack ) = p ; 
  429.       } 
  430.       break ; 
  431.     case 7 : 
  432.     case 11 : 
  433.       {
  434.         if ( ligaturepresent ) {
  435.           p = newligature ( hf , curl , link ( curq ) ) ; 
  436.           if ( lfthit ) {
  437.         subtype ( p ) = 2 ; 
  438.         lfthit = false ; 
  439.           } 
  440.           if ( false ) 
  441.           if ( ligstack == 0 ) {
  442.         incr ( subtype ( p ) ) ; 
  443.         rthit = false ; 
  444.           } 
  445.           link ( curq ) = p ; 
  446.           t = p ; 
  447.           ligaturepresent = false ; 
  448.         } 
  449.         curq = t ; 
  450.         curl = rembyte ( q ) ; 
  451.         ligaturepresent = true ; 
  452.       } 
  453.       break ; 
  454.     default: 
  455.       {
  456.         curl = rembyte ( q ) ; 
  457.         ligaturepresent = true ; 
  458.         if ( ligstack > 0 ) {
  459.           if ( ligptr ( ligstack ) > 0 ) {
  460.         link ( t ) = ligptr ( ligstack ) ; 
  461.         t = link ( t ) ; 
  462.         incr ( j ) ; 
  463.           } 
  464.           p = ligstack ; 
  465.           ligstack = link ( p ) ; 
  466.           freenode ( p , smallnodesize ) ; 
  467.           if ( ligstack == 0 ) {
  468.         if ( j < n ) 
  469.         curr = hu [ j + 1 ] ; 
  470.         else curr = bchar ; 
  471.         if ( odd ( hyf [ j ] ) ) 
  472.         currh = hchar ; 
  473.         else currh = nonchar ; 
  474.           } 
  475.           else curr = character ( ligstack ) ; 
  476.         } 
  477.         else if ( j == n ) 
  478.           goto lab30 ; 
  479.         else {
  480.           {
  481.         link ( t ) = getavail () ; 
  482.         t = link ( t ) ; 
  483.         font ( t ) = hf ; 
  484.         character ( t ) = curr ; 
  485.           } 
  486.           incr ( j ) ; 
  487.           {
  488.         if ( j < n ) 
  489.         curr = hu [ j + 1 ] ; 
  490.         else curr = bchar ; 
  491.         if ( odd ( hyf [ j ] ) ) 
  492.         currh = hchar ; 
  493.         else currh = nonchar ; 
  494.           } 
  495.         } 
  496.       } 
  497.       break ; 
  498.     } 
  499.     if ( opbyte ( q ) > 4 ) 
  500.     if ( opbyte ( q ) != 7 ) 
  501.     goto lab30 ; 
  502.     goto lab22 ; 
  503.       } 
  504.       w = zcharkern ( hf ,  q ) ; 
  505.       goto lab30 ; 
  506.     } 
  507.     if ( skipbyte ( q ) >= stopflag ) 
  508.     if ( currh == nonchar ) 
  509.       goto lab30 ; 
  510.     else {
  511.       currh = nonchar ; 
  512.       goto lab22 ; 
  513.     }
  514. #ifdef FONTPTR
  515.     ligp = ligp + skipbyte ( q ) + 1 ; 
  516.     q = ligp->qqqq ; 
  517. #else
  518.     k = k + skipbyte ( q ) + 1 ; 
  519.     q = fontinfo [ k ] .qqqq ;
  520. #endif
  521.   }
  522.  
  523. lab30:
  524.   if ( ligaturepresent ) {
  525.     p = newligature ( hf , curl , link ( curq ) ) ; 
  526.     if ( lfthit ) {
  527.       subtype ( p ) = 2 ; 
  528.       lfthit = false ; 
  529.     } 
  530.     if ( rthit ) 
  531.     if ( ligstack == 0 ) {
  532.       incr ( subtype ( p ) ) ; 
  533.       rthit = false ; 
  534.     } 
  535.     link ( curq ) = p ; 
  536.     t = p ; 
  537.     ligaturepresent = false ; 
  538.   } 
  539.   if ( w != 0 ) {
  540.     link ( t ) = newkern ( w ) ; 
  541.     t = link ( t ) ; 
  542.     w = 0 ; 
  543.   } 
  544.   if ( ligstack > 0 ) {
  545.     curq = t ; 
  546.     curl = character ( ligstack ) ; 
  547.     ligaturepresent = true ; 
  548.     {
  549.       if ( ligptr ( ligstack ) > 0 ) {
  550.     link ( t ) = ligptr ( ligstack ) ; 
  551.     t = link ( t ) ; 
  552.     incr ( j ) ; 
  553.       } 
  554.       p = ligstack ; 
  555.       ligstack = link ( p ) ; 
  556.       freenode ( p , smallnodesize ) ; 
  557.       if ( ligstack == 0 ) {
  558.     if ( j < n ) 
  559.     curr = hu [ j + 1 ] ; 
  560.     else curr = bchar ; 
  561.     if ( odd ( hyf [ j ] ) ) 
  562.     currh = hchar ; 
  563.     else currh = nonchar ; 
  564.       } 
  565.       else curr = character ( ligstack ) ; 
  566.     } 
  567.     goto lab22 ; 
  568.   }
  569.   return(j);
  570. }
  571.  
  572.  
  573. void hyphenate ( void )
  574. {/* 50 30 40 41 42 45 10 */ hyphenate_regmem 
  575.   register schar i, j, l  ; 
  576.   register halfword q, r, s  ; 
  577.   register halfword bchar;
  578.   register halfword majortail, minortail  ; 
  579.   register ASCIIcode c  ; 
  580.   register schar cloc  ; 
  581.   register integer rcount  ; 
  582.   register halfword hyfnode  ; 
  583.   register hyphpointer h  ; 
  584.  
  585.   for( j = hn ; j >= 0 ; --j ) {
  586.     hyf [ j ] = 0 ; 
  587.   }
  588.   h = hc [ 1 ] ; 
  589.   incr ( hn ) ; 
  590.   hc [ hn ] = curlang ; 
  591.   {register integer for_end; j = 2 ; for_end = hn ; if ( j <= for_end) do 
  592.     h = ( h + h + hc [ j ] ) % hyphsize ; 
  593.   while ( j++ < for_end ) ; } 
  594.  
  595.   while ( true ) {
  596.     register strnumber k;
  597.  
  598.     k = hyphword(h) ; 
  599.     if ( k == 0 ) 
  600.       goto lab45 ; 
  601.     if ( length ( k ) < hn ) 
  602.       goto lab45 ; 
  603.     if ( length ( k ) == hn ) {
  604.       register poolpointer u;
  605.  
  606.       j = 1 ; 
  607.       u = strstart [ k ] ; 
  608.       do {
  609.     if ( strpool [ u ] < hc [ j ] )
  610.       goto lab45 ; 
  611.     if ( strpool [ u ] > hc [ j ] )
  612.       goto lab30 ; 
  613.     incr ( j ); incr ( u );
  614.       } while ( j <= hn );
  615.       s = hyphlist(h); 
  616.       while ( s != 0 ) {
  617.     hyf [ info ( s ) ] = 1 ; 
  618.     s = link ( s ) ; 
  619.       } 
  620.       decr ( hn );
  621.       goto lab40;
  622.     } 
  623. lab30:
  624.     if ( h > 0 ) 
  625.       decr ( h ) ; 
  626.     else h = hyphsize ; 
  627.   }
  628. lab45: decr ( hn ) ; 
  629.   if ( trietrc [ curlang + 1 ] != curlang ) 
  630.     return ;
  631.  
  632.   hc [ 0 ] = 0 ; 
  633.   hc [ hn + 1 ] = 0 ; 
  634.   hc [ hn + 2 ] = 256 ; 
  635.  
  636.   { register SMALLhalfword r_opstart = opstart[curlang];
  637.  
  638.   {register integer for_end; j = 0 ; for_end = hn - rhyf + 1 ; if ( j <= 
  639.   for_end) do 
  640.     {
  641.       register triepointer z;
  642.  
  643.       z = trietrl [ curlang + 1 ] + hc [ j ] ; 
  644.       l = j ; 
  645.       while ( hc [ l ] == trietrc [ z ] ) {
  646.     if ( trietro [ z ] != mintrieop ) {
  647.       register integer v;
  648.  
  649.       v = trietro [ z ] ;
  650.       do {
  651.         v = v + r_opstart;        /* opstart [ curlang ] ; */
  652.         i = l - hyfdistance(v);
  653.         if ( hyfnum(v) > hyf [ i ] ) 
  654.           hyf [ i ] = hyfnum(v);
  655.         v = hyfnext(v);
  656.       } while ( v != mintrieop );
  657.     }
  658.     incr ( l ) ; 
  659.     z = trietrl [ z ] + hc [ l ] ; 
  660.       }
  661.     } 
  662.   while ( j++ < for_end ) ; }
  663.   }
  664.  
  665. lab40: {
  666.       register integer for_end; j = 0 ; for_end = lhyf - 1 ; if ( j <= 
  667.   for_end) do 
  668.     hyf [ j ] = 0 ; 
  669.   while ( j++ < for_end ) ; } 
  670.   {register integer for_end; j = 0 ; for_end = rhyf - 1 ; if ( j <= for_end) 
  671.   do 
  672.     hyf [ hn - j ] = 0 ; 
  673.   while ( j++ < for_end ) ; } 
  674.   {register integer for_end; j = lhyf ; for_end = hn - rhyf ; if ( j <= 
  675.   for_end) do 
  676.     if ( odd ( hyf [ j ] ) ) 
  677.     goto lab41 ; 
  678.   while ( j++ < for_end ) ; } 
  679.   return ; 
  680.  
  681. lab41: ;
  682.   /* 903.  Replace nodes ha..hb by a sequence of nodes ... */
  683.   q = link ( hb );  link ( hb ) = 0;  r = link ( ha );  link ( ha ) = 0;
  684.   bchar = hyf_bchar;  /* bchar = nonchar; */  /* TeX 3.141 */
  685. #if 0  /* TeX 3.141 */
  686.   if ( ! ischarnode ( hb ) ) 
  687.     if ( ztype ( hb ) == ligaturenode ) 
  688.       if ( odd ( subtype ( hb ) ) ) 
  689.     bchar = fontbchar(hf); 
  690. #endif
  691.   if ( ischarnode ( ha ) ) 
  692.     if ( font ( ha ) != hf ) 
  693.       goto lab42 ; 
  694.     else {
  695.       initlist = ha ; 
  696.       initlig = false ; 
  697.       hu [ 0 ] = character ( ha ) ; 
  698.     } 
  699.   else if ( ztype ( ha ) == ligaturenode ) 
  700.   if ( font ( ligchar ( ha ) ) != hf ) 
  701.     goto lab42 ; 
  702.   else {
  703.     initlist = ligptr ( ha ) ; 
  704.     initlig = true ; 
  705.     initlft = ( subtype ( ha ) > 1 ) ; 
  706.     hu [ 0 ] = character ( ligchar ( ha ) ) ; 
  707.     if ( initlist == 0 ) 
  708.     if ( initlft ) {
  709.       hu [ 0 ] = 256 ; 
  710.       initlig = false ; 
  711.     }
  712.     freenode ( ha , smallnodesize ) ; 
  713.   }
  714.   else {
  715.     if ( ! ischarnode ( r ) ) 
  716.     if ( ztype ( r ) == ligaturenode ) 
  717.     if ( subtype ( r ) > 1 ) 
  718.       goto lab42 ; 
  719.     j = 1 ; 
  720.     s = ha ; 
  721.     initlist = 0 ; 
  722.     goto lab50 ; 
  723.   } 
  724.   s = curp ; 
  725.   while ( link ( s ) != ha )
  726.     s = link ( s ) ; 
  727.   j = 0 ; 
  728.   goto lab50 ; 
  729.  
  730. lab42:
  731.   s = ha ; 
  732.   j = 0 ; 
  733.   hu [ 0 ] = 256 ; 
  734.   initlig = false ; 
  735.   initlist = 0 ; 
  736.  
  737. lab50:
  738.   flushnodelist ( r ) ; 
  739.   do {
  740.     l = j ; 
  741.     j = reconstitute ( j , hn , bchar , hyfchar ) + 1 ; 
  742.     if ( hyphenpassed == 0 ) {
  743.       link ( s ) = link ( holdhead ) ; 
  744.       while ( link ( s ) > 0 )
  745.     s = link ( s ) ; 
  746.       if ( odd ( hyf [ j - 1 ] ) ) {
  747.     l = j ; 
  748.     hyphenpassed = j - 1 ; 
  749.     link ( holdhead ) = 0 ; 
  750.       } 
  751.     } 
  752.     if ( hyphenpassed > 0 ) 
  753.     do {
  754.       r = getnode ( smallnodesize ) ; 
  755.       link ( r ) = link ( holdhead ) ; 
  756.       ztype ( r ) = discnode ; 
  757.       majortail = r ; 
  758.       rcount = 0 ; 
  759.       while ( link ( majortail ) > 0 ) {
  760.     majortail = link ( majortail ) ; 
  761.     incr ( rcount ) ; 
  762.       } 
  763.       i = hyphenpassed ; 
  764.       hyf [ i ] = 0 ; 
  765.       minortail = 0 ; 
  766.       prebreak ( r ) = 0 ; 
  767.       hyfnode = newcharacter ( hf , hyfchar ) ; 
  768.       if ( hyfnode != 0 ) {
  769.     incr ( i ) ; 
  770.     c = hu [ i ] ; 
  771.     hu [ i ] = hyfchar ; 
  772.     freeavail ( hyfnode ) ; 
  773.       } 
  774.       while ( l <= i ) {
  775.     l = reconstitute ( l , i , fontbchar(hf), nonchar ) + 1 ; 
  776.     if ( link ( holdhead ) > 0 ) {
  777.       if ( minortail == 0 ) 
  778.       prebreak ( r ) = link ( holdhead ) ; 
  779.       else link ( minortail ) = link ( holdhead ) ; 
  780.       minortail = link ( holdhead ) ; 
  781.       while ( link ( minortail ) > 0 ) minortail = link ( minortail ) ; 
  782.     } 
  783.       } 
  784.       if ( hyfnode != 0 ) {
  785.     hu [ i ] = c ; 
  786.     l = i ; 
  787.     decr ( i ) ; 
  788.       } 
  789.       minortail = 0 ; 
  790.       postbreak ( r ) = 0 ; 
  791.       cloc = 0 ; 
  792.       if ( bcharlabel(hf) < nonaddress ) {
  793.     decr ( l ) ; 
  794.     c = hu [ l ] ; 
  795.     cloc = l ; 
  796.     hu [ l ] = 256 ; 
  797.       } 
  798.       while ( l < j ) {
  799.     do {
  800.       l = reconstitute ( l , hn , bchar , nonchar ) + 1 ; 
  801.       if ( cloc > 0 ) {
  802.         hu [ cloc ] = c ; 
  803.         cloc = 0 ; 
  804.       } 
  805.       if ( link ( holdhead ) > 0 ) {
  806.         if ( minortail == 0 ) 
  807.         postbreak ( r ) = link ( holdhead ) ; 
  808.         else link ( minortail ) = link ( holdhead ) ; 
  809.         minortail = link ( holdhead ) ; 
  810.         while ( link ( minortail ) > 0 ) minortail = link ( minortail ) ; 
  811.       } 
  812.     } while ( ! ( l >= j ) ) ; 
  813.     while ( l > j ) {        
  814.       j = reconstitute ( j , hn , bchar , nonchar ) + 1 ; 
  815.       link ( majortail ) = link ( holdhead ) ; 
  816.       while ( link ( majortail ) > 0 ) {
  817.         majortail = link ( majortail ) ; 
  818.         incr ( rcount ) ; 
  819.       } 
  820.     } 
  821.       }
  822.       if ( rcount > 127 ) {
  823.     link ( s ) = link ( r ) ; 
  824.     link ( r ) = 0 ; 
  825.     flushnodelist ( r ) ; 
  826.       } else {
  827.     link ( s ) = r ; 
  828.     replacecount ( r ) = rcount ; 
  829.       } 
  830.       s = majortail ; 
  831.       hyphenpassed = j - 1 ; 
  832.       link ( holdhead ) = 0 ; 
  833.     } while ( ! ( ! odd ( hyf [ j - 1 ] ) ) ) ; 
  834.   } while ( ! ( j > hn ) ) ; 
  835.   link ( s ) = q ; 
  836.   flushlist ( initlist ) ; 
  837. }
  838.  
  839.  
  840. void newhyphexceptions ( void )
  841. {/* 21 10 40 45 */ newhyphexceptions_regmem 
  842.   register short n  ; 
  843.   register short j  ; 
  844.   register hyphpointer h  ; 
  845.   register strnumber k  ; 
  846.   register halfword p  ; 
  847.   /* register halfword q; */
  848.   register strnumber s;
  849.   /* register poolpointer u, v; */
  850.  
  851.   scanleftbrace () ; 
  852.   if ( language <= 0 || language > 255 )
  853.     curlang = 0 ; 
  854.   else
  855.     curlang = language ; 
  856.   n = 0 ; 
  857.   p = 0 ; 
  858.  
  859.   while ( true ) {
  860.     getxtoken () ; 
  861. lab21:
  862.     switch ( curcmd ) {
  863.     case 16 : 
  864.     curchr = scancharnum ();    /* curchr = curval; */
  865.     curcmd = 68 ; 
  866.     /* goto lab21 ; */
  867.     /* FALL THROUGH */
  868.     case 11 : 
  869.     case 12 : 
  870.     case 68 : 
  871.       if ( curchr == 45 ) {
  872.     if ( n < 63 ) {
  873.       register long_halfword q;
  874.  
  875.       q = getavail ();
  876.       link ( q ) = p;
  877.       info ( q ) = n;
  878.       p = q;
  879.     }
  880.       } else {
  881.     if ( lccode ( curchr ) == 0 ) {
  882.       print_err("Not a letter");
  883.       zhelp1( STR_H_LETTERSINHYPH );
  884.       error () ; 
  885.     } else if ( n < 63 ) {
  886.       incr ( n ) ; 
  887.       hc [ n ] = lccode ( curchr ) ; 
  888.     } 
  889.       } 
  890.       break ; 
  891.     case 10 : 
  892.     case 2 : 
  893.       if ( n > 1 ) {
  894.     incr ( n ) ; 
  895.     hc [ n ] = curlang ; 
  896.     strroom ( n ) ; 
  897.     h = 0 ; 
  898.     for( j = 1 ; j <=n ; j++ ) {
  899.       h = ( h + h + hc [ j ] ) % hyphsize ; 
  900.       appendchar ( hc [ j ] ) ; 
  901.     }
  902.     s = makestring () ; 
  903.  
  904.     if ( hyphcount == hyphsize ) 
  905.       overflow(12, hyphsize);
  906.     incr ( hyphcount ) ; 
  907.  
  908.     while ( hyphword(h) != 0 ) {
  909.       k = hyphword(h); 
  910.       if ( length ( k ) < length ( s ) ) 
  911.         goto lab40 ; 
  912.       if ( length ( k ) > length ( s ) ) 
  913.         goto lab45 ; 
  914. #if 0
  915.       { register poolpointer u, v;
  916.         u = strstart [ k ]; v = strstart [ s ];
  917.         do {
  918.           if ( strpool [ u ] < strpool [ v ] ) 
  919.             goto lab40 ; 
  920.           if ( strpool [ u ] > strpool [ v ] ) 
  921.             goto lab45 ; 
  922.           incr ( u ); incr ( v );
  923.         } while ( u != strstart [ k + 1 ] );
  924.       }
  925. #else
  926.       { register ASCIIcode *u, *v, *ep;
  927.         u = &strpool[strstart [ k ]]; ep = &strpool[strstart[k+1]];
  928.         v = &strpool[strstart [ s ]];
  929.         do {
  930.           if ( *u < *v ) 
  931.             goto lab40 ; 
  932.           if ( *u > *v ) 
  933.             goto lab45 ; 
  934.           incr(u); incr(v);
  935.         } while ( u != ep );
  936.       }
  937. #endif
  938. lab40:
  939.       { register halfword q;
  940.  
  941.         q = hyphlist(h); hyphlist(h) = p; p = q;
  942.       }
  943.       { register strnumber t;
  944.  
  945.         t = hyphword(h); hyphword(h) = s; s = t;
  946.       }
  947. lab45:
  948.       if ( h > 0 )
  949.         decr ( h );
  950.       else
  951.         h = hyphsize ; 
  952.     }
  953.     hyphword(h) = s ; 
  954.     hyphlist(h) = p ; 
  955.       }
  956.       if ( curcmd == 2 ) 
  957.     return;
  958.       n = 0;
  959.       p = 0;
  960.       break ; 
  961.     default: 
  962.       {
  963.     p_print_err( STR_H_IMPROPER );
  964.     printesc( STR_HYPHENATION );
  965.     c_print(" will be flushed");
  966.     zhelp1( STR_H_HYPH_EXC_ONLY );
  967.     error () ; 
  968.       } 
  969.       break ; 
  970.     }
  971.   }
  972. }
  973.  
  974.  
  975. halfword prunepagetop ( halfword p )
  976. { prunepagetop_regmem 
  977.   register halfword prevp  ; 
  978.   register halfword q  ; 
  979.  
  980.   prevp = temphead ; 
  981.   link ( temphead ) = p ; 
  982.  
  983.  while ( p != 0 )
  984.   switch ( ztype ( p ) ) {
  985.   case hlistnode : 
  986.   case vlistnode : 
  987.   case rulenode : 
  988.     {
  989.       q = newskipparam ( splittopskipcode ) ; 
  990.       link ( prevp ) = q ; 
  991.       link ( q ) = p ; 
  992.       if ( width ( tempptr ) > height ( p ) ) 
  993.     width ( tempptr ) = width ( tempptr ) - height ( p ) ; 
  994.       else
  995.     width ( tempptr ) = 0 ; 
  996.       p = 0 ; 
  997.     } 
  998.     break ; 
  999.   case whatsitnode : 
  1000.   case marknode : 
  1001.   case insnode : 
  1002.     {
  1003.       prevp = p ; 
  1004.       p = link ( prevp ) ; 
  1005.     } 
  1006.     break ; 
  1007.   case gluenode : 
  1008.   case kernnode : 
  1009.   case penaltynode : 
  1010.     {
  1011.       q = p ; 
  1012.       p = link ( q ) ; 
  1013.       link ( q ) = 0 ; 
  1014.       link ( prevp ) = p ; 
  1015.       flushnodelist ( q ) ; 
  1016.     } 
  1017.     break ; 
  1018.   default: 
  1019.     confusion("pruning");
  1020.     break ; 
  1021.   }
  1022.   return( link ( temphead ) );
  1023. } 
  1024.  
  1025.  
  1026. halfword vertbreak ( halfword p, scaled h, scaled d )
  1027. {/* 30 45 90 */ vertbreak_regmem 
  1028.   register halfword prevp  ; 
  1029.   register halfword q, r  ; 
  1030.   register integer pi  ; 
  1031.   register integer b  ; 
  1032.   register integer leastcost  ; 
  1033.   register halfword bestplace  ; 
  1034.   register scaled prevdp  ; 
  1035.   register smallnumber t  ; 
  1036.  
  1037.   prevp = p ; 
  1038.   leastcost = awfulbad ; 
  1039.   activewidth [ 0 ] = 0 ; 
  1040.   activewidth [ 1 ] = 0 ; 
  1041.   activewidth [ 2 ] = 0 ; 
  1042.   activewidth [ 3 ] = 0 ; 
  1043.   activewidth [ 4 ] = 0 ; 
  1044.   activewidth [ 5 ] = 0 ; 
  1045.   prevdp = 0 ; 
  1046.  
  1047.   while ( true ) {
  1048.     if ( p == 0 ) 
  1049.       pi = ejectpenalty ; 
  1050.     else switch ( ztype ( p ) ) 
  1051.     {case hlistnode : 
  1052.     case vlistnode : 
  1053.     case rulenode : 
  1054.       {
  1055.     activewidth [ 0 ] += prevdp + height ( p ) ; 
  1056.     prevdp = depth ( p ) ; 
  1057.     goto lab45 ; 
  1058.       } 
  1059.       break ; 
  1060.     case whatsitnode : 
  1061.       goto lab45 ; 
  1062.       break ; 
  1063.     case gluenode : 
  1064.       if ( precedesbreak ( prevp ) ) 
  1065.     pi = 0 ;
  1066.       else
  1067.     goto lab90 ; 
  1068.       break ; 
  1069.     case kernnode : 
  1070.       {
  1071.     if ( link ( p ) == 0 ) 
  1072.       t = penaltynode ; 
  1073.     else
  1074.       t = ztype ( link ( p ) ) ; 
  1075.     if ( t == gluenode ) 
  1076.       pi = 0 ; 
  1077.     else
  1078.       goto lab90 ; 
  1079.       } 
  1080.       break ; 
  1081.     case penaltynode : 
  1082.       pi = mem [ p + 1 ] .cint ; 
  1083.       break ; 
  1084.     case marknode : 
  1085.     case insnode : 
  1086.       goto lab45 ; 
  1087.       break ; 
  1088.     default: 
  1089.       confusion("vertbreak");
  1090.       break ; 
  1091.     } 
  1092.     if ( pi < infpenalty ) {
  1093.       if ( activewidth [ 0 ] < h ) 
  1094.       if ( ( activewidth [ 2 ] != 0 ) || ( activewidth [ 3 ] != 0 ) || ( 
  1095.       activewidth [ 4 ] != 0 ) ) 
  1096.       b = 0 ; 
  1097.       else b = badness ( h - activewidth [ 0 ] , activewidth [ 1 ] ) ; 
  1098.       else if ( activewidth [ 0 ] - h > activewidth [ 5 ] ) 
  1099.       b = awfulbad ; 
  1100.       else b = badness ( activewidth [ 0 ] - h , activewidth [ 5 ] ) ; 
  1101.       if ( b < awfulbad ) 
  1102.       if ( pi <= ejectpenalty ) 
  1103.       b = pi ; 
  1104.       else if ( b < infbad ) 
  1105.       b = b + pi ; 
  1106.       else b = 100000L ; 
  1107.       if ( b <= leastcost ) {
  1108.     bestplace = p ; 
  1109.     leastcost = b ; 
  1110.     bestheightplusdepth = activewidth [ 0 ] + prevdp ;
  1111.       } 
  1112.       if ( ( b == awfulbad ) || ( pi <= ejectpenalty ) ) 
  1113.       goto lab30 ; 
  1114.     } 
  1115.     if ( ( ztype ( p ) < gluenode ) || ( ztype ( p ) > kernnode ) ) 
  1116.     goto lab45 ; 
  1117.  
  1118. lab90:
  1119.     if ( ztype ( p ) == kernnode ) 
  1120.       q = p ; 
  1121.     else {
  1122.       q = glueptr ( p ) ; 
  1123.       activewidth [ 1 + stretchorder ( q ) ] += stretch ( q );
  1124.       activewidth [ 5 ] += shrink ( q ) ; 
  1125.       if ( ( shrinkorder ( q ) != normal ) && ( shrink ( q ) != 0 ) ) {
  1126.     print_err("Infinite glue shrinkage found in box being split");
  1127.     zhelp3( STR_H_THEBOX_VSPLIT, STR_H_SHRINKABLEGLUE,
  1128.         STR_H_SINCETHE_OFFENSIVE);
  1129.     error();
  1130.     r = newspec ( q ) ; 
  1131.     shrinkorder ( r ) = normal ; 
  1132.     deleteglueref ( q ) ; 
  1133.     glueptr ( p ) = r ; 
  1134.     q = r ; 
  1135.       } 
  1136.     }
  1137.     activewidth [ 0 ] += prevdp + width ( q ) ; 
  1138.     prevdp = 0 ;
  1139.  
  1140. lab45:
  1141.     if ( prevdp > d ) {
  1142.       activewidth [ 0 ] += prevdp - d ; 
  1143.       prevdp = d;
  1144.     }
  1145.     prevp = p ; 
  1146.     p = link ( prevp ) ; 
  1147.   }
  1148.  
  1149. lab30:
  1150.   return( bestplace );
  1151. }
  1152.  
  1153.  
  1154. long_halfword vsplit ( eightbits n, scaled h )
  1155. { vsplit_regmem 
  1156.   register halfword v  ; 
  1157.   register halfword p  ; 
  1158.   register halfword q  ; 
  1159.  
  1160.   v = box ( n ) ; 
  1161.   if ( splitfirstmark != 0 ) {
  1162.     deletetokenref ( splitfirstmark ) ; 
  1163.     splitfirstmark = 0 ; 
  1164.     deletetokenref ( splitbotmark ) ; 
  1165.     splitbotmark = 0 ; 
  1166.   } 
  1167.   if ( v == 0 ) {
  1168.     return( 0L ) ; 
  1169.   } 
  1170.   if ( ztype ( v ) != vlistnode ) {
  1171.     print_err("");
  1172.     printesc( STR_VSPLIT );
  1173.     c_print(" needs a ");
  1174.     printesc( STR_VBOX );
  1175.     zhelp1( STR_H_THEBOX_SPLITHBOX );
  1176.     error();
  1177.     return( 0L );
  1178.   }
  1179.  
  1180.   q = vertbreak ( listptr(v), h, splitmaxdepth );
  1181.   p = listptr ( v ) ; 
  1182.   if ( p == q ) 
  1183.     listptr ( v ) = 0 ; 
  1184.   else while ( true ) {
  1185.     if ( ztype ( p ) == marknode ) 
  1186.     if ( splitfirstmark == 0 ) {
  1187.       splitfirstmark = markptr ( p ) ; 
  1188.       splitbotmark = splitfirstmark ; 
  1189.       tokenrefcount ( splitfirstmark ) = tokenrefcount ( splitfirstmark ) + 2;
  1190.     } else {
  1191.       deletetokenref ( splitbotmark ) ; 
  1192.       splitbotmark = markptr ( p ) ; 
  1193.       addtokenref ( splitbotmark ) ; 
  1194.     } 
  1195.     if ( link ( p ) == q ) {
  1196.       link ( p ) = 0 ; 
  1197.       goto lab30 ; 
  1198.     } 
  1199.     p = link ( p ) ; 
  1200.   }
  1201.  
  1202. lab30:
  1203.   q = prunepagetop ( q ) ; 
  1204.   p = listptr ( v ) ; 
  1205.   freenode ( v , boxnodesize ) ; 
  1206.   if ( q == 0 ) 
  1207.     box ( n ) = 0 ; 
  1208.   else
  1209.     box ( n ) = vpackage ( q , 0 , 1 , maxdimen ) ; 
  1210.  
  1211.   return( vpackage ( p , h , 0 , splitmaxdepth ) );
  1212. }
  1213.  
  1214.  
  1215. void printtotals ( void )
  1216. { printtotals_regmem
  1217.  
  1218.   printscaled ( pagesofar [ 1 ] ) ; 
  1219.   if ( pagesofar [ 2 ] != 0 ) {
  1220.     print( STR_PLUS_ );
  1221.     printscaled ( pagesofar [ 2 ] ) ; 
  1222.     c_print("");
  1223.   } 
  1224.   if ( pagesofar [ 3 ] != 0 ) {
  1225.     print( STR_PLUS_ );
  1226.     printscaled ( pagesofar [ 3 ] ) ; 
  1227.     print( STR_FIL );
  1228.   } 
  1229.   if ( pagesofar [ 4 ] != 0 ) {
  1230.     print( STR_PLUS_ );
  1231.     printscaled ( pagesofar [ 4 ] ) ; 
  1232.     c_print("fill");
  1233.   } 
  1234.   if ( pagesofar [ 5 ] != 0 ) {
  1235.     print( STR_PLUS_ );
  1236.     printscaled ( pagesofar [ 5 ] ) ; 
  1237.     c_print("filll");
  1238.   }
  1239.   if ( pagesofar [ 6 ] != 0 ) {
  1240.     print( STR_MINUS_ );
  1241.     printscaled ( pagesofar [ 6 ] ) ; 
  1242.   } 
  1243. }
  1244.  
  1245.  
  1246. void freezepagespecs ( smallnumber s )
  1247. { freezepagespecs_regmem
  1248.  
  1249.   pagecontents = s ; 
  1250.   pagemaxdepth = maxdepth ; 
  1251.   pagesofar [ 0 ] = vsize ; 
  1252.   pagesofar [ 1 ] = 0 ; 
  1253.   pagesofar [ 2 ] = 0 ; 
  1254.   pagesofar [ 3 ] = 0 ; 
  1255.   pagesofar [ 4 ] = 0 ; 
  1256.   pagesofar [ 5 ] = 0 ; 
  1257.   pagesofar [ 6 ] = 0 ; 
  1258.   pagesofar [ 7 ] = 0 ; 
  1259.   leastpagecost = awfulbad ; 
  1260. #ifdef STAT
  1261.   if ( tracingpages > 0 ) {
  1262.     begindiagnostic();
  1263.     c_printnl("%% goal height=");
  1264.     printscaled( pagesofar[0] );
  1265.     c_print(", max depth=");
  1266.     printscaled( pagemaxdepth );
  1267.     enddiagnostic( false );
  1268.   }
  1269. #endif /* STAT */
  1270. }
  1271.  
  1272.  
  1273. void boxerror ( eightbits n )
  1274. { boxerror_regmem
  1275.  
  1276.   error(); 
  1277.   begindiagnostic();
  1278.   c_printnl("The following box has been deleted:");
  1279.   showbox ( box ( n ) );
  1280.   enddiagnostic ( true );
  1281.   flushnodelist ( box ( n ) );
  1282.   box ( n ) = 0;
  1283. }
  1284.  
  1285.  
  1286. void ensurevbox ( eightbits n )
  1287. { ensurevbox_regmem
  1288.   register halfword p  ; 
  1289.  
  1290.   p = box ( n ) ; 
  1291.   if ( p != 0 ) 
  1292.   if ( ztype ( p ) == hlistnode ) {
  1293.     print_err("Insertions can only be added to a vbox");
  1294.     zhelp2( STR_H_TUTTUT_INSERT, STR_H_PROCEED_DISCRADCONT);
  1295.     boxerror ( n ) ; 
  1296.   }
  1297. }
  1298.  
  1299.  
  1300. void fireup ( halfword c )
  1301. {/* 10 */ fireup_regmem
  1302.   register halfword p, q, r, s  ; 
  1303.   register halfword prevp  ; 
  1304.   unsigned char n  ; 
  1305.   boolean wait  ; 
  1306.   /*register*/ integer savevbadness  ; 
  1307.   /*register*/ scaled savevfuzz  ; 
  1308.   /*register*/ halfword savesplittopskip  ; 
  1309.  
  1310.   if ( ztype ( bestpagebreak ) == penaltynode ) {
  1311.     geqworddefine ( intbase + outputpenaltycode, mem[bestpagebreak+1].cint );
  1312.     mem [ bestpagebreak + 1 ] .cint = infpenalty ; 
  1313.   } else
  1314.     geqworddefine ( intbase + outputpenaltycode , infpenalty ) ; 
  1315.  
  1316.   if ( botmark != 0 ) {
  1317.     if ( topmark != 0 ) 
  1318.       deletetokenref ( topmark ) ; 
  1319.     topmark = botmark ; 
  1320.     addtokenref ( topmark ) ; 
  1321.     deletetokenref ( firstmark ) ; 
  1322.     firstmark = 0 ; 
  1323.   } 
  1324.  
  1325.   if ( c == bestpagebreak ) 
  1326.     bestpagebreak = 0 ; 
  1327.  
  1328.   if ( box ( 255 ) != 0 ) {
  1329.     print_err("");
  1330.     printesc( STR_BOX );
  1331.     c_print("255 is not void");
  1332.     zhelp2( STR_H_YOUSHOULDNTUSEBOX, STR_H_PROCEED_DISCRADCONT );
  1333.     boxerror( 255 );
  1334.   } 
  1335.   insertpenalties = 0 ; 
  1336.   savesplittopskip = splittopskip ; 
  1337.   if ( holdinginserts <= 0 ) {
  1338.     r = link ( pageinshead ) ; 
  1339.     while ( r != pageinshead ) {
  1340.       if ( bestinsptr ( r ) != 0 ) {
  1341.     n = subtype ( r ) ; 
  1342.     ensurevbox ( n ) ; 
  1343.     if ( box ( n ) == 0 )
  1344.       box ( n ) = newnullbox () ; 
  1345.     p = box ( n ) + listoffset ; 
  1346.     while ( link ( p ) != 0 )
  1347.       p = link ( p ) ; 
  1348.     lastinsptr ( r ) = p ; 
  1349.       } 
  1350.       r = link ( r ) ; 
  1351.     } 
  1352.   } 
  1353.   q = holdhead ; 
  1354.   link ( q ) = 0 ; 
  1355.   prevp = pagehead ; 
  1356.   p = link ( prevp ) ; 
  1357.   while ( p != bestpagebreak ) {
  1358.     if ( ztype ( p ) == insnode ) {
  1359.       if ( holdinginserts <= 0 ) {
  1360.     r = link ( pageinshead ) ; 
  1361.     while ( subtype ( r ) != subtype ( p ) )
  1362.       r = link ( r ) ; 
  1363.     if ( bestinsptr ( r ) == 0 ) 
  1364.       wait = true ; 
  1365.     else {
  1366.       wait = false ; 
  1367.       s = lastinsptr ( r ) ; 
  1368.       link ( s ) = insptr ( p ) ; 
  1369.       if ( bestinsptr ( r ) == p ) {
  1370.         if ( ztype ( r ) == splitup ) 
  1371.         if ( ( brokenins ( r ) == p ) && ( brokenptr ( r ) != 0 ) ) {
  1372.           while ( link ( s ) != brokenptr ( r ) )
  1373.         s = link ( s ) ; 
  1374.           link ( s ) = 0 ; 
  1375.           splittopskip = splittopptr ( p ) ; 
  1376.           insptr ( p ) = prunepagetop ( brokenptr ( r ) ) ; 
  1377.           if ( insptr ( p ) != 0 ) {
  1378.         tempptr = vpackage ( insptr ( p ) , 0 , 1 , maxdimen ) ; 
  1379.         height ( p ) = height ( tempptr ) + depth ( tempptr ) ; 
  1380.         freenode ( tempptr , boxnodesize ) ; 
  1381.         wait = true ; 
  1382.           }
  1383.         }
  1384.         bestinsptr ( r ) = 0 ; 
  1385.         n = subtype ( r ) ; 
  1386.         tempptr = listptr ( box ( n ) ) ; 
  1387.         freenode ( box ( n ) , boxnodesize ) ; 
  1388.         box ( n ) = vpackage ( tempptr , 0 , 1 , maxdimen ) ; 
  1389.       } else {
  1390.         while ( link ( s ) != 0 )
  1391.           s = link ( s ) ; 
  1392.         lastinsptr ( r ) = s ; 
  1393.       } 
  1394.     } 
  1395.     link ( prevp ) = link ( p ) ; 
  1396.     link ( p ) = 0 ; 
  1397.     if ( wait ) {
  1398.       link ( q ) = p ; 
  1399.       q = p ; 
  1400.       incr ( insertpenalties ) ; 
  1401.     } else {
  1402.       deleteglueref ( splittopptr ( p ) ) ; 
  1403.       freenode ( p , insnodesize ) ; 
  1404.     } 
  1405.     p = prevp ; 
  1406.       } 
  1407.     } else if ( ztype ( p ) == marknode ) {
  1408.       if ( firstmark == 0 ) {
  1409.     firstmark = markptr ( p ) ; 
  1410.     addtokenref ( firstmark ) ; 
  1411.       }
  1412.       if ( botmark != 0 ) 
  1413.     deletetokenref ( botmark ) ; 
  1414.       botmark = markptr ( p ) ; 
  1415.       addtokenref ( botmark ) ; 
  1416.     }
  1417.     prevp = p ; 
  1418.     p = link ( prevp ) ; 
  1419.   }
  1420.   splittopskip = savesplittopskip ; 
  1421.   if ( p != 0 ) {
  1422.     if ( link ( contribhead ) == 0 ) 
  1423.     if ( nestptr == 0 ) 
  1424.       curlist .tailfield = pagetail ; 
  1425.     else nest [ 0 ] .tailfield = pagetail ; 
  1426.     link ( pagetail ) = link ( contribhead ) ; 
  1427.     link ( contribhead ) = p ; 
  1428.     link ( prevp ) = 0 ; 
  1429.   } 
  1430.   savevbadness = vbadness ; 
  1431.   vbadness = infbad ; 
  1432.   savevfuzz = vfuzz ; 
  1433.   vfuzz = maxdimen ; 
  1434.   box ( 255 ) = vpackage ( link ( pagehead ) , bestsize , 0 , pagemaxdepth ) ; 
  1435.   vbadness = savevbadness ; 
  1436.   vfuzz = savevfuzz ; 
  1437.   if ( lastglue != maxhalfword ) 
  1438.     deleteglueref ( lastglue ) ; 
  1439.   pagecontents = 0 ; 
  1440.   pagetail = pagehead ; 
  1441.   link ( pagehead ) = 0 ; 
  1442.   lastglue = maxhalfword ; 
  1443.   lastpenalty = 0 ; 
  1444.   lastkern = 0 ; 
  1445.   pagesofar [ 7 ] = 0 ; 
  1446.   pagemaxdepth = 0 ; 
  1447.   if ( q != holdhead ) {
  1448.     link ( pagehead ) = link ( holdhead ) ; 
  1449.     pagetail = q ; 
  1450.   }
  1451.   r = link ( pageinshead ) ; 
  1452.   while ( r != pageinshead ) {
  1453.     q = link ( r ) ; 
  1454.     freenode ( r , pageinsnodesize ) ; 
  1455.     r = q ; 
  1456.   } 
  1457.   link ( pageinshead ) = pageinshead ; 
  1458.   if ( ( topmark != 0 ) && ( firstmark == 0 ) ) {
  1459.     firstmark = topmark ; 
  1460.     addtokenref ( topmark ) ; 
  1461.   } 
  1462.   if ( outputroutine != 0 ) 
  1463.   if ( deadcycles >= maxdeadcycles ) {
  1464.     print_err("Output loop---");
  1465.     printint ( deadcycles ) ; 
  1466.     c_print(" consecutive dead cycles");
  1467.     zhelp1( STR_H_IVE_OUTPUT_AWRY );
  1468.     error();
  1469.   } else {
  1470.     outputactive = true ; 
  1471.     incr ( deadcycles ) ; 
  1472.     pushnest () ; 
  1473.     curlist .modefield = -vmode ;
  1474.     curlist .auxfield .cint = ignoredepth ; 
  1475.     curlist .mlfield = - (integer) line ; 
  1476.     begintokenlist ( outputroutine , outputtext ) ; 
  1477.     newsavelevel ( outputgroup ) ; 
  1478.     normalparagraph () ; 
  1479.     scanleftbrace () ; 
  1480.     return ; 
  1481.   } 
  1482.  
  1483.   if ( link ( pagehead ) != 0 ) {
  1484.     if ( link ( contribhead ) == 0 ) 
  1485.       if ( nestptr == 0 ) 
  1486.     curlist .tailfield = pagetail ; 
  1487.       else
  1488.     nest [ 0 ] .tailfield = pagetail ; 
  1489.     else
  1490.       link ( pagetail ) = link ( contribhead ) ; 
  1491.     link ( contribhead ) = link ( pagehead ) ; 
  1492.     link ( pagehead ) = 0 ; 
  1493.     pagetail = pagehead ; 
  1494.   }
  1495.   shipout ( box ( 255 ) ) ; 
  1496.   box ( 255 ) = 0 ; 
  1497. }
  1498.  
  1499.  
  1500. void buildpage ( void )
  1501. {/* 10 30 31 22 80 90 */ buildpage_regmem 
  1502.   register halfword p  ; 
  1503.   register halfword q, r  ; 
  1504.   register integer b, c  ; 
  1505.   register integer pi  ; 
  1506.   unsigned char n  ; 
  1507.   register scaled delta, h, w  ; 
  1508.  
  1509.   if ( ( link ( contribhead ) == 0 ) || outputactive ) 
  1510.     return ; 
  1511.  
  1512.   do {
  1513. lab22:
  1514.     p = link ( contribhead ) ; 
  1515.     if ( lastglue != maxhalfword ) 
  1516.       deleteglueref ( lastglue ) ; 
  1517.     lastpenalty = 0 ; 
  1518.     lastkern = 0 ; 
  1519.     if ( ztype ( p ) == gluenode ) {
  1520.       lastglue = glueptr ( p ) ; 
  1521.       addglueref ( lastglue ) ; 
  1522.     } else {
  1523.       lastglue = maxhalfword ; 
  1524.       if ( ztype ( p ) == penaltynode ) 
  1525.     lastpenalty = mem [ p + 1 ] .cint ; 
  1526.       else if ( ztype ( p ) == kernnode ) 
  1527.     lastkern = width ( p ) ; 
  1528.     }
  1529.     switch ( ztype ( p ) ) 
  1530.     {case hlistnode : 
  1531.     case vlistnode : 
  1532.     case rulenode : 
  1533.       if ( pagecontents < boxthere ) {
  1534.     if ( pagecontents == 0 ) 
  1535.       freezepagespecs ( boxthere ) ; 
  1536.     else
  1537.       pagecontents = boxthere ; 
  1538.     q = newskipparam ( topskipcode ) ; 
  1539.     if ( width ( tempptr ) > height ( p ) ) 
  1540.       width ( tempptr ) = width ( tempptr ) - height ( p ) ; 
  1541.     else
  1542.       width ( tempptr ) = 0 ; 
  1543.     link ( q ) = p ; 
  1544.     link ( contribhead ) = q ; 
  1545.     goto lab22 ; 
  1546.       } else {
  1547.     pagesofar [ 1 ] = pagesofar [ 1 ] + pagesofar [ 7 ] + height ( p ) ; 
  1548.     pagesofar [ 7 ] = depth ( p ) ; 
  1549.     goto lab80 ; 
  1550.       }
  1551.       break ; 
  1552.     case whatsitnode : 
  1553.       goto lab80 ; 
  1554.       break ; 
  1555.     case gluenode : 
  1556.       if ( pagecontents < boxthere ) 
  1557.     goto lab31 ; 
  1558.       else if ( precedesbreak ( pagetail ) ) 
  1559.     pi = 0 ; 
  1560.       else
  1561.     goto lab90 ; 
  1562.       break ; 
  1563.     case kernnode : 
  1564.       if ( pagecontents < boxthere ) 
  1565.     goto lab31 ; 
  1566.       else if ( link ( p ) == 0 ) 
  1567.     return ; 
  1568.       else if ( ztype ( link ( p ) ) == gluenode ) 
  1569.     pi = 0 ; 
  1570.       else
  1571.     goto lab90 ; 
  1572.       break ; 
  1573.     case penaltynode : 
  1574.       if ( pagecontents < boxthere ) 
  1575.     goto lab31 ; 
  1576.       else
  1577.     pi = mem [ p + 1 ] .cint ; 
  1578.       break ; 
  1579.     case marknode : 
  1580.       goto lab80 ; 
  1581.       break ; 
  1582.     case insnode : 
  1583.       {
  1584.     if ( pagecontents == 0 ) 
  1585.       freezepagespecs ( insertsonly ) ; 
  1586.     n = subtype ( p ) ; 
  1587.     r = pageinshead ; 
  1588.     while ( n >= subtype ( link ( r ) ) )
  1589.       r = link ( r ) ; 
  1590.     n = n ; 
  1591.     if ( subtype ( r ) != n ) {
  1592.       q = getnode ( pageinsnodesize ) ; 
  1593.       link ( q ) = link ( r ) ; 
  1594.       link ( r ) = q ; 
  1595.       r = q ; 
  1596.       subtype ( r ) = n ; 
  1597.       ztype ( r ) = inserting ; 
  1598.       ensurevbox ( n ) ; 
  1599.       if ( box ( n ) == 0 ) 
  1600.         height ( r ) = 0 ; 
  1601.       else
  1602.         height ( r ) = height ( box ( n ) ) + depth ( box ( n ) ) ; 
  1603.       bestinsptr ( r ) = 0 ; 
  1604.       q = skip ( n ) ; 
  1605.       if ( count ( n ) == 1000 ) 
  1606.         h = height ( r ) ; 
  1607.       else
  1608.         h = xovern ( height ( r ) , 1000 ) * count ( n ) ; 
  1609.       pagesofar [ 0 ] = pagesofar [ 0 ] - h - width ( q ) ; 
  1610.       pagesofar [ 2 + stretchorder ( q ) ] += stretch ( q ) ; 
  1611.       pagesofar [ 6 ] += shrink ( q ) ; 
  1612.       if ( ( shrinkorder ( q ) != normal ) && ( shrink ( q ) != 0 ) ) {
  1613.         print_err("Infinite glue shrinkage inserted from ");
  1614.         printesc( STR_SKIP );
  1615.         printint ( n ) ; 
  1616.         zhelp2( STR_H_THECORRECTIONGLUE, STR_H_SINCETHE_OFFENSIVE );
  1617.         error();
  1618.       } 
  1619.     } 
  1620.     if ( ztype ( r ) == splitup ) 
  1621.       insertpenalties = insertpenalties + floatcost ( p ) ; 
  1622.     else {
  1623.       lastinsptr ( r ) = p ; 
  1624.       delta = pagesofar [ 0 ] - pagesofar [ 1 ] - pagesofar [ 7 ] + 
  1625.       pagesofar [ 6 ] ; 
  1626.       if ( count ( n ) == 1000 ) 
  1627.         h = height ( p ) ; 
  1628.       else
  1629.         h = xovern ( height ( p ) , 1000 ) * count ( n ) ; 
  1630.       if ( ( ( h <= 0 ) || ( h <= delta ) ) && ( height ( p ) + height ( r 
  1631.       ) <= dimen ( n ) ) ) 
  1632.       {
  1633.         pagesofar [ 0 ] -= h ; 
  1634.         height ( r ) += height ( p ) ; 
  1635.       } else {
  1636.         if ( count ( n ) <= 0 ) 
  1637.           w = maxdimen ; 
  1638.         else {
  1639.           w = pagesofar [ 0 ] - pagesofar [ 1 ] - pagesofar [ 7 ] ; 
  1640.           if ( count ( n ) != 1000 ) 
  1641.         w = xovern ( w , count ( n ) ) * 1000 ; 
  1642.         } 
  1643.         if ( w > dimen ( n ) - height ( r ) ) 
  1644.           w = dimen ( n ) - height ( r ) ; 
  1645.         q = vertbreak ( insptr ( p ) , w , depth ( p ) ) ; 
  1646.         height ( r ) += bestheightplusdepth ; 
  1647. #ifdef STAT
  1648.         if ( tracingpages > 0 ) {
  1649.           begindiagnostic () ; 
  1650.           c_printnl("% split");
  1651.           printint ( n ) ; 
  1652.           c_print(" to ");
  1653.           printscaled ( w ) ; 
  1654.           printchar ( 44 ) ; 
  1655.           printscaled ( bestheightplusdepth ) ; 
  1656.           c_print(" p=");
  1657.           if ( q == 0 ) 
  1658.         printint ( ejectpenalty ) ; 
  1659.           else if ( ztype ( q ) == penaltynode ) 
  1660.         printint ( mem [ q + 1 ] .cint ) ; 
  1661.           else
  1662.         printchar ( 48 ) ; 
  1663.           enddiagnostic ( false ) ; 
  1664.         } 
  1665. #endif /* STAT */
  1666.         if ( count ( n ) != 1000 ) 
  1667.           bestheightplusdepth = xovern(bestheightplusdepth, 1000)*count(n);
  1668.         pagesofar [ 0 ] -= bestheightplusdepth;
  1669.         ztype ( r ) = splitup ; 
  1670.         brokenptr ( r ) = q ; 
  1671.         brokenins ( r ) = p ; 
  1672.         if ( q == 0 )
  1673.           insertpenalties += ejectpenalty ; 
  1674.         else if ( ztype ( q ) == penaltynode ) 
  1675.           insertpenalties += mem [ q + 1 ] .cint ; 
  1676.       }
  1677.     }
  1678.     goto lab80 ; 
  1679.       } 
  1680.       break ; 
  1681.     default: 
  1682.       confusion("page");
  1683.       break ; 
  1684.     } 
  1685.     if ( pi < infpenalty ) {
  1686.       if ( pagesofar [ 1 ] < pagesofar [ 0 ] ) 
  1687.       if ( ( pagesofar [ 3 ] != 0 ) || ( pagesofar [ 4 ] != 0 ) || ( pagesofar 
  1688.       [ 5 ] != 0 ) ) 
  1689.       b = 0 ; 
  1690.       else b = badness ( pagesofar [ 0 ] - pagesofar [ 1 ] , pagesofar [ 2 ] );
  1691.       else if ( pagesofar [ 1 ] - pagesofar [ 0 ] > pagesofar [ 6 ] ) 
  1692.       b = awfulbad ; 
  1693.       else b = badness ( pagesofar [ 1 ] - pagesofar [ 0 ] , pagesofar [ 6 ] );
  1694.       if ( b < awfulbad ) 
  1695.       if ( pi <= ejectpenalty ) 
  1696.       c = pi ; 
  1697.       else if ( b < infbad ) 
  1698.       c = b + pi + insertpenalties ; 
  1699.       else c = 100000L ; 
  1700.       else c = b ; 
  1701.       if ( insertpenalties >= 10000 ) 
  1702.       c = awfulbad ; 
  1703. #ifdef STAT
  1704.       if ( tracingpages > 0 ) {
  1705.     begindiagnostic () ; 
  1706.     printnl ( 37 ) ; 
  1707.     c_print(" t=");
  1708.     printtotals () ; 
  1709.     c_print(" g=");
  1710.     printscaled ( pagesofar [ 0 ] ) ; 
  1711.     c_print(" b=");
  1712.     if ( b == awfulbad ) printchar ( 42 ) ; else printint ( b ) ; 
  1713.     c_print(" p=");
  1714.     printint ( pi ) ; 
  1715.     c_print(" c=");
  1716.     if ( c == awfulbad ) 
  1717.       printchar ( 42 ) ; 
  1718.     else
  1719.       printint ( c ) ; 
  1720.     if ( c <= leastpagecost ) 
  1721.       printchar ( 35 ) ; 
  1722.     enddiagnostic ( false ) ; 
  1723.       } 
  1724. #endif /* STAT */
  1725.       if ( c <= leastpagecost ) {
  1726.     bestpagebreak = p ; 
  1727.     bestsize = pagesofar [ 0 ] ; 
  1728.     leastpagecost = c ; 
  1729.     r = link ( pageinshead ) ; 
  1730.     while ( r != pageinshead ) {
  1731.       bestinsptr ( r ) = lastinsptr ( r ) ; 
  1732.       r = link ( r ) ; 
  1733.     } 
  1734.       } 
  1735.       if ( ( c == awfulbad ) || ( pi <= ejectpenalty ) ) {
  1736.     fireup ( p ) ; 
  1737.     if ( outputactive ) 
  1738.       return ; 
  1739.     goto lab30 ; 
  1740.       }
  1741.     } 
  1742.     if ( ( ztype ( p ) < gluenode ) || ( ztype ( p ) > kernnode ) ) 
  1743.       goto lab80 ; 
  1744. lab90:
  1745.     if ( ztype ( p ) == kernnode ) 
  1746.       q = p ; 
  1747.     else {
  1748.       q = glueptr ( p ) ; 
  1749.       pagesofar [ 2 + stretchorder ( q ) ] += stretch ( q ) ; 
  1750.       pagesofar [ 6 ] += shrink ( q ) ; 
  1751.       if ( ( shrinkorder ( q ) != normal ) && ( shrink ( q ) != 0 ) ) {
  1752.     print_err("Infinite glue shrinkage found on current page");
  1753.     zhelp3( STR_H_THEPAGE_INFINITELY, STR_H_SHRINKABLEGLUE,
  1754.         STR_H_SINCETHE_OFFENSIVE );
  1755.     error();
  1756.     r = newspec ( q ) ; 
  1757.     shrinkorder ( r ) = normal ; 
  1758.     deleteglueref ( q ) ; 
  1759.     glueptr ( p ) = r ; 
  1760.     q = r ; 
  1761.       } 
  1762.     } 
  1763.     pagesofar [ 1 ] = pagesofar [ 1 ] + pagesofar [ 7 ] + width ( q ) ; 
  1764.     pagesofar [ 7 ] = 0 ; 
  1765. lab80:
  1766.     if ( pagesofar [ 7 ] > pagemaxdepth ) {
  1767.       pagesofar [ 1 ] = pagesofar [ 1 ] + pagesofar [ 7 ] - pagemaxdepth ; 
  1768.       pagesofar [ 7 ] = pagemaxdepth ; 
  1769.     }
  1770.     link ( pagetail ) = p ; 
  1771.     pagetail = p ; 
  1772.     link ( contribhead ) = link ( p ) ; 
  1773.     link ( p ) = 0 ; 
  1774.     goto lab30 ; 
  1775.  
  1776. lab31:
  1777.     link ( contribhead ) = link ( p ) ; 
  1778.     link ( p ) = 0 ; 
  1779.     flushnodelist ( p ) ; 
  1780. lab30: ;
  1781.   } while ( ! ( link ( contribhead ) == 0 ) ) ;
  1782.  
  1783.   if ( nestptr == 0 ) 
  1784.     curlist .tailfield = contribhead ; 
  1785.   else nest [ 0 ] .tailfield = contribhead ; 
  1786. }
  1787.  
  1788.  
  1789. void insertdollarsign ( void )
  1790. { insertdollarsign_regmem
  1791.  
  1792.   backinput () ; 
  1793.   curtok = mathshifttoken + 36 ; 
  1794.   print_err("Missing $ inserted");
  1795.   zhelp1( STR_H_IVE_BEGINMATH );
  1796.   inserror () ; 
  1797. } 
  1798.  
  1799.  
  1800. void youcant ( void)
  1801. { youcant_regmem
  1802.  
  1803.   p_print_err( STR_H_YOUCANTUSE );
  1804.   printcmdchr( curcmd , curchr );
  1805.   c_print("' in ");
  1806.   printmode( curlist .modefield );
  1807. } 
  1808.  
  1809.  
  1810. void reportillegalcase ( void )
  1811. { reportillegalcase_regmem
  1812.  
  1813.   youcant();
  1814.   zhelp1( STR_H_SORRY_NOTPROGRAMMED );
  1815.   error();
  1816. }
  1817.  
  1818.  
  1819. boolean privileged ( void )
  1820. { privileged_regmem
  1821.  
  1822.   if ( curlist .modefield > 0 ) 
  1823.     return(true);
  1824.   else {
  1825.     reportillegalcase () ; 
  1826.     return(false);
  1827.   }
  1828. }
  1829.  
  1830.  
  1831. boolean itsallover ( void )
  1832. {/* 10 */ itsallover_regmem
  1833.  
  1834.   if ( privileged () ) {
  1835.     if ( ( pagehead == pagetail ) && ( curlist .headfield == curlist 
  1836.     .tailfield ) && ( deadcycles == 0 ) ) 
  1837.     {
  1838.       return(true);
  1839.     } 
  1840.     backinput () ; 
  1841.     tailappend ( newnullbox () ) ; 
  1842.     width ( curlist .tailfield ) = hsize ; 
  1843.     tailappend ( newglue ( fillglue ) ) ; 
  1844.     tailappend ( newpenalty ( -1073741824L ) ) ; 
  1845.     buildpage () ; 
  1846.   }
  1847.   return(false) ; 
  1848. }
  1849.  
  1850.  
  1851. void appendglue ( void )
  1852. { appendglue_regmem
  1853.   register smallnumber s;
  1854.   register long_halfword r_curval;
  1855.  
  1856.   s = curchr ; 
  1857.   switch ( s ) {
  1858.   case 0 : 
  1859.     r_curval = filglue ; 
  1860.     break ; 
  1861.   case 1 : 
  1862.     r_curval = fillglue ; 
  1863.     break ; 
  1864.   case 2 : 
  1865.     r_curval = ssglue ; 
  1866.     break ; 
  1867.   case 3 : 
  1868.     r_curval = filnegglue ; 
  1869.     break ; 
  1870.   case 4 : 
  1871.     r_curval = scanglue ( glueval );
  1872.     break ; 
  1873.   case 5 : 
  1874.     r_curval = scanglue ( muval );
  1875.     break ; 
  1876.   }
  1877.   tailappend ( newglue ( r_curval ) );
  1878.   if ( s >= 4 ) {
  1879.     decr ( gluerefcount ( r_curval ) );
  1880.     if ( s > 4 )
  1881.       subtype ( curlist .tailfield ) = muglue;
  1882.   }
  1883. }
  1884.  
  1885.  
  1886. void appendkern ( void )
  1887. { register quarterword s;
  1888.   register integer r_curval;
  1889.  
  1890.   s = curchr ; 
  1891.   r_curval = scandimen ( s == muglue, false, false );
  1892.   { appendkern_regmem
  1893.     tailappend ( newkern ( r_curval ) );
  1894.     subtype ( curlist .tailfield ) = s;
  1895.   }
  1896. }
  1897.  
  1898.  
  1899. void offsave ( void )
  1900. { offsave_regmem
  1901.   register halfword p ;
  1902.  
  1903.   if ( curgroup == bottomlevel ) {
  1904.     print_err("Extra ");
  1905.     printcmdchr ( curcmd , curchr ) ; 
  1906.     zhelp1( STR_H_THINGS_MIXEDUP );
  1907.     error () ; 
  1908.   } else {
  1909.     backinput () ; 
  1910.     p = getavail () ; 
  1911.     link ( temphead ) = p ; 
  1912.     print_err("Missing ");
  1913.  
  1914.     switch ( curgroup ) {
  1915.     case semisimplegroup : 
  1916.       {
  1917.     info ( p ) = cstokenflag + frozenendgroup ; 
  1918.     printesc( STR_ENDGROUP );
  1919.       } 
  1920.       break ; 
  1921.     case mathshiftgroup : 
  1922.       {
  1923.     info ( p ) = mathshifttoken + 36 ; 
  1924.     printchar ( 36 ) ; 
  1925.       } 
  1926.       break ; 
  1927.     case mathleftgroup : 
  1928.       {
  1929.     info ( p ) = cstokenflag + frozenright ; 
  1930.     link ( p ) = getavail () ; 
  1931.     p = link ( p ) ; 
  1932.     info ( p ) = othertoken + 46 ; 
  1933.     c_printesc("right.");
  1934.       } 
  1935.       break ; 
  1936.     default: 
  1937.       {
  1938.     info ( p ) = rightbracetoken + 125 ; 
  1939.     printchar ( 125 ) ; 
  1940.       } 
  1941.       break ; 
  1942.     } 
  1943.     c_print(" inserted");
  1944.     begintokenlist ( link ( temphead ) , inserted ) ; 
  1945.     zhelp1( STR_H_IVE_INSERTED_SOMETHING );
  1946.     error () ; 
  1947.   }
  1948. }
  1949.  
  1950.  
  1951. void extrarightbrace ( void )
  1952. { extrarightbrace_regmem
  1953.  
  1954.   print_err("Extra }, or forgotten ");
  1955.  
  1956.   switch ( curgroup ) {
  1957.   case semisimplegroup : 
  1958.     printesc( STR_ENDGROUP );
  1959.     break ; 
  1960.   case mathshiftgroup : 
  1961.     printchar ( 36 ) ; 
  1962.     break ; 
  1963.   case mathleftgroup : 
  1964.     printesc( STR_RIGHT );
  1965.     break ; 
  1966.   }
  1967.   zhelp1( STR_H_IVE_GROUPCLOSING );
  1968.   error();
  1969.   incr ( alignstate );
  1970. }
  1971.  
  1972.  
  1973. void normalparagraph ( void )
  1974. { normalparagraph_regmem
  1975.  
  1976.   if ( looseness != 0 ) 
  1977.     eqworddefine ( intbase + loosenesscode , 0 ) ; 
  1978.   if ( hangindent != 0 ) 
  1979.     eqworddefine ( dimenbase + hangindentcode , 0 ) ; 
  1980.   if ( hangafter != 1 ) 
  1981.     eqworddefine ( intbase + hangaftercode , 1 ) ; 
  1982.   if ( parshapeptr != 0 ) 
  1983.     eqdefine ( parshapeloc , shaperef , 0 ) ; 
  1984. }
  1985.  
  1986. /* -- end -- */
  1987.