home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex11.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  24.4 KB  |  1,088 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void zpostlinebreak ( finalwidowpenalty ) 
  5. integer finalwidowpenalty ; 
  6. {/* 30 31 */ postlinebreak_regmem 
  7.   halfword q, r, s  ; 
  8.   boolean discbreak  ; 
  9.   boolean postdiscbreak  ; 
  10.   scaled curwidth  ; 
  11.   scaled curindent  ; 
  12.   quarterword t  ; 
  13.   integer pen  ; 
  14.   halfword curline  ; 
  15.   q = mem [ bestbet + 1 ] .hh .v.RH ; 
  16.   curp = 0 ; 
  17.   do {
  18.       r = q ; 
  19.     q = mem [ q + 1 ] .hh .v.LH ; 
  20.     mem [ r + 1 ] .hh .v.LH = curp ; 
  21.     curp = r ; 
  22.   } while ( ! ( q == 0 ) ) ; 
  23.   curline = curlist .pgfield + 1 ; 
  24.   do {
  25.       q = mem [ curp + 1 ] .hh .v.RH ; 
  26.     discbreak = false ; 
  27.     postdiscbreak = false ; 
  28.     if ( q != 0 ) 
  29.     if ( mem [ q ] .hh.b0 == 10 ) 
  30.     {
  31.       deleteglueref ( mem [ q + 1 ] .hh .v.LH ) ; 
  32.       mem [ q + 1 ] .hh .v.LH = eqtb [ 3790 ] .hh .v.RH ; 
  33.       mem [ q ] .hh.b1 = 9 ; 
  34.       incr ( mem [ eqtb [ 3790 ] .hh .v.RH ] .hh .v.RH ) ; 
  35.       goto lab30 ; 
  36.     } 
  37.     else {
  38.     
  39.       if ( mem [ q ] .hh.b0 == 7 ) 
  40.       {
  41.     t = mem [ q ] .hh.b1 ; 
  42.     if ( t == 0 ) 
  43.     r = mem [ q ] .hh .v.RH ; 
  44.     else {
  45.         
  46.       r = q ; 
  47.       while ( t > 1 ) {
  48.           
  49.         r = mem [ r ] .hh .v.RH ; 
  50.         decr ( t ) ; 
  51.       } 
  52.       s = mem [ r ] .hh .v.RH ; 
  53.       if ( ! ( s >= himemmin ) ) 
  54.       if ( mem [ curp + 1 ] .hh .v.LH != 0 ) 
  55.       if ( mem [ mem [ curp + 1 ] .hh .v.LH + 1 ] .hh .v.RH == s ) 
  56.       s = r ; 
  57.       r = mem [ s ] .hh .v.RH ; 
  58.       mem [ s ] .hh .v.RH = 0 ; 
  59.       flushnodelist ( mem [ q ] .hh .v.RH ) ; 
  60.       mem [ q ] .hh.b1 = 0 ; 
  61.     } 
  62.     if ( mem [ q + 1 ] .hh .v.RH != 0 ) 
  63.     {
  64.       s = mem [ q + 1 ] .hh .v.RH ; 
  65.       while ( mem [ s ] .hh .v.RH != 0 ) s = mem [ s ] .hh .v.RH ; 
  66.       mem [ s ] .hh .v.RH = r ; 
  67.       r = mem [ q + 1 ] .hh .v.RH ; 
  68.       mem [ q + 1 ] .hh .v.RH = 0 ; 
  69.       postdiscbreak = true ; 
  70.     } 
  71.     if ( mem [ q + 1 ] .hh .v.LH != 0 ) 
  72.     {
  73.       s = mem [ q + 1 ] .hh .v.LH ; 
  74.       mem [ q ] .hh .v.RH = s ; 
  75.       while ( mem [ s ] .hh .v.RH != 0 ) s = mem [ s ] .hh .v.RH ; 
  76.       mem [ q + 1 ] .hh .v.LH = 0 ; 
  77.       q = s ; 
  78.     } 
  79.     mem [ q ] .hh .v.RH = r ; 
  80.     discbreak = true ; 
  81.       } 
  82.       else if ( ( mem [ q ] .hh.b0 == 9 ) || ( mem [ q ] .hh.b0 == 11 ) ) 
  83.       mem [ q + 1 ] .cint = 0 ; 
  84.     } 
  85.     else {
  86.     
  87.       q = memtop - 3 ; 
  88.       while ( mem [ q ] .hh .v.RH != 0 ) q = mem [ q ] .hh .v.RH ; 
  89.     } 
  90.     r = newparamglue ( 8 ) ; 
  91.     mem [ r ] .hh .v.RH = mem [ q ] .hh .v.RH ; 
  92.     mem [ q ] .hh .v.RH = r ; 
  93.     q = r ; 
  94.     lab30: ; 
  95.     r = mem [ q ] .hh .v.RH ; 
  96.     mem [ q ] .hh .v.RH = 0 ; 
  97.     q = mem [ memtop - 3 ] .hh .v.RH ; 
  98.     mem [ memtop - 3 ] .hh .v.RH = r ; 
  99.     if ( eqtb [ 3789 ] .hh .v.RH != 0 ) 
  100.     {
  101.       r = newparamglue ( 7 ) ; 
  102.       mem [ r ] .hh .v.RH = q ; 
  103.       q = r ; 
  104.     } 
  105.     if ( curline > lastspecialline ) 
  106.     {
  107.       curwidth = secondwidth ; 
  108.       curindent = secondindent ; 
  109.     } 
  110.     else if ( eqtb [ 4312 ] .hh .v.RH == 0 ) 
  111.     {
  112.       curwidth = firstwidth ; 
  113.       curindent = firstindent ; 
  114.     } 
  115.     else {
  116.     
  117.       curwidth = mem [ eqtb [ 4312 ] .hh .v.RH + 2 * curline ] .cint ; 
  118.       curindent = mem [ eqtb [ 4312 ] .hh .v.RH + 2 * curline - 1 ] .cint ; 
  119.     } 
  120.     adjusttail = memtop - 5 ; 
  121.     justbox = hpack ( q , curwidth , 0 ) ; 
  122.     mem [ justbox + 4 ] .cint = curindent ; 
  123.     appendtovlist ( justbox ) ; 
  124.     if ( memtop - 5 != adjusttail ) 
  125.     {
  126.       mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 5 ] .hh .v.RH ; 
  127.       curlist .tailfield = adjusttail ; 
  128.     } 
  129.     adjusttail = 0 ; 
  130.     if ( curline + 1 != bestline ) 
  131.     {
  132.       pen = eqtb [ 6176 ] .cint ; 
  133.       if ( curline == curlist .pgfield + 1 ) 
  134.       pen = pen + eqtb [ 6168 ] .cint ; 
  135.       if ( curline + 2 == bestline ) 
  136.       pen = pen + finalwidowpenalty ; 
  137.       if ( discbreak ) 
  138.       pen = pen + eqtb [ 6171 ] .cint ; 
  139.       if ( pen != 0 ) 
  140.       {
  141.     r = newpenalty ( pen ) ; 
  142.     mem [ curlist .tailfield ] .hh .v.RH = r ; 
  143.     curlist .tailfield = r ; 
  144.       } 
  145.     } 
  146.     incr ( curline ) ; 
  147.     curp = mem [ curp + 1 ] .hh .v.LH ; 
  148.     if ( curp != 0 ) 
  149.     if ( ! postdiscbreak ) 
  150.     {
  151.       r = memtop - 3 ; 
  152.       while ( true ) {
  153.       
  154.     q = mem [ r ] .hh .v.RH ; 
  155.     if ( q == mem [ curp + 1 ] .hh .v.RH ) 
  156.     goto lab31 ; 
  157.     if ( ( q >= himemmin ) ) 
  158.     goto lab31 ; 
  159.     if ( ( mem [ q ] .hh.b0 < 9 ) ) 
  160.     goto lab31 ; 
  161.     if ( mem [ q ] .hh.b1 == 2 ) 
  162.     if ( mem [ q ] .hh.b0 == 11 ) 
  163.     goto lab31 ; 
  164.     r = q ; 
  165.       } 
  166.       lab31: if ( r != memtop - 3 ) 
  167.       {
  168.     mem [ r ] .hh .v.RH = 0 ; 
  169.     flushnodelist ( mem [ memtop - 3 ] .hh .v.RH ) ; 
  170.     mem [ memtop - 3 ] .hh .v.RH = q ; 
  171.       } 
  172.     } 
  173.   } while ( ! ( curp == 0 ) ) ; 
  174.   if ( ( curline != bestline ) || ( mem [ memtop - 3 ] .hh .v.RH != 0 ) ) 
  175.   confusion ( 932 ) ; 
  176.   curlist .pgfield = bestline - 1 ; 
  177. } 
  178. smallnumber zreconstitute ( j , n , bchar , hchar ) 
  179. smallnumber j ; 
  180. smallnumber n ; 
  181. halfword bchar ; 
  182. halfword hchar ; 
  183. {/* 22 30 */ register smallnumber Result; reconstitute_regmem 
  184.   halfword p  ; 
  185.   halfword t  ; 
  186.   fourquarters q  ; 
  187.   halfword currh  ; 
  188.   halfword testchar  ; 
  189.   scaled w  ; 
  190.   fontindex k  ; 
  191.   hyphenpassed = 0 ; 
  192.   t = memtop - 4 ; 
  193.   w = 0 ; 
  194.   mem [ memtop - 4 ] .hh .v.RH = 0 ; 
  195.   curl = hu [ j ] ; 
  196.   curq = t ; 
  197.   if ( j == 0 ) 
  198.   {
  199.     ligaturepresent = initlig ; 
  200.     p = initlist ; 
  201.     if ( ligaturepresent ) 
  202.     lfthit = initlft ; 
  203.     while ( p > 0 ) {
  204.     
  205.       {
  206.     mem [ t ] .hh .v.RH = getavail () ; 
  207.     t = mem [ t ] .hh .v.RH ; 
  208.     mem [ t ] .hh.b0 = hf ; 
  209.     mem [ t ] .hh.b1 = mem [ p ] .hh.b1 ; 
  210.       } 
  211.       p = mem [ p ] .hh .v.RH ; 
  212.     } 
  213.   } 
  214.   else if ( curl < 256 ) 
  215.   {
  216.     mem [ t ] .hh .v.RH = getavail () ; 
  217.     t = mem [ t ] .hh .v.RH ; 
  218.     mem [ t ] .hh.b0 = hf ; 
  219.     mem [ t ] .hh.b1 = curl ; 
  220.   } 
  221.   ligstack = 0 ; 
  222.   {
  223.     if ( j < n ) 
  224.     curr = hu [ j + 1 ] ; 
  225.     else curr = bchar ; 
  226.     if ( odd ( hyf [ j ] ) ) 
  227.     currh = hchar ; 
  228.     else currh = 256 ; 
  229.   } 
  230.   lab22: if ( curl == 256 ) 
  231.   {
  232.     k = bcharlabel [ hf ] ; 
  233.     if ( k == fontmemsize ) 
  234.     goto lab30 ; 
  235.     else q = fontinfo [ k ] .qqqq ; 
  236.   } 
  237.   else {
  238.       
  239.     q = fontinfo [ charbase [ hf ] + curl ] .qqqq ; 
  240.     if ( ( ( q .b2 ) % 4 ) != 1 ) 
  241.     goto lab30 ; 
  242.     k = ligkernbase [ hf ] + q .b3 ; 
  243.     q = fontinfo [ k ] .qqqq ; 
  244.     if ( q .b0 > 128 ) 
  245.     {
  246.       k = ligkernbase [ hf ] + 256 * q .b2 + q .b3 + 32768L - 256 * ( 128 ) ; 
  247.       q = fontinfo [ k ] .qqqq ; 
  248.     } 
  249.   } 
  250.   if ( currh < 256 ) 
  251.   testchar = currh ; 
  252.   else testchar = curr ; 
  253.   while ( true ) {
  254.       
  255.     if ( q .b1 == testchar ) 
  256.     if ( q .b0 <= 128 ) 
  257.     if ( currh < 256 ) 
  258.     {
  259.       hyphenpassed = j ; 
  260.       hchar = 256 ; 
  261.       currh = 256 ; 
  262.       goto lab22 ; 
  263.     } 
  264.     else {
  265.     
  266.       if ( hchar < 256 ) 
  267.       if ( odd ( hyf [ j ] ) ) 
  268.       {
  269.     hyphenpassed = j ; 
  270.     hchar = 256 ; 
  271.       } 
  272.       if ( q .b2 < 128 ) 
  273.       {
  274.     if ( curl == 256 ) 
  275.     lfthit = true ; 
  276.     if ( j == n ) 
  277.     if ( ligstack == 0 ) 
  278.     rthit = true ; 
  279.     {
  280.       if ( interrupt != 0 ) 
  281.       pauseforinstructions () ; 
  282.     } 
  283.     switch ( q .b2 ) 
  284.     {case 1 : 
  285.     case 5 : 
  286.       {
  287.         curl = q .b3 ; 
  288.         ligaturepresent = true ; 
  289.       } 
  290.       break ; 
  291.     case 2 : 
  292.     case 6 : 
  293.       {
  294.         curr = q .b3 ; 
  295.         if ( ligstack > 0 ) 
  296.         mem [ ligstack ] .hh.b1 = curr ; 
  297.         else {
  298.         
  299.           ligstack = newligitem ( curr ) ; 
  300.           if ( j == n ) 
  301.           bchar = 256 ; 
  302.           else {
  303.           
  304.         p = getavail () ; 
  305.         mem [ ligstack + 1 ] .hh .v.RH = p ; 
  306.         mem [ p ] .hh.b1 = hu [ j + 1 ] ; 
  307.         mem [ p ] .hh.b0 = hf ; 
  308.           } 
  309.         } 
  310.       } 
  311.       break ; 
  312.     case 3 : 
  313.       {
  314.         curr = q .b3 ; 
  315.         p = ligstack ; 
  316.         ligstack = newligitem ( curr ) ; 
  317.         mem [ ligstack ] .hh .v.RH = p ; 
  318.       } 
  319.       break ; 
  320.     case 7 : 
  321.     case 11 : 
  322.       {
  323.         if ( ligaturepresent ) 
  324.         {
  325.           p = newligature ( hf , curl , mem [ curq ] .hh .v.RH ) ; 
  326.           if ( lfthit ) 
  327.           {
  328.         mem [ p ] .hh.b1 = 2 ; 
  329.         lfthit = false ; 
  330.           } 
  331.           if ( false ) 
  332.           if ( ligstack == 0 ) 
  333.           {
  334.         incr ( mem [ p ] .hh.b1 ) ; 
  335.         rthit = false ; 
  336.           } 
  337.           mem [ curq ] .hh .v.RH = p ; 
  338.           t = p ; 
  339.           ligaturepresent = false ; 
  340.         } 
  341.         curq = t ; 
  342.         curl = q .b3 ; 
  343.         ligaturepresent = true ; 
  344.       } 
  345.       break ; 
  346.       default: 
  347.       {
  348.         curl = q .b3 ; 
  349.         ligaturepresent = true ; 
  350.         if ( ligstack > 0 ) 
  351.         {
  352.           if ( mem [ ligstack + 1 ] .hh .v.RH > 0 ) 
  353.           {
  354.         mem [ t ] .hh .v.RH = mem [ ligstack + 1 ] .hh .v.RH ; 
  355.         t = mem [ t ] .hh .v.RH ; 
  356.         incr ( j ) ; 
  357.           } 
  358.           p = ligstack ; 
  359.           ligstack = mem [ p ] .hh .v.RH ; 
  360.           freenode ( p , 2 ) ; 
  361.           if ( ligstack == 0 ) 
  362.           {
  363.         if ( j < n ) 
  364.         curr = hu [ j + 1 ] ; 
  365.         else curr = bchar ; 
  366.         if ( odd ( hyf [ j ] ) ) 
  367.         currh = hchar ; 
  368.         else currh = 256 ; 
  369.           } 
  370.           else curr = mem [ ligstack ] .hh.b1 ; 
  371.         } 
  372.         else if ( j == n ) 
  373.         goto lab30 ; 
  374.         else {
  375.         
  376.           {
  377.         mem [ t ] .hh .v.RH = getavail () ; 
  378.         t = mem [ t ] .hh .v.RH ; 
  379.         mem [ t ] .hh.b0 = hf ; 
  380.         mem [ t ] .hh.b1 = curr ; 
  381.           } 
  382.           incr ( j ) ; 
  383.           {
  384.         if ( j < n ) 
  385.         curr = hu [ j + 1 ] ; 
  386.         else curr = bchar ; 
  387.         if ( odd ( hyf [ j ] ) ) 
  388.         currh = hchar ; 
  389.         else currh = 256 ; 
  390.           } 
  391.         } 
  392.       } 
  393.       break ; 
  394.     } 
  395.     if ( q .b2 > 4 ) 
  396.     if ( q .b2 != 7 ) 
  397.     goto lab30 ; 
  398.     goto lab22 ; 
  399.       } 
  400.       w = fontinfo [ kernbase [ hf ] + 256 * q .b2 + q .b3 ] .cint ; 
  401.       goto lab30 ; 
  402.     } 
  403.     if ( q .b0 >= 128 ) 
  404.     if ( currh == 256 ) 
  405.     goto lab30 ; 
  406.     else {
  407.     
  408.       currh = 256 ; 
  409.       goto lab22 ; 
  410.     } 
  411.     k = k + q .b0 + 1 ; 
  412.     q = fontinfo [ k ] .qqqq ; 
  413.   } 
  414.   lab30: ; 
  415.   if ( ligaturepresent ) 
  416.   {
  417.     p = newligature ( hf , curl , mem [ curq ] .hh .v.RH ) ; 
  418.     if ( lfthit ) 
  419.     {
  420.       mem [ p ] .hh.b1 = 2 ; 
  421.       lfthit = false ; 
  422.     } 
  423.     if ( rthit ) 
  424.     if ( ligstack == 0 ) 
  425.     {
  426.       incr ( mem [ p ] .hh.b1 ) ; 
  427.       rthit = false ; 
  428.     } 
  429.     mem [ curq ] .hh .v.RH = p ; 
  430.     t = p ; 
  431.     ligaturepresent = false ; 
  432.   } 
  433.   if ( w != 0 ) 
  434.   {
  435.     mem [ t ] .hh .v.RH = newkern ( w ) ; 
  436.     t = mem [ t ] .hh .v.RH ; 
  437.     w = 0 ; 
  438.   } 
  439.   if ( ligstack > 0 ) 
  440.   {
  441.     curq = t ; 
  442.     curl = mem [ ligstack ] .hh.b1 ; 
  443.     ligaturepresent = true ; 
  444.     {
  445.       if ( mem [ ligstack + 1 ] .hh .v.RH > 0 ) 
  446.       {
  447.     mem [ t ] .hh .v.RH = mem [ ligstack + 1 ] .hh .v.RH ; 
  448.     t = mem [ t ] .hh .v.RH ; 
  449.     incr ( j ) ; 
  450.       } 
  451.       p = ligstack ; 
  452.       ligstack = mem [ p ] .hh .v.RH ; 
  453.       freenode ( p , 2 ) ; 
  454.       if ( ligstack == 0 ) 
  455.       {
  456.     if ( j < n ) 
  457.     curr = hu [ j + 1 ] ; 
  458.     else curr = bchar ; 
  459.     if ( odd ( hyf [ j ] ) ) 
  460.     currh = hchar ; 
  461.     else currh = 256 ; 
  462.       } 
  463.       else curr = mem [ ligstack ] .hh.b1 ; 
  464.     } 
  465.     goto lab22 ; 
  466.   } 
  467.   Result = j ; 
  468.   return(Result) ; 
  469. } 
  470. void hyphenate ( ) 
  471. {/* 50 30 40 41 42 45 10 */ hyphenate_regmem 
  472.   schar i, j, l  ; 
  473.   halfword q, r, s  ; 
  474.   halfword bchar  ; 
  475.   halfword majortail, minortail  ; 
  476.   ASCIIcode c  ; 
  477.   schar cloc  ; 
  478.   integer rcount  ; 
  479.   halfword hyfnode  ; 
  480.   triepointer z  ; 
  481.   integer v  ; 
  482.   hyphpointer h  ; 
  483.   strnumber k  ; 
  484.   poolpointer u  ; 
  485.   {register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do 
  486.     hyf [ j ] = 0 ; 
  487.   while ( j++ < for_end ) ; } 
  488.   h = hc [ 1 ] ; 
  489.   incr ( hn ) ; 
  490.   hc [ hn ] = curlang ; 
  491.   {register integer for_end; j = 2 ; for_end = hn ; if ( j <= for_end) do 
  492.     h = ( h + h + hc [ j ] ) % 307 ; 
  493.   while ( j++ < for_end ) ; } 
  494.   while ( true ) {
  495.       
  496.     k = hyphword [ h ] ; 
  497.     if ( k == 0 ) 
  498.     goto lab45 ; 
  499.     if ( ( strstart [ k + 1 ] - strstart [ k ] ) < hn ) 
  500.     goto lab45 ; 
  501.     if ( ( strstart [ k + 1 ] - strstart [ k ] ) == hn ) 
  502.     {
  503.       j = 1 ; 
  504.       u = strstart [ k ] ; 
  505.       do {
  506.       if ( strpool [ u ] < hc [ j ] ) 
  507.     goto lab45 ; 
  508.     if ( strpool [ u ] > hc [ j ] ) 
  509.     goto lab30 ; 
  510.     incr ( j ) ; 
  511.     incr ( u ) ; 
  512.       } while ( ! ( j > hn ) ) ; 
  513.       s = hyphlist [ h ] ; 
  514.       while ( s != 0 ) {
  515.       
  516.     hyf [ mem [ s ] .hh .v.LH ] = 1 ; 
  517.     s = mem [ s ] .hh .v.RH ; 
  518.       } 
  519.       decr ( hn ) ; 
  520.       goto lab40 ; 
  521.     } 
  522.     lab30: ; 
  523.     if ( h > 0 ) 
  524.     decr ( h ) ; 
  525.     else h = 307 ; 
  526.   } 
  527.   lab45: decr ( hn ) ; 
  528.   if ( trietrc [ curlang + 1 ] != curlang ) 
  529.   return ; 
  530.   hc [ 0 ] = 0 ; 
  531.   hc [ hn + 1 ] = 0 ; 
  532.   hc [ hn + 2 ] = 256 ; 
  533.   {register integer for_end; j = 0 ; for_end = hn - rhyf + 1 ; if ( j <= 
  534.   for_end) do 
  535.     {
  536.       z = trietrl [ curlang + 1 ] + hc [ j ] ; 
  537.       l = j ; 
  538.       while ( hc [ l ] == trietrc [ z ] ) {
  539.       
  540.     if ( trietro [ z ] != mintrieop ) 
  541.     {
  542.       v = trietro [ z ] ; 
  543.       do {
  544.           v = v + opstart [ curlang ] ; 
  545.         i = l - hyfdistance [ v ] ; 
  546.         if ( hyfnum [ v ] > hyf [ i ] ) 
  547.         hyf [ i ] = hyfnum [ v ] ; 
  548.         v = hyfnext [ v ] ; 
  549.       } while ( ! ( v == mintrieop ) ) ; 
  550.     } 
  551.     incr ( l ) ; 
  552.     z = trietrl [ z ] + hc [ l ] ; 
  553.       } 
  554.     } 
  555.   while ( j++ < for_end ) ; } 
  556.   lab40: {
  557.       register integer for_end; j = 0 ; for_end = lhyf - 1 ; if ( j <= 
  558.   for_end) do 
  559.     hyf [ j ] = 0 ; 
  560.   while ( j++ < for_end ) ; } 
  561.   {register integer for_end; j = 0 ; for_end = rhyf - 1 ; if ( j <= for_end) 
  562.   do 
  563.     hyf [ hn - j ] = 0 ; 
  564.   while ( j++ < for_end ) ; } 
  565.   {register integer for_end; j = lhyf ; for_end = hn - rhyf ; if ( j <= 
  566.   for_end) do 
  567.     if ( odd ( hyf [ j ] ) ) 
  568.     goto lab41 ; 
  569.   while ( j++ < for_end ) ; } 
  570.   return ; 
  571.   lab41: ; 
  572.   q = mem [ hb ] .hh .v.RH ; 
  573.   mem [ hb ] .hh .v.RH = 0 ; 
  574.   r = mem [ ha ] .hh .v.RH ; 
  575.   mem [ ha ] .hh .v.RH = 0 ; 
  576.   bchar = 256 ; 
  577.   if ( ! ( hb >= himemmin ) ) 
  578.   if ( mem [ hb ] .hh.b0 == 6 ) 
  579.   if ( odd ( mem [ hb ] .hh.b1 ) ) 
  580.   bchar = fontbchar [ hf ] ; 
  581.   if ( ( ha >= himemmin ) ) 
  582.   if ( mem [ ha ] .hh.b0 != hf ) 
  583.   goto lab42 ; 
  584.   else {
  585.       
  586.     initlist = ha ; 
  587.     initlig = false ; 
  588.     hu [ 0 ] = mem [ ha ] .hh.b1 ; 
  589.   } 
  590.   else if ( mem [ ha ] .hh.b0 == 6 ) 
  591.   if ( mem [ ha + 1 ] .hh.b0 != hf ) 
  592.   goto lab42 ; 
  593.   else {
  594.       
  595.     initlist = mem [ ha + 1 ] .hh .v.RH ; 
  596.     initlig = true ; 
  597.     initlft = ( mem [ ha ] .hh.b1 > 1 ) ; 
  598.     hu [ 0 ] = mem [ ha + 1 ] .hh.b1 ; 
  599.     if ( initlist == 0 ) 
  600.     if ( initlft ) 
  601.     {
  602.       hu [ 0 ] = 256 ; 
  603.       initlig = false ; 
  604.     } 
  605.     freenode ( ha , 2 ) ; 
  606.   } 
  607.   else {
  608.       
  609.     if ( ! ( r >= himemmin ) ) 
  610.     if ( mem [ r ] .hh.b0 == 6 ) 
  611.     if ( mem [ r ] .hh.b1 > 1 ) 
  612.     goto lab42 ; 
  613.     j = 1 ; 
  614.     s = ha ; 
  615.     initlist = 0 ; 
  616.     goto lab50 ; 
  617.   } 
  618.   s = curp ; 
  619.   while ( mem [ s ] .hh .v.RH != ha ) s = mem [ s ] .hh .v.RH ; 
  620.   j = 0 ; 
  621.   goto lab50 ; 
  622.   lab42: s = ha ; 
  623.   j = 0 ; 
  624.   hu [ 0 ] = 256 ; 
  625.   initlig = false ; 
  626.   initlist = 0 ; 
  627.   lab50: flushnodelist ( r ) ; 
  628.   do {
  629.       l = j ; 
  630.     j = reconstitute ( j , hn , bchar , hyfchar ) + 1 ; 
  631.     if ( hyphenpassed == 0 ) 
  632.     {
  633.       mem [ s ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  634.       while ( mem [ s ] .hh .v.RH > 0 ) s = mem [ s ] .hh .v.RH ; 
  635.       if ( odd ( hyf [ j - 1 ] ) ) 
  636.       {
  637.     l = j ; 
  638.     hyphenpassed = j - 1 ; 
  639.     mem [ memtop - 4 ] .hh .v.RH = 0 ; 
  640.       } 
  641.     } 
  642.     if ( hyphenpassed > 0 ) 
  643.     do {
  644.     r = getnode ( 2 ) ; 
  645.       mem [ r ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  646.       mem [ r ] .hh.b0 = 7 ; 
  647.       majortail = r ; 
  648.       rcount = 0 ; 
  649.       while ( mem [ majortail ] .hh .v.RH > 0 ) {
  650.       
  651.     majortail = mem [ majortail ] .hh .v.RH ; 
  652.     incr ( rcount ) ; 
  653.       } 
  654.       i = hyphenpassed ; 
  655.       hyf [ i ] = 0 ; 
  656.       minortail = 0 ; 
  657.       mem [ r + 1 ] .hh .v.LH = 0 ; 
  658.       hyfnode = newcharacter ( hf , hyfchar ) ; 
  659.       if ( hyfnode != 0 ) 
  660.       {
  661.     incr ( i ) ; 
  662.     c = hu [ i ] ; 
  663.     hu [ i ] = hyfchar ; 
  664.     {
  665.       mem [ hyfnode ] .hh .v.RH = avail ; 
  666.       avail = hyfnode ; 
  667.     ;
  668. #ifdef STAT
  669.       decr ( dynused ) ; 
  670. #endif /* STAT */
  671.     } 
  672.       } 
  673.       while ( l <= i ) {
  674.       
  675.     l = reconstitute ( l , i , fontbchar [ hf ] , 256 ) + 1 ; 
  676.     if ( mem [ memtop - 4 ] .hh .v.RH > 0 ) 
  677.     {
  678.       if ( minortail == 0 ) 
  679.       mem [ r + 1 ] .hh .v.LH = mem [ memtop - 4 ] .hh .v.RH ; 
  680.       else mem [ minortail ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  681.       minortail = mem [ memtop - 4 ] .hh .v.RH ; 
  682.       while ( mem [ minortail ] .hh .v.RH > 0 ) minortail = mem [ 
  683.       minortail ] .hh .v.RH ; 
  684.     } 
  685.       } 
  686.       if ( hyfnode != 0 ) 
  687.       {
  688.     hu [ i ] = c ; 
  689.     l = i ; 
  690.     decr ( i ) ; 
  691.       } 
  692.       minortail = 0 ; 
  693.       mem [ r + 1 ] .hh .v.RH = 0 ; 
  694.       cloc = 0 ; 
  695.       if ( bcharlabel [ hf ] < fontmemsize ) 
  696.       {
  697.     decr ( l ) ; 
  698.     c = hu [ l ] ; 
  699.     cloc = l ; 
  700.     hu [ l ] = 256 ; 
  701.       } 
  702.       while ( l < j ) {
  703.       
  704.     do {
  705.         l = reconstitute ( l , hn , bchar , 256 ) + 1 ; 
  706.       if ( cloc > 0 ) 
  707.       {
  708.         hu [ cloc ] = c ; 
  709.         cloc = 0 ; 
  710.       } 
  711.       if ( mem [ memtop - 4 ] .hh .v.RH > 0 ) 
  712.       {
  713.         if ( minortail == 0 ) 
  714.         mem [ r + 1 ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  715.         else mem [ minortail ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  716.         minortail = mem [ memtop - 4 ] .hh .v.RH ; 
  717.         while ( mem [ minortail ] .hh .v.RH > 0 ) minortail = mem [ 
  718.         minortail ] .hh .v.RH ; 
  719.       } 
  720.     } while ( ! ( l >= j ) ) ; 
  721.     while ( l > j ) {
  722.         
  723.       j = reconstitute ( j , hn , bchar , 256 ) + 1 ; 
  724.       mem [ majortail ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  725.       while ( mem [ majortail ] .hh .v.RH > 0 ) {
  726.           
  727.         majortail = mem [ majortail ] .hh .v.RH ; 
  728.         incr ( rcount ) ; 
  729.       } 
  730.     } 
  731.       } 
  732.       if ( rcount > 127 ) 
  733.       {
  734.     mem [ s ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  735.     mem [ r ] .hh .v.RH = 0 ; 
  736.     flushnodelist ( r ) ; 
  737.       } 
  738.       else {
  739.       
  740.     mem [ s ] .hh .v.RH = r ; 
  741.     mem [ r ] .hh.b1 = rcount ; 
  742.       } 
  743.       s = majortail ; 
  744.       hyphenpassed = j - 1 ; 
  745.       mem [ memtop - 4 ] .hh .v.RH = 0 ; 
  746.     } while ( ! ( ! odd ( hyf [ j - 1 ] ) ) ) ; 
  747.   } while ( ! ( j > hn ) ) ; 
  748.   mem [ s ] .hh .v.RH = q ; 
  749.   flushlist ( initlist ) ; 
  750. } 
  751. void newhyphexceptions ( ) 
  752. {/* 21 10 40 45 */ newhyphexceptions_regmem 
  753.   smallnumber n  ; 
  754.   smallnumber j  ; 
  755.   hyphpointer h  ; 
  756.   strnumber k  ; 
  757.   halfword p  ; 
  758.   halfword q  ; 
  759.   strnumber s, t  ; 
  760.   poolpointer u, v  ; 
  761.   scanleftbrace () ; 
  762.   if ( eqtb [ 6213 ] .cint <= 0 ) 
  763.   curlang = 0 ; 
  764.   else if ( eqtb [ 6213 ] .cint > 255 ) 
  765.   curlang = 0 ; 
  766.   else curlang = eqtb [ 6213 ] .cint ; 
  767.   n = 0 ; 
  768.   p = 0 ; 
  769.   while ( true ) {
  770.       
  771.     getxtoken () ; 
  772.     lab21: switch ( curcmd ) 
  773.     {case 11 : 
  774.     case 12 : 
  775.     case 68 : 
  776.       if ( curchr == 45 ) 
  777.       {
  778.     if ( n < 63 ) 
  779.     {
  780.       q = getavail () ; 
  781.       mem [ q ] .hh .v.RH = p ; 
  782.       mem [ q ] .hh .v.LH = n ; 
  783.       p = q ; 
  784.     } 
  785.       } 
  786.       else {
  787.       
  788.     if ( eqtb [ 5139 + curchr ] .hh .v.RH == 0 ) 
  789.     {
  790.       {
  791.         if ( interaction == 3 ) 
  792.         wakeupterminal () ; 
  793.         printnl ( 262 ) ; 
  794.         print ( 938 ) ; 
  795.       } 
  796.       {
  797.         helpptr = 2 ; 
  798.         helpline [ 1 ] = 939 ; 
  799.         helpline [ 0 ] = 940 ; 
  800.       } 
  801.       error () ; 
  802.     } 
  803.     else if ( n < 63 ) 
  804.     {
  805.       incr ( n ) ; 
  806.       hc [ n ] = eqtb [ 5139 + curchr ] .hh .v.RH ; 
  807.     } 
  808.       } 
  809.       break ; 
  810.     case 16 : 
  811.       {
  812.     scancharnum () ; 
  813.     curchr = curval ; 
  814.     curcmd = 68 ; 
  815.     goto lab21 ; 
  816.       } 
  817.       break ; 
  818.     case 10 : 
  819.     case 2 : 
  820.       {
  821.     if ( n > 1 ) 
  822.     {
  823.       incr ( n ) ; 
  824.       hc [ n ] = curlang ; 
  825.       {
  826.         if ( poolptr + n > poolsize ) 
  827.         overflow ( 257 , poolsize - initpoolptr ) ; 
  828.       } 
  829.       h = 0 ; 
  830.       {register integer for_end; j = 1 ; for_end = n ; if ( j <= for_end) 
  831.       do 
  832.         {
  833.           h = ( h + h + hc [ j ] ) % 307 ; 
  834.           {
  835.         strpool [ poolptr ] = hc [ j ] ; 
  836.         incr ( poolptr ) ; 
  837.           } 
  838.         } 
  839.       while ( j++ < for_end ) ; } 
  840.       s = makestring () ; 
  841.       if ( hyphcount == 307 ) 
  842.       overflow ( 941 , 307 ) ; 
  843.       incr ( hyphcount ) ; 
  844.       while ( hyphword [ h ] != 0 ) {
  845.           
  846.         k = hyphword [ h ] ; 
  847.         if ( ( strstart [ k + 1 ] - strstart [ k ] ) < ( strstart [ s + 1 
  848.         ] - strstart [ s ] ) ) 
  849.         goto lab40 ; 
  850.         if ( ( strstart [ k + 1 ] - strstart [ k ] ) > ( strstart [ s + 1 
  851.         ] - strstart [ s ] ) ) 
  852.         goto lab45 ; 
  853.         u = strstart [ k ] ; 
  854.         v = strstart [ s ] ; 
  855.         do {
  856.         if ( strpool [ u ] < strpool [ v ] ) 
  857.           goto lab40 ; 
  858.           if ( strpool [ u ] > strpool [ v ] ) 
  859.           goto lab45 ; 
  860.           incr ( u ) ; 
  861.           incr ( v ) ; 
  862.         } while ( ! ( u == strstart [ k + 1 ] ) ) ; 
  863.         lab40: q = hyphlist [ h ] ; 
  864.         hyphlist [ h ] = p ; 
  865.         p = q ; 
  866.         t = hyphword [ h ] ; 
  867.         hyphword [ h ] = s ; 
  868.         s = t ; 
  869.         lab45: ; 
  870.         if ( h > 0 ) 
  871.         decr ( h ) ; 
  872.         else h = 307 ; 
  873.       } 
  874.       hyphword [ h ] = s ; 
  875.       hyphlist [ h ] = p ; 
  876.     } 
  877.     if ( curcmd == 2 ) 
  878.     return ; 
  879.     n = 0 ; 
  880.     p = 0 ; 
  881.       } 
  882.       break ; 
  883.       default: 
  884.       {
  885.     {
  886.       if ( interaction == 3 ) 
  887.       wakeupterminal () ; 
  888.       printnl ( 262 ) ; 
  889.       print ( 676 ) ; 
  890.     } 
  891.     printesc ( 934 ) ; 
  892.     print ( 935 ) ; 
  893.     {
  894.       helpptr = 2 ; 
  895.       helpline [ 1 ] = 936 ; 
  896.       helpline [ 0 ] = 937 ; 
  897.     } 
  898.     error () ; 
  899.       } 
  900.       break ; 
  901.     } 
  902.   } 
  903. } 
  904. halfword zprunepagetop ( p ) 
  905. halfword p ; 
  906. {register halfword Result; prunepagetop_regmem 
  907.   halfword prevp  ; 
  908.   halfword q  ; 
  909.   prevp = memtop - 3 ; 
  910.   mem [ memtop - 3 ] .hh .v.RH = p ; 
  911.   while ( p != 0 ) switch ( mem [ p ] .hh.b0 ) 
  912.   {case 0 : 
  913.   case 1 : 
  914.   case 2 : 
  915.     {
  916.       q = newskipparam ( 10 ) ; 
  917.       mem [ prevp ] .hh .v.RH = q ; 
  918.       mem [ q ] .hh .v.RH = p ; 
  919.       if ( mem [ tempptr + 1 ] .cint > mem [ p + 3 ] .cint ) 
  920.       mem [ tempptr + 1 ] .cint = mem [ tempptr + 1 ] .cint - mem [ p + 3 ] 
  921.       .cint ; 
  922.       else mem [ tempptr + 1 ] .cint = 0 ; 
  923.       p = 0 ; 
  924.     } 
  925.     break ; 
  926.   case 8 : 
  927.   case 4 : 
  928.   case 3 : 
  929.     {
  930.       prevp = p ; 
  931.       p = mem [ prevp ] .hh .v.RH ; 
  932.     } 
  933.     break ; 
  934.   case 10 : 
  935.   case 11 : 
  936.   case 12 : 
  937.     {
  938.       q = p ; 
  939.       p = mem [ q ] .hh .v.RH ; 
  940.       mem [ q ] .hh .v.RH = 0 ; 
  941.       mem [ prevp ] .hh .v.RH = p ; 
  942.       flushnodelist ( q ) ; 
  943.     } 
  944.     break ; 
  945.     default: 
  946.     confusion ( 952 ) ; 
  947.     break ; 
  948.   } 
  949.   Result = mem [ memtop - 3 ] .hh .v.RH ; 
  950.   return(Result) ; 
  951. } 
  952. halfword zvertbreak ( p , h , d ) 
  953. halfword p ; 
  954. scaled h ; 
  955. scaled d ; 
  956. {/* 30 45 90 */ register halfword Result; vertbreak_regmem 
  957.   halfword prevp  ; 
  958.   halfword q, r  ; 
  959.   integer pi  ; 
  960.   integer b  ; 
  961.   integer leastcost  ; 
  962.   halfword bestplace  ; 
  963.   scaled prevdp  ; 
  964.   smallnumber t  ; 
  965.   prevp = p ; 
  966.   leastcost = 1073741823L ; 
  967.   activewidth [ 1 ] = 0 ; 
  968.   activewidth [ 2 ] = 0 ; 
  969.   activewidth [ 3 ] = 0 ; 
  970.   activewidth [ 4 ] = 0 ; 
  971.   activewidth [ 5 ] = 0 ; 
  972.   activewidth [ 6 ] = 0 ; 
  973.   prevdp = 0 ; 
  974.   while ( true ) {
  975.       
  976.     if ( p == 0 ) 
  977.     pi = -10000 ; 
  978.     else switch ( mem [ p ] .hh.b0 ) 
  979.     {case 0 : 
  980.     case 1 : 
  981.     case 2 : 
  982.       {
  983.     activewidth [ 1 ] = activewidth [ 1 ] + prevdp + mem [ p + 3 ] .cint ; 
  984.     prevdp = mem [ p + 2 ] .cint ; 
  985.     goto lab45 ; 
  986.       } 
  987.       break ; 
  988.     case 8 : 
  989.       goto lab45 ; 
  990.       break ; 
  991.     case 10 : 
  992.       if ( ( mem [ prevp ] .hh.b0 < 9 ) ) 
  993.       pi = 0 ; 
  994.       else goto lab90 ; 
  995.       break ; 
  996.     case 11 : 
  997.       {
  998.     if ( mem [ p ] .hh .v.RH == 0 ) 
  999.     t = 12 ; 
  1000.     else t = mem [ mem [ p ] .hh .v.RH ] .hh.b0 ; 
  1001.     if ( t == 10 ) 
  1002.     pi = 0 ; 
  1003.     else goto lab90 ; 
  1004.       } 
  1005.       break ; 
  1006.     case 12 : 
  1007.       pi = mem [ p + 1 ] .cint ; 
  1008.       break ; 
  1009.     case 4 : 
  1010.     case 3 : 
  1011.       goto lab45 ; 
  1012.       break ; 
  1013.       default: 
  1014.       confusion ( 953 ) ; 
  1015.       break ; 
  1016.     } 
  1017.     if ( pi < 10000 ) 
  1018.     {
  1019.       if ( activewidth [ 1 ] < h ) 
  1020.       if ( ( activewidth [ 3 ] != 0 ) || ( activewidth [ 4 ] != 0 ) || ( 
  1021.       activewidth [ 5 ] != 0 ) ) 
  1022.       b = 0 ; 
  1023.       else b = badness ( h - activewidth [ 1 ] , activewidth [ 2 ] ) ; 
  1024.       else if ( activewidth [ 1 ] - h > activewidth [ 6 ] ) 
  1025.       b = 1073741823L ; 
  1026.       else b = badness ( activewidth [ 1 ] - h , activewidth [ 6 ] ) ; 
  1027.       if ( b < 1073741823L ) 
  1028.       if ( pi <= -10000 ) 
  1029.       b = pi ; 
  1030.       else if ( b < 10000 ) 
  1031.       b = b + pi ; 
  1032.       else b = 100000L ; 
  1033.       if ( b <= leastcost ) 
  1034.       {
  1035.     bestplace = p ; 
  1036.     leastcost = b ; 
  1037.     bestheightplusdepth = activewidth [ 1 ] + prevdp ; 
  1038.       } 
  1039.       if ( ( b == 1073741823L ) || ( pi <= -10000 ) ) 
  1040.       goto lab30 ; 
  1041.     } 
  1042.     if ( ( mem [ p ] .hh.b0 < 10 ) || ( mem [ p ] .hh.b0 > 11 ) ) 
  1043.     goto lab45 ; 
  1044.     lab90: if ( mem [ p ] .hh.b0 == 11 ) 
  1045.     q = p ; 
  1046.     else {
  1047.     
  1048.       q = mem [ p + 1 ] .hh .v.LH ; 
  1049.       activewidth [ 2 + mem [ q ] .hh.b0 ] = activewidth [ 2 + mem [ q ] 
  1050.       .hh.b0 ] + mem [ q + 2 ] .cint ; 
  1051.       activewidth [ 6 ] = activewidth [ 6 ] + mem [ q + 3 ] .cint ; 
  1052.       if ( ( mem [ q ] .hh.b1 != 0 ) && ( mem [ q + 3 ] .cint != 0 ) ) 
  1053.       {
  1054.     {
  1055.       if ( interaction == 3 ) 
  1056.       wakeupterminal () ; 
  1057.       printnl ( 262 ) ; 
  1058.       print ( 954 ) ; 
  1059.     } 
  1060.     {
  1061.       helpptr = 4 ; 
  1062.       helpline [ 3 ] = 955 ; 
  1063.       helpline [ 2 ] = 956 ; 
  1064.       helpline [ 1 ] = 957 ; 
  1065.       helpline [ 0 ] = 915 ; 
  1066.     } 
  1067.     error () ; 
  1068.     r = newspec ( q ) ; 
  1069.     mem [ r ] .hh.b1 = 0 ; 
  1070.     deleteglueref ( q ) ; 
  1071.     mem [ p + 1 ] .hh .v.LH = r ; 
  1072.     q = r ; 
  1073.       } 
  1074.     } 
  1075.     activewidth [ 1 ] = activewidth [ 1 ] + prevdp + mem [ q + 1 ] .cint ; 
  1076.     prevdp = 0 ; 
  1077.     lab45: if ( prevdp > d ) 
  1078.     {
  1079.       activewidth [ 1 ] = activewidth [ 1 ] + prevdp - d ; 
  1080.       prevdp = d ; 
  1081.     } 
  1082.     prevp = p ; 
  1083.     p = mem [ prevp ] .hh .v.RH ; 
  1084.   } 
  1085.   lab30: Result = bestplace ; 
  1086.   return(Result) ; 
  1087. } 
  1088.