home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / tex5.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-18  |  17.6 KB  |  692 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. #if 0            /* nach math.c */
  5.  
  6. void zmakefraction ( q ) 
  7. scaled zmakeop ( q ) 
  8. void zmakeord ( q ) 
  9. void zmakescripts ( q , delta ) 
  10. smallnumber zmakeleftright ( q , style , maxd , maxh ) 
  11. void mlisttohlist ( ) 
  12.  
  13. #endif
  14.  
  15. void pushalignment ( void )
  16. { register halfword p  ; 
  17.  
  18.   p = getnode ( alignstacknodesize ) ; 
  19.  
  20.   { pushalignment_regmem
  21.  
  22.   link ( p ) = alignptr ; 
  23.   info ( p ) = curalign ; 
  24.   llink ( p ) = preamble ; 
  25.   rlink ( p ) = curspan ; 
  26.   mem [ p + 2 ] .cint = curloop ; 
  27.   mem [ p + 3 ] .cint = alignstate ; 
  28.   info ( p + 4 ) = curhead ; 
  29.   link ( p + 4 ) = curtail ;
  30.   }
  31.   alignptr = p ; 
  32.   curhead = getavail () ;
  33. }
  34.  
  35. void popalignment ( void )
  36. { popalignment_regmem 
  37.   register halfword p  ; 
  38.  
  39.   freeavail ( curhead ) ; 
  40.   p = alignptr ; 
  41.   curtail = link ( p + 4 ) ; 
  42.   curhead = info ( p + 4 ) ; 
  43.   alignstate = mem [ p + 3 ] .cint ; 
  44.   curloop = mem [ p + 2 ] .cint ; 
  45.   curspan = rlink ( p ) ; 
  46.   preamble = llink ( p ) ; 
  47.   curalign = info ( p ) ; 
  48.   alignptr = link ( p ) ; 
  49.   freenode ( p , alignstacknodesize ) ; 
  50. }
  51.  
  52. void getpreambletoken ( void )
  53. { getpreambletoken_regmem 
  54.   register eightbits r_curcmd;
  55.  
  56. lab20:
  57.   r_curcmd = gettoken () ; 
  58.   while ( (r_curcmd == 4) && (curchr == spancode) ) {
  59.     r_curcmd = gettoken ();
  60.     if ( r_curcmd > maxcommand ) {
  61.       expand ();
  62.       r_curcmd = gettoken ();
  63.     }
  64.   }
  65.  
  66.   if ( r_curcmd == 9 )
  67.     fatalerror( STR_H_FE_INTERWOVEN );
  68.  
  69.   if ( (r_curcmd == assign_glue) && (curchr == gluebase + tabskipcode) ) {
  70.     scanoptionalequals ();
  71.     { register long_halfword r_curval;
  72.  
  73.       r_curval = scanglue( glueval );
  74.       if ( globaldefs > 0 )
  75.     geqdefine( gluebase + tabskipcode, glueref, r_curval );
  76.       else
  77.     eqdefine( gluebase + tabskipcode, glueref, r_curval );
  78.     }
  79.     goto lab20;
  80.   }
  81. }
  82.  
  83. void initalign ( void )
  84. {/* 30 31 32 22 */ initalign_regmem 
  85.   register halfword savecsptr  ; 
  86.   register halfword p  ; 
  87.  
  88.   savecsptr = curcs ; 
  89.   pushalignment () ; 
  90.   alignstate = -1000000L ; 
  91.   if ( ( curlist .modefield == mmode )
  92.   && ( ( curlist .tailfield != curlist .headfield )
  93.     || ( curlist .auxfield .cint != 0 ) ) )
  94.   {
  95.     p_print_err( STR_H_IMPROPER );
  96.     printesc ( 516 ) ; 
  97.     c_print(" inside $$'s");
  98.     zhelp2( STR_H_DISPLAYSCANUSE, STR_H_SOIVE_FORMULAS );
  99.     error () ; 
  100.     flushmath () ; 
  101.   } 
  102.   pushnest () ; 
  103.   if ( curlist .modefield == mmode ) {
  104.     curlist .modefield = -vmode;
  105.     curlist .auxfield .cint = nest [ nestptr - 2 ] .auxfield .cint ; 
  106.   } else if ( curlist .modefield > 0 ) 
  107.     curlist .modefield = - curlist .modefield ; 
  108.   scanspec ( aligngroup , false ) ; 
  109.   preamble = 0 ; 
  110.   curalign = alignhead ; 
  111.   curloop = 0 ; 
  112.   scannerstatus = aligning ; 
  113.   warningindex = savecsptr ; 
  114.   alignstate = -1000000L ; 
  115.   while ( true ) {
  116.     link ( curalign ) = newparamglue ( tabskipcode ) ; 
  117.     curalign = link ( curalign ) ; 
  118.     if ( curcmd == 5 ) 
  119.       goto lab30 ; 
  120.     p = holdhead ; 
  121.     link ( p ) = 0 ; 
  122.     while ( true ) {
  123.       getpreambletoken () ; 
  124.       if ( curcmd == 6 ) 
  125.     goto lab31 ; 
  126.       if ( ( curcmd <= 5 ) && ( curcmd >= 4 ) && ( alignstate == -1000000L ) ) 
  127.       if ( ( p == holdhead ) && ( curloop == 0 ) && ( curcmd == 4 ) ) 
  128.     curloop = curalign ; 
  129.       else {
  130.     print_err("Missing # inserted in alignment preamble");
  131.     zhelp2( STR_H_THERESHOULD_TAB, STR_H_NONESOIVEPUT );
  132.     backerror () ; 
  133.     goto lab31 ; 
  134.       } else if ( ( curcmd != 10 ) || ( p != holdhead ) ) {
  135.     link ( p ) = getavail () ; 
  136.     p = link ( p ) ; 
  137.     info ( p ) = curtok ; 
  138.       }
  139.     }
  140. lab31: ; 
  141.     link ( curalign ) = newnullbox () ; 
  142.     curalign = link ( curalign ) ; 
  143.     info ( curalign ) = endspan ; 
  144.     width ( curalign ) = nullflag ; 
  145.     upart ( curalign ) = link ( holdhead ) ; 
  146.     p = holdhead ; 
  147.     link ( p ) = 0 ; 
  148.     while ( true ) {
  149. lab22:
  150.       getpreambletoken () ; 
  151.       if ( ( curcmd <= 5 ) && ( curcmd >= 4 ) && ( alignstate == -1000000L ) ) 
  152.         goto lab32 ; 
  153.       if ( curcmd == 6 ) {
  154.     print_err("Only one # is allowed per tab");
  155.     zhelp2( STR_H_THERESHOULD_TAB, STR_H_MORETHANONE_SOIM );
  156.     error () ; 
  157.     goto lab22 ; 
  158.       }
  159.       link ( p ) = getavail () ; 
  160.       p = link ( p ) ; 
  161.       info ( p ) = curtok ; 
  162.     }
  163. lab32:
  164.     link ( p ) = getavail () ; 
  165.     p = link ( p ) ; 
  166.     info ( p ) = endtemplatetoken ; 
  167.     vpart ( curalign ) = link ( holdhead ) ; 
  168.   }
  169. lab30:
  170.   scannerstatus = normal ; 
  171.   newsavelevel ( aligngroup ) ; 
  172.   if ( everycr != 0 ) 
  173.     begintokenlist ( everycr , everycrtext ) ; 
  174.   alignpeek () ; 
  175. }
  176.  
  177. void initspan ( halfword p )
  178. { initspan_regmem 
  179.  
  180.   pushnest () ; 
  181.   if ( curlist .modefield == -hmode )
  182.     curlist .auxfield .hh .v.LH = 1000 ; 
  183.   else {
  184.     curlist .auxfield .cint = ignoredepth ; 
  185.     normalparagraph () ; 
  186.   } 
  187.   curspan = p ; 
  188. } 
  189.  
  190. void initrow ( void )
  191. { initrow_regmem 
  192.  
  193.   pushnest () ; 
  194.   curlist.modefield = - ((hmode + vmode) + curlist.modefield);
  195.   if ( curlist .modefield == -hmode )
  196.     curlist .auxfield .hh .v.LH = 0 ; 
  197.   else
  198.     curlist .auxfield .cint = 0 ; 
  199.   tailappend ( newglue ( glueptr ( preamble ) ) ) ; 
  200.   subtype ( curlist .tailfield ) = tabskipcode + 1 ; 
  201.   curalign = link ( preamble ) ; 
  202.   curtail = curhead ; 
  203.   initspan ( curalign ) ; 
  204. }
  205.  
  206. void initcol ( void )
  207. { initcol_regmem 
  208.  
  209.   extrainfo ( curalign ) = curcmd ; 
  210.   if ( curcmd == 63 ) 
  211.     alignstate = 0 ; 
  212.   else {
  213.     backinput () ; 
  214.     begintokenlist ( upart ( curalign ) , utemplate ) ; 
  215.   } 
  216. }
  217.  
  218. boolean fincol ( void )
  219. {/* 10 */ fincol_regmem 
  220.   register halfword p  ; 
  221.   register halfword q, r  ; 
  222.   register halfword s  ; 
  223.   register halfword u  ; 
  224.   register scaled w  ; 
  225.   register glueord o  ; 
  226.   register halfword n  ; 
  227.  
  228.   if ( curalign == 0 ) 
  229.     confusion("endv"); /* 902 */
  230.   q = link ( curalign ) ; 
  231.   if ( q == 0 )
  232.     confusion("endv"); /* 902 */
  233.   if ( alignstate < 500000L ) 
  234.     fatalerror( STR_H_FE_INTERWOVEN );
  235.   p = link ( q ) ; 
  236.   if ( ( p == 0 ) && ( extrainfo ( curalign ) < crcode ) ) 
  237.   if ( curloop != 0 ) {
  238.     link ( q ) = newnullbox () ; 
  239.     p = link ( q ) ; 
  240.     info ( p ) = endspan ; 
  241.     width ( p ) = nullflag ; 
  242.     curloop = link ( curloop ) ; 
  243.     q = holdhead ; 
  244.     r = upart ( curloop ) ; 
  245.     while ( r != 0 ) {
  246.       link ( q ) = getavail () ; 
  247.       q = link ( q ) ; 
  248.       info ( q ) = info ( r ) ; 
  249.       r = link ( r ) ; 
  250.     } 
  251.     link ( q ) = 0 ; 
  252.     upart ( p ) = link ( holdhead ) ; 
  253.     q = holdhead ; 
  254.     r = vpart ( curloop ) ; 
  255.     while ( r != 0 ) {
  256.       link ( q ) = getavail () ; 
  257.       q = link ( q ) ; 
  258.       info ( q ) = info ( r ) ; 
  259.       r = link ( r ) ; 
  260.     } 
  261.     link ( q ) = 0 ; 
  262.     vpart ( p ) = link ( holdhead ) ; 
  263.     curloop = link ( curloop ) ; 
  264.     link ( p ) = newglue ( glueptr ( curloop ) ) ; 
  265.   } else {
  266.     print_err("Extra alignment tab has been changed to ");
  267.     printesc( STR_CR );
  268.     zhelp1( STR_H_YOUHAVE_SPANORTAB );
  269.     extrainfo ( curalign ) = crcode ; 
  270.     error () ; 
  271.   }
  272.   if ( extrainfo ( curalign ) != spancode ) {
  273.     unsave () ; 
  274.     newsavelevel ( aligngroup ) ; 
  275.     {
  276.       if ( curlist .modefield == -hmode ) {
  277.     adjusttail = curtail ; 
  278.     u = hpack ( link ( curlist .headfield ) , 0 , 1 ) ; 
  279.     w = width ( u ) ; 
  280.     curtail = adjusttail ; 
  281.     adjusttail = 0 ; 
  282.       } else {
  283.     u = vpackage ( link ( curlist .headfield ) , 0 , 1 , 0 ) ; 
  284.     w = height ( u ) ; 
  285.       } 
  286.       n = 0 ; 
  287.       if ( curspan != curalign ) {
  288.     q = curspan ; 
  289.     do {
  290.       incr ( n ) ; 
  291.       q = link ( link ( q ) ) ; 
  292.     } while ( ! ( q == curalign ) ) ; 
  293.     if ( n > maxquarterword ) 
  294.       confusion("256 spans"); /* 907 */
  295.     q = curspan ; 
  296.     while ( link ( info ( q ) ) < n ) q = info ( q ) ; 
  297.     if ( link ( info ( q ) ) > n ) {
  298.       s = getnode ( spannodesize ) ; 
  299.       info ( s ) = info ( q ) ; 
  300.       link ( s ) = n ; 
  301.       info ( q ) = s ; 
  302.       width ( s ) = w ; 
  303.     }
  304.     else if ( width ( info ( q ) ) < w ) 
  305.     width ( info ( q ) ) = w ; 
  306.       }
  307.       else if ( w > width ( curalign ) ) 
  308.       width ( curalign ) = w ; 
  309.       ztype ( u ) = unsetnode ; 
  310.       spancount ( u ) = n ; 
  311.       if ( totalstretch [ filll ] != 0 ) 
  312.     o = filll ; 
  313.       else if ( totalstretch [ fill ] != 0 ) 
  314.     o = fill ; 
  315.       else if ( totalstretch [ fil ] != 0 ) 
  316.     o = fil ; 
  317.       else
  318.     o = normal ; 
  319.       glueorder ( u ) = o ; 
  320.       gluestretch ( u ) = totalstretch [ o ] ; 
  321.       if ( totalshrink [ filll ] != 0 ) 
  322.     o = filll ; 
  323.       else if ( totalshrink [ fill ] != 0 ) 
  324.     o = fill ; 
  325.       else if ( totalshrink [ fil ] != 0 ) 
  326.     o = fil ; 
  327.       else
  328.     o = normal ; 
  329.       gluesign ( u ) = o ; 
  330.       glueshrink ( u ) = totalshrink [ o ] ; 
  331.       popnest () ; 
  332.       link ( curlist .tailfield ) = u ; 
  333.       curlist .tailfield = u ; 
  334.     }
  335.     tailappend ( newglue ( glueptr ( link ( curalign ) ) ) ) ; 
  336.     subtype ( curlist .tailfield ) = tabskipcode + 1 ; 
  337.     if ( extrainfo ( curalign ) >= crcode ) {
  338.       return(true) ; 
  339.     }
  340.     initspan ( p ) ; 
  341.   }
  342.   alignstate = 1000000L ;
  343. #if 0
  344.   do {
  345.     getxtoken () ; 
  346.   } while ( ! ( curcmd != 10 ) ) ; 
  347. #else
  348.   getxnbtoken(0);
  349. #endif
  350.   curalign = p ; 
  351.   initcol () ; 
  352.  
  353.   return(false);
  354. }
  355.  
  356. void finrow ( void )
  357. { finrow_regmem 
  358.   register halfword p  ; 
  359.  
  360.   if ( curlist .modefield == -hmode ) {
  361.     p = hpack ( link ( curlist .headfield ) , 0 , 1 ) ; 
  362.     popnest () ; 
  363.     appendtovlist ( p ) ; 
  364.     if ( curhead != curtail ) {
  365.       link ( curlist .tailfield ) = link ( curhead ) ; 
  366.       curlist .tailfield = curtail ; 
  367.     } 
  368.   } else {
  369.     p = vpackage ( link ( curlist .headfield ) , 0 , 1 , maxdimen ) ; 
  370.     popnest () ; 
  371.     link ( curlist .tailfield ) = p ; 
  372.     curlist .tailfield = p ; 
  373.     curlist .auxfield .hh .v.LH = 1000 ; 
  374.   } 
  375.   ztype ( p ) = unsetnode ; 
  376.   gluestretch ( p ) = 0 ; 
  377.   if ( everycr != 0 )
  378.     begintokenlist ( everycr , everycrtext ) ; 
  379.   alignpeek () ; 
  380. }
  381.  
  382. void finalign ( void )
  383. { finalign_regmem 
  384.   register halfword p, q, r, s, u, v  ; 
  385.   register scaled t, w  ; 
  386.   register scaled o  ; 
  387.   register halfword n  ; 
  388.   register scaled rulesave  ; 
  389.   memoryword auxsave  ; 
  390.  
  391.   if ( curgroup != aligngroup ) 
  392.     confusion("align1"); /* 908 */
  393.   unsave () ; 
  394.   if ( curgroup != aligngroup ) 
  395.     confusion("align2"); /* 909 */
  396.   unsave () ; 
  397.   if ( nest [ nestptr - 1 ] .modefield == mmode ) 
  398.     o = displayindent ; 
  399.   else o = 0 ; 
  400.   q = link ( preamble ) ; 
  401.   do {
  402.     flushlist ( upart ( q ) ) ; 
  403.     flushlist ( vpart ( q ) ) ; 
  404.     p = link ( link ( q ) ) ; 
  405.     if ( width ( q ) == nullflag ) {
  406.       width ( q ) = 0 ; 
  407.       r = link ( q ) ; 
  408.       s = glueptr ( r ) ; 
  409.       if ( s != zeroglue ) {
  410.     addglueref ( zeroglue ) ; 
  411.     deleteglueref ( s ) ; 
  412.     glueptr ( r ) = zeroglue ; 
  413.       } 
  414.     }
  415.     if ( info ( q ) != endspan ) {
  416.       t = width ( q ) + width ( glueptr ( link ( q ) ) ) ; 
  417.       r = info ( q ) ; 
  418.       s = endspan ; 
  419.       info ( s ) = p ; 
  420.       n = 1 ; 
  421.       do {
  422.     width ( r ) = width ( r ) - t ; 
  423.     u = info ( r ) ; 
  424.     while ( link ( r ) > n ) {
  425.       s = info ( s ) ; 
  426.       n = link ( info ( s ) ) + 1 ; 
  427.     } 
  428.     if ( link ( r ) < n ) {
  429.       info ( r ) = info ( s ) ; 
  430.       info ( s ) = r ; 
  431.       decr ( link ( r ) ) ; 
  432.       s = r ; 
  433.     } else {
  434.       if ( width ( r ) > width ( info ( s ) ) ) 
  435.         width ( info ( s ) ) = width ( r ) ; 
  436.       freenode ( r , spannodesize ) ; 
  437.     }
  438.     r = u ; 
  439.       } while ( ! ( r == endspan ) ) ; 
  440.     }
  441.     ztype ( q ) = unsetnode ; 
  442.     spancount ( q ) = 0 ; 
  443.     height ( q ) = 0 ; 
  444.     depth ( q ) = 0 ; 
  445.     glueorder ( q ) = normal ; 
  446.     gluesign ( q ) = normal ; 
  447.     gluestretch ( q ) = 0 ; 
  448.     glueshrink ( q ) = 0 ; 
  449.     q = p ; 
  450.   } while ( ! ( q == 0 ) ) ; 
  451.   saveptr = saveptr - 2 ; 
  452.   packbeginline = - (integer) curlist .mlfield ; 
  453.   if ( curlist .modefield == -vmode ) {
  454.     rulesave = overfullrule ; 
  455.     overfullrule = 0 ; 
  456.     p = hpack ( preamble , saved ( 1 ) , saved ( 0 ) ) ; 
  457.     overfullrule = rulesave ; 
  458.   } else {
  459.     q = link ( preamble ) ; 
  460.     do {
  461.       height ( q ) = width ( q ) ; 
  462.       width ( q ) = 0 ; 
  463.       q = link ( link ( q ) ) ; 
  464.     } while ( ! ( q == 0 ) ) ; 
  465.     p = vpackage ( preamble , saved ( 1 ) , saved ( 0 ) , maxdimen ) ; 
  466.     q = link ( preamble ) ; 
  467.     do {
  468.       width ( q ) = height ( q ) ; 
  469.       height ( q ) = 0 ; 
  470.       q = link ( link ( q ) ) ; 
  471.     } while ( ! ( q == 0 ) ) ; 
  472.   }
  473.   packbeginline = 0 ; 
  474.   q = link ( curlist .headfield ) ; 
  475.   s = curlist .headfield ; 
  476.   while ( q != 0 ) {
  477.     if ( ! ischarnode ( q ) ) 
  478.     if ( ztype ( q ) == unsetnode ) {
  479.       if ( curlist .modefield == -vmode ) {
  480.     ztype ( q ) = hlistnode ; 
  481.     width ( q ) = width ( p ) ; 
  482.       } else {
  483.     ztype ( q ) = vlistnode ; 
  484.     height ( q ) = height ( p ) ; 
  485.       } 
  486.       glueorder ( q ) = glueorder ( p ) ; 
  487.       gluesign ( q ) = gluesign ( p ) ; 
  488.       glueset ( q ) = glueset ( p ) ; 
  489.       shiftamount ( q ) = o ; 
  490.       r = link ( listptr ( q ) ) ; 
  491.       s = link ( listptr ( p ) ) ; 
  492.       do {
  493.     n = spancount ( r ) ; 
  494.     t = width ( s ) ; 
  495.     w = t ; 
  496.     u = holdhead ; 
  497.     while ( n > 0 ) {
  498.       decr ( n ) ; 
  499.       s = link ( s ) ; 
  500.       v = glueptr ( s ) ; 
  501.       link ( u ) = newglue ( v ) ; 
  502.       u = link ( u ) ; 
  503.       subtype ( u ) = tabskipcode + 1 ; 
  504.       t = t + width ( v ) ; 
  505.       if ( gluesign ( p ) == stretching ) {
  506.         if ( stretchorder ( v ) == glueorder ( p ) ) 
  507.         t = t + round ( glueset ( p ) * stretch ( v ) ) ; 
  508.       } else if ( gluesign ( p ) == shrinking ) {
  509.         if ( shrinkorder ( v ) == glueorder ( p ) ) 
  510.         t = t - round ( glueset ( p ) * shrink ( v ) ) ; 
  511.       }
  512.       s = link ( s ) ; 
  513.       link ( u ) = newnullbox () ; 
  514.       u = link ( u ) ; 
  515.       t = t + width ( s ) ; 
  516.       if ( curlist .modefield == -vmode ) 
  517.         width ( u ) = width ( s ) ; 
  518.       else {
  519.         ztype ( u ) = vlistnode ; 
  520.         height ( u ) = width ( s ) ; 
  521.       } 
  522.     }
  523.     if ( curlist .modefield == -vmode ) {
  524.       height ( r ) = height ( q ) ; 
  525.       depth ( r ) = depth ( q ) ; 
  526.       if ( t == width ( r ) ) {
  527.         gluesign ( r ) = normal ; 
  528.         glueorder ( r ) = normal ; 
  529.         glueset ( r ) = 0.0 ; 
  530.       } else if ( t > width ( r ) ) {
  531.         gluesign ( r ) = stretching ; 
  532.         if ( gluestretch ( r ) == 0 ) 
  533.         glueset ( r ) = 0.0 ; 
  534.         else glueset ( r ) = ( t - width ( r ) ) / ((double) gluestretch ( 
  535.         r ) ) ; 
  536.       } else {
  537.         glueorder ( r ) = gluesign ( r ) ; 
  538.         gluesign ( r ) = shrinking ; 
  539.         if ( glueshrink ( r ) == 0 ) 
  540.         glueset ( r ) = 0.0 ; 
  541.         else if ( ( glueorder ( r ) == normal ) && ( width ( r ) - t > 
  542.         glueshrink ( r ) ) ) 
  543.         glueset ( r ) = 1.0 ; 
  544.         else glueset ( r ) = ( width ( r ) - t ) / ((double) glueshrink ( 
  545.         r ) ) ; 
  546.       } 
  547.       width ( r ) = w ; 
  548.       ztype ( r ) = hlistnode ; 
  549.     } else {
  550.       width ( r ) = width ( q ) ; 
  551.       if ( t == height ( r ) ) {
  552.         gluesign ( r ) = normal ; 
  553.         glueorder ( r ) = normal ; 
  554.         glueset ( r ) = 0.0 ; 
  555.       } else if ( t > height ( r ) ) {
  556.         gluesign ( r ) = stretching ; 
  557.         if ( gluestretch ( r ) == 0 ) 
  558.         glueset ( r ) = 0.0 ; 
  559.         else glueset ( r ) = ( t - height ( r ) ) / ((double) gluestretch 
  560.         ( r ) ) ; 
  561.       } else {
  562.         glueorder ( r ) = gluesign ( r ) ; 
  563.         gluesign ( r ) = shrinking ; 
  564.         if ( glueshrink ( r ) == 0 ) 
  565.         glueset ( r ) = 0.0 ; 
  566.         else if ( ( glueorder ( r ) == normal ) && ( height ( r ) - t > 
  567.         glueshrink ( r ) ) ) 
  568.         glueset ( r ) = 1.0 ; 
  569.         else glueset ( r ) = ( height ( r ) - t ) / ((double) glueshrink ( 
  570.         r ) ) ; 
  571.       } 
  572.       height ( r ) = w ; 
  573.       ztype ( r ) = vlistnode ; 
  574.     }
  575.     shiftamount ( r ) = 0 ; 
  576.     if ( u != holdhead ) {
  577.       link ( u ) = link ( r ) ; 
  578.       link ( r ) = link ( holdhead ) ; 
  579.       r = u ; 
  580.     } 
  581.     r = link ( link ( r ) ) ; 
  582.     s = link ( link ( s ) ) ; 
  583.       } while ( ! ( r == 0 ) ) ; 
  584.     } else if ( ztype ( q ) == rulenode ) {
  585.       if ( isrunning ( width ( q ) ) ) 
  586.       width ( q ) = width ( p ) ; 
  587.       if ( isrunning ( height ( q ) ) ) 
  588.       height ( q ) = height ( p ) ; 
  589.       if ( isrunning ( depth ( q ) ) ) 
  590.       depth ( q ) = depth ( p ) ; 
  591.       if ( o != 0 ) {
  592.     r = link ( q ) ; 
  593.     link ( q ) = 0 ; 
  594.     q = hpack ( q , 0 , 1 ) ; 
  595.     shiftamount ( q ) = o ; 
  596.     link ( q ) = r ; 
  597.     link ( s ) = q ; 
  598.       } 
  599.     }
  600.     s = q ; 
  601.     q = link ( q ) ; 
  602.   }
  603.   flushnodelist ( p ) ; 
  604.   popalignment () ; 
  605.   auxsave = curlist .auxfield ; 
  606.   p = link ( curlist .headfield ) ; 
  607.   q = curlist .tailfield ; 
  608.   popnest () ; 
  609.   if ( curlist .modefield == mmode ) {
  610.     doassignments () ; 
  611.     if ( curcmd != 3 ) {
  612.       print_err("Missing $$ inserted");
  613.       zhelp1( STR_H_DISPLAYSCANUSE );
  614.       backerror () ; 
  615.     } else {
  616.       check_that_dollar_follows();
  617.     }
  618.     popnest () ; 
  619.     tailappend ( newpenalty ( predisplaypenalty ) ) ; 
  620.     tailappend ( newparamglue ( abovedisplayskipcode ) ) ; 
  621.     link ( curlist .tailfield ) = p ; 
  622.     if ( p != 0 ) 
  623.       curlist .tailfield = q ; 
  624.     tailappend ( newpenalty ( postdisplaypenalty ) ) ; 
  625.     tailappend ( newparamglue ( belowdisplayskipcode ) ) ; 
  626.     curlist .auxfield .cint = auxsave .cint ; 
  627.     resumeafterdisplay () ; 
  628.  
  629.   } else {
  630.  
  631.     curlist .auxfield = auxsave ; 
  632.     link ( curlist .tailfield ) = p ; 
  633.     if ( p != 0 ) 
  634.       curlist .tailfield = q;
  635.     if ( curlist .modefield == vmode ) 
  636.       buildpage ();
  637.   }
  638. }
  639.  
  640. void alignpeek ( void )
  641. { alignpeek_regmem 
  642.   register eightbits r_curcmd;
  643.  
  644. lab20:
  645.   alignstate = 1000000L ;
  646. #if 0
  647.   do {
  648.     r_curcmd = getxtoken () ; 
  649.   } while ( r_curcmd == 10 );
  650. #else
  651.   r_curcmd = getxnbtoken(0);
  652. #endif
  653.   if ( r_curcmd == 34 ) {
  654.     scanleftbrace () ; 
  655.     newsavelevel ( noaligngroup ) ; 
  656.     if ( curlist .modefield == -vmode ) 
  657.       normalparagraph () ; 
  658.   } else if ( r_curcmd == 2 ) 
  659.     finalign () ; 
  660.   else if ( ( r_curcmd == 5 ) && ( curchr == crcrcode ) ) 
  661.     goto lab20 ; 
  662.   else {
  663.     initrow () ; 
  664.     initcol () ; 
  665.   } 
  666. }
  667.  
  668. long_halfword finiteshrink ( halfword p )
  669. { finiteshrink_regmem 
  670.  
  671.   if ( noshrinkerroryet ) {
  672.     noshrinkerroryet = false ; 
  673.     print_err("Infinite glue shrinkage found in a paragraph");
  674.     zhelp2( STR_H_THEPARAGRAPHJUST, STR_H_SINCETHE_OFFENSIVE );
  675.     error();
  676.   }
  677.   { register long_halfword q;
  678.  
  679.   q = newspec ( p ) ; 
  680.   shrinkorder ( q ) = normal ; 
  681.   deleteglueref ( p ) ; 
  682.  
  683.   return(q) ;
  684.   }
  685. }
  686.  
  687. #if 0        /* in linebrk.c */
  688.  
  689. void ztrybreak ( pi , breaktype ) 
  690.  
  691. #endif
  692.