home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex7.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  22.1 KB  |  1,051 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void zcharwarning ( f , c ) 
  5. internalfontnumber f ; 
  6. eightbits c ; 
  7. {charwarning_regmem 
  8.   if ( eqtb [ 6198 ] .cint > 0 ) 
  9.   {
  10.     begindiagnostic () ; 
  11.     printnl ( 818 ) ; 
  12.     print ( c ) ; 
  13.     print ( 819 ) ; 
  14.     print ( fontname [ f ] ) ; 
  15.     printchar ( 33 ) ; 
  16.     enddiagnostic ( false ) ; 
  17.   } 
  18. } 
  19. halfword znewcharacter ( f , c ) 
  20. internalfontnumber f ; 
  21. eightbits c ; 
  22. {/* 10 */ register halfword Result; newcharacter_regmem 
  23.   halfword p  ; 
  24.   if ( fontbc [ f ] <= c ) 
  25.   if ( fontec [ f ] >= c ) 
  26.   if ( ( fontinfo [ charbase [ f ] + c ] .qqqq .b0 > 0 ) ) 
  27.   {
  28.     p = getavail () ; 
  29.     mem [ p ] .hh.b0 = f ; 
  30.     mem [ p ] .hh.b1 = c ; 
  31.     Result = p ; 
  32.     return(Result) ; 
  33.   } 
  34.   charwarning ( f , c ) ; 
  35.   Result = 0 ; 
  36.   return(Result) ; 
  37. } 
  38. void dviswap ( ) 
  39. {dviswap_regmem 
  40.   if ( dvilimit == dvibufsize ) 
  41.   {
  42.     writedvi ( 0 , halfbuf - 1 ) ; 
  43.     dvilimit = halfbuf ; 
  44.     dvioffset = dvioffset + dvibufsize ; 
  45.     dviptr = 0 ; 
  46.   } 
  47.   else {
  48.       
  49.     writedvi ( halfbuf , dvibufsize - 1 ) ; 
  50.     dvilimit = dvibufsize ; 
  51.   } 
  52.   dvigone = dvigone + halfbuf ; 
  53. } 
  54. void zdvifour ( x ) 
  55. integer x ; 
  56. {dvifour_regmem 
  57.   if ( x >= 0 ) 
  58.   {
  59.     dvibuf [ dviptr ] = x / 16777216L ; 
  60.     incr ( dviptr ) ; 
  61.     if ( dviptr == dvilimit ) 
  62.     dviswap () ; 
  63.   } 
  64.   else {
  65.       
  66.     x = x + 1073741824L ; 
  67.     x = x + 1073741824L ; 
  68.     {
  69.       dvibuf [ dviptr ] = ( x / 16777216L ) + 128 ; 
  70.       incr ( dviptr ) ; 
  71.       if ( dviptr == dvilimit ) 
  72.       dviswap () ; 
  73.     } 
  74.   } 
  75.   x = x % 16777216L ; 
  76.   {
  77.     dvibuf [ dviptr ] = x / 65536L ; 
  78.     incr ( dviptr ) ; 
  79.     if ( dviptr == dvilimit ) 
  80.     dviswap () ; 
  81.   } 
  82.   x = x % 65536L ; 
  83.   {
  84.     dvibuf [ dviptr ] = x / 256 ; 
  85.     incr ( dviptr ) ; 
  86.     if ( dviptr == dvilimit ) 
  87.     dviswap () ; 
  88.   } 
  89.   {
  90.     dvibuf [ dviptr ] = x % 256 ; 
  91.     incr ( dviptr ) ; 
  92.     if ( dviptr == dvilimit ) 
  93.     dviswap () ; 
  94.   } 
  95. } 
  96. void zdvipop ( l ) 
  97. integer l ; 
  98. {dvipop_regmem 
  99.   if ( ( l == dvioffset + dviptr ) && ( dviptr > 0 ) ) 
  100.   decr ( dviptr ) ; 
  101.   else {
  102.       
  103.     dvibuf [ dviptr ] = 142 ; 
  104.     incr ( dviptr ) ; 
  105.     if ( dviptr == dvilimit ) 
  106.     dviswap () ; 
  107.   } 
  108. } 
  109. void zdvifontdef ( f ) 
  110. internalfontnumber f ; 
  111. {dvifontdef_regmem 
  112.   poolpointer k  ; 
  113.   {
  114.     dvibuf [ dviptr ] = 243 ; 
  115.     incr ( dviptr ) ; 
  116.     if ( dviptr == dvilimit ) 
  117.     dviswap () ; 
  118.   } 
  119.   {
  120.     dvibuf [ dviptr ] = f - 1 ; 
  121.     incr ( dviptr ) ; 
  122.     if ( dviptr == dvilimit ) 
  123.     dviswap () ; 
  124.   } 
  125.   {
  126.     dvibuf [ dviptr ] = fontcheck [ f ] .b0 ; 
  127.     incr ( dviptr ) ; 
  128.     if ( dviptr == dvilimit ) 
  129.     dviswap () ; 
  130.   } 
  131.   {
  132.     dvibuf [ dviptr ] = fontcheck [ f ] .b1 ; 
  133.     incr ( dviptr ) ; 
  134.     if ( dviptr == dvilimit ) 
  135.     dviswap () ; 
  136.   } 
  137.   {
  138.     dvibuf [ dviptr ] = fontcheck [ f ] .b2 ; 
  139.     incr ( dviptr ) ; 
  140.     if ( dviptr == dvilimit ) 
  141.     dviswap () ; 
  142.   } 
  143.   {
  144.     dvibuf [ dviptr ] = fontcheck [ f ] .b3 ; 
  145.     incr ( dviptr ) ; 
  146.     if ( dviptr == dvilimit ) 
  147.     dviswap () ; 
  148.   } 
  149.   dvifour ( fontsize [ f ] ) ; 
  150.   dvifour ( fontdsize [ f ] ) ; 
  151.   {
  152.     dvibuf [ dviptr ] = ( strstart [ fontarea [ f ] + 1 ] - strstart [ 
  153.     fontarea [ f ] ] ) ; 
  154.     incr ( dviptr ) ; 
  155.     if ( dviptr == dvilimit ) 
  156.     dviswap () ; 
  157.   } 
  158.   {
  159.     dvibuf [ dviptr ] = ( strstart [ fontname [ f ] + 1 ] - strstart [ 
  160.     fontname [ f ] ] ) ; 
  161.     incr ( dviptr ) ; 
  162.     if ( dviptr == dvilimit ) 
  163.     dviswap () ; 
  164.   } 
  165.   {register integer for_end; k = strstart [ fontarea [ f ] ] ; for_end = 
  166.   strstart [ fontarea [ f ] + 1 ] - 1 ; if ( k <= for_end) do 
  167.     {
  168.       dvibuf [ dviptr ] = strpool [ k ] ; 
  169.       incr ( dviptr ) ; 
  170.       if ( dviptr == dvilimit ) 
  171.       dviswap () ; 
  172.     } 
  173.   while ( k++ < for_end ) ; } 
  174.   {register integer for_end; k = strstart [ fontname [ f ] ] ; for_end = 
  175.   strstart [ fontname [ f ] + 1 ] - 1 ; if ( k <= for_end) do 
  176.     {
  177.       dvibuf [ dviptr ] = strpool [ k ] ; 
  178.       incr ( dviptr ) ; 
  179.       if ( dviptr == dvilimit ) 
  180.       dviswap () ; 
  181.     } 
  182.   while ( k++ < for_end ) ; } 
  183. } 
  184. void zmovement ( w , o ) 
  185. scaled w ; 
  186. eightbits o ; 
  187. {/* 10 40 45 2 1 */ movement_regmem 
  188.   smallnumber mstate  ; 
  189.   halfword p, q  ; 
  190.   integer k  ; 
  191.   q = getnode ( 3 ) ; 
  192.   mem [ q + 1 ] .cint = w ; 
  193.   mem [ q + 2 ] .cint = dvioffset + dviptr ; 
  194.   if ( o == 157 ) 
  195.   {
  196.     mem [ q ] .hh .v.RH = downptr ; 
  197.     downptr = q ; 
  198.   } 
  199.   else {
  200.       
  201.     mem [ q ] .hh .v.RH = rightptr ; 
  202.     rightptr = q ; 
  203.   } 
  204.   p = mem [ q ] .hh .v.RH ; 
  205.   mstate = 0 ; 
  206.   while ( p != 0 ) {
  207.       
  208.     if ( mem [ p + 1 ] .cint == w ) 
  209.     switch ( mstate + mem [ p ] .hh .v.LH ) 
  210.     {case 3 : 
  211.     case 4 : 
  212.     case 15 : 
  213.     case 16 : 
  214.       if ( mem [ p + 2 ] .cint < dvigone ) 
  215.       goto lab45 ; 
  216.       else {
  217.       
  218.     k = mem [ p + 2 ] .cint - dvioffset ; 
  219.     if ( k < 0 ) 
  220.     k = k + dvibufsize ; 
  221.     dvibuf [ k ] = dvibuf [ k ] + 5 ; 
  222.     mem [ p ] .hh .v.LH = 1 ; 
  223.     goto lab40 ; 
  224.       } 
  225.       break ; 
  226.     case 5 : 
  227.     case 9 : 
  228.     case 11 : 
  229.       if ( mem [ p + 2 ] .cint < dvigone ) 
  230.       goto lab45 ; 
  231.       else {
  232.       
  233.     k = mem [ p + 2 ] .cint - dvioffset ; 
  234.     if ( k < 0 ) 
  235.     k = k + dvibufsize ; 
  236.     dvibuf [ k ] = dvibuf [ k ] + 10 ; 
  237.     mem [ p ] .hh .v.LH = 2 ; 
  238.     goto lab40 ; 
  239.       } 
  240.       break ; 
  241.     case 1 : 
  242.     case 2 : 
  243.     case 8 : 
  244.     case 13 : 
  245.       goto lab40 ; 
  246.       break ; 
  247.       default: 
  248.       ; 
  249.       break ; 
  250.     } 
  251.     else switch ( mstate + mem [ p ] .hh .v.LH ) 
  252.     {case 1 : 
  253.       mstate = 6 ; 
  254.       break ; 
  255.     case 2 : 
  256.       mstate = 12 ; 
  257.       break ; 
  258.     case 8 : 
  259.     case 13 : 
  260.       goto lab45 ; 
  261.       break ; 
  262.       default: 
  263.       ; 
  264.       break ; 
  265.     } 
  266.     p = mem [ p ] .hh .v.RH ; 
  267.   } 
  268.   lab45: ; 
  269.   mem [ q ] .hh .v.LH = 3 ; 
  270.   if ( abs ( w ) >= 8388608L ) 
  271.   {
  272.     {
  273.       dvibuf [ dviptr ] = o + 3 ; 
  274.       incr ( dviptr ) ; 
  275.       if ( dviptr == dvilimit ) 
  276.       dviswap () ; 
  277.     } 
  278.     dvifour ( w ) ; 
  279.     return ; 
  280.   } 
  281.   if ( abs ( w ) >= 32768L ) 
  282.   {
  283.     {
  284.       dvibuf [ dviptr ] = o + 2 ; 
  285.       incr ( dviptr ) ; 
  286.       if ( dviptr == dvilimit ) 
  287.       dviswap () ; 
  288.     } 
  289.     if ( w < 0 ) 
  290.     w = w + 16777216L ; 
  291.     {
  292.       dvibuf [ dviptr ] = w / 65536L ; 
  293.       incr ( dviptr ) ; 
  294.       if ( dviptr == dvilimit ) 
  295.       dviswap () ; 
  296.     } 
  297.     w = w % 65536L ; 
  298.     goto lab2 ; 
  299.   } 
  300.   if ( abs ( w ) >= 128 ) 
  301.   {
  302.     {
  303.       dvibuf [ dviptr ] = o + 1 ; 
  304.       incr ( dviptr ) ; 
  305.       if ( dviptr == dvilimit ) 
  306.       dviswap () ; 
  307.     } 
  308.     if ( w < 0 ) 
  309.     w = w + 65536L ; 
  310.     goto lab2 ; 
  311.   } 
  312.   {
  313.     dvibuf [ dviptr ] = o ; 
  314.     incr ( dviptr ) ; 
  315.     if ( dviptr == dvilimit ) 
  316.     dviswap () ; 
  317.   } 
  318.   if ( w < 0 ) 
  319.   w = w + 256 ; 
  320.   goto lab1 ; 
  321.   lab2: {
  322.       
  323.     dvibuf [ dviptr ] = w / 256 ; 
  324.     incr ( dviptr ) ; 
  325.     if ( dviptr == dvilimit ) 
  326.     dviswap () ; 
  327.   } 
  328.   lab1: {
  329.       
  330.     dvibuf [ dviptr ] = w % 256 ; 
  331.     incr ( dviptr ) ; 
  332.     if ( dviptr == dvilimit ) 
  333.     dviswap () ; 
  334.   } 
  335.   return ; 
  336.   lab40: mem [ q ] .hh .v.LH = mem [ p ] .hh .v.LH ; 
  337.   if ( mem [ q ] .hh .v.LH == 1 ) 
  338.   {
  339.     {
  340.       dvibuf [ dviptr ] = o + 4 ; 
  341.       incr ( dviptr ) ; 
  342.       if ( dviptr == dvilimit ) 
  343.       dviswap () ; 
  344.     } 
  345.     while ( mem [ q ] .hh .v.RH != p ) {
  346.     
  347.       q = mem [ q ] .hh .v.RH ; 
  348.       switch ( mem [ q ] .hh .v.LH ) 
  349.       {case 3 : 
  350.     mem [ q ] .hh .v.LH = 5 ; 
  351.     break ; 
  352.       case 4 : 
  353.     mem [ q ] .hh .v.LH = 6 ; 
  354.     break ; 
  355.     default: 
  356.     ; 
  357.     break ; 
  358.       } 
  359.     } 
  360.   } 
  361.   else {
  362.       
  363.     {
  364.       dvibuf [ dviptr ] = o + 9 ; 
  365.       incr ( dviptr ) ; 
  366.       if ( dviptr == dvilimit ) 
  367.       dviswap () ; 
  368.     } 
  369.     while ( mem [ q ] .hh .v.RH != p ) {
  370.     
  371.       q = mem [ q ] .hh .v.RH ; 
  372.       switch ( mem [ q ] .hh .v.LH ) 
  373.       {case 3 : 
  374.     mem [ q ] .hh .v.LH = 4 ; 
  375.     break ; 
  376.       case 5 : 
  377.     mem [ q ] .hh .v.LH = 6 ; 
  378.     break ; 
  379.     default: 
  380.     ; 
  381.     break ; 
  382.       } 
  383.     } 
  384.   } 
  385. } 
  386. void zprunemovements ( l ) 
  387. integer l ; 
  388. {/* 30 10 */ prunemovements_regmem 
  389.   halfword p  ; 
  390.   while ( downptr != 0 ) {
  391.       
  392.     if ( mem [ downptr + 2 ] .cint < l ) 
  393.     goto lab30 ; 
  394.     p = downptr ; 
  395.     downptr = mem [ p ] .hh .v.RH ; 
  396.     freenode ( p , 3 ) ; 
  397.   } 
  398.   lab30: while ( rightptr != 0 ) {
  399.       
  400.     if ( mem [ rightptr + 2 ] .cint < l ) 
  401.     return ; 
  402.     p = rightptr ; 
  403.     rightptr = mem [ p ] .hh .v.RH ; 
  404.     freenode ( p , 3 ) ; 
  405.   } 
  406. } 
  407. void zspecialout ( p ) 
  408. halfword p ; 
  409. {specialout_regmem 
  410.   schar oldsetting  ; 
  411.   poolpointer k  ; 
  412.   if ( curh != dvih ) 
  413.   {
  414.     movement ( curh - dvih , 143 ) ; 
  415.     dvih = curh ; 
  416.   } 
  417.   if ( curv != dviv ) 
  418.   {
  419.     movement ( curv - dviv , 157 ) ; 
  420.     dviv = curv ; 
  421.   } 
  422.   oldsetting = selector ; 
  423.   selector = 21 ; 
  424.   showtokenlist ( mem [ mem [ p + 1 ] .hh .v.RH ] .hh .v.RH , 0 , poolsize - 
  425.   poolptr ) ; 
  426.   selector = oldsetting ; 
  427.   {
  428.     if ( poolptr + 1 > poolsize ) 
  429.     overflow ( 257 , poolsize - initpoolptr ) ; 
  430.   } 
  431.   if ( ( poolptr - strstart [ strptr ] ) < 256 ) 
  432.   {
  433.     {
  434.       dvibuf [ dviptr ] = 239 ; 
  435.       incr ( dviptr ) ; 
  436.       if ( dviptr == dvilimit ) 
  437.       dviswap () ; 
  438.     } 
  439.     {
  440.       dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ; 
  441.       incr ( dviptr ) ; 
  442.       if ( dviptr == dvilimit ) 
  443.       dviswap () ; 
  444.     } 
  445.   } 
  446.   else {
  447.       
  448.     {
  449.       dvibuf [ dviptr ] = 242 ; 
  450.       incr ( dviptr ) ; 
  451.       if ( dviptr == dvilimit ) 
  452.       dviswap () ; 
  453.     } 
  454.     dvifour ( ( poolptr - strstart [ strptr ] ) ) ; 
  455.   } 
  456.   {register integer for_end; k = strstart [ strptr ] ; for_end = poolptr - 1 
  457.   ; if ( k <= for_end) do 
  458.     {
  459.       dvibuf [ dviptr ] = strpool [ k ] ; 
  460.       incr ( dviptr ) ; 
  461.       if ( dviptr == dvilimit ) 
  462.       dviswap () ; 
  463.     } 
  464.   while ( k++ < for_end ) ; } 
  465.   poolptr = strstart [ strptr ] ; 
  466. } 
  467. void zwriteout ( p ) 
  468. halfword p ; 
  469. {writeout_regmem 
  470.   schar oldsetting  ; 
  471.   integer oldmode  ; 
  472.   smallnumber j  ; 
  473.   halfword q, r  ; 
  474.   q = getavail () ; 
  475.   mem [ q ] .hh .v.LH = 637 ; 
  476.   r = getavail () ; 
  477.   mem [ q ] .hh .v.RH = r ; 
  478.   mem [ r ] .hh .v.LH = 7617 ; 
  479.   begintokenlist ( q , 4 ) ; 
  480.   begintokenlist ( mem [ p + 1 ] .hh .v.RH , 15 ) ; 
  481.   q = getavail () ; 
  482.   mem [ q ] .hh .v.LH = 379 ; 
  483.   begintokenlist ( q , 4 ) ; 
  484.   oldmode = curlist .modefield ; 
  485.   curlist .modefield = 0 ; 
  486.   curcs = writeloc ; 
  487.   q = scantoks ( false , true ) ; 
  488.   gettoken () ; 
  489.   if ( curtok != 7617 ) 
  490.   {
  491.     {
  492.       if ( interaction == 3 ) 
  493.       wakeupterminal () ; 
  494.       printnl ( 262 ) ; 
  495.       print ( 1287 ) ; 
  496.     } 
  497.     {
  498.       helpptr = 2 ; 
  499.       helpline [ 1 ] = 1288 ; 
  500.       helpline [ 0 ] = 1005 ; 
  501.     } 
  502.     error () ; 
  503.     do {
  504.     gettoken () ; 
  505.     } while ( ! ( curtok == 7617 ) ) ; 
  506.   } 
  507.   curlist .modefield = oldmode ; 
  508.   endtokenlist () ; 
  509.   oldsetting = selector ; 
  510.   j = mem [ p + 1 ] .hh .v.LH ; 
  511.   if ( writeopen [ j ] ) 
  512.   selector = j ; 
  513.   else {
  514.       
  515.     if ( ( j == 17 ) && ( selector == 19 ) ) 
  516.     selector = 18 ; 
  517.     printnl ( 335 ) ; 
  518.   } 
  519.   tokenshow ( defref ) ; 
  520.   println () ; 
  521.   flushlist ( defref ) ; 
  522.   selector = oldsetting ; 
  523. } 
  524. void zoutwhat ( p ) 
  525. halfword p ; 
  526. {outwhat_regmem 
  527.   smallnumber j  ; 
  528.   switch ( mem [ p ] .hh.b1 ) 
  529.   {case 0 : 
  530.   case 1 : 
  531.   case 2 : 
  532.     if ( ! doingleaders ) 
  533.     {
  534.       j = mem [ p + 1 ] .hh .v.LH ; 
  535.       if ( mem [ p ] .hh.b1 == 1 ) 
  536.       writeout ( p ) ; 
  537.       else {
  538.       
  539.     if ( writeopen [ j ] ) 
  540.     aclose ( writefile [ j ] ) ; 
  541.     if ( mem [ p ] .hh.b1 == 2 ) 
  542.     writeopen [ j ] = false ; 
  543.     else if ( j < 16 ) 
  544.     {
  545.       curname = mem [ p + 1 ] .hh .v.RH ; 
  546.       curarea = mem [ p + 2 ] .hh .v.LH ; 
  547.       curext = mem [ p + 2 ] .hh .v.RH ; 
  548.       if ( curext == 335 ) 
  549.       curext = 784 ; 
  550.       packfilename ( curname , curarea , curext ) ; 
  551.       while ( ! aopenout ( writefile [ j ] ) ) promptfilename ( 1290 , 784 
  552.       ) ; 
  553.       writeopen [ j ] = true ; 
  554.     } 
  555.       } 
  556.     } 
  557.     break ; 
  558.   case 3 : 
  559.     specialout ( p ) ; 
  560.     break ; 
  561.   case 4 : 
  562.     ; 
  563.     break ; 
  564.     default: 
  565.     confusion ( 1289 ) ; 
  566.     break ; 
  567.   } 
  568. } 
  569. void hlistout ( ) 
  570. {/* 21 13 14 15 */ hlistout_regmem 
  571.   scaled baseline  ; 
  572.   scaled leftedge  ; 
  573.   scaled saveh, savev  ; 
  574.   halfword thisbox  ; 
  575.   glueord gorder  ; 
  576.   schar gsign  ; 
  577.   halfword p  ; 
  578.   integer saveloc  ; 
  579.   halfword leaderbox  ; 
  580.   scaled leaderwd  ; 
  581.   scaled lx  ; 
  582.   boolean outerdoingleaders  ; 
  583.   scaled edge  ; 
  584.   thisbox = tempptr ; 
  585.   gorder = mem [ thisbox + 5 ] .hh.b1 ; 
  586.   gsign = mem [ thisbox + 5 ] .hh.b0 ; 
  587.   p = mem [ thisbox + 5 ] .hh .v.RH ; 
  588.   incr ( curs ) ; 
  589.   if ( curs > 0 ) 
  590.   {
  591.     dvibuf [ dviptr ] = 141 ; 
  592.     incr ( dviptr ) ; 
  593.     if ( dviptr == dvilimit ) 
  594.     dviswap () ; 
  595.   } 
  596.   if ( curs > maxpush ) 
  597.   maxpush = curs ; 
  598.   saveloc = dvioffset + dviptr ; 
  599.   baseline = curv ; 
  600.   leftedge = curh ; 
  601.   while ( p != 0 ) lab21: if ( ( p >= himemmin ) ) 
  602.   {
  603.     if ( curh != dvih ) 
  604.     {
  605.       movement ( curh - dvih , 143 ) ; 
  606.       dvih = curh ; 
  607.     } 
  608.     if ( curv != dviv ) 
  609.     {
  610.       movement ( curv - dviv , 157 ) ; 
  611.       dviv = curv ; 
  612.     } 
  613.     do {
  614.     f = mem [ p ] .hh.b0 ; 
  615.       c = mem [ p ] .hh.b1 ; 
  616.       if ( f != dvif ) 
  617.       {
  618.     if ( ! fontused [ f ] ) 
  619.     {
  620.       dvifontdef ( f ) ; 
  621.       fontused [ f ] = true ; 
  622.     } 
  623.     if ( f <= 64 ) 
  624.     {
  625.       dvibuf [ dviptr ] = f + 170 ; 
  626.       incr ( dviptr ) ; 
  627.       if ( dviptr == dvilimit ) 
  628.       dviswap () ; 
  629.     } 
  630.     else {
  631.         
  632.       {
  633.         dvibuf [ dviptr ] = 235 ; 
  634.         incr ( dviptr ) ; 
  635.         if ( dviptr == dvilimit ) 
  636.         dviswap () ; 
  637.       } 
  638.       {
  639.         dvibuf [ dviptr ] = f - 1 ; 
  640.         incr ( dviptr ) ; 
  641.         if ( dviptr == dvilimit ) 
  642.         dviswap () ; 
  643.       } 
  644.     } 
  645.     dvif = f ; 
  646.       } 
  647.       if ( c >= 128 ) 
  648.       {
  649.     dvibuf [ dviptr ] = 128 ; 
  650.     incr ( dviptr ) ; 
  651.     if ( dviptr == dvilimit ) 
  652.     dviswap () ; 
  653.       } 
  654.       {
  655.     dvibuf [ dviptr ] = c ; 
  656.     incr ( dviptr ) ; 
  657.     if ( dviptr == dvilimit ) 
  658.     dviswap () ; 
  659.       } 
  660.       curh = curh + fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + c 
  661.       ] .qqqq .b0 ] .cint ; 
  662.       p = mem [ p ] .hh .v.RH ; 
  663.     } while ( ! ( ! ( p >= himemmin ) ) ) ; 
  664.     dvih = curh ; 
  665.   } 
  666.   else {
  667.       
  668.     switch ( mem [ p ] .hh.b0 ) 
  669.     {case 0 : 
  670.     case 1 : 
  671.       if ( mem [ p + 5 ] .hh .v.RH == 0 ) 
  672.       curh = curh + mem [ p + 1 ] .cint ; 
  673.       else {
  674.       
  675.     saveh = dvih ; 
  676.     savev = dviv ; 
  677.     curv = baseline + mem [ p + 4 ] .cint ; 
  678.     tempptr = p ; 
  679.     edge = curh ; 
  680.     if ( mem [ p ] .hh.b0 == 1 ) 
  681.     vlistout () ; 
  682.     else hlistout () ; 
  683.     dvih = saveh ; 
  684.     dviv = savev ; 
  685.     curh = edge + mem [ p + 1 ] .cint ; 
  686.     curv = baseline ; 
  687.       } 
  688.       break ; 
  689.     case 2 : 
  690.       {
  691.     ruleht = mem [ p + 3 ] .cint ; 
  692.     ruledp = mem [ p + 2 ] .cint ; 
  693.     rulewd = mem [ p + 1 ] .cint ; 
  694.     goto lab14 ; 
  695.       } 
  696.       break ; 
  697.     case 8 : 
  698.       outwhat ( p ) ; 
  699.       break ; 
  700.     case 10 : 
  701.       {
  702.     g = mem [ p + 1 ] .hh .v.LH ; 
  703.     rulewd = mem [ g + 1 ] .cint ; 
  704.     if ( gsign != 0 ) 
  705.     {
  706.       if ( gsign == 1 ) 
  707.       {
  708.         if ( mem [ g ] .hh.b0 == gorder ) 
  709.         rulewd = rulewd + round ( mem [ thisbox + 6 ] .gr * mem [ g + 2 ] 
  710.         .cint ) ; 
  711.       } 
  712.       else {
  713.           
  714.         if ( mem [ g ] .hh.b1 == gorder ) 
  715.         rulewd = rulewd - round ( mem [ thisbox + 6 ] .gr * mem [ g + 3 ] 
  716.         .cint ) ; 
  717.       } 
  718.     } 
  719.     if ( mem [ p ] .hh.b1 >= 100 ) 
  720.     {
  721.       leaderbox = mem [ p + 1 ] .hh .v.RH ; 
  722.       if ( mem [ leaderbox ] .hh.b0 == 2 ) 
  723.       {
  724.         ruleht = mem [ leaderbox + 3 ] .cint ; 
  725.         ruledp = mem [ leaderbox + 2 ] .cint ; 
  726.         goto lab14 ; 
  727.       } 
  728.       leaderwd = mem [ leaderbox + 1 ] .cint ; 
  729.       if ( ( leaderwd > 0 ) && ( rulewd > 0 ) ) 
  730.       {
  731.         rulewd = rulewd + 10 ; 
  732.         edge = curh + rulewd ; 
  733.         lx = 0 ; 
  734.         if ( mem [ p ] .hh.b1 == 100 ) 
  735.         {
  736.           saveh = curh ; 
  737.           curh = leftedge + leaderwd * ( ( curh - leftedge ) / leaderwd ) 
  738.           ; 
  739.           if ( curh < saveh ) 
  740.           curh = curh + leaderwd ; 
  741.         } 
  742.         else {
  743.         
  744.           lq = rulewd / leaderwd ; 
  745.           lr = rulewd % leaderwd ; 
  746.           if ( mem [ p ] .hh.b1 == 101 ) 
  747.           curh = curh + ( lr / 2 ) ; 
  748.           else {
  749.           
  750.         lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  751.         curh = curh + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ; 
  752.           } 
  753.         } 
  754.         while ( curh + leaderwd <= edge ) {
  755.         
  756.           curv = baseline + mem [ leaderbox + 4 ] .cint ; 
  757.           if ( curv != dviv ) 
  758.           {
  759.         movement ( curv - dviv , 157 ) ; 
  760.         dviv = curv ; 
  761.           } 
  762.           savev = dviv ; 
  763.           if ( curh != dvih ) 
  764.           {
  765.         movement ( curh - dvih , 143 ) ; 
  766.         dvih = curh ; 
  767.           } 
  768.           saveh = dvih ; 
  769.           tempptr = leaderbox ; 
  770.           outerdoingleaders = doingleaders ; 
  771.           doingleaders = true ; 
  772.           if ( mem [ leaderbox ] .hh.b0 == 1 ) 
  773.           vlistout () ; 
  774.           else hlistout () ; 
  775.           doingleaders = outerdoingleaders ; 
  776.           dviv = savev ; 
  777.           dvih = saveh ; 
  778.           curv = savev ; 
  779.           curh = saveh + leaderwd + lx ; 
  780.         } 
  781.         curh = edge - 10 ; 
  782.         goto lab15 ; 
  783.       } 
  784.     } 
  785.     goto lab13 ; 
  786.       } 
  787.       break ; 
  788.     case 11 : 
  789.     case 9 : 
  790.       curh = curh + mem [ p + 1 ] .cint ; 
  791.       break ; 
  792.     case 6 : 
  793.       {
  794.     mem [ memtop - 12 ] = mem [ p + 1 ] ; 
  795.     mem [ memtop - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  796.     p = memtop - 12 ; 
  797.     goto lab21 ; 
  798.       } 
  799.       break ; 
  800.       default: 
  801.       ; 
  802.       break ; 
  803.     } 
  804.     goto lab15 ; 
  805.     lab14: if ( ( ruleht == -1073741824L ) ) 
  806.     ruleht = mem [ thisbox + 3 ] .cint ; 
  807.     if ( ( ruledp == -1073741824L ) ) 
  808.     ruledp = mem [ thisbox + 2 ] .cint ; 
  809.     ruleht = ruleht + ruledp ; 
  810.     if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) 
  811.     {
  812.       if ( curh != dvih ) 
  813.       {
  814.     movement ( curh - dvih , 143 ) ; 
  815.     dvih = curh ; 
  816.       } 
  817.       curv = baseline + ruledp ; 
  818.       if ( curv != dviv ) 
  819.       {
  820.     movement ( curv - dviv , 157 ) ; 
  821.     dviv = curv ; 
  822.       } 
  823.       {
  824.     dvibuf [ dviptr ] = 132 ; 
  825.     incr ( dviptr ) ; 
  826.     if ( dviptr == dvilimit ) 
  827.     dviswap () ; 
  828.       } 
  829.       dvifour ( ruleht ) ; 
  830.       dvifour ( rulewd ) ; 
  831.       curv = baseline ; 
  832.       dvih = dvih + rulewd ; 
  833.     } 
  834.     lab13: curh = curh + rulewd ; 
  835.     lab15: p = mem [ p ] .hh .v.RH ; 
  836.   } 
  837.   prunemovements ( saveloc ) ; 
  838.   if ( curs > 0 ) 
  839.   dvipop ( saveloc ) ; 
  840.   decr ( curs ) ; 
  841. } 
  842. void vlistout ( ) 
  843. {/* 13 14 15 */ vlistout_regmem 
  844.   scaled leftedge  ; 
  845.   scaled topedge  ; 
  846.   scaled saveh, savev  ; 
  847.   halfword thisbox  ; 
  848.   glueord gorder  ; 
  849.   schar gsign  ; 
  850.   halfword p  ; 
  851.   integer saveloc  ; 
  852.   halfword leaderbox  ; 
  853.   scaled leaderht  ; 
  854.   scaled lx  ; 
  855.   boolean outerdoingleaders  ; 
  856.   scaled edge  ; 
  857.   thisbox = tempptr ; 
  858.   gorder = mem [ thisbox + 5 ] .hh.b1 ; 
  859.   gsign = mem [ thisbox + 5 ] .hh.b0 ; 
  860.   p = mem [ thisbox + 5 ] .hh .v.RH ; 
  861.   incr ( curs ) ; 
  862.   if ( curs > 0 ) 
  863.   {
  864.     dvibuf [ dviptr ] = 141 ; 
  865.     incr ( dviptr ) ; 
  866.     if ( dviptr == dvilimit ) 
  867.     dviswap () ; 
  868.   } 
  869.   if ( curs > maxpush ) 
  870.   maxpush = curs ; 
  871.   saveloc = dvioffset + dviptr ; 
  872.   leftedge = curh ; 
  873.   curv = curv - mem [ thisbox + 3 ] .cint ; 
  874.   topedge = curv ; 
  875.   while ( p != 0 ) {
  876.       
  877.     if ( ( p >= himemmin ) ) 
  878.     confusion ( 821 ) ; 
  879.     else {
  880.     
  881.       switch ( mem [ p ] .hh.b0 ) 
  882.       {case 0 : 
  883.       case 1 : 
  884.     if ( mem [ p + 5 ] .hh .v.RH == 0 ) 
  885.     curv = curv + mem [ p + 3 ] .cint + mem [ p + 2 ] .cint ; 
  886.     else {
  887.         
  888.       curv = curv + mem [ p + 3 ] .cint ; 
  889.       if ( curv != dviv ) 
  890.       {
  891.         movement ( curv - dviv , 157 ) ; 
  892.         dviv = curv ; 
  893.       } 
  894.       saveh = dvih ; 
  895.       savev = dviv ; 
  896.       curh = leftedge + mem [ p + 4 ] .cint ; 
  897.       tempptr = p ; 
  898.       if ( mem [ p ] .hh.b0 == 1 ) 
  899.       vlistout () ; 
  900.       else hlistout () ; 
  901.       dvih = saveh ; 
  902.       dviv = savev ; 
  903.       curv = savev + mem [ p + 2 ] .cint ; 
  904.       curh = leftedge ; 
  905.     } 
  906.     break ; 
  907.       case 2 : 
  908.     {
  909.       ruleht = mem [ p + 3 ] .cint ; 
  910.       ruledp = mem [ p + 2 ] .cint ; 
  911.       rulewd = mem [ p + 1 ] .cint ; 
  912.       goto lab14 ; 
  913.     } 
  914.     break ; 
  915.       case 8 : 
  916.     outwhat ( p ) ; 
  917.     break ; 
  918.       case 10 : 
  919.     {
  920.       g = mem [ p + 1 ] .hh .v.LH ; 
  921.       ruleht = mem [ g + 1 ] .cint ; 
  922.       if ( gsign != 0 ) 
  923.       {
  924.         if ( gsign == 1 ) 
  925.         {
  926.           if ( mem [ g ] .hh.b0 == gorder ) 
  927.           ruleht = ruleht + round ( mem [ thisbox + 6 ] .gr * mem [ g + 2 
  928.           ] .cint ) ; 
  929.         } 
  930.         else {
  931.         
  932.           if ( mem [ g ] .hh.b1 == gorder ) 
  933.           ruleht = ruleht - round ( mem [ thisbox + 6 ] .gr * mem [ g + 3 
  934.           ] .cint ) ; 
  935.         } 
  936.       } 
  937.       if ( mem [ p ] .hh.b1 >= 100 ) 
  938.       {
  939.         leaderbox = mem [ p + 1 ] .hh .v.RH ; 
  940.         if ( mem [ leaderbox ] .hh.b0 == 2 ) 
  941.         {
  942.           rulewd = mem [ leaderbox + 1 ] .cint ; 
  943.           ruledp = 0 ; 
  944.           goto lab14 ; 
  945.         } 
  946.         leaderht = mem [ leaderbox + 3 ] .cint + mem [ leaderbox + 2 ] 
  947.         .cint ; 
  948.         if ( ( leaderht > 0 ) && ( ruleht > 0 ) ) 
  949.         {
  950.           ruleht = ruleht + 10 ; 
  951.           edge = curv + ruleht ; 
  952.           lx = 0 ; 
  953.           if ( mem [ p ] .hh.b1 == 100 ) 
  954.           {
  955.         savev = curv ; 
  956.         curv = topedge + leaderht * ( ( curv - topedge ) / leaderht ) 
  957.         ; 
  958.         if ( curv < savev ) 
  959.         curv = curv + leaderht ; 
  960.           } 
  961.           else {
  962.           
  963.         lq = ruleht / leaderht ; 
  964.         lr = ruleht % leaderht ; 
  965.         if ( mem [ p ] .hh.b1 == 101 ) 
  966.         curv = curv + ( lr / 2 ) ; 
  967.         else {
  968.             
  969.           lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  970.           curv = curv + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ; 
  971.         } 
  972.           } 
  973.           while ( curv + leaderht <= edge ) {
  974.           
  975.         curh = leftedge + mem [ leaderbox + 4 ] .cint ; 
  976.         if ( curh != dvih ) 
  977.         {
  978.           movement ( curh - dvih , 143 ) ; 
  979.           dvih = curh ; 
  980.         } 
  981.         saveh = dvih ; 
  982.         curv = curv + mem [ leaderbox + 3 ] .cint ; 
  983.         if ( curv != dviv ) 
  984.         {
  985.           movement ( curv - dviv , 157 ) ; 
  986.           dviv = curv ; 
  987.         } 
  988.         savev = dviv ; 
  989.         tempptr = leaderbox ; 
  990.         outerdoingleaders = doingleaders ; 
  991.         doingleaders = true ; 
  992.         if ( mem [ leaderbox ] .hh.b0 == 1 ) 
  993.         vlistout () ; 
  994.         else hlistout () ; 
  995.         doingleaders = outerdoingleaders ; 
  996.         dviv = savev ; 
  997.         dvih = saveh ; 
  998.         curh = saveh ; 
  999.         curv = savev - mem [ leaderbox + 3 ] .cint + leaderht + lx ; 
  1000.           } 
  1001.           curv = edge - 10 ; 
  1002.           goto lab15 ; 
  1003.         } 
  1004.       } 
  1005.       goto lab13 ; 
  1006.     } 
  1007.     break ; 
  1008.       case 11 : 
  1009.     curv = curv + mem [ p + 1 ] .cint ; 
  1010.     break ; 
  1011.     default: 
  1012.     ; 
  1013.     break ; 
  1014.       } 
  1015.       goto lab15 ; 
  1016.       lab14: if ( ( rulewd == -1073741824L ) ) 
  1017.       rulewd = mem [ thisbox + 1 ] .cint ; 
  1018.       ruleht = ruleht + ruledp ; 
  1019.       curv = curv + ruleht ; 
  1020.       if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) 
  1021.       {
  1022.     if ( curh != dvih ) 
  1023.     {
  1024.       movement ( curh - dvih , 143 ) ; 
  1025.       dvih = curh ; 
  1026.     } 
  1027.     if ( curv != dviv ) 
  1028.     {
  1029.       movement ( curv - dviv , 157 ) ; 
  1030.       dviv = curv ; 
  1031.     } 
  1032.     {
  1033.       dvibuf [ dviptr ] = 137 ; 
  1034.       incr ( dviptr ) ; 
  1035.       if ( dviptr == dvilimit ) 
  1036.       dviswap () ; 
  1037.     } 
  1038.     dvifour ( ruleht ) ; 
  1039.     dvifour ( rulewd ) ; 
  1040.       } 
  1041.       goto lab15 ; 
  1042.       lab13: curv = curv + ruleht ; 
  1043.     } 
  1044.     lab15: p = mem [ p ] .hh .v.RH ; 
  1045.   } 
  1046.   prunemovements ( saveloc ) ; 
  1047.   if ( curs > 0 ) 
  1048.   dvipop ( saveloc ) ; 
  1049.   decr ( curs ) ; 
  1050. } 
  1051.