home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / texsrc.arc / TEX4.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  54KB  |  2,176 lines
  1. overlay "tex4"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5. startinput () { /* 30 */ r_startinput 
  6.   scanfilename () ; 
  7.   if ( curext == 206 ) 
  8.   curext = 644 ; 
  9.   packfilename ( curname , curarea , curext ) ; 
  10.   while ( true ) { 
  11.     beginfilerea () ; 
  12.     if ( aopenin ( inputfile [ curinput .indexfield ] , inputpathspec ) ) 
  13.     goto lab30 ; 
  14.     endfilereadi () ; 
  15.     promptfilena ( 640 , 644 ) ; 
  16.   } 
  17.   lab30: curinput .namefield = amakenamestr ( inputfile [ curinput .indexfield 
  18.   ] ) ; 
  19.   if ( jobname == 0 ) 
  20.   {
  21.     jobname = curname ; 
  22.     openlogfile () ; 
  23.   } 
  24.   if ( termoffset + ( strstart [ curinput .namefield + 1 ] - strstart [ 
  25.   curinput .namefield ] ) > maxprintline - 2 ) 
  26.   println () ; 
  27.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  28.   printchar ( 32 ) ; 
  29.   printchar ( 40 ) ; 
  30.   print ( curinput .namefield ) ; 
  31.   termflush ( output ) ; 
  32.   curinput .statefield = 33 ; 
  33.   {
  34.     if ( ! inputln ( inputfile [ curinput .indexfield ] , false ) ) 
  35.     ; 
  36.     firmupthelin () ; 
  37.     if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  38.     decr ( curinput .limitfield ) ; 
  39.     else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  40.     first = curinput .limitfield + 1 ; 
  41.     curinput .locfield = curinput .startfield ; 
  42.     line = 1 ; 
  43.   } 
  44. } 
  45. internalfont zreadfontinfo ( u , nom , aire , s ) 
  46. halfword u ; 
  47. strnumber nom , aire ; 
  48. scaled s ; 
  49. {/* 30 11 45 */ register internalfont Result; 
  50.   r_readfontinfo 
  51.   integer k ; 
  52.   boolean fileopened ; 
  53.   halfword lf, lh, bc, ec, nw, nh, nd, ni, nl, nk, ne, np ; 
  54.   internalfont f ; 
  55.   internalfont g ; 
  56.   eightbits a, b, c, d ; 
  57.   fourquarters qw ; 
  58.   scaled sw ; 
  59.   scaled z ; 
  60.   integer alpha ; 
  61.   quarterword beta ; 
  62.   g = 0 ; 
  63.   fileopened = false ; 
  64.   packfilename ( nom , aire , 664 ) ; 
  65.   if ( ! bopenin ( tfmfile ) ) 
  66.   goto lab11 ; 
  67.   fileopened = true ; 
  68.   {
  69.     {
  70.       lf = tfmtemp ; 
  71.       if ( lf > 127 ) 
  72.       goto lab11 ; 
  73.       tfmtemp = getc ( tfmfile ) ; 
  74.       lf = lf * 256 + tfmtemp ; 
  75.     } 
  76.     tfmtemp = getc ( tfmfile ) ; 
  77.     {
  78.       lh = tfmtemp ; 
  79.       if ( lh > 127 ) 
  80.       goto lab11 ; 
  81.       tfmtemp = getc ( tfmfile ) ; 
  82.       lh = lh * 256 + tfmtemp ; 
  83.     } 
  84.     tfmtemp = getc ( tfmfile ) ; 
  85.     {
  86.       bc = tfmtemp ; 
  87.       if ( bc > 127 ) 
  88.       goto lab11 ; 
  89.       tfmtemp = getc ( tfmfile ) ; 
  90.       bc = bc * 256 + tfmtemp ; 
  91.     } 
  92.     tfmtemp = getc ( tfmfile ) ; 
  93.     {
  94.       ec = tfmtemp ; 
  95.       if ( ec > 127 ) 
  96.       goto lab11 ; 
  97.       tfmtemp = getc ( tfmfile ) ; 
  98.       ec = ec * 256 + tfmtemp ; 
  99.     } 
  100.     if ( ( bc > ec + 1 ) || ( ec > 255 ) ) 
  101.     goto lab11 ; 
  102.     tfmtemp = getc ( tfmfile ) ; 
  103.     {
  104.       nw = tfmtemp ; 
  105.       if ( nw > 127 ) 
  106.       goto lab11 ; 
  107.       tfmtemp = getc ( tfmfile ) ; 
  108.       nw = nw * 256 + tfmtemp ; 
  109.     } 
  110.     tfmtemp = getc ( tfmfile ) ; 
  111.     {
  112.       nh = tfmtemp ; 
  113.       if ( nh > 127 ) 
  114.       goto lab11 ; 
  115.       tfmtemp = getc ( tfmfile ) ; 
  116.       nh = nh * 256 + tfmtemp ; 
  117.     } 
  118.     tfmtemp = getc ( tfmfile ) ; 
  119.     {
  120.       nd = tfmtemp ; 
  121.       if ( nd > 127 ) 
  122.       goto lab11 ; 
  123.       tfmtemp = getc ( tfmfile ) ; 
  124.       nd = nd * 256 + tfmtemp ; 
  125.     } 
  126.     tfmtemp = getc ( tfmfile ) ; 
  127.     {
  128.       ni = tfmtemp ; 
  129.       if ( ni > 127 ) 
  130.       goto lab11 ; 
  131.       tfmtemp = getc ( tfmfile ) ; 
  132.       ni = ni * 256 + tfmtemp ; 
  133.     } 
  134.     tfmtemp = getc ( tfmfile ) ; 
  135.     {
  136.       nl = tfmtemp ; 
  137.       if ( nl > 127 ) 
  138.       goto lab11 ; 
  139.       tfmtemp = getc ( tfmfile ) ; 
  140.       nl = nl * 256 + tfmtemp ; 
  141.     } 
  142.     tfmtemp = getc ( tfmfile ) ; 
  143.     {
  144.       nk = tfmtemp ; 
  145.       if ( nk > 127 ) 
  146.       goto lab11 ; 
  147.       tfmtemp = getc ( tfmfile ) ; 
  148.       nk = nk * 256 + tfmtemp ; 
  149.     } 
  150.     tfmtemp = getc ( tfmfile ) ; 
  151.     {
  152.       ne = tfmtemp ; 
  153.       if ( ne > 127 ) 
  154.       goto lab11 ; 
  155.       tfmtemp = getc ( tfmfile ) ; 
  156.       ne = ne * 256 + tfmtemp ; 
  157.     } 
  158.     tfmtemp = getc ( tfmfile ) ; 
  159.     {
  160.       np = tfmtemp ; 
  161.       if ( np > 127 ) 
  162.       goto lab11 ; 
  163.       tfmtemp = getc ( tfmfile ) ; 
  164.       np = np * 256 + tfmtemp ; 
  165.     } 
  166.     if ( lf != 6 + lh + ( ec - bc + 1 ) + nw + nh + nd + ni + nl + nk + ne + 
  167.     np ) 
  168.     goto lab11 ; 
  169.   } 
  170.   lf = lf - 6 - lh ; 
  171.   if ( np < 7 ) 
  172.   lf = lf + 7 - np ; 
  173.   if ( ( fontptr == fontmax ) || ( fmemptr + lf > fontmemsize ) ) 
  174.   {
  175.     {
  176.       if ( interaction == 3 ) 
  177.       wakeuptermin () ; 
  178.       printnl ( 133 ) ; 
  179.       print ( 655 ) ; 
  180.     } 
  181.     sprintcs ( u ) ; 
  182.     printchar ( 61 ) ; 
  183.     printfilenam ( nom , aire , 206 ) ; 
  184.     if ( s >= 0 ) 
  185.     {
  186.       print ( 598 ) ; 
  187.       printscaled ( s ) ; 
  188.       print ( 262 ) ; 
  189.     } 
  190.     else if ( s != - 1000 ) 
  191.     {
  192.       print ( 656 ) ; 
  193.       printint ( - s ) ; 
  194.     } 
  195.     print ( 665 ) ; 
  196.     {
  197.       helpptr = 4 ; 
  198.       helpline [ 3 ] = 666 ; 
  199.       helpline [ 2 ] = 667 ; 
  200.       helpline [ 1 ] = 668 ; 
  201.       helpline [ 0 ] = 669 ; 
  202.     } 
  203.     error () ; 
  204.     goto lab30 ; 
  205.   } 
  206.   f = fontptr + 1 ; 
  207.   charbase [ f ] = fmemptr - bc ; 
  208.   widthbase [ f ] = charbase [ f ] + ec + 1 ; 
  209.   heightbase [ f ] = widthbase [ f ] + nw ; 
  210.   depthbase [ f ] = heightbase [ f ] + nh ; 
  211.   italicbase [ f ] = depthbase [ f ] + nd ; 
  212.   ligkernbase [ f ] = italicbase [ f ] + ni ; 
  213.   kernbase [ f ] = ligkernbase [ f ] + nl ; 
  214.   extenbase [ f ] = kernbase [ f ] + nk ; 
  215.   parambase [ f ] = extenbase [ f ] + ne ; 
  216.   {
  217.     if ( lh < 2 ) 
  218.     goto lab11 ; 
  219.     {
  220.       tfmtemp = getc ( tfmfile ) ; 
  221.       a = tfmtemp ; 
  222.       qw .b0 = a ; 
  223.       tfmtemp = getc ( tfmfile ) ; 
  224.       b = tfmtemp ; 
  225.       qw .b1 = b ; 
  226.       tfmtemp = getc ( tfmfile ) ; 
  227.       c = tfmtemp ; 
  228.       qw .b2 = c ; 
  229.       tfmtemp = getc ( tfmfile ) ; 
  230.       d = tfmtemp ; 
  231.       qw .b3 = d ; 
  232.       fontcheck [ f ] = qw ; 
  233.     } 
  234.     tfmtemp = getc ( tfmfile ) ; 
  235.     {
  236.       z = tfmtemp ; 
  237.       if ( z > 127 ) 
  238.       goto lab11 ; 
  239.       tfmtemp = getc ( tfmfile ) ; 
  240.       z = z * 256 + tfmtemp ; 
  241.     } 
  242.     tfmtemp = getc ( tfmfile ) ; 
  243.     z = z * 256 + tfmtemp ; 
  244.     tfmtemp = getc ( tfmfile ) ; 
  245.     z = ( z * 16 ) + ( tfmtemp / 16 ) ; 
  246.     if ( z < 65536 ) 
  247.     goto lab11 ; 
  248.     while ( lh > 2 ) { 
  249.       tfmtemp = getc ( tfmfile ) ; 
  250.       tfmtemp = getc ( tfmfile ) ; 
  251.       tfmtemp = getc ( tfmfile ) ; 
  252.       tfmtemp = getc ( tfmfile ) ; 
  253.       decr ( lh ) ; 
  254.     } 
  255.     fontdsize [ f ] = z ; 
  256.     if ( s != - 1000 ) 
  257.     if ( s >= 0 ) 
  258.     z = s ; 
  259.     else z = xnoverd ( z , - s , 1000 ) ; 
  260.     fontsize [ f ] = z ; 
  261.   } 
  262.   for ( k = fmemptr ; k <= widthbase [ f ] - 1 ; k ++ ) 
  263.   {
  264.     {
  265.       tfmtemp = getc ( tfmfile ) ; 
  266.       a = tfmtemp ; 
  267.       qw .b0 = a ; 
  268.       tfmtemp = getc ( tfmfile ) ; 
  269.       b = tfmtemp ; 
  270.       qw .b1 = b ; 
  271.       tfmtemp = getc ( tfmfile ) ; 
  272.       c = tfmtemp ; 
  273.       qw .b2 = c ; 
  274.       tfmtemp = getc ( tfmfile ) ; 
  275.       d = tfmtemp ; 
  276.       qw .b3 = d ; 
  277.       fontinfo [ k ] .qqqq = qw ; 
  278.     } 
  279.     if ( ( a >= nw ) || ( b / 16 >= nh ) || ( b % 16 >= nd ) || ( c / 4 >= ni 
  280.     ) ) 
  281.     goto lab11 ; 
  282.     switch ( c % 4 ) 
  283.     {case 1 : 
  284.       if ( d >= nl ) 
  285.       goto lab11 ; 
  286.       break ; 
  287.     case 3 : 
  288.       if ( d >= ne ) 
  289.       goto lab11 ; 
  290.       break ; 
  291.     case 2 : 
  292.       {
  293.     {
  294.       if ( ( d < bc ) || ( d > ec ) ) 
  295.       goto lab11 ; 
  296.     } 
  297.     while ( d < k + bc - fmemptr ) { 
  298.       qw = fontinfo [ charbase [ f ] + d ] .qqqq ; 
  299.       if ( ( ( qw .b2 ) % 4 ) != 2 ) 
  300.       goto lab45 ; 
  301.       d = qw .b3 ; 
  302.     } 
  303.     if ( d == k + bc - fmemptr ) 
  304.     goto lab11 ; 
  305.     lab45: ; 
  306.       } 
  307.       break ; 
  308.     default : 
  309.       ; 
  310.       break ; 
  311.     } 
  312.   } 
  313.   {
  314.     {
  315.       alpha = 16 ; 
  316.       while ( z >= 8388608 ) { 
  317.     z = z / 2 ; 
  318.     alpha = alpha + alpha ; 
  319.       } 
  320.       beta = 256 / alpha ; 
  321.       alpha = alpha * z ; 
  322.     } 
  323.     for ( k = widthbase [ f ] ; k <= ligkernbase [ f ] - 1 ; k ++ ) 
  324.     {
  325.       tfmtemp = getc ( tfmfile ) ; 
  326.       a = tfmtemp ; 
  327.       tfmtemp = getc ( tfmfile ) ; 
  328.       b = tfmtemp ; 
  329.       tfmtemp = getc ( tfmfile ) ; 
  330.       c = tfmtemp ; 
  331.       tfmtemp = getc ( tfmfile ) ; 
  332.       d = tfmtemp ; 
  333.       sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  334.       beta ; 
  335.       if ( a == 0 ) 
  336.       fontinfo [ k ] .cint = sw ; 
  337.       else if ( a == 255 ) 
  338.       fontinfo [ k ] .cint = sw - alpha ; 
  339.       else goto lab11 ; 
  340.     } 
  341.     if ( fontinfo [ widthbase [ f ] ] .cint != 0 ) 
  342.     goto lab11 ; 
  343.     if ( fontinfo [ heightbase [ f ] ] .cint != 0 ) 
  344.     goto lab11 ; 
  345.     if ( fontinfo [ depthbase [ f ] ] .cint != 0 ) 
  346.     goto lab11 ; 
  347.     if ( fontinfo [ italicbase [ f ] ] .cint != 0 ) 
  348.     goto lab11 ; 
  349.   } 
  350.   {
  351.     for ( k = ligkernbase [ f ] ; k <= kernbase [ f ] - 1 ; k ++ ) 
  352.     {
  353.       {
  354.     tfmtemp = getc ( tfmfile ) ; 
  355.     a = tfmtemp ; 
  356.     qw .b0 = a ; 
  357.     tfmtemp = getc ( tfmfile ) ; 
  358.     b = tfmtemp ; 
  359.     qw .b1 = b ; 
  360.     tfmtemp = getc ( tfmfile ) ; 
  361.     c = tfmtemp ; 
  362.     qw .b2 = c ; 
  363.     tfmtemp = getc ( tfmfile ) ; 
  364.     d = tfmtemp ; 
  365.     qw .b3 = d ; 
  366.     fontinfo [ k ] .qqqq = qw ; 
  367.       } 
  368.       {
  369.     if ( ( b < bc ) || ( b > ec ) ) 
  370.     goto lab11 ; 
  371.       } 
  372.       if ( c < 128 ) 
  373.       {
  374.     if ( ( d < bc ) || ( d > ec ) ) 
  375.     goto lab11 ; 
  376.       } 
  377.       else if ( d >= nk ) 
  378.       goto lab11 ; 
  379.     } 
  380.     if ( ( nl > 0 ) && ( a < 128 ) ) 
  381.     goto lab11 ; 
  382.     for ( k = kernbase [ f ] ; k <= extenbase [ f ] - 1 ; k ++ ) 
  383.     {
  384.       tfmtemp = getc ( tfmfile ) ; 
  385.       a = tfmtemp ; 
  386.       tfmtemp = getc ( tfmfile ) ; 
  387.       b = tfmtemp ; 
  388.       tfmtemp = getc ( tfmfile ) ; 
  389.       c = tfmtemp ; 
  390.       tfmtemp = getc ( tfmfile ) ; 
  391.       d = tfmtemp ; 
  392.       sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  393.       beta ; 
  394.       if ( a == 0 ) 
  395.       fontinfo [ k ] .cint = sw ; 
  396.       else if ( a == 255 ) 
  397.       fontinfo [ k ] .cint = sw - alpha ; 
  398.       else goto lab11 ; 
  399.     } 
  400.   } 
  401.   for ( k = extenbase [ f ] ; k <= parambase [ f ] - 1 ; k ++ ) 
  402.   {
  403.     {
  404.       tfmtemp = getc ( tfmfile ) ; 
  405.       a = tfmtemp ; 
  406.       qw .b0 = a ; 
  407.       tfmtemp = getc ( tfmfile ) ; 
  408.       b = tfmtemp ; 
  409.       qw .b1 = b ; 
  410.       tfmtemp = getc ( tfmfile ) ; 
  411.       c = tfmtemp ; 
  412.       qw .b2 = c ; 
  413.       tfmtemp = getc ( tfmfile ) ; 
  414.       d = tfmtemp ; 
  415.       qw .b3 = d ; 
  416.       fontinfo [ k ] .qqqq = qw ; 
  417.     } 
  418.     if ( a != 0 ) 
  419.     {
  420.       if ( ( a < bc ) || ( a > ec ) ) 
  421.       goto lab11 ; 
  422.     } 
  423.     if ( b != 0 ) 
  424.     {
  425.       if ( ( b < bc ) || ( b > ec ) ) 
  426.       goto lab11 ; 
  427.     } 
  428.     if ( c != 0 ) 
  429.     {
  430.       if ( ( c < bc ) || ( c > ec ) ) 
  431.       goto lab11 ; 
  432.     } 
  433.     {
  434.       if ( ( d < bc ) || ( d > ec ) ) 
  435.       goto lab11 ; 
  436.     } 
  437.   } 
  438.   {
  439.     for ( k = 1 ; k <= np ; k ++ ) 
  440.     if ( k == 1 ) 
  441.     {
  442.       tfmtemp = getc ( tfmfile ) ; 
  443.       sw = tfmtemp ; 
  444.       if ( sw > 127 ) 
  445.       sw = sw - 256 ; 
  446.       tfmtemp = getc ( tfmfile ) ; 
  447.       sw = sw * 256 + tfmtemp ; 
  448.       tfmtemp = getc ( tfmfile ) ; 
  449.       sw = sw * 256 + tfmtemp ; 
  450.       tfmtemp = getc ( tfmfile ) ; 
  451.       fontinfo [ parambase [ f ] ] .cint = ( sw * 16 ) + ( tfmtemp / 16 ) ; 
  452.     } 
  453.     else { 
  454.       tfmtemp = getc ( tfmfile ) ; 
  455.       a = tfmtemp ; 
  456.       tfmtemp = getc ( tfmfile ) ; 
  457.       b = tfmtemp ; 
  458.       tfmtemp = getc ( tfmfile ) ; 
  459.       c = tfmtemp ; 
  460.       tfmtemp = getc ( tfmfile ) ; 
  461.       d = tfmtemp ; 
  462.       sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  463.       beta ; 
  464.       if ( a == 0 ) 
  465.       fontinfo [ parambase [ f ] + k - 1 ] .cint = sw ; 
  466.       else if ( a == 255 ) 
  467.       fontinfo [ parambase [ f ] + k - 1 ] .cint = sw - alpha ; 
  468.       else goto lab11 ; 
  469.     } 
  470.     if ( eof ( tfmfile ) ) 
  471.     goto lab11 ; 
  472.     for ( k = np + 1 ; k <= 7 ; k ++ ) 
  473.     fontinfo [ parambase [ f ] + k - 1 ] .cint = 0 ; 
  474.   } 
  475.   if ( np >= 7 ) 
  476.   fontparams [ f ] = np ; 
  477.   else fontparams [ f ] = 7 ; 
  478.   hyphenchar [ f ] = eqtb [ 5313 ] .cint ; 
  479.   skewchar [ f ] = eqtb [ 5314 ] .cint ; 
  480.   fontname [ f ] = nom ; 
  481.   fontarea [ f ] = aire ; 
  482.   fontbc [ f ] = bc ; 
  483.   fontec [ f ] = ec ; 
  484.   fontglue [ f ] = 0 ; 
  485.   charbase [ f ] = charbase [ f ] ; 
  486.   widthbase [ f ] = widthbase [ f ] ; 
  487.   ligkernbase [ f ] = ligkernbase [ f ] ; 
  488.   kernbase [ f ] = kernbase [ f ] ; 
  489.   extenbase [ f ] = extenbase [ f ] ; 
  490.   decr ( parambase [ f ] ) ; 
  491.   fmemptr = fmemptr + lf ; 
  492.   fontptr = f ; 
  493.   g = f ; 
  494.   goto lab30 ; 
  495.   lab11: { 
  496.     if ( interaction == 3 ) 
  497.     wakeuptermin () ; 
  498.     printnl ( 133 ) ; 
  499.     print ( 655 ) ; 
  500.   } 
  501.   sprintcs ( u ) ; 
  502.   printchar ( 61 ) ; 
  503.   printfilenam ( nom , aire , 206 ) ; 
  504.   if ( s >= 0 ) 
  505.   {
  506.     print ( 598 ) ; 
  507.     printscaled ( s ) ; 
  508.     print ( 262 ) ; 
  509.   } 
  510.   else if ( s != - 1000 ) 
  511.   {
  512.     print ( 656 ) ; 
  513.     printint ( - s ) ; 
  514.   } 
  515.   if ( fileopened ) 
  516.   print ( 657 ) ; 
  517.   else print ( 658 ) ; 
  518.   {
  519.     helpptr = 5 ; 
  520.     helpline [ 4 ] = 659 ; 
  521.     helpline [ 3 ] = 660 ; 
  522.     helpline [ 2 ] = 661 ; 
  523.     helpline [ 1 ] = 662 ; 
  524.     helpline [ 0 ] = 663 ; 
  525.   } 
  526.   error () ; 
  527.   lab30: if ( fileopened ) 
  528.   bclose ( tfmfile ) ; 
  529.   Result = g ; 
  530.   return(Result) ; 
  531. } 
  532. zcharwarning ( f , c ) 
  533. internalfont f ; 
  534. eightbits c ; 
  535. {r_charwarning 
  536.   if ( eqtb [ 5302 ] .cint > 0 ) 
  537.   {
  538.     begindiagnos () ; 
  539.     printnl ( 678 ) ; 
  540.     printASCII ( c ) ; 
  541.     print ( 679 ) ; 
  542.     print ( fontname [ f ] ) ; 
  543.     printchar ( 33 ) ; 
  544.     enddiagnosti ( false ) ; 
  545.   } 
  546. } 
  547. halfword znewcharacter ( f , c ) 
  548. internalfont f ; 
  549. eightbits c ; 
  550. {/* 10 */ register halfword Result; r_newcharacter 
  551.   halfword p ; 
  552.   if ( fontbc [ f ] <= c ) 
  553.   if ( fontec [ f ] >= c ) 
  554.   if ( ( fontinfo [ charbase [ f ] + c ] .qqqq .b0 > 0 ) ) 
  555.   {
  556.     p = getavail () ; 
  557.     mem [(long) p ] .hh.b0 = f ; 
  558.     mem [(long) p ] .hh.b1 = c ; 
  559.     Result = p ; 
  560.     return(Result) ; 
  561.   } 
  562.   charwarning ( f , c ) ; 
  563.   Result = 0 ; 
  564.   return(Result) ; 
  565. } 
  566. dviswap () { r_dviswap 
  567.   if ( dvilimit == dvibufsize ) 
  568.   {
  569.     writedvi ( 0 , halfbuf - 1 ) ; 
  570.     dvilimit = halfbuf ; 
  571.     dvioffset = dvioffset + dvibufsize ; 
  572.     dviptr = 0 ; 
  573.   } 
  574.   else { 
  575.     writedvi ( halfbuf , dvibufsize - 1 ) ; 
  576.     dvilimit = dvibufsize ; 
  577.   } 
  578.   dvigone = dvigone + halfbuf ; 
  579. } 
  580. zdvifour ( x ) 
  581. integer x ; 
  582. {r_dvifour 
  583.   if ( x >= 0 ) 
  584.   {
  585.     dvibuf [ dviptr ] = x / 16777216 ; 
  586.     incr ( dviptr ) ; 
  587.     if ( dviptr == dvilimit ) 
  588.     dviswap () ; 
  589.   } 
  590.   else { 
  591.     x = x + 1073741824 ; 
  592.     x = x + 1073741824 ; 
  593.     {
  594.       dvibuf [ dviptr ] = ( x / 16777216 ) + 128 ; 
  595.       incr ( dviptr ) ; 
  596.       if ( dviptr == dvilimit ) 
  597.       dviswap () ; 
  598.     } 
  599.   } 
  600.   x = x % 16777216 ; 
  601.   {
  602.     dvibuf [ dviptr ] = x / 65536 ; 
  603.     incr ( dviptr ) ; 
  604.     if ( dviptr == dvilimit ) 
  605.     dviswap () ; 
  606.   } 
  607.   x = x % 65536 ; 
  608.   {
  609.     dvibuf [ dviptr ] = x / 256 ; 
  610.     incr ( dviptr ) ; 
  611.     if ( dviptr == dvilimit ) 
  612.     dviswap () ; 
  613.   } 
  614.   {
  615.     dvibuf [ dviptr ] = x % 256 ; 
  616.     incr ( dviptr ) ; 
  617.     if ( dviptr == dvilimit ) 
  618.     dviswap () ; 
  619.   } 
  620. } 
  621. zdvipop ( l ) 
  622. integer l ; 
  623. {r_dvipop 
  624.   if ( ( l == dvioffset + dviptr ) && ( dviptr > 0 ) ) 
  625.   decr ( dviptr ) ; 
  626.   else { 
  627.     dvibuf [ dviptr ] = 142 ; 
  628.     incr ( dviptr ) ; 
  629.     if ( dviptr == dvilimit ) 
  630.     dviswap () ; 
  631.   } 
  632. } 
  633. zdvifontdef ( f ) 
  634. internalfont f ; 
  635. {r_dvifontdef 
  636.   poolpointer k ; 
  637.   {
  638.     dvibuf [ dviptr ] = 243 ; 
  639.     incr ( dviptr ) ; 
  640.     if ( dviptr == dvilimit ) 
  641.     dviswap () ; 
  642.   } 
  643.   {
  644.     dvibuf [ dviptr ] = f - 1 ; 
  645.     incr ( dviptr ) ; 
  646.     if ( dviptr == dvilimit ) 
  647.     dviswap () ; 
  648.   } 
  649.   {
  650.     dvibuf [ dviptr ] = fontcheck [ f ] .b0 ; 
  651.     incr ( dviptr ) ; 
  652.     if ( dviptr == dvilimit ) 
  653.     dviswap () ; 
  654.   } 
  655.   {
  656.     dvibuf [ dviptr ] = fontcheck [ f ] .b1 ; 
  657.     incr ( dviptr ) ; 
  658.     if ( dviptr == dvilimit ) 
  659.     dviswap () ; 
  660.   } 
  661.   {
  662.     dvibuf [ dviptr ] = fontcheck [ f ] .b2 ; 
  663.     incr ( dviptr ) ; 
  664.     if ( dviptr == dvilimit ) 
  665.     dviswap () ; 
  666.   } 
  667.   {
  668.     dvibuf [ dviptr ] = fontcheck [ f ] .b3 ; 
  669.     incr ( dviptr ) ; 
  670.     if ( dviptr == dvilimit ) 
  671.     dviswap () ; 
  672.   } 
  673.   dvifour ( fontsize [ f ] ) ; 
  674.   dvifour ( fontdsize [ f ] ) ; 
  675.   {
  676.     dvibuf [ dviptr ] = ( strstart [ fontarea [ f ] + 1 ] - strstart [ 
  677.     fontarea [ f ] ] ) ; 
  678.     incr ( dviptr ) ; 
  679.     if ( dviptr == dvilimit ) 
  680.     dviswap () ; 
  681.   } 
  682.   {
  683.     dvibuf [ dviptr ] = ( strstart [ fontname [ f ] + 1 ] - strstart [ 
  684.     fontname [ f ] ] ) ; 
  685.     incr ( dviptr ) ; 
  686.     if ( dviptr == dvilimit ) 
  687.     dviswap () ; 
  688.   } 
  689.   for ( k = strstart [ fontarea [ f ] ] ; k <= strstart [ fontarea [ f ] + 1 ] 
  690.   - 1 ; k ++ ) 
  691.   {
  692.     dvibuf [ dviptr ] = strpool [ k ] ; 
  693.     incr ( dviptr ) ; 
  694.     if ( dviptr == dvilimit ) 
  695.     dviswap () ; 
  696.   } 
  697.   for ( k = strstart [ fontname [ f ] ] ; k <= strstart [ fontname [ f ] + 1 ] 
  698.   - 1 ; k ++ ) 
  699.   {
  700.     dvibuf [ dviptr ] = strpool [ k ] ; 
  701.     incr ( dviptr ) ; 
  702.     if ( dviptr == dvilimit ) 
  703.     dviswap () ; 
  704.   } 
  705. } 
  706. zmovement ( w , o ) 
  707. scaled w ; 
  708. eightbits o ; 
  709. {/* 10 40 45 2 1 */ r_movement 
  710.   smallnumber mstate ; 
  711.   halfword p, q ; 
  712.   integer k ; 
  713.   q = getnode ( 3 ) ; 
  714.   mem [(long) q + 1 ] .cint = w ; 
  715.   mem [(long) q + 2 ] .cint = dvioffset + dviptr ; 
  716.   if ( o == 157 ) 
  717.   {
  718.     mem [(long) q ] .hh .v.RH = downptr ; 
  719.     downptr = q ; 
  720.   } 
  721.   else { 
  722.     mem [(long) q ] .hh .v.RH = rightptr ; 
  723.     rightptr = q ; 
  724.   } 
  725.   p = mem [(long) q ] .hh .v.RH ; 
  726.   mstate = 0 ; 
  727.   while ( p != 0 ) { 
  728.     if ( mem [(long) p + 1 ] .cint == w ) 
  729.     switch ( mstate + mem [(long) p ] .hh .v.LH ) 
  730.     {case 3 : 
  731.     case 4 : 
  732.     case 15 : 
  733.     case 16 : 
  734.       if ( mem [(long) p + 2 ] .cint < dvigone ) 
  735.       goto lab45 ; 
  736.       else { 
  737.     k = mem [(long) p + 2 ] .cint - dvioffset ; 
  738.     if ( k < 0 ) 
  739.     k = k + dvibufsize ; 
  740.     dvibuf [ k ] = dvibuf [ k ] + 5 ; 
  741.     mem [(long) p ] .hh .v.LH = 1 ; 
  742.     goto lab40 ; 
  743.       } 
  744.       break ; 
  745.     case 5 : 
  746.     case 9 : 
  747.     case 11 : 
  748.       if ( mem [(long) p + 2 ] .cint < dvigone ) 
  749.       goto lab45 ; 
  750.       else { 
  751.     k = mem [(long) p + 2 ] .cint - dvioffset ; 
  752.     if ( k < 0 ) 
  753.     k = k + dvibufsize ; 
  754.     dvibuf [ k ] = dvibuf [ k ] + 10 ; 
  755.     mem [(long) p ] .hh .v.LH = 2 ; 
  756.     goto lab40 ; 
  757.       } 
  758.       break ; 
  759.     case 1 : 
  760.     case 2 : 
  761.     case 8 : 
  762.     case 13 : 
  763.       goto lab40 ; 
  764.       break ; 
  765.     default : 
  766.       ; 
  767.       break ; 
  768.     } 
  769.     else switch ( mstate + mem [(long) p ] .hh .v.LH ) 
  770.     {case 1 : 
  771.       mstate = 6 ; 
  772.       break ; 
  773.     case 2 : 
  774.       mstate = 12 ; 
  775.       break ; 
  776.     case 8 : 
  777.     case 13 : 
  778.       goto lab45 ; 
  779.       break ; 
  780.     default : 
  781.       ; 
  782.       break ; 
  783.     } 
  784.     p = mem [(long) p ] .hh .v.RH ; 
  785.   } 
  786.   lab45: ; 
  787.   mem [(long) q ] .hh .v.LH = 3 ; 
  788.   if ( abs ( w ) >= 8388608 ) 
  789.   {
  790.     {
  791.       dvibuf [ dviptr ] = o + 3 ; 
  792.       incr ( dviptr ) ; 
  793.       if ( dviptr == dvilimit ) 
  794.       dviswap () ; 
  795.     } 
  796.     dvifour ( w ) ; 
  797.     return ; 
  798.   } 
  799.   if ( abs ( w ) >= 32768 ) 
  800.   {
  801.     {
  802.       dvibuf [ dviptr ] = o + 2 ; 
  803.       incr ( dviptr ) ; 
  804.       if ( dviptr == dvilimit ) 
  805.       dviswap () ; 
  806.     } 
  807.     if ( w < 0 ) 
  808.     w = w + 16777216 ; 
  809.     {
  810.       dvibuf [ dviptr ] = w / 65536 ; 
  811.       incr ( dviptr ) ; 
  812.       if ( dviptr == dvilimit ) 
  813.       dviswap () ; 
  814.     } 
  815.     w = w % 65536 ; 
  816.     goto lab2 ; 
  817.   } 
  818.   if ( abs ( w ) >= 128 ) 
  819.   {
  820.     {
  821.       dvibuf [ dviptr ] = o + 1 ; 
  822.       incr ( dviptr ) ; 
  823.       if ( dviptr == dvilimit ) 
  824.       dviswap () ; 
  825.     } 
  826.     if ( w < 0 ) 
  827.     w = w + 65536 ; 
  828.     goto lab2 ; 
  829.   } 
  830.   {
  831.     dvibuf [ dviptr ] = o ; 
  832.     incr ( dviptr ) ; 
  833.     if ( dviptr == dvilimit ) 
  834.     dviswap () ; 
  835.   } 
  836.   if ( w < 0 ) 
  837.   w = w + 256 ; 
  838.   goto lab1 ; 
  839.   lab2: { 
  840.     dvibuf [ dviptr ] = w / 256 ; 
  841.     incr ( dviptr ) ; 
  842.     if ( dviptr == dvilimit ) 
  843.     dviswap () ; 
  844.   } 
  845.   lab1: { 
  846.     dvibuf [ dviptr ] = w % 256 ; 
  847.     incr ( dviptr ) ; 
  848.     if ( dviptr == dvilimit ) 
  849.     dviswap () ; 
  850.   } 
  851.   return ; 
  852.   lab40: mem [(long) q ] .hh .v.LH = mem [(long) p ] .hh .v.LH ; 
  853.   if ( mem [(long) q ] .hh .v.LH == 1 ) 
  854.   {
  855.     {
  856.       dvibuf [ dviptr ] = o + 4 ; 
  857.       incr ( dviptr ) ; 
  858.       if ( dviptr == dvilimit ) 
  859.       dviswap () ; 
  860.     } 
  861.     while ( mem [(long) q ] .hh .v.RH != p ) { 
  862.       q = mem [(long) q ] .hh .v.RH ; 
  863.       switch ( mem [(long) q ] .hh .v.LH ) 
  864.       {case 3 : 
  865.     mem [(long) q ] .hh .v.LH = 5 ; 
  866.     break ; 
  867.       case 4 : 
  868.     mem [(long) q ] .hh .v.LH = 6 ; 
  869.     break ; 
  870.       default : 
  871.  
  872.     break ; 
  873.       } 
  874.     } 
  875.   } 
  876.   else { 
  877.     {
  878.       dvibuf [ dviptr ] = o + 9 ; 
  879.       incr ( dviptr ) ; 
  880.       if ( dviptr == dvilimit ) 
  881.       dviswap () ; 
  882.     } 
  883.     while ( mem [(long) q ] .hh .v.RH != p ) { 
  884.       q = mem [(long) q ] .hh .v.RH ; 
  885.       switch ( mem [(long) q ] .hh .v.LH ) 
  886.       {case 3 : 
  887.     mem [(long) q ] .hh .v.LH = 4 ; 
  888.     break ; 
  889.       case 5 : 
  890.     mem [(long) q ] .hh .v.LH = 6 ; 
  891.     break ; 
  892.       default : 
  893.  
  894.     break ; 
  895.       } 
  896.     } 
  897.   } 
  898. } 
  899. zprunemovemen ( l ) 
  900. integer l ; 
  901. {/* 30 10 */ r_prunemovemen 
  902.   halfword p ; 
  903.   while ( downptr != 0 ) { 
  904.     if ( mem [(long) downptr + 2 ] .cint < l ) 
  905.     goto lab30 ; 
  906.     p = downptr ; 
  907.     downptr = mem [(long) p ] .hh .v.RH ; 
  908.     freenode ( p , 3 ) ; 
  909.   } 
  910.   lab30: while ( rightptr != 0 ) { 
  911.     if ( mem [(long) rightptr + 2 ] .cint < l ) 
  912.     return ; 
  913.     p = rightptr ; 
  914.     rightptr = mem [(long) p ] .hh .v.RH ; 
  915.     freenode ( p , 3 ) ; 
  916.   } 
  917. } 
  918. zspecialout ( p ) 
  919. halfword p ; 
  920. {r_specialout 
  921.   quarterword oldsetting ; 
  922.   poolpointer k ; 
  923.   if ( curh != dvih ) 
  924.   {
  925.     movement ( curh - dvih , 143 ) ; 
  926.     dvih = curh ; 
  927.   } 
  928.   if ( curv != dviv ) 
  929.   {
  930.     movement ( curv - dviv , 157 ) ; 
  931.     dviv = curv ; 
  932.   } 
  933.   oldsetting = selector ; 
  934.   selector = 21 ; 
  935.   showtokenlis ( mem [(long) mem [(long) p + 1 ] .hh .v.RH ] .hh .v.RH , 0 , poolsize - 
  936.   poolptr ) ; 
  937.   selector = oldsetting ; 
  938.   {
  939.     if ( poolptr + 1 > poolsize ) 
  940.     overflow ( 128 , poolsize - initpoolptr ) ; 
  941.   } 
  942.   if ( ( poolptr - strstart [ strptr ] ) < 256 ) 
  943.   {
  944.     {
  945.       dvibuf [ dviptr ] = 239 ; 
  946.       incr ( dviptr ) ; 
  947.       if ( dviptr == dvilimit ) 
  948.       dviswap () ; 
  949.     } 
  950.     {
  951.       dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ; 
  952.       incr ( dviptr ) ; 
  953.       if ( dviptr == dvilimit ) 
  954.       dviswap () ; 
  955.     } 
  956.   } 
  957.   else { 
  958.     {
  959.       dvibuf [ dviptr ] = 242 ; 
  960.       incr ( dviptr ) ; 
  961.       if ( dviptr == dvilimit ) 
  962.       dviswap () ; 
  963.     } 
  964.     dvifour ( ( poolptr - strstart [ strptr ] ) ) ; 
  965.   } 
  966.   for ( k = strstart [ strptr ] ; k <= poolptr - 1 ; k ++ ) 
  967.   {
  968.     dvibuf [ dviptr ] = strpool [ k ] ; 
  969.     incr ( dviptr ) ; 
  970.     if ( dviptr == dvilimit ) 
  971.     dviswap () ; 
  972.   } 
  973.   poolptr = strstart [ strptr ] ; 
  974. } 
  975. zwriteout ( p ) 
  976. halfword p ; 
  977. {r_writeout 
  978.   quarterword oldsetting ; 
  979.   integer oldmode ; 
  980.   smallnumber j ; 
  981.   halfword q, r ; 
  982.   q = getavail () ; 
  983.   mem [(long) q ] .hh .v.LH = 637 ; 
  984.   r = getavail () ; 
  985.   mem [(long) q ] .hh .v.RH = r ; 
  986.   mem [(long) r ] .hh .v.LH = 7362 ; 
  987.   begintokenli ( q , 4 ) ; 
  988.   begintokenli ( mem [(long) p + 1 ] .hh .v.RH , 15 ) ; 
  989.   q = getavail () ; 
  990.   mem [(long) q ] .hh .v.LH = 379 ; 
  991.   begintokenli ( q , 4 ) ; 
  992.   oldmode = curlist .modefield ; 
  993.   curlist .modefield = 0 ; 
  994.   curcs = writeloc ; 
  995.   q = scantoks ( false , true ) ; 
  996.   gettoken () ; 
  997.   if ( curtok != 7362 ) 
  998.   {
  999.     {
  1000.       if ( interaction == 3 ) 
  1001.       wakeuptermin () ; 
  1002.       printnl ( 133 ) ; 
  1003.       print ( 1139 ) ; 
  1004.     } 
  1005.     {
  1006.       helpptr = 2 ; 
  1007.       helpline [ 1 ] = 1140 ; 
  1008.       helpline [ 0 ] = 860 ; 
  1009.     } 
  1010.     error () ; 
  1011.     do { gettoken () ; 
  1012.     } while ( ! ( curtok == 7362 ) ) ; 
  1013.   } 
  1014.   curlist .modefield = oldmode ; 
  1015.   endtokenlist () ; 
  1016.   oldsetting = selector ; 
  1017.   j = mem [(long) p + 1 ] .hh .v.LH ; 
  1018.   if ( writeopen [ j ] ) 
  1019.   selector = j ; 
  1020.   else { 
  1021.     if ( ( j == 17 ) && ( selector == 19 ) ) 
  1022.     selector = 18 ; 
  1023.     printnl ( 206 ) ; 
  1024.   } 
  1025.   showtokenlis ( mem [(long) defref ] .hh .v.RH , 0 , 10000000 ) ; 
  1026.   println () ; 
  1027.   flushlist ( defref ) ; 
  1028.   selector = oldsetting ; 
  1029. } 
  1030. zoutwhat ( p ) 
  1031. halfword p ; 
  1032. {r_outwhat 
  1033.   smallnumber j ; 
  1034.   switch ( mem [(long) p ] .hh.b1 ) 
  1035.   {case 0 : 
  1036.   case 1 : 
  1037.   case 2 : 
  1038.     if ( ! doingleaders ) 
  1039.     {
  1040.       j = mem [(long) p + 1 ] .hh .v.LH ; 
  1041.       if ( mem [(long) p ] .hh.b1 == 1 ) 
  1042.       writeout ( p ) ; 
  1043.       else { 
  1044.     if ( writeopen [ j ] ) 
  1045.     aclose ( writefile [ j ] ) ; 
  1046.     if ( mem [(long) p ] .hh.b1 == 2 ) 
  1047.     writeopen [ j ] = false ; 
  1048.     else if ( j < 16 ) 
  1049.     {
  1050.       curname = mem [(long) p + 1 ] .hh .v.RH ; 
  1051.       curarea = mem [(long) p + 2 ] .hh .v.LH ; 
  1052.       curext = mem [(long) p + 2 ] .hh .v.RH ; 
  1053.       if ( curext == 206 ) 
  1054.       curext = 644 ; 
  1055.       packfilename ( curname , curarea , curext ) ; 
  1056.       while ( ! aopenout ( writefile [ j ] ) ) promptfilena ( 1142 , 644 ) 
  1057.       ; 
  1058.       writeopen [ j ] = true ; 
  1059.     } 
  1060.       } 
  1061.     } 
  1062.     break ; 
  1063.   case 3 : 
  1064.     specialout ( p ) ; 
  1065.     break ; 
  1066.   default : 
  1067.     confusion ( 1141 ) ; 
  1068.     break ; 
  1069.   } 
  1070. } 
  1071. hlistout () { /* 21 13 14 15 */ r_hlistout 
  1072.   scaled baseline ; 
  1073.   scaled leftedge ; 
  1074.   scaled saveh, savev ; 
  1075.   halfword thisbox ; 
  1076.   glueord gorder ; 
  1077.   quarterword gsign ; 
  1078.   halfword p ; 
  1079.   integer saveloc ; 
  1080.   halfword leaderbox ; 
  1081.   scaled leaderwd ; 
  1082.   scaled lx ; 
  1083.   boolean outerdoingle ; 
  1084.   scaled edge ; 
  1085.   fourquarters qi;
  1086.   thisbox = tempptr ; 
  1087.   gorder = mem [(long) thisbox + 5 ] .hh.b1 ; 
  1088.   gsign = mem [(long) thisbox + 5 ] .hh.b0 ; 
  1089.   p = mem [(long) thisbox + 5 ] .hh .v.RH ; 
  1090.   incr ( curs ) ; 
  1091.   if ( curs > 0 ) 
  1092.   {
  1093.     dvibuf [ dviptr ] = 141 ; 
  1094.     incr ( dviptr ) ; 
  1095.     if ( dviptr == dvilimit ) 
  1096.     dviswap () ; 
  1097.   } 
  1098.   if ( curs > maxpush ) 
  1099.   maxpush = curs ; 
  1100.   saveloc = dvioffset + dviptr ; 
  1101.   baseline = curv ; 
  1102.   leftedge = curh ; 
  1103.   while ( p != 0 ) lab21: if ( ( p >= himemmin ) ) 
  1104.   {
  1105.     if ( curh != dvih ) 
  1106.     {
  1107.       movement ( curh - dvih , 143 ) ; 
  1108.       dvih = curh ; 
  1109.     } 
  1110.     if ( curv != dviv ) 
  1111.     {
  1112.       movement ( curv - dviv , 157 ) ; 
  1113.       dviv = curv ; 
  1114.     } 
  1115.     do { f = mem [(long) p ] .hh.b0 ; 
  1116.       c = mem [(long) p ] .hh.b1 ; 
  1117.       if ( f != dvif ) 
  1118.       {
  1119.     if ( ! fontused [ f ] ) 
  1120.     {
  1121.       dvifontdef ( f ) ; 
  1122.       fontused [ f ] = true ; 
  1123.     } 
  1124.     if ( f <= 64 ) 
  1125.     {
  1126.       dvibuf [ dviptr ] = f + 170 ; 
  1127.       incr ( dviptr ) ; 
  1128.       if ( dviptr == dvilimit ) 
  1129.       dviswap () ; 
  1130.     } 
  1131.     else { 
  1132.       {
  1133.         dvibuf [ dviptr ] = 235 ; 
  1134.         incr ( dviptr ) ; 
  1135.         if ( dviptr == dvilimit ) 
  1136.         dviswap () ; 
  1137.       } 
  1138.       {
  1139.         dvibuf [ dviptr ] = f - 1 ; 
  1140.         incr ( dviptr ) ; 
  1141.         if ( dviptr == dvilimit ) 
  1142.         dviswap () ; 
  1143.       } 
  1144.     } 
  1145.     dvif = f ; 
  1146.       } 
  1147.       if ( c >= 128 ) 
  1148.       {
  1149.     dvibuf [ dviptr ] = 128 ; 
  1150.     incr ( dviptr ) ; 
  1151.     if ( dviptr == dvilimit ) 
  1152.     dviswap () ; 
  1153.       } 
  1154.       {
  1155.     dvibuf [ dviptr ] = c ; 
  1156.     incr ( dviptr ) ; 
  1157.     if ( dviptr == dvilimit ) 
  1158.     dviswap () ; 
  1159.       } 
  1160. /*      curh = curh + fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + c 
  1161.       ] .qqqq .b0 ] .cint ; */
  1162. qi=    fontinfo [ charbase [ f ] + c  ] .qqqq;
  1163.   curh = curh + fontinfo [ widthbase [ f ] + qi .b0 ] .cint ;
  1164.       p = mem [(long) p ] .hh .v.RH ; 
  1165.     } while ( ! ( ! ( p >= himemmin ) ) ) ; 
  1166.     dvih = curh ; 
  1167.   } 
  1168.   else { 
  1169.     switch ( mem [(long) p ] .hh.b0 ) 
  1170.     {case 0 : 
  1171.     case 1 : 
  1172.       if ( mem [(long) p + 5 ] .hh .v.RH == 0 ) 
  1173.       curh = curh + mem [(long) p + 1 ] .cint ; 
  1174.       else { 
  1175.     saveh = dvih ; 
  1176.     savev = dviv ; 
  1177.     curv = baseline + mem [(long) p + 4 ] .cint ; 
  1178.     tempptr = p ; 
  1179.     edge = curh ; 
  1180.     if ( mem [(long) p ] .hh.b0 == 1 ) 
  1181.     vlistout () ; 
  1182.     else hlistout () ; 
  1183.     dvih = saveh ; 
  1184.     dviv = savev ; 
  1185.     curh = edge + mem [(long) p + 1 ] .cint ; 
  1186.     curv = baseline ; 
  1187.       } 
  1188.       break ; 
  1189.     case 2 : 
  1190.       {
  1191.     ruleht = mem [(long) p + 3 ] .cint ; 
  1192.     ruledp = mem [(long) p + 2 ] .cint ; 
  1193.     rulewd = mem [(long) p + 1 ] .cint ; 
  1194.     goto lab14 ; 
  1195.       } 
  1196.       break ; 
  1197.     case 8 : 
  1198.       outwhat ( p ) ; 
  1199.       break ; 
  1200.     case 10 : 
  1201.       {
  1202.     g = mem [(long) p + 1 ] .hh .v.LH ; 
  1203.     rulewd = mem [(long) g + 1 ] .cint ; 
  1204.     if ( gsign != 0 ) 
  1205.     {
  1206.       if ( gsign == 1 ) 
  1207.       {
  1208.         if ( mem [(long) g ] .hh.b0 == gorder ) 
  1209.         rulewd = rulewd + round ( mem [(long) thisbox + 6 ] .gr * mem [(long) g + 2 ] 
  1210.         .cint ) ; 
  1211.       } 
  1212.       else { 
  1213.         if ( mem [(long) g ] .hh.b1 == gorder ) 
  1214.         rulewd = rulewd - round ( mem [(long) thisbox + 6 ] .gr * mem [(long) g + 3 ] 
  1215.         .cint ) ; 
  1216.       } 
  1217.     } 
  1218.     if ( mem [(long) p ] .hh.b1 >= 100 ) 
  1219.     {
  1220.       leaderbox = mem [(long) p + 1 ] .hh .v.RH ; 
  1221.       if ( mem [(long) leaderbox ] .hh.b0 == 2 ) 
  1222.       {
  1223.         ruleht = mem [(long) leaderbox + 3 ] .cint ; 
  1224.         ruledp = mem [(long) leaderbox + 2 ] .cint ; 
  1225.         goto lab14 ; 
  1226.       } 
  1227.       leaderwd = mem [(long) leaderbox + 1 ] .cint ; 
  1228.       if ( ( leaderwd > 0 ) && ( rulewd > 0 ) ) 
  1229.       {
  1230.         rulewd = rulewd + 10 ; 
  1231.         edge = curh + rulewd ; 
  1232.         lx = 0 ; 
  1233.         if ( mem [(long) p ] .hh.b1 == 100 ) 
  1234.         {
  1235.           saveh = curh ; 
  1236.           curh = leftedge + leaderwd * ( ( curh - leftedge ) / leaderwd ) 
  1237.           ; 
  1238.           if ( curh < saveh ) 
  1239.           curh = curh + leaderwd ; 
  1240.         } 
  1241.         else { 
  1242.           lq = rulewd / leaderwd ; 
  1243.           lr = rulewd % leaderwd ; 
  1244.           if ( mem [(long) p ] .hh.b1 == 101 ) 
  1245.           curh = curh + ( lr / 2 ) ; 
  1246.           else { 
  1247.         lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  1248.         curh = curh + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ; 
  1249.           } 
  1250.         } 
  1251.         while ( curh + leaderwd <= edge ) { 
  1252.           curv = baseline + mem [(long) leaderbox + 4 ] .cint ; 
  1253.           if ( curv != dviv ) 
  1254.           {
  1255.         movement ( curv - dviv , 157 ) ; 
  1256.         dviv = curv ; 
  1257.           } 
  1258.           savev = dviv ; 
  1259.           if ( curh != dvih ) 
  1260.           {
  1261.         movement ( curh - dvih , 143 ) ; 
  1262.         dvih = curh ; 
  1263.           } 
  1264.           saveh = dvih ; 
  1265.           tempptr = leaderbox ; 
  1266.           outerdoingle = doingleaders ; 
  1267.           doingleaders = true ; 
  1268.           if ( mem [(long) leaderbox ] .hh.b0 == 1 ) 
  1269.           vlistout () ; 
  1270.           else hlistout () ; 
  1271.           doingleaders = outerdoingle ; 
  1272.           dviv = savev ; 
  1273.           dvih = saveh ; 
  1274.           curv = savev ; 
  1275.           curh = saveh + leaderwd + lx ; 
  1276.         } 
  1277.         curh = edge - 10 ; 
  1278.         goto lab15 ; 
  1279.       } 
  1280.     } 
  1281.     goto lab13 ; 
  1282.       } 
  1283.       break ; 
  1284.     case 11 : 
  1285.     case 9 : 
  1286.       curh = curh + mem [(long) p + 1 ] .cint ; 
  1287.       break ; 
  1288.     case 6 : 
  1289.       {
  1290.     mem [(long) memtop - 12 ] = mem [(long) p + 1 ] ; 
  1291.     mem [(long) memtop - 12 ] .hh .v.RH = mem [(long) p ] .hh .v.RH ; 
  1292.     p = memtop - 12 ; 
  1293.     goto lab21 ; 
  1294.       } 
  1295.       break ; 
  1296.     default : 
  1297.       ; 
  1298.       break ; 
  1299.     } 
  1300.     goto lab15 ; 
  1301.     lab14: if ( ( ruleht == - 1073741824 ) ) 
  1302.     ruleht = mem [(long) thisbox + 3 ] .cint ; 
  1303.     if ( ( ruledp == - 1073741824 ) ) 
  1304.     ruledp = mem [(long) thisbox + 2 ] .cint ; 
  1305.     ruleht = ruleht + ruledp ; 
  1306.     if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) 
  1307.     {
  1308.       if ( curh != dvih ) 
  1309.       {
  1310.     movement ( curh - dvih , 143 ) ; 
  1311.     dvih = curh ; 
  1312.       } 
  1313.       curv = baseline + ruledp ; 
  1314.       if ( curv != dviv ) 
  1315.       {
  1316.     movement ( curv - dviv , 157 ) ; 
  1317.     dviv = curv ; 
  1318.       } 
  1319.       {
  1320.     dvibuf [ dviptr ] = 132 ; 
  1321.     incr ( dviptr ) ; 
  1322.     if ( dviptr == dvilimit ) 
  1323.     dviswap () ; 
  1324.       } 
  1325.       dvifour ( ruleht ) ; 
  1326.       dvifour ( rulewd ) ; 
  1327.       curv = baseline ; 
  1328.       dvih = dvih + rulewd ; 
  1329.     } 
  1330.     lab13: curh = curh + rulewd ; 
  1331.     lab15: p = mem [(long) p ] .hh .v.RH ; 
  1332.   } 
  1333.   prunemovemen ( saveloc ) ; 
  1334.   if ( curs > 0 ) 
  1335.   dvipop ( saveloc ) ; 
  1336.   decr ( curs ) ; 
  1337. } 
  1338. vlistout () { /* 13 14 15 */ r_vlistout 
  1339.   scaled leftedge ; 
  1340.   scaled topedge ; 
  1341.   scaled saveh, savev ; 
  1342.   halfword thisbox ; 
  1343.   glueord gorder ; 
  1344.   quarterword gsign ; 
  1345.   halfword p ; 
  1346.   integer saveloc ; 
  1347.   halfword leaderbox ; 
  1348.   scaled leaderht ; 
  1349.   scaled lx ; 
  1350.   boolean outerdoingle ; 
  1351.   scaled edge ; 
  1352.   thisbox = tempptr ; 
  1353.   gorder = mem [(long) thisbox + 5 ] .hh.b1 ; 
  1354.   gsign = mem [(long) thisbox + 5 ] .hh.b0 ; 
  1355.   p = mem [(long) thisbox + 5 ] .hh .v.RH ; 
  1356.   incr ( curs ) ; 
  1357.   if ( curs > 0 ) 
  1358.   {
  1359.     dvibuf [ dviptr ] = 141 ; 
  1360.     incr ( dviptr ) ; 
  1361.     if ( dviptr == dvilimit ) 
  1362.     dviswap () ; 
  1363.   } 
  1364.   if ( curs > maxpush ) 
  1365.   maxpush = curs ; 
  1366.   saveloc = dvioffset + dviptr ; 
  1367.   leftedge = curh ; 
  1368.   curv = curv - mem [(long) thisbox + 3 ] .cint ; 
  1369.   topedge = curv ; 
  1370.   while ( p != 0 ) { 
  1371.     if ( ( p >= himemmin ) ) 
  1372.     confusion ( 681 ) ; 
  1373.     else { 
  1374.       switch ( mem [(long) p ] .hh.b0 ) 
  1375.       {case 0 : 
  1376.       case 1 : 
  1377.     if ( mem [(long) p + 5 ] .hh .v.RH == 0 ) 
  1378.     curv = curv + mem [(long) p + 3 ] .cint + mem [(long) p + 2 ] .cint ; 
  1379.     else { 
  1380.       curv = curv + mem [(long) p + 3 ] .cint ; 
  1381.       if ( curv != dviv ) 
  1382.       {
  1383.         movement ( curv - dviv , 157 ) ; 
  1384.         dviv = curv ; 
  1385.       } 
  1386.       saveh = dvih ; 
  1387.       savev = dviv ; 
  1388.       curh = leftedge + mem [(long) p + 4 ] .cint ; 
  1389.       tempptr = p ; 
  1390.       if ( mem [(long) p ] .hh.b0 == 1 ) 
  1391.       vlistout () ; 
  1392.       else hlistout () ; 
  1393.       dvih = saveh ; 
  1394.       dviv = savev ; 
  1395.       curv = savev + mem [(long) p + 2 ] .cint ; 
  1396.       curh = leftedge ; 
  1397.     } 
  1398.     break ; 
  1399.       case 2 : 
  1400.     {
  1401.       ruleht = mem [(long) p + 3 ] .cint ; 
  1402.       ruledp = mem [(long) p + 2 ] .cint ; 
  1403.       rulewd = mem [(long) p + 1 ] .cint ; 
  1404.       goto lab14 ; 
  1405.     } 
  1406.     break ; 
  1407.       case 8 : 
  1408.     outwhat ( p ) ; 
  1409.     break ; 
  1410.       case 10 : 
  1411.     {
  1412.       g = mem [(long) p + 1 ] .hh .v.LH ; 
  1413.       ruleht = mem [(long) g + 1 ] .cint ; 
  1414.       if ( gsign != 0 ) 
  1415.       {
  1416.         if ( gsign == 1 ) 
  1417.         {
  1418.           if ( mem [(long) g ] .hh.b0 == gorder ) 
  1419.           ruleht = ruleht + round ( mem [(long) thisbox + 6 ] .gr * mem [(long) g + 2 
  1420.           ] .cint ) ; 
  1421.         } 
  1422.         else { 
  1423.           if ( mem [(long) g ] .hh.b1 == gorder ) 
  1424.           ruleht = ruleht - round ( mem [(long) thisbox + 6 ] .gr * mem [(long) g + 3 
  1425.           ] .cint ) ; 
  1426.         } 
  1427.       } 
  1428.       if ( mem [(long) p ] .hh.b1 >= 100 ) 
  1429.       {
  1430.         leaderbox = mem [(long) p + 1 ] .hh .v.RH ; 
  1431.         if ( mem [(long) leaderbox ] .hh.b0 == 2 ) 
  1432.         {
  1433.           rulewd = mem [(long) leaderbox + 1 ] .cint ; 
  1434.           ruledp = 0 ; 
  1435.           goto lab14 ; 
  1436.         } 
  1437.         leaderht = mem [(long) leaderbox + 3 ] .cint + mem [(long) leaderbox + 2 ] 
  1438.         .cint ; 
  1439.         if ( ( leaderht > 0 ) && ( ruleht > 0 ) ) 
  1440.         {
  1441.           ruleht = ruleht + 10 ; 
  1442.           edge = curv + ruleht ; 
  1443.           lx = 0 ; 
  1444.           if ( mem [(long) p ] .hh.b1 == 100 ) 
  1445.           {
  1446.         savev = curv ; 
  1447.         curv = topedge + leaderht * ( ( curv - topedge ) / leaderht ) 
  1448.         ; 
  1449.         if ( curv < savev ) 
  1450.         curv = curv + leaderht ; 
  1451.           } 
  1452.           else { 
  1453.         lq = ruleht / leaderht ; 
  1454.         lr = ruleht % leaderht ; 
  1455.         if ( mem [(long) p ] .hh.b1 == 101 ) 
  1456.         curv = curv + ( lr / 2 ) ; 
  1457.         else { 
  1458.           lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  1459.           curv = curv + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ; 
  1460.         } 
  1461.           } 
  1462.           while ( curv + leaderht <= edge ) { 
  1463.         curh = leftedge + mem [(long) leaderbox + 4 ] .cint ; 
  1464.         if ( curh != dvih ) 
  1465.         {
  1466.           movement ( curh - dvih , 143 ) ; 
  1467.           dvih = curh ; 
  1468.         } 
  1469.         saveh = dvih ; 
  1470.         curv = curv + mem [(long) leaderbox + 3 ] .cint ; 
  1471.         if ( curv != dviv ) 
  1472.         {
  1473.           movement ( curv - dviv , 157 ) ; 
  1474.           dviv = curv ; 
  1475.         } 
  1476.         savev = dviv ; 
  1477.         tempptr = leaderbox ; 
  1478.         outerdoingle = doingleaders ; 
  1479.         doingleaders = true ; 
  1480.         if ( mem [(long) leaderbox ] .hh.b0 == 1 ) 
  1481.         vlistout () ; 
  1482.         else hlistout () ; 
  1483.         doingleaders = outerdoingle ; 
  1484.         dviv = savev ; 
  1485.         dvih = saveh ; 
  1486.         curh = saveh ; 
  1487.         curv = savev - mem [(long) leaderbox + 3 ] .cint + leaderht + lx ; 
  1488.           } 
  1489.           curv = edge - 10 ; 
  1490.           goto lab15 ; 
  1491.         } 
  1492.       } 
  1493.       goto lab13 ; 
  1494.     } 
  1495.     break ; 
  1496.       case 11 : 
  1497.     curv = curv + mem [(long) p + 1 ] .cint ; 
  1498.     break ; 
  1499.       default : 
  1500.  
  1501.     break ; 
  1502.       } 
  1503.       goto lab15 ; 
  1504.       lab14: if ( ( rulewd == - 1073741824 ) ) 
  1505.       rulewd = mem [(long) thisbox + 1 ] .cint ; 
  1506.       ruleht = ruleht + ruledp ; 
  1507.       curv = curv + ruleht ; 
  1508.       if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) 
  1509.       {
  1510.     if ( curh != dvih ) 
  1511.     {
  1512.       movement ( curh - dvih , 143 ) ; 
  1513.       dvih = curh ; 
  1514.     } 
  1515.     if ( curv != dviv ) 
  1516.     {
  1517.       movement ( curv - dviv , 157 ) ; 
  1518.       dviv = curv ; 
  1519.     } 
  1520.     {
  1521.       dvibuf [ dviptr ] = 137 ; 
  1522.       incr ( dviptr ) ; 
  1523.       if ( dviptr == dvilimit ) 
  1524.       dviswap () ; 
  1525.     } 
  1526.     dvifour ( ruleht ) ; 
  1527.     dvifour ( rulewd ) ; 
  1528.       } 
  1529.       goto lab15 ; 
  1530.       lab13: curv = curv + ruleht ; 
  1531.     } 
  1532.     lab15: p = mem [(long) p ] .hh .v.RH ; 
  1533.   } 
  1534.   prunemovemen ( saveloc ) ; 
  1535.   if ( curs > 0 ) 
  1536.   dvipop ( saveloc ) ; 
  1537.   decr ( curs ) ; 
  1538. } 
  1539. zshipout ( p ) 
  1540. halfword p ; 
  1541. {/* 30 */ r_shipout 
  1542.   integer pageloc ; 
  1543.   quarterword j, k ; 
  1544.   poolpointer s ; 
  1545.   quarterword oldsetting ; 
  1546.   if ( eqtb [ 5301 ] .cint > 0 ) 
  1547.   {
  1548.     printnl ( 206 ) ; 
  1549.     println () ; 
  1550.     print ( 682 ) ; 
  1551.   } 
  1552.   if ( termoffset > maxprintline - 9 ) 
  1553.   println () ; 
  1554.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  1555.   printchar ( 32 ) ; 
  1556.   printchar ( 91 ) ; 
  1557.   j = 9 ; 
  1558.   while ( ( eqtb [ 5317 + j ] .cint == 0 ) && ( j > 0 ) ) decr ( j ) ; 
  1559.   for ( k = 0 ; k <= j ; k ++ ) 
  1560.   {
  1561.     printint ( eqtb [ 5317 + k ] .cint ) ; 
  1562.     if ( k < j ) 
  1563.     printchar ( 46 ) ; 
  1564.   } 
  1565.   termflush ( output ) ; 
  1566.   if ( eqtb [ 5301 ] .cint > 0 ) 
  1567.   {
  1568.     printchar ( 93 ) ; 
  1569.     begindiagnos () ; 
  1570.     showbox ( p ) ; 
  1571.     enddiagnosti ( true ) ; 
  1572.   } 
  1573.   if ( ( mem [(long) p + 3 ] .cint > 1073741823 ) || ( mem [(long) p + 2 ] .cint > 
  1574.   1073741823 ) || ( mem [(long) p + 3 ] .cint + mem [(long) p + 2 ] .cint + eqtb [ 5720 ] 
  1575.   .cint > 1073741823 ) || ( mem [(long) p + 1 ] .cint + eqtb [ 5719 ] .cint > 
  1576.   1073741823 ) ) 
  1577.   {
  1578.     {
  1579.       if ( interaction == 3 ) 
  1580.       wakeuptermin () ; 
  1581.       printnl ( 133 ) ; 
  1582.       print ( 686 ) ; 
  1583.     } 
  1584.     {
  1585.       helpptr = 2 ; 
  1586.       helpline [ 1 ] = 687 ; 
  1587.       helpline [ 0 ] = 688 ; 
  1588.     } 
  1589.     error () ; 
  1590.     if ( eqtb [ 5301 ] .cint <= 0 ) 
  1591.     {
  1592.       begindiagnos () ; 
  1593.       printnl ( 689 ) ; 
  1594.       showbox ( p ) ; 
  1595.       enddiagnosti ( true ) ; 
  1596.     } 
  1597.     goto lab30 ; 
  1598.   } 
  1599.   if ( mem [(long) p + 3 ] .cint + mem [(long) p + 2 ] .cint + eqtb [ 5720 ] .cint > maxv 
  1600.   ) 
  1601.   maxv = mem [(long) p + 3 ] .cint + mem [(long) p + 2 ] .cint + eqtb [ 5720 ] .cint ; 
  1602.   if ( mem [(long) p + 1 ] .cint + eqtb [ 5719 ] .cint > maxh ) 
  1603.   maxh = mem [(long) p + 1 ] .cint + eqtb [ 5719 ] .cint ; 
  1604.   dvih = 0 ; 
  1605.   dviv = 0 ; 
  1606.   curh = eqtb [ 5719 ] .cint ; 
  1607.   dvif = 0 ; 
  1608.   if ( outputfilena == 0 ) 
  1609.   {
  1610.     if ( jobname == 0 ) 
  1611.     openlogfile () ; 
  1612.     packjobname ( 647 ) ; 
  1613.     while ( ! bopenout ( dvifile ) ) promptfilena ( 648 , 647 ) ; 
  1614.     outputfilena = bmakenamestr ( dvifile ) ; 
  1615.   } 
  1616.   if ( totalpages == 0 ) 
  1617.   {
  1618.     {
  1619.       dvibuf [ dviptr ] = 247 ; 
  1620.       incr ( dviptr ) ; 
  1621.       if ( dviptr == dvilimit ) 
  1622.       dviswap () ; 
  1623.     } 
  1624.     {
  1625.       dvibuf [ dviptr ] = 2 ; 
  1626.       incr ( dviptr ) ; 
  1627.       if ( dviptr == dvilimit ) 
  1628.       dviswap () ; 
  1629.     } 
  1630.     dvifour ( 25400000 ) ; 
  1631.     dvifour ( 473628672 ) ; 
  1632.     preparemag () ; 
  1633.     dvifour ( eqtb [ 5284 ] .cint ) ; 
  1634.     oldsetting = selector ; 
  1635.     selector = 21 ; 
  1636.     print ( 680 ) ; 
  1637.     printint ( eqtb [ 5290 ] .cint ) ; 
  1638.     printchar ( 46 ) ; 
  1639.     printtwo ( eqtb [ 5289 ] .cint ) ; 
  1640.     printchar ( 46 ) ; 
  1641.     printtwo ( eqtb [ 5288 ] .cint ) ; 
  1642.     printchar ( 58 ) ; 
  1643.     printtwo ( eqtb [ 5287 ] .cint / 60 ) ; 
  1644.     printtwo ( eqtb [ 5287 ] .cint % 60 ) ; 
  1645.     selector = oldsetting ; 
  1646.     {
  1647.       dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ; 
  1648.       incr ( dviptr ) ; 
  1649.       if ( dviptr == dvilimit ) 
  1650.       dviswap () ; 
  1651.     } 
  1652.     for ( s = strstart [ strptr ] ; s <= poolptr - 1 ; s ++ ) 
  1653.     {
  1654.       dvibuf [ dviptr ] = strpool [ s ] ; 
  1655.       incr ( dviptr ) ; 
  1656.       if ( dviptr == dvilimit ) 
  1657.       dviswap () ; 
  1658.     } 
  1659.     poolptr = strstart [ strptr ] ; 
  1660.   } 
  1661.   pageloc = dvioffset + dviptr ; 
  1662.   {
  1663.     dvibuf [ dviptr ] = 139 ; 
  1664.     incr ( dviptr ) ; 
  1665.     if ( dviptr == dvilimit ) 
  1666.     dviswap () ; 
  1667.   } 
  1668.   for ( k = 0 ; k <= 9 ; k ++ ) 
  1669.   dvifour ( eqtb [ 5317 + k ] .cint ) ; 
  1670.   dvifour ( lastbop ) ; 
  1671.   lastbop = pageloc ; 
  1672.   curv = mem [(long) p + 3 ] .cint + eqtb [ 5720 ] .cint ; 
  1673.   tempptr = p ; 
  1674.   if ( mem [(long) p ] .hh.b0 == 1 ) 
  1675.   vlistout () ; 
  1676.   else hlistout () ; 
  1677.   {
  1678.     dvibuf [ dviptr ] = 140 ; 
  1679.     incr ( dviptr ) ; 
  1680.     if ( dviptr == dvilimit ) 
  1681.     dviswap () ; 
  1682.   } 
  1683.   incr ( totalpages ) ; 
  1684.   curs = - 1 ; 
  1685.   lab30: ; 
  1686.   if ( eqtb [ 5301 ] .cint <= 0 ) 
  1687.   printchar ( 93 ) ; 
  1688.   deadcycles = 0 ; 
  1689.   termflush ( output ) ; 
  1690.  
  1691. #ifdef STAT
  1692.   if ( eqtb [ 5298 ] .cint > 1 ) 
  1693.   {
  1694.     printnl ( 683 ) ; 
  1695.     printint ( varused ) ; 
  1696.     printchar ( 38 ) ; 
  1697.     printint ( dynused ) ; 
  1698.     printchar ( 59 ) ; 
  1699.   } 
  1700. #endif /* STAT */
  1701.   flushnodelis ( p ) ; 
  1702.  
  1703. #ifdef STAT
  1704.   if ( eqtb [ 5298 ] .cint > 1 ) 
  1705.   {
  1706.     print ( 684 ) ; 
  1707.     printint ( varused ) ; 
  1708.     printchar ( 38 ) ; 
  1709.     printint ( dynused ) ; 
  1710.     print ( 685 ) ; 
  1711.     printint ( himemmin - lomemmax - 1 ) ; 
  1712.     println () ; 
  1713.   } 
  1714. #endif /* STAT */
  1715. } 
  1716. scanspec () { /* 40 */ r_scanspec 
  1717.   if ( scankeyword ( 695 ) ) 
  1718.   savestack [ saveptr + 0 ] .cint = 0 ; 
  1719.   else if ( scankeyword ( 696 ) ) 
  1720.   savestack [ saveptr + 0 ] .cint = 1 ; 
  1721.   else { 
  1722.     savestack [ saveptr + 0 ] .cint = 1 ; 
  1723.     savestack [ saveptr + 1 ] .cint = 0 ; 
  1724.     goto lab40 ; 
  1725.   } 
  1726.   scandimen ( false , false , false ) ; 
  1727.   savestack [ saveptr + 1 ] .cint = curval ; 
  1728.   lab40: saveptr = saveptr + 2 ; 
  1729.   scanleftbrac () ; 
  1730. } 
  1731. halfword zhpack ( p , w , m ) 
  1732. halfword p ; 
  1733. scaled w ; 
  1734. smallnumber m ; 
  1735. {/* 21 50 10 */ register halfword Result; r_hpack 
  1736.   halfword r ; 
  1737.   halfword q ; 
  1738.   scaled h, d, x ; 
  1739.   scaled s ; 
  1740.   halfword g ; 
  1741.   glueord o ; 
  1742.   internalfont f ; 
  1743.   fourquarters i ; 
  1744.   eightbits hd ; 
  1745.   integer b ; 
  1746.   r = getnode ( 7 ) ; 
  1747.   mem [(long) r ] .hh.b0 = 0 ; 
  1748.   mem [(long) r ] .hh.b1 = 0 ; 
  1749.   mem [(long) r + 4 ] .cint = 0 ; 
  1750.   q = r + 5 ; 
  1751.   mem [(long) q ] .hh .v.RH = p ; 
  1752.   h = 0 ; 
  1753.   d = 0 ; 
  1754.   x = 0 ; 
  1755.   totalstretch [ 0 ] = 0 ; 
  1756.   totalshrink [ 0 ] = 0 ; 
  1757.   totalstretch [ 1 ] = 0 ; 
  1758.   totalshrink [ 1 ] = 0 ; 
  1759.   totalstretch [ 2 ] = 0 ; 
  1760.   totalshrink [ 2 ] = 0 ; 
  1761.   totalstretch [ 3 ] = 0 ; 
  1762.   totalshrink [ 3 ] = 0 ; 
  1763.   while ( p != 0 ) { 
  1764.     lab21: while ( ( p >= himemmin ) ) { 
  1765.       f = mem [(long) p ] .hh.b0 ; 
  1766.       i = fontinfo [ charbase [ f ] + mem [(long) p ] .hh.b1 ] .qqqq ; 
  1767.       hd = i .b1 ; 
  1768.       x = x + fontinfo [ widthbase [ f ] + i .b0 ] .cint ; 
  1769.       s = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint ; 
  1770.       if ( s > h ) 
  1771.       h = s ; 
  1772.       s = fontinfo [ depthbase [ f ] + ( hd ) % 16 ] .cint ; 
  1773.       if ( s > d ) 
  1774.       d = s ; 
  1775.       p = mem [(long) p ] .hh .v.RH ; 
  1776.     } 
  1777.     if ( p != 0 ) 
  1778.     {
  1779.       switch ( mem [(long) p ] .hh.b0 ) 
  1780.       {case 0 : 
  1781.       case 1 : 
  1782.       case 2 : 
  1783.       case 13 : 
  1784.     {
  1785.       x = x + mem [(long) p + 1 ] .cint ; 
  1786.       if ( mem [(long) p ] .hh.b0 >= 2 ) 
  1787.       s = 0 ; 
  1788.       else s = mem [(long) p + 4 ] .cint ; 
  1789.       if ( mem [(long) p + 3 ] .cint - s > h ) 
  1790.       h = mem [(long) p + 3 ] .cint - s ; 
  1791.       if ( mem [(long) p + 2 ] .cint + s > d ) 
  1792.       d = mem [(long) p + 2 ] .cint + s ; 
  1793.     } 
  1794.     break ; 
  1795.       case 3 : 
  1796.       case 4 : 
  1797.       case 5 : 
  1798.     if ( adjusttail != 0 ) 
  1799.     {
  1800.       while ( mem [(long) q ] .hh .v.RH != p ) q = mem [(long) q ] .hh .v.RH ; 
  1801.       if ( mem [(long) p ] .hh.b0 == 5 ) 
  1802.       {
  1803.         mem [(long) adjusttail ] .hh .v.RH = mem [(long) p + 1 ] .cint ; 
  1804.         while ( mem [(long) adjusttail ] .hh .v.RH != 0 ) adjusttail = mem [(long) 
  1805.         adjusttail ] .hh .v.RH ; 
  1806.         p = mem [(long) p ] .hh .v.RH ; 
  1807.         freenode ( mem [(long) q ] .hh .v.RH , 2 ) ; 
  1808.       } 
  1809.       else { 
  1810.         mem [(long) adjusttail ] .hh .v.RH = p ; 
  1811.         adjusttail = p ; 
  1812.         p = mem [(long) p ] .hh .v.RH ; 
  1813.       } 
  1814.       mem [(long) q ] .hh .v.RH = p ; 
  1815.       p = q ; 
  1816.     } 
  1817.     break ; 
  1818.       case 8 : 
  1819.  
  1820.     break ; 
  1821.       case 10 : 
  1822.     {
  1823.       g = mem [(long) p + 1 ] .hh .v.LH ; 
  1824.       x = x + mem [(long) g + 1 ] .cint ; 
  1825.       o = mem [(long) g ] .hh.b0 ; 
  1826.       totalstretch [ o ] = totalstretch [ o ] + mem [(long) g + 2 ] .cint ; 
  1827.       o = mem [(long) g ] .hh.b1 ; 
  1828.       totalshrink [ o ] = totalshrink [ o ] + mem [(long) g + 3 ] .cint ; 
  1829.       if ( mem [(long) p ] .hh.b1 >= 100 ) 
  1830.       {
  1831.         g = mem [(long) p + 1 ] .hh .v.RH ; 
  1832.         if ( mem [(long) g + 3 ] .cint > h ) 
  1833.         h = mem [(long) g + 3 ] .cint ; 
  1834.         if ( mem [(long) g + 2 ] .cint > d ) 
  1835.         d = mem [(long) g + 2 ] .cint ; 
  1836.       } 
  1837.     } 
  1838.     break ; 
  1839.       case 11 : 
  1840.       case 9 : 
  1841.     x = x + mem [(long) p + 1 ] .cint ; 
  1842.     break ; 
  1843.       case 6 : 
  1844.     {
  1845.       mem [(long) memtop - 12 ] = mem [(long) p + 1 ] ; 
  1846.       mem [(long) memtop - 12 ] .hh .v.RH = mem [(long) p ] .hh .v.RH ; 
  1847.       p = memtop - 12 ; 
  1848.       goto lab21 ; 
  1849.     } 
  1850.     break ; 
  1851.       default : 
  1852.  
  1853.     break ; 
  1854.       } 
  1855.       p = mem [(long) p ] .hh .v.RH ; 
  1856.     } 
  1857.   } 
  1858.   if ( adjusttail != 0 ) 
  1859.   mem [(long) adjusttail ] .hh .v.RH = 0 ; 
  1860.   mem [(long) r + 3 ] .cint = h ; 
  1861.   mem [(long) r + 2 ] .cint = d ; 
  1862.   if ( m == 1 ) 
  1863.   w = x + w ; 
  1864.   mem [(long) r + 1 ] .cint = w ; 
  1865.   x = w - x ; 
  1866.   if ( x == 0 ) 
  1867.   {
  1868.     mem [(long) r + 5 ] .hh.b0 = 0 ; 
  1869.     mem [(long) r + 5 ] .hh.b1 = 0 ; 
  1870.     mem [(long) r + 6 ] .gr = 0.0 ; 
  1871.     goto lab10 ; 
  1872.   } 
  1873.   else if ( x > 0 ) 
  1874.   {
  1875.     if ( totalstretch [ 3 ] != 0 ) 
  1876.     o = 3 ; 
  1877.     else if ( totalstretch [ 2 ] != 0 ) 
  1878.     o = 2 ; 
  1879.     else if ( totalstretch [ 1 ] != 0 ) 
  1880.     o = 1 ; 
  1881.     else o = 0 ; 
  1882.     mem [(long) r + 5 ] .hh.b1 = o ; 
  1883.     mem [(long) r + 5 ] .hh.b0 = 1 ; 
  1884.     if ( totalstretch [ o ] != 0 ) 
  1885.     mem [(long) r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ; 
  1886.     else { 
  1887.       mem [(long) r + 5 ] .hh.b0 = 0 ; 
  1888.       mem [(long) r + 6 ] .gr = 0.0 ; 
  1889.     } 
  1890.     if ( ( eqtb [ 5293 ] .cint < 10000 ) && ( o == 0 ) && ( mem [(long) r + 5 ] .hh 
  1891.     .v.RH != 0 ) ) 
  1892.     {
  1893.       b = badness ( x , totalstretch [ 0 ] ) ; 
  1894.       if ( b > eqtb [ 5293 ] .cint ) 
  1895.       {
  1896.     println () ; 
  1897.     if ( b > 100 ) 
  1898.     printnl ( 697 ) ; 
  1899.     else printnl ( 698 ) ; 
  1900.     print ( 699 ) ; 
  1901.     printint ( b ) ; 
  1902.     goto lab50 ; 
  1903.       } 
  1904.     } 
  1905.     goto lab10 ; 
  1906.   } 
  1907.   else { 
  1908.     if ( totalshrink [ 3 ] != 0 ) 
  1909.     o = 3 ; 
  1910.     else if ( totalshrink [ 2 ] != 0 ) 
  1911.     o = 2 ; 
  1912.     else if ( totalshrink [ 1 ] != 0 ) 
  1913.     o = 1 ; 
  1914.     else o = 0 ; 
  1915.     mem [(long) r + 5 ] .hh.b1 = o ; 
  1916.     mem [(long) r + 5 ] .hh.b0 = 2 ; 
  1917.     if ( totalshrink [ o ] != 0 ) 
  1918.     mem [(long) r + 6 ] .gr = ( - x ) / ((double) totalshrink [ o ] ) ; 
  1919.     else { 
  1920.       mem [(long) r + 5 ] .hh.b0 = 0 ; 
  1921.       mem [(long) r + 6 ] .gr = 0.0 ; 
  1922.     } 
  1923.     if ( ( totalshrink [ o ] < - x ) && ( o == 0 ) && ( mem [(long) r + 5 ] .hh 
  1924.     .v.RH != 0 ) ) 
  1925.     {
  1926.       mem [(long) r + 6 ] .gr = 1.0 ; 
  1927.       if ( ( - x - totalshrink [ 0 ] > eqtb [ 5709 ] .cint ) || ( eqtb [ 5293 
  1928.       ] .cint < 100 ) ) 
  1929.       {
  1930.     if ( ( eqtb [ 5717 ] .cint > 0 ) && ( - x - totalshrink [ 0 ] > eqtb [ 
  1931.     5709 ] .cint ) ) 
  1932.     {
  1933.       while ( mem [(long) q ] .hh .v.RH != 0 ) q = mem [(long) q ] .hh .v.RH ; 
  1934.       mem [(long) q ] .hh .v.RH = newrule () ; 
  1935.       mem [(long) mem [(long) q ] .hh .v.RH + 1 ] .cint = eqtb [ 5717 ] .cint ; 
  1936.     } 
  1937.     println () ; 
  1938.     printnl ( 705 ) ; 
  1939.     printscaled ( - x - totalshrink [ 0 ] ) ; 
  1940.     print ( 706 ) ; 
  1941.     goto lab50 ; 
  1942.       } 
  1943.     } 
  1944.     else if ( ( eqtb [ 5293 ] .cint < 100 ) && ( o == 0 ) && ( mem [(long) r + 5 ] 
  1945.     .hh .v.RH != 0 ) ) 
  1946.     {
  1947.       b = badness ( - x , totalshrink [ 0 ] ) ; 
  1948.       if ( b > eqtb [ 5293 ] .cint ) 
  1949.       {
  1950.     println () ; 
  1951.     printnl ( 707 ) ; 
  1952.     printint ( b ) ; 
  1953.     goto lab50 ; 
  1954.       } 
  1955.     } 
  1956.     goto lab10 ; 
  1957.   } 
  1958.   lab50: if ( outputactive ) 
  1959.   print ( 700 ) ; 
  1960.   else { 
  1961.     if ( packbeginlin != 0 ) 
  1962.     {
  1963.       if ( packbeginlin > 0 ) 
  1964.       print ( 701 ) ; 
  1965.       else print ( 702 ) ; 
  1966.       printint ( abs ( packbeginlin ) ) ; 
  1967.       print ( 703 ) ; 
  1968.     } 
  1969.     else print ( 704 ) ; 
  1970.     printint ( line ) ; 
  1971.   } 
  1972.   println () ; 
  1973.   fontinshortd = 0 ; 
  1974.   shortdisplay ( mem [(long) r + 5 ] .hh .v.RH ) ; 
  1975.   println () ; 
  1976.   begindiagnos () ; 
  1977.   showbox ( r ) ; 
  1978.   enddiagnosti ( true ) ; 
  1979.   lab10: Result = r ; 
  1980.   return(Result) ; 
  1981. } 
  1982. halfword zvpackage ( p , h , m , l ) 
  1983. halfword p ; 
  1984. scaled h ; 
  1985. smallnumber m ; 
  1986. scaled l ; 
  1987. {/* 50 10 */ register halfword Result; r_vpackage 
  1988.   halfword r ; 
  1989.   scaled w, d, x ; 
  1990.   scaled s ; 
  1991.   halfword g ; 
  1992.   glueord o ; 
  1993.   integer b ; 
  1994.   r = getnode ( 7 ) ; 
  1995.   mem [(long) r ] .hh.b0 = 1 ; 
  1996.   mem [(long) r ] .hh.b1 = 0 ; 
  1997.   mem [(long) r + 4 ] .cint = 0 ; 
  1998.   mem [(long) r + 5 ] .hh .v.RH = p ; 
  1999.   w = 0 ; 
  2000.   d = 0 ; 
  2001.   x = 0 ; 
  2002.   totalstretch [ 0 ] = 0 ; 
  2003.   totalshrink [ 0 ] = 0 ; 
  2004.   totalstretch [ 1 ] = 0 ; 
  2005.   totalshrink [ 1 ] = 0 ; 
  2006.   totalstretch [ 2 ] = 0 ; 
  2007.   totalshrink [ 2 ] = 0 ; 
  2008.   totalstretch [ 3 ] = 0 ; 
  2009.   totalshrink [ 3 ] = 0 ; 
  2010.   while ( p != 0 ) { 
  2011.     if ( ( p >= himemmin ) ) 
  2012.     confusion ( 708 ) ; 
  2013.     else switch ( mem [(long) p ] .hh.b0 ) 
  2014.     {case 0 : 
  2015.     case 1 : 
  2016.     case 2 : 
  2017.     case 13 : 
  2018.       {
  2019.     x = x + d + mem [(long) p + 3 ] .cint ; 
  2020.     d = mem [(long) p + 2 ] .cint ; 
  2021.     if ( mem [(long) p ] .hh.b0 >= 2 ) 
  2022.     s = 0 ; 
  2023.     else s = mem [(long) p + 4 ] .cint ; 
  2024.     if ( mem [(long) p + 1 ] .cint + s > w ) 
  2025.     w = mem [(long) p + 1 ] .cint + s ; 
  2026.       } 
  2027.       break ; 
  2028.     case 8 : 
  2029.       ; 
  2030.       break ; 
  2031.     case 10 : 
  2032.       {
  2033.     x = x + d ; 
  2034.     d = 0 ; 
  2035.     g = mem [(long) p + 1 ] .hh .v.LH ; 
  2036.     x = x + mem [(long) g + 1 ] .cint ; 
  2037.     o = mem [(long) g ] .hh.b0 ; 
  2038.     totalstretch [ o ] = totalstretch [ o ] + mem [(long) g + 2 ] .cint ; 
  2039.     o = mem [(long) g ] .hh.b1 ; 
  2040.     totalshrink [ o ] = totalshrink [ o ] + mem [(long) g + 3 ] .cint ; 
  2041.     if ( mem [(long) p ] .hh.b1 >= 100 ) 
  2042.     {
  2043.       g = mem [(long) p + 1 ] .hh .v.RH ; 
  2044.       if ( mem [(long) g + 1 ] .cint > w ) 
  2045.       w = mem [(long) g + 1 ] .cint ; 
  2046.     } 
  2047.       } 
  2048.       break ; 
  2049.     case 11 : 
  2050.       {
  2051.     x = x + d + mem [(long) p + 1 ] .cint ; 
  2052.     d = 0 ; 
  2053.       } 
  2054.       break ; 
  2055.     default : 
  2056.       ; 
  2057.       break ; 
  2058.     } 
  2059.     p = mem [(long) p ] .hh .v.RH ; 
  2060.   } 
  2061.   mem [(long) r + 1 ] .cint = w ; 
  2062.   if ( d > l ) 
  2063.   {
  2064.     x = x + d - l ; 
  2065.     mem [(long) r + 2 ] .cint = l ; 
  2066.   } 
  2067.   else mem [(long) r + 2 ] .cint = d ; 
  2068.   if ( m == 1 ) 
  2069.   h = x + h ; 
  2070.   mem [(long) r + 3 ] .cint = h ; 
  2071.   x = h - x ; 
  2072.   if ( x == 0 ) 
  2073.   {
  2074.     mem [(long) r + 5 ] .hh.b0 = 0 ; 
  2075.     mem [(long) r + 5 ] .hh.b1 = 0 ; 
  2076.     mem [(long) r + 6 ] .gr = 0.0 ; 
  2077.     goto lab10 ; 
  2078.   } 
  2079.   else if ( x > 0 ) 
  2080.   {
  2081.     if ( totalstretch [ 3 ] != 0 ) 
  2082.     o = 3 ; 
  2083.     else if ( totalstretch [ 2 ] != 0 ) 
  2084.     o = 2 ; 
  2085.     else if ( totalstretch [ 1 ] != 0 ) 
  2086.     o = 1 ; 
  2087.     else o = 0 ; 
  2088.     mem [(long) r + 5 ] .hh.b1 = o ; 
  2089.     mem [(long) r + 5 ] .hh.b0 = 1 ; 
  2090.     if ( totalstretch [ o ] != 0 ) 
  2091.     mem [(long) r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ; 
  2092.     else { 
  2093.       mem [(long) r + 5 ] .hh.b0 = 0 ; 
  2094.       mem [(long) r + 6 ] .gr = 0.0 ; 
  2095.     } 
  2096.     if ( ( eqtb [ 5294 ] .cint < 10000 ) && ( o == 0 ) && ( mem [(long) r + 5 ] .hh 
  2097.     .v.RH != 0 ) ) 
  2098.     {
  2099.       b = badness ( x , totalstretch [ 0 ] ) ; 
  2100.       if ( b > eqtb [ 5294 ] .cint ) 
  2101.       {
  2102.     println () ; 
  2103.     if ( b > 100 ) 
  2104.     printnl ( 697 ) ; 
  2105.     else printnl ( 698 ) ; 
  2106.     print ( 709 ) ; 
  2107.     printint ( b ) ; 
  2108.     goto lab50 ; 
  2109.       } 
  2110.     } 
  2111.     goto lab10 ; 
  2112.   } 
  2113.   else { 
  2114.     if ( totalshrink [ 3 ] != 0 ) 
  2115.     o = 3 ; 
  2116.     else if ( totalshrink [ 2 ] != 0 ) 
  2117.     o = 2 ; 
  2118.     else if ( totalshrink [ 1 ] != 0 ) 
  2119.     o = 1 ; 
  2120.     else o = 0 ; 
  2121.     mem [(long) r + 5 ] .hh.b1 = o ; 
  2122.     mem [(long) r + 5 ] .hh.b0 = 2 ; 
  2123.     if ( totalshrink [ o ] != 0 ) 
  2124.     mem [(long) r + 6 ] .gr = ( - x ) / ((double) totalshrink [ o ] ) ; 
  2125.     else { 
  2126.       mem [(long) r + 5 ] .hh.b0 = 0 ; 
  2127.       mem [(long) r + 6 ] .gr = 0.0 ; 
  2128.     } 
  2129.     if ( ( totalshrink [ o ] < - x ) && ( o == 0 ) && ( mem [(long) r + 5 ] .hh 
  2130.     .v.RH != 0 ) ) 
  2131.     {
  2132.       mem [(long) r + 6 ] .gr = 1.0 ; 
  2133.       if ( ( - x - totalshrink [ 0 ] > eqtb [ 5710 ] .cint ) || ( eqtb [ 5294 
  2134.       ] .cint < 100 ) ) 
  2135.       {
  2136.     println () ; 
  2137.     printnl ( 710 ) ; 
  2138.     printscaled ( - x - totalshrink [ 0 ] ) ; 
  2139.     print ( 711 ) ; 
  2140.     goto lab50 ; 
  2141.       } 
  2142.     } 
  2143.     else if ( ( eqtb [ 5294 ] .cint < 100 ) && ( o == 0 ) && ( mem [(long) r + 5 ] 
  2144.     .hh .v.RH != 0 ) ) 
  2145.     {
  2146.       b = badness ( - x , totalshrink [ 0 ] ) ; 
  2147.       if ( b > eqtb [ 5294 ] .cint ) 
  2148.       {
  2149.     println () ; 
  2150.     printnl ( 712 ) ; 
  2151.     printint ( b ) ; 
  2152.     goto lab50 ; 
  2153.       } 
  2154.     } 
  2155.     goto lab10 ; 
  2156.   } 
  2157.   lab50: if ( outputactive ) 
  2158.   print ( 700 ) ; 
  2159.   else { 
  2160.     if ( packbeginlin != 0 ) 
  2161.     {
  2162.       print ( 702 ) ; 
  2163.       printint ( abs ( packbeginlin ) ) ; 
  2164.       print ( 703 ) ; 
  2165.     } 
  2166.     else print ( 704 ) ; 
  2167.     printint ( line ) ; 
  2168.     println () ; 
  2169.   } 
  2170.   begindiagnos () ; 
  2171.   showbox ( r ) ; 
  2172.   enddiagnosti ( true ) ; 
  2173.   lab10: Result = r ; 
  2174.   return(Result) ; 
  2175. } 
  2176.