home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / linebrk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-11  |  36.3 KB  |  1,568 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void trybreak ( integer pi, smallnumber breaktype )        /* 829. */
  5. {/* 10 30 31 22 60 */ trybreak_regmem 
  6.   register halfword r  ; 
  7.   register halfword prevr  ; 
  8.   register halfword oldl  ; 
  9.   boolean nobreakyet  ; 
  10.   register halfword prevprevr  ; 
  11. /* register halfword s; */
  12. /* register halfword q; */
  13. /* register halfword v; */
  14. /* register integer t; */
  15. /* register internalfontnumber f; */
  16.   register halfword l  ; 
  17.   boolean noderstaysactive  ; 
  18.   register scaled linewidth  ; 
  19.   register schar fitclass  ; 
  20.   register halfword b  ; 
  21.   register integer d  ; 
  22.   boolean artificialdemerits  ; 
  23. /* register halfword savelink; */
  24. /* register scaled shortfall; */
  25.  
  26. #if 0
  27.   scaled breakwidth[6];
  28.   scaled curactivewidth[6];
  29. #endif
  30.  
  31.   if ( abs ( pi ) >= infpenalty ) 
  32.     if ( pi > 0 ) 
  33.       goto lab10;
  34.     else
  35.       pi = ejectpenalty;
  36.  
  37.   nobreakyet = true ; 
  38.   oldl = 0 ;
  39.   prevr = active ; 
  40. #if 0
  41.   { register scaled *caw1 = &curactivewidth[0];
  42.     register scaled *aw  = &activewidth[0];
  43.  
  44.     *caw1++ = *aw++;    *caw1++ = *aw++;    *caw1++ = *aw++;
  45.     *caw1++ = *aw++;    *caw1++ = *aw++;    *caw1   = *aw;
  46.   }
  47. #else
  48.   { register scaled *aw  = &activewidth[0];
  49.  
  50.     curactivewidth[0] = *aw++;    curactivewidth[1] = *aw++;
  51.     curactivewidth[2] = *aw++;    curactivewidth[3] = *aw++;
  52.     curactivewidth[4] = *aw++;    curactivewidth[5] = *aw;
  53.   }
  54. #endif
  55.  
  56.   while ( true ) {
  57.       
  58. lab22:
  59.    { register long_halfword tmp_r;
  60.  
  61.     tmp_r = link ( prevr ) ; 
  62.  
  63.     while ( ztype ( tmp_r ) == deltanode ) {
  64. #if 0
  65.       curactivewidth [ 1 ] = curactivewidth [ 1 ] + mem [ r + 1 ] .cint ; 
  66.     ...
  67.       curactivewidth [ 6 ] = curactivewidth [ 6 ] + mem [ r + 6 ] .cint ; 
  68. #else
  69.       /* !!!! inner loop !!!! */
  70.       register scaled *caw = &curactivewidth[0];
  71.       register memoryword *memr = &mem[tmp_r];
  72.       memr++;  /* produces better code than: memr = &mem[tmp_r+1] */
  73.  
  74.       *caw++ += (memr++)->cint;      *caw++ += (memr++)->cint;
  75.       *caw++ += (memr++)->cint;      *caw++ += (memr++)->cint;
  76.       *caw++ += (memr++)->cint;      *caw   += memr->cint;
  77. #endif
  78.       prevprevr = prevr ; 
  79.       prevr = tmp_r ;
  80.       tmp_r = link ( /*prevr*/ tmp_r );        /* goto lab22; */
  81.     }
  82.  
  83.     r = tmp_r;
  84.     l = zlinenumber ( tmp_r ) ; 
  85.    }
  86.  
  87.     {
  88.       if ( l > oldl ) {
  89.     if ( ( minimumdemerits < awfulbad )
  90.         && ( ( oldl != easyline ) || ( r == lastactive ) ) ) {
  91.       if ( nobreakyet ) {
  92.         register halfword s;
  93.  
  94.         nobreakyet = false;
  95.         { register scaled *bw = &breakwidth[0];
  96.           register scaled *bg = &background[0];    /* was 1 */
  97.  
  98.           *bw++ = *bg++;  *bw++ = *bg++;  *bw++ = *bg++;
  99.           *bw++ = *bg++;  *bw++ = *bg++;  *bw   = *bg;
  100.         }
  101.         s = curp ; 
  102.         if ( breaktype > unhyphenated && /*curp*/ s != 0 ) {
  103.           register halfword v;
  104.           integer t;
  105.  
  106.           v = /*curp*/ s ; 
  107.           s = postbreak ( /*curp*/ v ) ; 
  108.           t = replacecount ( /*curp*/ v ) ; 
  109.           while ( t > 0 ) {
  110.         decr ( t ) ; 
  111.         v = link ( v ) ; 
  112.         if ( ischarnode ( v ) ) {
  113.           internalfontnumber f;
  114.  
  115.           f = font ( v ) ; 
  116.           breakwidth[0] -= zcharwidth(f, zcharinfo(f, character(v)));
  117.         } else switch ( ztype ( v ) ) {
  118.         case ligaturenode :
  119.           { internalfontnumber f;
  120.  
  121.             f = font ( ligchar ( v ) );
  122.             breakwidth [ 0 ] -= zcharwidth ( f,
  123.             zcharinfo ( f, character ( ligchar ( v ) ) ) ) ;
  124.           }
  125.           break ; 
  126.         case hlistnode : 
  127.         case vlistnode : 
  128.         case rulenode : 
  129.         case kernnode : 
  130.           breakwidth [ 0 ] -= width ( v ) ;
  131.           break ;
  132.         default: 
  133.           confusion("disc1");
  134.           break ; 
  135.         } 
  136.           }        /* while ( t > 0 ) */
  137.           while ( s != 0 ) {
  138.         if ( ischarnode ( s ) ) {
  139.           internalfontnumber f;
  140.  
  141.           f = font ( s ) ; 
  142.           breakwidth [ 0 ] += zcharwidth ( f,
  143.                 zcharinfo ( f, character ( s ) ) ) ;
  144.         } else switch ( ztype ( s ) ) {
  145.         case ligaturenode : 
  146.           { internalfontnumber f;
  147.  
  148.             f = font ( ligchar ( s ) ) ; 
  149.             breakwidth [ 0 ] += zcharwidth ( f,
  150.             zcharinfo ( f, character ( ligchar ( s ) ) ) ) ;
  151.           }
  152.           break ; 
  153.         case hlistnode : 
  154.         case vlistnode : 
  155.         case rulenode : 
  156. #if 1  /* 3.1415 */
  157.         case kernnode : 
  158. #endif
  159.           breakwidth [ 0 ] += width ( s ) ; 
  160.           break ; 
  161. #if 0  /* 3.1415 */
  162.         case kernnode : 
  163.           if ( ( t == 0 ) && ( subtype ( s ) != acckern ) ) 
  164.             t = -1 ; 
  165.           else
  166.             breakwidth [ 0 ] += width ( s ) ;
  167.           break ;
  168. #endif
  169.         default: 
  170.           confusion("disc2");
  171.           break ; 
  172.         } 
  173.         incr ( t ) ; 
  174.         s = link ( s ) ; 
  175.           }            /* while ( s != 0 ) */
  176.           breakwidth [ 0 ] += discwidth ;
  177. #if 0  /* 3.1415 */
  178.           if ( t == 0 )
  179.         s = link ( v ) ; 
  180. #else
  181.           if ( postbreak(curp) == 0 )
  182.         s = link ( v ) ; 
  183. #endif
  184.         }
  185.         while ( s != 0 ) {
  186.           if ( ischarnode ( s ) ) 
  187.         goto lab30 ; 
  188.           switch ( ztype ( s ) ) {
  189.           case gluenode : 
  190.         { register halfword v;
  191.  
  192.           v = glueptr ( s ) ; 
  193.           breakwidth [ 0 ] -= width ( v ) ;
  194.           breakwidth [ 1 + stretchorder ( v ) ] -= stretch ( v ) ;
  195.           breakwidth [ 5 ] -= shrink ( v ) ;
  196.         }
  197.         break ;
  198.           case penaltynode : 
  199.         break ; 
  200. #if 0  /* 3.1415 */
  201.           case mathnode : 
  202.           case kernnode : 
  203.         if ( subtype ( s ) == acckern )
  204.           goto lab30 ;
  205.         else
  206.           breakwidth [ 0 ] -= width ( s ) ;
  207.         break ; 
  208. #else
  209.           case mathnode : 
  210.           breakwidth [ 0 ] -= width ( s ) ;
  211.         break;
  212.           case kernnode : 
  213.         if ( subtype ( s ) != explicit )
  214.           goto lab30 ;
  215.         else
  216.           breakwidth [ 0 ] -= width ( s ) ;
  217.         break ; 
  218. #endif
  219.           default: 
  220.         goto lab30 ; 
  221.         break ; 
  222.           } 
  223.           s = link ( s ) ; 
  224.         }
  225. lab30: ;
  226.       }    /* if ( nobreakyet ) */
  227.  
  228.       if ( ztype ( prevr ) == deltanode ) {
  229. #if 0
  230.         converttobreakwidth ( 1 ); ... converttobreakwidth ( 6 );
  231. #else
  232.         register scaled *caw = &curactivewidth[0];
  233.         register scaled *bw  = &breakwidth[0];
  234.         register memoryword *mem_prevr = &mem[prevr];
  235.         mem_prevr++;
  236.  
  237.         (mem_prevr++)->cint += (*bw++ - *caw++);
  238.         (mem_prevr++)->cint += (*bw++ - *caw++);
  239.         (mem_prevr++)->cint += (*bw++ - *caw++);
  240.         (mem_prevr++)->cint += (*bw++ - *caw++);
  241.         (mem_prevr++)->cint += (*bw++ - *caw++);
  242.         (mem_prevr)->cint   += (*bw   - *caw);
  243. #endif
  244.       } else if ( prevr == active ) {
  245. #if 0
  246.         storebreakwidth ( 1 ); ... storebreakwidth ( 6 );
  247. #else
  248.         register scaled *aw = &activewidth[0];
  249.         register scaled *bw = &breakwidth[0];
  250.  
  251.         *aw++ = *bw++;  *aw++ = *bw++;  *aw++ = *bw++;
  252.         *aw++ = *bw++;  *aw++ = *bw++;  *aw   = *bw;
  253. #endif
  254.       } else {
  255.         register long_halfword q;
  256.  
  257.         q = getnode ( deltanodesize ) ; 
  258.         link ( q ) = r ;
  259.         /* ztype ( q ) = deltanode; subtype ( q ) = 0; */
  260.         set_type_subtype(q, deltanode, 0);
  261.  
  262. #if 0
  263.         newdeltatobreakwidth ( 1 ); ... newdeltatobreakwidth ( 6 );
  264. #else
  265.         { register scaled *caw = &curactivewidth[0];
  266.           register scaled *bw  = &breakwidth[0];
  267.           register memoryword *mem_q = &mem[q];
  268.           mem_q++;
  269.  
  270.           (mem_q++)->cint = *bw++ - *caw++;
  271.           (mem_q++)->cint = *bw++ - *caw++;
  272.           (mem_q++)->cint = *bw++ - *caw++;
  273.           (mem_q++)->cint = *bw++ - *caw++;
  274.           (mem_q++)->cint = *bw++ - *caw++;
  275.           (mem_q)->cint   = *bw   - *caw;
  276.         }
  277. #endif
  278.         prevprevr = prevr ; 
  279.         link ( prevr ) = q ; 
  280.         prevr = q ; 
  281.       } 
  282.  
  283.       if ( abs ( adjdemerits ) >= awfulbad - minimumdemerits ) 
  284.         minimumdemerits = awfulbad - 1 ; 
  285.       else
  286.         minimumdemerits += abs ( adjdemerits ) ;
  287.  
  288.       for( fitclass = 0 ; fitclass <= 3 ; fitclass++ ) {
  289.         if ( minimaldemerits [ fitclass ] <= minimumdemerits ) {
  290.         register long_halfword q;
  291.  
  292.         q = getnode ( passivenodesize ) ; 
  293.         link ( q ) = passive ; 
  294.         passive = q ; 
  295.         curbreak ( q ) = curp ; 
  296. #ifdef STAT
  297.         incr ( passnumber ) ; 
  298.         serial ( q ) = passnumber ; 
  299. #endif /* STAT */
  300.         prevbreak ( q ) = bestplace [ fitclass ] ;
  301.  
  302.         q = getnode ( activenodesize ) ; 
  303.         breaknode ( q ) = passive ; 
  304.         zlinenumber ( q ) = bestplline [ fitclass ] + 1 ; 
  305.         fitness ( q ) = fitclass ; 
  306.         ztype ( q ) = breaktype ; 
  307.         totaldemerits ( q ) = minimaldemerits [ fitclass ] ; 
  308.         link ( q ) = r;
  309.         link ( prevr ) = q;
  310.         prevr = q;
  311. #ifdef STAT
  312.         if ( tracingparagraphs > 0 ) {
  313.           c_printnl("@@");
  314.           printint ( serial ( passive ) );
  315.           c_print(": line ");
  316.           printint ( zlinenumber ( q ) - 1 );
  317.           printchar ( 46 );
  318.           printint ( fitclass );
  319.           if ( breaktype == hyphenated )
  320.             printchar ( 45 );
  321.           c_print(" t=");
  322.           printint ( totaldemerits ( q ) );
  323.           c_print(" -> @@");
  324.           if ( prevbreak ( passive ) == 0 )
  325.             printchar ( 48 );
  326.           else
  327.             printint ( serial ( prevbreak ( passive ) ) );
  328.         } 
  329. #endif /* STAT */
  330.         }
  331.         minimaldemerits [ fitclass ] = awfulbad ; 
  332.       }
  333.  
  334.       minimumdemerits = awfulbad ; 
  335.       if ( r != lastactive ) {
  336.         register long_halfword q;
  337.  
  338.         q = getnode ( deltanodesize ) ; 
  339.         link ( q ) = r ; 
  340.         /* ztype ( q ) = deltanode; subtype ( q ) = 0; */
  341.         set_type_subtype(q, deltanode, 0);
  342.  
  343. #if 0
  344.         newdeltafrombreakwidth ( 1 ); ... newdeltafrombreakwidth ( 6 );
  345. #else
  346.         { register scaled *caw = &curactivewidth[0];
  347.           register scaled *bw  = &breakwidth[0];
  348.           register memoryword *mem_q = &mem[q];
  349.           mem_q++;
  350.  
  351.           (mem_q++)->cint = *caw++ - *bw++;
  352.           (mem_q++)->cint = *caw++ - *bw++;
  353.           (mem_q++)->cint = *caw++ - *bw++;
  354.           (mem_q++)->cint = *caw++ - *bw++;
  355.           (mem_q++)->cint = *caw++ - *bw++;
  356.           (mem_q)->cint   = *caw   - *bw;
  357.         }
  358. #endif
  359.         prevprevr = prevr ; 
  360.         link ( prevr ) = q ; 
  361.         prevr = q ; 
  362.       } 
  363.     } 
  364.     if ( r == lastactive ) 
  365.       goto lab10 ;
  366.  
  367.     if ( l > easyline ) {
  368.       linewidth = secondwidth ; 
  369.       oldl = maxhalfword - 1 ; 
  370.     } else {
  371.       oldl = l ; 
  372.       if ( l > lastspecialline ) 
  373.         linewidth = secondwidth ; 
  374.       else if ( parshapeptr == 0 ) 
  375.         linewidth = firstwidth ; 
  376.       else
  377.         linewidth = mem [ parshapeptr + 2 * l ] .cint ; 
  378.     }
  379.       }
  380.     }
  381.     {
  382.       artificialdemerits = false ; 
  383.  
  384.     { register scaled *caw = &curactivewidth[0];
  385.       register scaled shortfall;
  386.  
  387.       shortfall = linewidth - *caw;    /*curactivewidth[0]*/
  388.  
  389.       if ( shortfall > 0 ) {
  390.     if ( *(caw+2) != 0 || *(caw+3) != 0 || *(caw+4) != 0 ) {
  391.       b = 0 ; 
  392.       fitclass = 2 ; 
  393.     } else {
  394.       if ( shortfall > 7230584L && *(caw+1) < 1663497L ) {
  395.         b = infbad ; 
  396.         fitclass = 0 ; 
  397.       } else {
  398.         b = badness ( shortfall, *(caw+1) );
  399.         if ( b > 12 ) 
  400.           if ( b > 99 ) 
  401.             fitclass = 0 ; 
  402.           else fitclass = 1 ; 
  403.         else fitclass = 2 ;
  404.       }
  405.         }
  406.       } else {
  407.     if ( - (integer) shortfall > *(caw+5) ) {
  408.       b = infbad + 1 ;
  409.       fitclass = 3 ;
  410.     } else {
  411.       b = badness ( - (integer) shortfall, *(caw+5) ) ; 
  412.     if ( b > 12 ) 
  413.       fitclass = 3 ; 
  414.     else
  415.       fitclass = 2 ;
  416.     }
  417.       }
  418.     }
  419.  
  420.       if ( ( b > infbad ) || ( pi == ejectpenalty ) ) {
  421.     if ( finalpass && ( minimumdemerits == awfulbad )
  422.          && ( link ( r ) == lastactive ) && ( prevr == active ) )
  423.       artificialdemerits = true ; 
  424.     else if ( b > threshold ) 
  425.       goto lab60 ; 
  426.     noderstaysactive = false ; 
  427.       } else {
  428.     prevr = r ; 
  429.     if ( b > threshold ) 
  430.       goto lab22 ; 
  431.     noderstaysactive = true ; 
  432.       }
  433.       if ( artificialdemerits ) 
  434.     d = 0 ; 
  435.       else {
  436.     d = linepenalty + b ; 
  437.     if ( abs ( d ) >= 10000 ) 
  438.       d = 100000000L ; 
  439.     else
  440.       d = d * d ; 
  441.     if ( pi != 0 ) {
  442.       if ( pi > 0 ) 
  443.         d = d + pi * pi ; 
  444.       else if ( pi > ejectpenalty ) 
  445.         d = d - pi * pi ; 
  446.     }
  447.     if ( ( breaktype == hyphenated ) && ( ztype ( r ) == hyphenated ) ) {
  448.       if ( curp != 0 ) 
  449.         d = d + doublehyphendemerits ; 
  450.       else
  451.         d = d + finalhyphendemerits ;
  452.     }
  453.     if ( abs ( toint ( fitclass ) - toint ( fitness ( r ) ) ) > 1 ) 
  454.       d = d + adjdemerits ; 
  455.       }
  456. #ifdef STAT
  457.       if ( tracingparagraphs > 0 ) {
  458.     if ( printednode != curp ) {
  459.       c_printnl("");
  460.       if ( curp == 0 ) 
  461.         shortdisplay ( link ( printednode ) );
  462.       else {
  463.         register halfword savelink;        /* (br) */
  464.  
  465.         savelink = link ( curp ) ; 
  466.         link ( curp ) = 0 ; 
  467.         c_printnl("");
  468.         shortdisplay ( link ( printednode ) ) ; 
  469.         link ( curp ) = savelink ; 
  470.       } 
  471.       printednode = curp ; 
  472.     } 
  473.     printnl ( 64 ) ; 
  474.     if ( curp == 0 ) 
  475.       printesc( STR_PAR );
  476.     else if ( ztype ( curp ) != gluenode ) {
  477.       if ( ztype ( curp ) == penaltynode ) 
  478.         printesc( STR_PENALTY );
  479.       else if ( ztype ( curp ) == discnode ) 
  480.         printesc( STR_DISCRETIONARY );
  481.       else if ( ztype ( curp ) == kernnode ) 
  482.         printesc( STR_KERN );
  483.       else
  484.         printesc( STR_MATH );
  485.     } 
  486.     c_print(" via @@");
  487.     if ( breaknode ( r ) == 0 ) 
  488.       printchar ( 48 ) ; 
  489.     else
  490.       printint ( serial ( breaknode ( r ) ) );
  491.     c_print(" b=");
  492.     if ( b > infbad ) 
  493.       printchar ( 42 ) ; 
  494.     else
  495.       printint ( b ) ; 
  496.     c_print(" p=");
  497.     printint ( pi ) ; 
  498.     c_print(" d=");
  499.     if ( artificialdemerits ) 
  500.       printchar ( 42 ) ; 
  501.     else
  502.       printint ( d ) ; 
  503.       } 
  504. #endif /* STAT */
  505.       d += totaldemerits ( r ) ; 
  506.       if ( d <= minimaldemerits [ fitclass ] ) {
  507.     minimaldemerits [ fitclass ] = d ; 
  508.     bestplace [ fitclass ] = breaknode ( r ) ; 
  509.     bestplline [ fitclass ] = l ; 
  510.     if ( d < minimumdemerits ) 
  511.       minimumdemerits = d ; 
  512.       }
  513.       if ( noderstaysactive ) 
  514.     goto lab22 ; 
  515. lab60:
  516.       link ( prevr ) = link ( r ) ; 
  517.       freenode ( r , activenodesize ) ; 
  518.  
  519.       if ( prevr == active ) {
  520.     r = link ( /*active*/ prevr ) ; 
  521.     if ( ztype ( r ) == deltanode ) {
  522. #if 0
  523.       updateactive ( 1 ) ; ... updateactive ( 6 ) ;
  524.       curavtivewidth[1..6] = activewidth[1..6];
  525. #else
  526.       { register scaled *caw = &curactivewidth[0];
  527.         register scaled *aw  = &activewidth[0];
  528.         register memoryword *memr = &mem[r];
  529.         memr++;
  530.  
  531.         *aw += (memr++)->cint;    *caw++ = *aw++;
  532.         *aw += (memr++)->cint;    *caw++ = *aw++;
  533.         *aw += (memr++)->cint;    *caw++ = *aw++;
  534.         *aw += (memr++)->cint;    *caw++ = *aw++;
  535.         *aw += (memr++)->cint;    *caw++ = *aw++;
  536.         *aw += (memr)->cint;    *caw   = *aw;
  537.       }
  538. #endif
  539.       link ( /*active*/ prevr ) = link ( r ) ; 
  540.       freenode ( r , deltanodesize ) ; 
  541.     } 
  542.  
  543.       } else if ( ztype ( prevr ) == deltanode ) {
  544.  
  545.     r = link ( prevr ) ; 
  546.     if ( r == lastactive ) {
  547. #if 0
  548.       downdatewidth ( 1 ); ... downdatewidth ( 6 );
  549. #else
  550.       register scaled *caw = &curactivewidth[0];
  551.       register memoryword *mem_prevr = &mem[prevr];
  552.       mem_prevr++;
  553.  
  554.       *caw++ -= (mem_prevr++)->cint;  *caw++ -= (mem_prevr++)->cint;
  555.       *caw++ -= (mem_prevr++)->cint;  *caw++ -= (mem_prevr++)->cint;
  556.       *caw++ -= (mem_prevr++)->cint;  *caw   -= (mem_prevr)->cint;
  557. #endif
  558.       link ( prevprevr ) = /*lastactive*/ r ;
  559.       freenode ( prevr , deltanodesize ) ; 
  560.       prevr = prevprevr ;
  561.  
  562.     } else if ( ztype ( r ) == deltanode ) {
  563. #if 0
  564.       curactivewidth [ 1 ] = curactivewidth [ 1 ] + mem [ r + 1 ] .cint;
  565.         ...
  566.       curactivewidth [ 6 ] = curactivewidth [ 6 ] + mem [ r + 6 ] .cint;
  567.       combinetwodeltas ( 1 ) ; ... combinetwodeltas ( 6 );
  568. #else
  569.       register scaled *caw = &curactivewidth[0];
  570.       register memoryword *mem_r = &mem[r];
  571.       register memoryword *mem_prevr = &mem[prevr];
  572.       mem_r++;
  573.       mem_prevr++;
  574.  
  575.       *caw++ += mem_r->cint;   (mem_prevr++)->cint += (mem_r++)->cint;
  576.       *caw++ += mem_r->cint;   (mem_prevr++)->cint += (mem_r++)->cint;
  577.       *caw++ += mem_r->cint;   (mem_prevr++)->cint += (mem_r++)->cint;
  578.       *caw++ += mem_r->cint;   (mem_prevr++)->cint += (mem_r++)->cint;
  579.       *caw++ += mem_r->cint;   (mem_prevr++)->cint += (mem_r++)->cint;
  580.       *caw   += mem_r->cint;    mem_prevr->cint    += mem_r->cint;
  581. #endif
  582.       link ( prevr ) = link ( r ) ; 
  583.       freenode ( r , deltanodesize ) ; 
  584.     } 
  585.       } 
  586.     }
  587.   }
  588.  
  589. lab10: ;
  590. #ifdef STAT
  591.   if ( curp != 0 && curp == printednode && ztype ( curp ) == discnode ) {
  592.     integer t;
  593.  
  594.     t = replacecount ( curp ) ; 
  595.     while ( t > 0 ) {
  596.       decr ( t ) ; 
  597.       printednode = link ( printednode ) ; 
  598.     } 
  599.   } 
  600. #endif /* STAT */
  601. }
  602.  
  603.   static void
  604. cleanup_memory_removing_breaknodes(void)
  605. { linebreak_regmem
  606.   register long_halfword q, r_curp;
  607.  
  608.   q = link(active);
  609.   while( (halfword)q != lastactive ) {
  610.     r_curp = link(q);
  611.     if ( ztype(q) == deltanode )
  612.       freenode( q, deltanodesize );
  613.     else
  614.       freenode( q, activenodesize );
  615.     q = r_curp;
  616.   }
  617.   q = passive;
  618.   while ( (halfword)q != 0 ) {
  619.     r_curp = link(q);
  620.     freenode( q, passivenodesize );
  621.     q = r_curp;
  622.   }
  623.   /* curp = r_curp; */ /* <<== notwendig ??? */
  624. }
  625.  
  626.  
  627. #ifndef OLD_TRYTO
  628.  
  629. /* 894. Try to hyphenate the following word */
  630.  
  631.   static void
  632. try_to_hyphenate(halfword curp)
  633. { linebreak_regmem
  634.  
  635.   halfword prevs;    /* (br) */
  636.   register halfword s, q;
  637.  
  638.   prevs = curp;
  639.   s = link ( prevs );
  640.   if ( s == 0 )
  641.     return;
  642.  
  643.   while ( true ) {
  644.     /* 896. Skip to node ha, ... */
  645.     register unsigned char c;    /* (br) */
  646.  
  647.     if ( ischarnode ( s ) ) {
  648.       c = character ( s );
  649.       hf = font ( s );
  650.     } else if ( ztype ( s ) == ligaturenode ) 
  651.       if ( ligptr ( s ) == 0 ) 
  652.     goto lab22;
  653.       else {
  654.     q = ligptr ( s );
  655.     c = character ( q );
  656.     hf = font ( q );
  657.       }
  658.     else if ( (ztype(s) == kernnode) && (subtype(s) == normal) )
  659.       goto lab22;
  660.     else if ( ztype ( s ) == whatsitnode ) {
  661.       if ( subtype ( s ) == languagenode ) {
  662.     curlang = whatlang ( s );
  663.     lhyf = whatlhm ( s );
  664.     rhyf = whatrhm ( s );
  665.       }
  666.       goto lab22;
  667.     } else
  668.       return;  /* goto lab31; */
  669.  
  670.     if ( lccode(c) != 0 )
  671.       if ( ( lccode(c) == c ) || ( uchyph > 0 ) )
  672.     goto lab32;
  673.       else
  674.     return;  /* goto lab31; */
  675.  
  676. lab22:
  677.     prevs = s;
  678.     s = link ( prevs );
  679.   }
  680.  
  681. lab32:
  682.   hyfchar = hyphenchar(hf);
  683.   if ( hyfchar < 0 )
  684.     return;  /* goto lab31; */
  685.  
  686.   if ( hyfchar > 255 )
  687.     return; /* goto lab31; */
  688.  
  689.   ha = prevs;
  690.  
  691.   if ( lhyf + rhyf > 63 ) 
  692.     return; /* goto lab31; */
  693.  
  694.   /* 897. Skip to node hb, putting letters into hu and hc */
  695.   hn = 0;
  696.   {
  697.     /* Damit es ein bisschen schneller geht, lokale Variable */
  698.     register unsigned short l_hyf_bchar;   /* TeX 3.141 */
  699.  
  700.     while ( true ) {
  701.       if ( ischarnode ( s ) ) {
  702.     register unsigned char c;    /* (br) */
  703.  
  704.     if ( font ( s ) != hf )
  705.       goto lab33;
  706.  
  707.     /* alt: c = character ( s ); */   /* TeX 3.141 */
  708.     /* neu: l_hyf_bchar = character(s);  c = l_hyf_bchar; */
  709.     c = character(s);  l_hyf_bchar = c; /* c muss unsigned sein */
  710.  
  711.     if ( lccode ( c ) == 0 )
  712.       goto lab33;
  713.     if ( hn == 63 )
  714.       goto lab33;
  715.     hb = s;
  716.     incr ( hn );
  717.     hu [ hn ] = c;
  718.     hc [ hn ] = lccode( c );
  719.         l_hyf_bchar = nonchar;   /* TeX 3.141 */
  720.       } else if ( ztype ( s ) == ligaturenode ) {
  721.     /* j nur hier benoetigt, deshalb ... */
  722.     register smallnumber j;
  723.  
  724.     if ( font ( ligchar ( s ) ) != hf ) 
  725.       goto lab33 ; 
  726.     j = hn ; 
  727.     q = ligptr ( s ) ; 
  728.     if ( q > 0 )    /* TeX 3.141 */
  729.       l_hyf_bchar = character(q);
  730.     while ( q > 0 ) {
  731.       unsigned char c;    /* (br) */
  732.  
  733.       c = character( q );
  734.       if ( lccode( c ) == 0 )
  735.         goto lab33;
  736.       if ( j == 63 )
  737.         goto lab33;
  738.       incr ( j );
  739.       hu [ j ] = c;
  740.       hc [ j ] = lccode ( c );
  741.       q = link( q );
  742.     }
  743.     hb = s;
  744.     hn = j;
  745.     if ( odd(subtype(s)) ) {  /* TeX 3.141 */
  746.       l_hyf_bchar = fontbchar(hf);
  747.     } else {
  748.       l_hyf_bchar = nonchar;
  749.     }
  750.       }    else if ( ( ztype(s) == kernnode ) && ( subtype(s) == normal ) ) {
  751.     hb = s;    /* TeX 3.141 */
  752.       } else {
  753.     goto lab33;
  754.       }
  755.       s = link ( s );
  756.     }
  757.  
  758. lab33: ;
  759.     hyf_bchar = l_hyf_bchar;    /* TeX 3.141 */
  760.   }
  761.  
  762.   /* 899. Check that the nodes following hb... */
  763.   if ( hn < lhyf + rhyf ) 
  764.     goto lab31;
  765.  
  766.   while ( true ) {
  767.     if ( ! ( ischarnode ( s ) ) ) {
  768.       switch ( ztype ( s ) ) {
  769.     case ligaturenode : 
  770.       break ; 
  771.     case kernnode : 
  772.       if ( subtype ( s ) != normal ) 
  773.         goto lab34 ; 
  774.       break ; 
  775.     case whatsitnode : 
  776.     case gluenode : 
  777.     case penaltynode : 
  778.     case insnode : 
  779.     case adjustnode : 
  780.     case marknode : 
  781.       goto lab34 ; 
  782.       break;
  783.     default:
  784.       return;  /* goto lab31; */
  785.       break;
  786.       }
  787.     }
  788.     s = link ( s );
  789.   }
  790.  
  791. lab34: ;
  792.   hyphenate ();
  793.  
  794. lab31: ;
  795. }
  796. #endif
  797.  
  798.  
  799.  
  800. void linebreak ( integer finalwidowpenalty )        /* 815. */
  801. {/* 30 31 32 33 34 35 22 */ linebreak_regmem 
  802.   boolean autobreaking;
  803. #ifndef OLD_PREVP
  804.   /* register */ halfword prevp;
  805. #else
  806.   boolean prevp;
  807. #endif
  808.   /*register halfword q, r, s;*/ /* , prevs; */ /* nach unten verlagert */
  809.   /* register internalfontnumber f; */  /* nach unten verlagert (mehrmals) */
  810.   /* register smallnumber j; */ /* nach unten verlagert */
  811.   /* unsigned char c; */ /* nach unten verlagert (mehrmals) */
  812.   boolean secondpass;
  813.  
  814.   packbeginline = curlist .mlfield ; 
  815.  
  816.   /* 816. Get ready to start line breaking */
  817.   link ( temphead ) = link ( curlist .headfield ) ; 
  818.   if ( ischarnode ( curlist .tailfield ) ) 
  819.     tailappend ( newpenalty ( infpenalty ) ) ; 
  820.   else if ( ztype ( curlist .tailfield ) != gluenode ) 
  821.     tailappend ( newpenalty ( infpenalty ) ) ; 
  822.   else {
  823.     ztype ( curlist .tailfield ) = penaltynode ; 
  824.     deleteglueref ( glueptr ( curlist .tailfield ) ) ; 
  825.     flushnodelist ( leaderptr ( curlist .tailfield ) ) ; 
  826.     mem [ curlist .tailfield + 1 ] .cint = infpenalty ; 
  827.   } 
  828.   link ( curlist .tailfield ) = newparamglue ( parfillskipcode ) ; 
  829. #if 1  /* 3.1415 */
  830.   initcurlang = curlist .pgfield % 0x010000L;
  831.   initlhyf = curlist .pgfield / 0x400000L;
  832.   initrhyf = ( curlist .pgfield / 0x010000L ) % 0x40;
  833. #endif
  834.   popnest () ; 
  835.  
  836.   /* 827. Get ready ... 816.+ */
  837.   noshrinkerroryet = true ; 
  838.   if ( shrinkorder ( leftskip ) != normal && shrink ( leftskip ) != 0 )  {
  839.     leftskip = finiteshrink ( leftskip ) ; 
  840.   } 
  841.   if ( shrinkorder ( rightskip ) != normal && shrink ( rightskip ) != 0  ) {
  842.     rightskip = finiteshrink ( rightskip ) ; 
  843.   } 
  844.  
  845.   background [ 1 ] = 0 ; 
  846.   background [ 2 ] = 0 ; 
  847.   background [ 3 ] = 0 ; 
  848.   background [ 4 ] = 0 ; 
  849.  
  850.   { register halfword q, r;
  851.  
  852.     q = leftskip;  r = rightskip;
  853.     background [ 0 ] = width ( q ) + width ( r ) ; 
  854.     background [ 1 + stretchorder ( q ) ] = stretch ( q );
  855.     background [ 1 + stretchorder ( r ) ] += stretch ( r );
  856.     background [ 5 ] = shrink ( q ) + shrink ( r );
  857.   }
  858.  
  859.   /* 834. Get ready ... 816.+ */
  860.   minimumdemerits = awfulbad ; 
  861.   minimaldemerits [ 0 ] = awfulbad ; 
  862.   minimaldemerits [ 1 ] = awfulbad ; 
  863.   minimaldemerits [ 2 ] = awfulbad ; 
  864.   minimaldemerits [ 3 ] = awfulbad ; 
  865.  
  866.   /* 848. Get ready ... 816.+ */
  867.   if ( parshapeptr == 0 ) 
  868.     if ( hangindent == 0 ) {
  869.       lastspecialline = 0 ; 
  870.       secondwidth = hsize ; 
  871.       secondindent = 0 ; 
  872.     } else {
  873.       lastspecialline = abs ( hangafter ) ; 
  874.       if ( hangafter < 0 ) {
  875.     firstwidth = hsize - abs ( hangindent ) ; 
  876.     if ( hangindent >= 0 ) 
  877.       firstindent = hangindent ; 
  878.     else firstindent = 0 ; 
  879.     secondwidth = hsize ; 
  880.     secondindent = 0 ; 
  881.       } else {
  882.     firstwidth = hsize ; 
  883.     firstindent = 0 ; 
  884.     secondwidth = hsize - abs ( hangindent ) ; 
  885.     if ( hangindent >= 0 ) 
  886.       secondindent = hangindent ; 
  887.     else secondindent = 0 ; 
  888.       }
  889.     }
  890.   else {
  891.     lastspecialline = info ( parshapeptr ) - 1 ; 
  892.     secondwidth = mem [ parshapeptr + 2 * ( lastspecialline + 1 ) ] .cint ; 
  893.     secondindent = mem [ parshapeptr + 2 * lastspecialline + 1 ] .cint ; 
  894.   }
  895.   if ( looseness == 0 ) 
  896.     easyline = lastspecialline;
  897.   else
  898.     easyline = maxhalfword;
  899.  
  900.   /* 863. Find optimal breakpoints */
  901.   threshold = pretolerance;
  902.   if ( threshold >= 0 ) {
  903. #ifdef STAT
  904.     if ( tracingparagraphs > 0 ) {
  905.       begindiagnostic () ; 
  906.       c_printnl("@firstpass");
  907.     } 
  908. #endif /* STAT */
  909.     secondpass = false;
  910.     finalpass = false;
  911.   } else {
  912.     threshold = tolerance;
  913.     secondpass = true;
  914.     finalpass = ( emergencystretch <= 0 );
  915. #ifdef STAT
  916.     if ( tracingparagraphs > 0 )
  917.       begindiagnostic ();
  918. #endif /* STAT */
  919.   }
  920.  
  921.   while ( true ) {
  922.     if ( threshold > infbad ) 
  923.       threshold = infbad;
  924.     if ( secondpass ) {
  925. #ifdef INITEX
  926.       if ( trienotready )
  927.     inittrie ();
  928. #endif /* INITEX */
  929. #if 0  /* 3.1415 */
  930.       lhyf = curlist .lhmfield;
  931.       rhyf = curlist .rhmfield;
  932.       curlang = 0;
  933. #else
  934.       curlang = initcurlang;
  935.       lhyf = initlhyf;
  936.       rhyf = initrhyf;
  937. #endif
  938.     }
  939.  
  940.     /* 864. Create an active breakpoint ... */
  941.     { register long_halfword q;
  942.  
  943.     q = getnode ( activenodesize );
  944.     ztype ( q ) = unhyphenated;
  945.     fitness ( q ) = 2;
  946.     link ( q ) = lastactive;
  947.     breaknode ( q ) = 0;
  948.     zlinenumber ( q ) = curlist .pgfield + 1;
  949.     totaldemerits ( q ) = 0;
  950.     link ( active ) = q;
  951.     }
  952.  
  953. #if 0
  954.     activewidth [ 0 ] = background [ 0 ] ; 
  955.     activewidth [ 1 ] = background [ 1 ] ; 
  956.     activewidth [ 2 ] = background [ 2 ] ; 
  957.     activewidth [ 3 ] = background [ 3 ] ; 
  958.     activewidth [ 4 ] = background [ 4 ] ; 
  959.     activewidth [ 5 ] = background [ 5 ] ;
  960. #else
  961.     { register scaled *act_w = &activewidth[0];
  962.       register scaled *bg = &background[0];
  963.  
  964.       *act_w++ = *bg++;        /* 1 */
  965.       *act_w++ = *bg++;
  966.       *act_w++ = *bg++;
  967.       *act_w++ = *bg++;
  968.       *act_w++ = *bg++;
  969.       *act_w   = *bg;        /* 6 */
  970.     }
  971. #endif
  972.  
  973.     passive = 0;
  974.     printednode = temphead;
  975.     passnumber = 0;
  976.     fontinshortdisplay = nullfont;
  977.     autobreaking = true;
  978.  
  979.     curp = link ( temphead );
  980. #ifndef OLD_PREVP
  981.     prevp = curp;    /* glue at beginning is not a legal breakpoint */
  982. #else
  983.     prevp = false;
  984. #endif
  985.  
  986. #ifdef ERWEITERUNG
  987.   { int anzahl_zeichen = 0;
  988. #endif
  989.  
  990.     while ( ( curp != 0 ) && ( link ( active ) != lastactive ) ) {
  991.       if ( ischarnode(curp) ) {
  992.     /* 867. Advance |cur_p| to the node following the present ... */
  993.     /* !! inner loop !! */
  994.     /* Gib' dem Compiler ein paar Tips bzgl. Registern ... */
  995.         register internalfontnumber f, old_f = -1;
  996.     register halfword tmp_curp = curp;
  997.     register scaled act_width = activewidth[0];
  998.         register SMALLmemoryword *old_width, *old_info;
  999.  
  1000. #ifndef OLD_PREVP
  1001.     prevp = tmp_curp;
  1002. #else
  1003.     prevp = true;
  1004. #endif
  1005.  
  1006. #if 0
  1007.     do {
  1008. #ifdef ERWEITERUNG
  1009.           anzahl_zeichen++;
  1010. #endif
  1011.       f = font ( tmp_curp );
  1012.       act_width += zcharwidth(f, zcharinfo(f, character(tmp_curp)) );
  1013.       tmp_curp = link ( tmp_curp );
  1014.     } while ( ischarnode( tmp_curp ) );
  1015. #else
  1016.     do {
  1017. #ifdef ERWEITERUNG
  1018.           anzahl_zeichen++;
  1019. #endif
  1020.       f = font ( tmp_curp );
  1021.       /* Die Breite eines einzigen Wortes (ohne Kernings, etc.) oder
  1022.          Teil davon.  Nur in Ausnahmefaellen werden dabei Character
  1023.          aus mehreren Fonts verwendet, deshalb ... */
  1024.       if( f != old_f ) {
  1025. #ifdef FONTPTR
  1026.         old_info = charbase(f);
  1027.         old_width = widthbase(f);
  1028. #else
  1029.         old_info = &fontinfo[charbase(f)];
  1030.         old_width = &fontinfo[widthbase(f)];
  1031. #endif
  1032.         old_f = f;
  1033.       }
  1034.       act_width += (*(old_width +
  1035.             (*(old_info + character(tmp_curp))).qqqq.b0)).cint;
  1036.       tmp_curp = link(tmp_curp);
  1037.     } while ( ischarnode(tmp_curp) );
  1038. #endif
  1039.     curp = tmp_curp;
  1040.     activewidth[0] = act_width;
  1041.       }
  1042.  
  1043.       switch ( ztype ( curp ) ) {
  1044.       case hlistnode:
  1045.       case vlistnode:
  1046.       case rulenode:
  1047.     activewidth[0] += width ( curp );
  1048. #ifdef ERWEITERUNG
  1049.           anzahl_zeichen = 0;
  1050. #endif
  1051.     break;
  1052.       case whatsitnode : 
  1053.     if ( subtype ( curp ) == languagenode ) {
  1054.       curlang = whatlang ( curp );
  1055.       lhyf = whatlhm ( curp );
  1056.       rhyf = whatrhm ( curp );
  1057.     }
  1058. #ifdef ERWEITERUNG
  1059.           anzahl_zeichen = 0;
  1060. #endif
  1061.     break;
  1062.       case gluenode : 
  1063.     {
  1064.       /* 868. If node cur_p is a legal breakpoint ... */
  1065.       if ( autobreaking ) {
  1066. #ifndef OLD_PREVP
  1067.         if ( ischarnode ( prevp ) ) 
  1068.           trybreak ( 0, unhyphenated ) ; 
  1069.         else if ( precedesbreak ( prevp ) ) 
  1070.           trybreak ( 0, unhyphenated ) ; 
  1071. #if 1  /* 3.1415 */
  1072.         else if ( ( ztype ( prevp ) == kernnode )
  1073.            && ( subtype( prevp ) != explicit ) )
  1074.           trybreak ( 0, unhyphenated ) ; 
  1075. #endif
  1076. #else
  1077.         if ( prevp )
  1078.           trybreak ( 0, unhyphenated );
  1079. #endif
  1080.       }
  1081.  
  1082.       if ( ( shrinkorder( glueptr(curp) ) != normal )
  1083.         && ( shrink( glueptr(curp) ) != 0 ) ) {
  1084.         glueptr(curp) = finiteshrink ( glueptr(curp) );
  1085.       }
  1086.  
  1087.       { register halfword q;
  1088.  
  1089.       q = glueptr ( curp );
  1090.       activewidth[ 0 ] += width ( q );
  1091.       activewidth[ 1 + stretchorder ( q ) ] += stretch ( q );
  1092.       activewidth[ 5 ] += shrink ( q );
  1093.       }
  1094.  
  1095.       if ( secondpass && autobreaking ) {
  1096.  
  1097. #ifndef OLD_TRY_TO
  1098.         try_to_hyphenate(curp);
  1099. #else
  1100.         /* 894. Try to hyphenate the following word */
  1101.         halfword prevs;    /* (br) */
  1102.         register halfword s;  /* br */
  1103.  
  1104.         prevs = curp;
  1105.         s = link ( prevs );
  1106.         if ( s != 0 ) {
  1107.           while ( true ) {
  1108.         unsigned char c;    /* (br) */
  1109.  
  1110.         if ( ischarnode ( s ) ) {
  1111.           c = character ( s );
  1112.           hf = font ( s );
  1113.         } else if ( ztype ( s ) == ligaturenode ) 
  1114.           if ( ligptr ( s ) == 0 ) 
  1115.             goto lab22 ; 
  1116.           else {
  1117.             register halfword q;
  1118.  
  1119.             q = ligptr ( s ) ; 
  1120.             c = character ( q ) ; 
  1121.             hf = font ( q ) ; 
  1122.           } 
  1123.         else if ( (ztype(s) == kernnode) && (subtype(s) == normal) )
  1124.           goto lab22 ; 
  1125.         else if ( ztype ( s ) == whatsitnode ) {
  1126.           if ( subtype ( s ) == languagenode ) {
  1127.             curlang = whatlang ( s ) ; 
  1128.             lhyf = whatlhm ( s ) ; 
  1129.             rhyf = whatrhm ( s ) ; 
  1130.           } 
  1131.           goto lab22 ; 
  1132.         }
  1133.         else goto lab31 ; 
  1134.         if ( lccode ( c ) != 0 ) 
  1135.           if ( ( lccode ( c ) == c ) || ( uchyph > 0 ) ) 
  1136.             goto lab32 ; 
  1137.           else
  1138.             goto lab31 ; 
  1139. lab22:        prevs = s ; 
  1140.         s = link ( prevs ) ; 
  1141.           }
  1142. lab32:          hyfchar = hyphenchar(hf);
  1143.           if ( hyfchar < 0 )
  1144.         goto lab31 ; 
  1145.           if ( hyfchar > 255 ) 
  1146.         goto lab31 ; 
  1147.           ha = prevs ; 
  1148.  
  1149.           if ( lhyf + rhyf > 63 ) 
  1150.         goto lab31 ; 
  1151.  
  1152.           /* 897. Skip to node hb, putting letters into hu and hc */
  1153.           hn = 0;
  1154.         {
  1155.           /* Damit es ein bisschen schneller geht, lokale Variable */
  1156.           unsigned short l_hyf_bchar;  /* TeX 3.141 */
  1157.  
  1158.           while ( true ) {
  1159.         if ( ischarnode ( s ) ) {
  1160.           unsigned char c;    /* (br) */
  1161.  
  1162.           if ( font ( s ) != hf )
  1163.             goto lab33;
  1164.  
  1165.           /* alt: c = character ( s ); */ /* TeX 3.141 */
  1166.           /* neu: l_hyf_bchar = character(s);  c = l_hyf_bchar; */
  1167.           c = character(s); l_hyf_bchar = c; /* c muss unsigned sein */
  1168.  
  1169.           if ( lccode ( c ) == 0 )
  1170.             goto lab33;
  1171.           if ( hn == 63 )
  1172.             goto lab33;
  1173.           hb = s;
  1174.           incr ( hn );
  1175.           hu [ hn ] = c;
  1176.           hc [ hn ] = lccode( c );
  1177.           l_hyf_bchar = nonchar;   /* TeX 3.141 */
  1178.         } else if ( ztype ( s ) == ligaturenode ) {
  1179.           /* j nur hier benoetigt, deshalb ... */
  1180.           register smallnumber j;
  1181.           register halfword q;
  1182.  
  1183.           if ( font ( ligchar ( s ) ) != hf ) 
  1184.             goto lab33 ; 
  1185.  
  1186.           j = hn ; 
  1187.           q = ligptr ( s ) ; 
  1188.           if ( q > 0 )    /* TeX 3.141 */
  1189.             l_hyf_bchar = character(q);
  1190.           while ( q > 0 ) {
  1191.             unsigned char c;    /* (br) */
  1192.  
  1193.             c = character( q );
  1194.             if ( lccode( c ) == 0 )
  1195.               goto lab33;
  1196.             if ( j == 63 )
  1197.               goto lab33;
  1198.             incr ( j );
  1199.             hu [ j ] = c;
  1200.             hc [ j ] = lccode ( c );
  1201.             q = link( q );
  1202.           }
  1203.           hb = s;
  1204.           hn = j ; 
  1205.           if ( odd(subtype(s)) ) {  /* TeX 3.141 */
  1206.             l_hyf_bchar = fontbchar(hf);
  1207.           } else {
  1208.             l_hyf_bchar = nonchar;
  1209.           }
  1210.         } else if ( ( ztype(s) == kernnode )
  1211.              && ( subtype(s) == normal ) ) {
  1212.           hb = s;  /* TeX 3.141 */
  1213.           l_hyf_bchar = fontbchar(hf);  /* TeX 3.1415 */
  1214.         } else {
  1215.           goto lab33;
  1216.         }
  1217.  
  1218.         s = link ( s );
  1219.           }
  1220. lab33: ;
  1221.           hyf_bchar = l_hyf_bchar;
  1222.         }
  1223.  
  1224.           if ( hn < lhyf + rhyf ) 
  1225.         goto lab31;
  1226.  
  1227.           while ( true ) {
  1228.         if ( ! ( ischarnode ( s ) ) ) 
  1229.         switch ( ztype ( s ) ) {
  1230.         case ligaturenode : 
  1231.           break ; 
  1232.         case kernnode : 
  1233.           if ( subtype ( s ) != normal ) 
  1234.             goto lab34 ; 
  1235.           break ; 
  1236.         case whatsitnode : 
  1237.         case gluenode : 
  1238.         case penaltynode : 
  1239.         case insnode : 
  1240.         case adjustnode : 
  1241.         case marknode : 
  1242.           goto lab34 ; 
  1243.           break;
  1244.         default:
  1245.           goto lab31;
  1246.           break;
  1247.         }
  1248.         s = link ( s );
  1249.           }
  1250. lab34: ;
  1251.           hyphenate ();
  1252.         }
  1253. lab31: ;
  1254.  
  1255. #endif  /* OLD_TRY_TO */
  1256.  
  1257.       }
  1258.  
  1259. #ifdef ERWEITERUNG
  1260.           anzahl_zeichen = 0;
  1261. #endif
  1262.  
  1263.     }
  1264.     break;
  1265.  
  1266.       case ligaturenode : 
  1267.     { register internalfontnumber f;  /* (br) */
  1268.  
  1269.       f = font ( ligchar ( curp ) );
  1270.       activewidth [ 0 ] += zcharwidth ( f,
  1271.             zcharinfo ( f, character ( ligchar ( curp ) ) ) ) ;
  1272.     }
  1273.  
  1274. #ifdef ERWEITERUNG
  1275.     { register halfword q = ligptr(curp);
  1276.  
  1277.       while ( q > 0 ) {
  1278.         anzahl_zeichen++;
  1279.         q = link(q);
  1280.       }
  1281.     }
  1282. #endif
  1283.  
  1284.     break;
  1285.       case discnode : 
  1286.     { register halfword s;  /* br */
  1287.  
  1288.       s = prebreak ( curp );
  1289.       discwidth = 0;
  1290.       if ( s == 0 ) {
  1291. #ifdef ERWEITERUNG
  1292.         if( anzahl_zeichen > lhyf ) {
  1293. #endif
  1294.           trybreak ( exhyphenpenalty, hyphenated );
  1295. #ifdef ERWEITERUNG
  1296.           anzahl_zeichen = 0;
  1297.         }
  1298. #endif
  1299.       } else {
  1300.         do {
  1301.           if ( ischarnode(s) ) {
  1302.         register internalfontnumber f;  /* (br) */
  1303.  
  1304. #ifdef ERWEITERUNG
  1305.         anzahl_zeichen++;
  1306. #endif
  1307.         f = font(s);
  1308.         discwidth += zcharwidth (f, zcharinfo (f, character(s) ) );
  1309.           } else switch ( ztype(s) ) {
  1310.           case ligaturenode:
  1311.         { register internalfontnumber f;  /* (br) */
  1312.  
  1313.           f = font ( ligchar(s) );
  1314.           discwidth += zcharwidth ( f,
  1315.             zcharinfo ( f, character( ligchar(s) ) ) ) ;
  1316.         }
  1317. #ifdef ERWEITERUNG
  1318.         { register halfword q = ligptr(s);
  1319.  
  1320.           while ( q > 0 ) {
  1321.             anzahl_zeichen++;
  1322.             q = link(q);
  1323.           }
  1324.         }
  1325. #endif
  1326.         break;
  1327.           case hlistnode:
  1328.           case vlistnode:
  1329.           case rulenode:
  1330.           case kernnode:
  1331.         discwidth += width(s); 
  1332. #ifdef ERWEITERUNG
  1333.         anzahl_zeichen = 0;
  1334. #endif
  1335.         break;
  1336.           default: 
  1337.         confusion("disc3"); /* 930 */
  1338.         break; 
  1339.           }
  1340.           s = link( s );
  1341.         } while ( s != 0 );
  1342.         activewidth[0] += discwidth;
  1343. #ifdef ERWEITERUNG
  1344.         if( anzahl_zeichen > lhyf ) {
  1345. #endif
  1346.           trybreak ( hyphenpenalty , hyphenated );
  1347. #ifdef ERWEITERUNG
  1348.           anzahl_zeichen = 0;
  1349.         }
  1350. #endif
  1351.         activewidth[0] -= discwidth;
  1352.       }
  1353.  
  1354.     { register halfword r;
  1355.  
  1356.       r = replacecount ( curp );
  1357.       s = link ( curp );
  1358.       while ( r > 0 ) {
  1359.         if ( ischarnode ( s ) ) {
  1360.           register internalfontnumber f;  /* (br) */
  1361.  
  1362. #ifdef ERWEITERUNG
  1363.           anzahl_zeichen++;
  1364. #endif
  1365.           f = font ( s );
  1366.           activewidth[0] += zcharwidth ( f,
  1367.                     zcharinfo ( f, character(s) ) );
  1368.         } else switch ( ztype ( s ) ) {
  1369.         case ligaturenode : 
  1370.           { register internalfontnumber f;  /* (br) */
  1371.  
  1372.         f = font ( ligchar(s) );
  1373.         activewidth[0] += zcharwidth ( f,
  1374.             zcharinfo ( f, character ( ligchar(s) ) ) );
  1375.           }
  1376. #ifdef ERWEITERUNG
  1377.           { register halfword q = ligptr(s);
  1378.  
  1379.         while ( q > 0 ) {
  1380.           anzahl_zeichen++;
  1381.           q = link(q);
  1382.         }
  1383.           }
  1384. #endif
  1385.           break;
  1386.         case hlistnode:
  1387.         case vlistnode:
  1388.         case rulenode:
  1389.         case kernnode:
  1390.           activewidth[0] += width(s);
  1391. #ifdef ERWEITERUNG
  1392.           anzahl_zeichen = 0;
  1393. #endif
  1394.           break;
  1395.         default:
  1396.           confusion("disc4"); /* 931 */
  1397.           break;
  1398.         }
  1399.         decr ( r );
  1400.         s = link ( s );
  1401.       }
  1402.     }
  1403.  
  1404. #ifndef OLD_PREVP
  1405.       prevp = curp;
  1406. #else
  1407.       prevp = true;
  1408. #endif
  1409.       curp = s;
  1410.       goto lab35;
  1411.     }
  1412.     break;
  1413.  
  1414.       case mathnode:
  1415.     /* innerhalb einer Formel *nicht* umbrechen */
  1416.     autobreaking = ( subtype(curp) == after);
  1417.  
  1418.     if ( ! ischarnode ( link(curp) ) && autobreaking )
  1419.       if ( ztype ( link(curp) ) == gluenode )
  1420.         trybreak( 0, unhyphenated );
  1421.     activewidth[0] += width(curp);
  1422. #ifdef ERWEITERUNG
  1423.           anzahl_zeichen = 0;
  1424. #endif
  1425.     break;
  1426.  
  1427.       case kernnode:
  1428. #if 1  /* 3.1415 */
  1429.     if ( subtype(curp) == explicit ) {
  1430. #endif
  1431.     if ( ! ischarnode ( link(curp) ) && autobreaking )
  1432.       if ( ztype ( link(curp) ) == gluenode )
  1433.         trybreak( 0, unhyphenated );
  1434. #ifdef ERWEITERUNG
  1435.           anzahl_zeichen = 0;
  1436. #endif
  1437.     activewidth[0] += width(curp);
  1438. #if 1  /* 3.1415 */
  1439.     } else {
  1440. #ifdef OLD_PREVP
  1441.     prevp = true ;
  1442. #endif
  1443.       activewidth[0] += width(curp);
  1444.     }
  1445. #endif
  1446.     break;
  1447.  
  1448.       case penaltynode:
  1449.     trybreak ( mem[ curp + 1 ].cint, unhyphenated );
  1450. #ifdef ERWEITERUNG
  1451.           anzahl_zeichen = 0;
  1452. #endif
  1453.     break;
  1454.       case marknode:
  1455.       case insnode:
  1456.       case adjustnode:
  1457. #ifdef ERWEITERUNG
  1458.           anzahl_zeichen = 0;
  1459. #endif
  1460.     break;
  1461.       default:
  1462.     confusion("paragraph");
  1463.     break;
  1464.       }
  1465. #ifndef OLD_PREVP
  1466.       prevp = curp;
  1467. #else
  1468.       if ( ztype ( curp ) < 9 )
  1469.     prevp = true;
  1470.       else
  1471.     prevp = false;
  1472. #endif
  1473.       curp = link ( curp );
  1474. lab35: ;
  1475.     }
  1476. #ifdef ERWEITERUNG
  1477.   }
  1478. #endif
  1479.  
  1480.     if ( curp == 0 ) {
  1481.       trybreak ( ejectpenalty , hyphenated );
  1482.       if ( link ( active ) != lastactive ) {
  1483.     { register halfword r;
  1484.  
  1485.       r = link ( active );
  1486.       fewestdemerits = awfulbad;
  1487.       do {
  1488.         if ( ztype ( r ) != deltanode ) 
  1489.           if ( totaldemerits ( r ) < fewestdemerits ) {
  1490.             fewestdemerits = totaldemerits ( r );
  1491.             bestbet = r;
  1492.           }
  1493.         r = link ( r );
  1494.       } while ( r != lastactive );
  1495.       bestline = zlinenumber( bestbet );
  1496.     }
  1497.  
  1498.     if ( looseness == 0 )
  1499.       goto lab30;
  1500.  
  1501.     { register halfword r;
  1502.  
  1503.       r = link ( active );
  1504.       actuallooseness = 0;
  1505.       do {
  1506.         if ( ztype ( r ) != deltanode ) {
  1507.           linediff = toint ( zlinenumber ( r ) ) - toint ( bestline );
  1508.           if ( ( (linediff < actuallooseness) && (looseness <= linediff) )
  1509.         || ( (linediff > actuallooseness) && (looseness >= linediff) ) )
  1510.           {
  1511.         bestbet = r;
  1512.         actuallooseness = linediff;
  1513.         fewestdemerits = totaldemerits(r);
  1514.           } else if ( ( linediff == actuallooseness )
  1515.                && ( totaldemerits(r) < fewestdemerits ) )
  1516.           {
  1517.         bestbet = r;
  1518.         fewestdemerits = totaldemerits(r);
  1519.           }
  1520.         }
  1521.         r = link( r );
  1522.       } while ( r != lastactive );
  1523.       bestline = zlinenumber ( bestbet );
  1524.     }
  1525.  
  1526.     if ( ( actuallooseness == looseness ) || finalpass )
  1527.       goto lab30;
  1528.       }
  1529.     }
  1530.  
  1531.     cleanup_memory_removing_breaknodes();
  1532.  
  1533.     if ( ! secondpass ) {
  1534. #ifdef STAT
  1535.       if ( tracingparagraphs > 0 ) 
  1536.     c_printnl("@secondpass");
  1537. #endif /* STAT */
  1538.       threshold = tolerance;
  1539.       secondpass = true;
  1540.       finalpass = ( emergencystretch <= 0 );
  1541.     } else {
  1542. #ifdef STAT
  1543.       if ( tracingparagraphs > 0 ) 
  1544.     c_printnl("@emergencypass");
  1545. #endif /* STAT */
  1546.       background[1] += emergencystretch; 
  1547.       finalpass = true;
  1548.     }
  1549.   }
  1550.  
  1551. lab30: ;
  1552. #ifdef STAT
  1553.   if ( tracingparagraphs > 0 ) {
  1554.     enddiagnostic ( true );
  1555.     normalizeselector ();
  1556.   }
  1557. #endif /* STAT */
  1558.  
  1559.   postlinebreak ( finalwidowpenalty );
  1560.  
  1561.   cleanup_memory_removing_breaknodes();
  1562.  
  1563.   packbeginline = 0;
  1564. }
  1565.  
  1566.  
  1567. /* -- eof -- */
  1568.