home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / shipout.c < prev    next >
C/C++ Source or Header  |  1993-10-11  |  32KB  |  1,365 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. #define synch_h \
  5.   if( curh != dvih ) { movement(curh-dvih, right1); dvih = curh; }
  6.  
  7. #define synch_v \
  8.   if( curv != dviv ) { movement(curv-dviv, down1); dviv = curv; }
  9.  
  10.  
  11. /* static quarterword c, f; */
  12. static scaled ruleht, ruledp, rulewd;
  13. static scaled dvih, dviv;
  14. static scaled curh, curv;
  15. static internalfontnumber dvif;
  16. static integer curs = -1;
  17.  
  18. static halfword downptr = 0, rightptr = 0;
  19.  
  20. static void movement ( scaled w, eightbits o );
  21. static void prunemovements ( integer l );
  22. static void specialout ( halfword p );
  23. static void writeout ( halfword p );
  24. static void hlistout ( halfword thisbox );
  25. static void vlistout ( halfword thisbox );
  26.  
  27.  
  28. void dviswap ( void )
  29. { dviswap_regmem 
  30.  
  31.   if ( dvilimit == dvibufsize ) {
  32.     writedvi ( 0 , halfbuf - 1 ) ; 
  33.     dvilimit = halfbuf ; 
  34.     dvioffset = dvioffset + dvibufsize ; 
  35.     dviptr = 0 ; 
  36.   } else {
  37.     writedvi ( halfbuf , dvibufsize - 1 ) ; 
  38.     dvilimit = dvibufsize ; 
  39.   } 
  40.   dvigone = dvigone + halfbuf ; 
  41. }
  42.  
  43. void dvifour ( integer x ) 
  44. { dvifour_regmem 
  45.  
  46. #if defined(atarist) || defined(AMIGA)
  47.   /* 68000 rechnet im 2er-Komplement, deshalb nicht notwendig */
  48.   union { char cc[4]; long ll; } xx;
  49.   xx.ll = x;
  50.   dviout ( xx.cc[0] );   dviout ( xx.cc[1] );
  51.   dviout ( xx.cc[2] );   dviout ( xx.cc[3] );
  52. #else
  53.   if ( x >= 0 ) 
  54.     dviout ( x / 16777216L ) ; 
  55.   else {
  56.     x = x + 1073741824L ; 
  57.     x = x + 1073741824L ; 
  58.     dviout ( ( x / 16777216L ) + 128 ) ; 
  59.   } 
  60.   x = x % 16777216L ; 
  61.   dviout ( x / 65536L ) ; 
  62.   x = x % 65536L ; 
  63.   dviout ( x / 256 ) ; 
  64.   dviout ( x % 256 ) ;
  65. #endif
  66. } 
  67.  
  68. void dvipop ( integer l )
  69. { dvipop_regmem 
  70.  
  71.   if ( ( l == dvioffset + dviptr ) && ( dviptr > 0 ) ) 
  72.     decr ( dviptr ) ; 
  73.   else dviout ( pop ) ; 
  74. }
  75.  
  76. void dvifontdef ( internalfontnumber f )
  77. { dvifontdef_regmem 
  78.   register poolpointer k  ; 
  79.  
  80.   dviout ( fntdef1 ) ; 
  81.   dviout ( f - 1 ) ; 
  82.   dviout ( fontcheck(f).b0 ) ; 
  83.   dviout ( fontcheck(f).b1 ) ; 
  84.   dviout ( fontcheck(f).b2 ) ; 
  85.   dviout ( fontcheck(f).b3 ) ; 
  86.   dvifour ( fontsize(f) ) ; 
  87.   dvifour ( fontdsize(f) ) ; 
  88.   dviout ( length ( fontarea(f) ) ) ; 
  89.   dviout ( length ( fontname(f) ) ) ; 
  90.   {register integer for_end; k = strstart [ fontarea(f) ] ; for_end = 
  91.   strstart [ fontarea(f) + 1 ] - 1 ; if ( k <= for_end) do 
  92.     dviout ( strpool [ k ] ) ; 
  93.   while ( k++ < for_end ) ; } 
  94.   {register integer for_end; k = strstart [ fontname(f) ] ; for_end = 
  95.   strstart [ fontname(f) + 1 ] - 1 ; if ( k <= for_end) do 
  96.     dviout ( strpool [ k ] ) ; 
  97.   while ( k++ < for_end ) ; } 
  98. } 
  99.  
  100.   static
  101. void movement ( scaled w, eightbits o )        /* 607. */
  102. { movement_regmem 
  103.   register halfword q;
  104.   register smallnumber mstate  ; 
  105.   register halfword p;
  106.   register integer k  ; 
  107.  
  108.   q = getnode ( movementnodesize );
  109.  
  110.   width ( q ) = w ; 
  111.   location ( q ) = dvioffset + dviptr ; 
  112.   if ( o == down1 ) {
  113.     link ( q ) = downptr ; 
  114.     downptr = q ; 
  115.   } else {
  116.     link ( q ) = rightptr ; 
  117.     rightptr = q ; 
  118.   } 
  119.   p = link ( q ) ; 
  120.   mstate = 0 ; 
  121.   while ( p != 0 ) {
  122.     if ( width ( p ) == w ) 
  123.     switch ( mstate + info ( p ) ) 
  124.     {case 3 : 
  125.     case 4 : 
  126.     case 15 : 
  127.     case 16 : 
  128.       if ( location ( p ) < dvigone ) 
  129.       goto lab45 ; 
  130.       else {
  131.     k = location ( p ) - dvioffset ; 
  132.     if ( k < 0 ) 
  133.     k = k + dvibufsize ; 
  134.     dvibuf [ k ] = dvibuf [ k ] + y1 - down1 ; 
  135.     info ( p ) = 1 ; 
  136.     goto lab40 ; 
  137.       } 
  138.       break ; 
  139.     case 5 : 
  140.     case 9 : 
  141.     case 11 : 
  142.       if ( location ( p ) < dvigone ) 
  143.       goto lab45 ; 
  144.       else {
  145.     k = location ( p ) - dvioffset ; 
  146.     if ( k < 0 ) 
  147.     k = k + dvibufsize ; 
  148.     dvibuf [ k ] = dvibuf [ k ] + z1 - down1 ; 
  149.     info ( p ) = 2 ; 
  150.     goto lab40 ; 
  151.       } 
  152.       break ; 
  153.     case 1 : 
  154.     case 2 : 
  155.     case 8 : 
  156.     case 13 : 
  157.       goto lab40 ; 
  158.       break ; 
  159.     default: 
  160.       break ; 
  161.     } 
  162.     else switch ( mstate + info ( p ) ) 
  163.     {case 1 : 
  164.       mstate = 6 ; 
  165.       break ; 
  166.     case 2 : 
  167.       mstate = 12 ; 
  168.       break ; 
  169.     case 8 : 
  170.     case 13 : 
  171.       goto lab45 ; 
  172.       break ; 
  173.     default: 
  174.       break ; 
  175.     } 
  176.     p = link ( p ) ; 
  177.   } 
  178.  
  179. lab45:
  180.   info ( q ) = 3 ; 
  181.  
  182.   if ( abs ( w ) >= 8388608L ) {
  183.     dviout ( o + 3 ) ; dvifour ( w ) ; 
  184.     return ; 
  185.   }
  186.   if ( abs ( w ) >= 32768L ) {
  187.     dviout ( o + 2 ) ; 
  188.     if ( w < 0 ) 
  189.       w = w + 16777216L ; 
  190.     dviout ( w / 65536L ) ; 
  191.     w = w % 65536L ; 
  192.   } else if ( abs ( w ) >= 128 ) {
  193.     dviout ( o + 1 ) ; 
  194.     if ( w < 0 ) 
  195.       w = w + 65536L ; 
  196.   } else {
  197.     dviout ( o ) ; 
  198.     if ( w < 0 ) 
  199.       w = w + 256 ; 
  200.     goto lab1 ; 
  201.   }
  202.  
  203.   dviout ( w / 256 ) ;
  204. lab1:
  205.   dviout ( w % 256 ) ; 
  206.   return ; 
  207.  
  208. lab40:
  209.   info ( q ) = info ( p ) ; 
  210.   if ( info ( q ) == 1 ) {
  211.     dviout ( o + y0 - down1 ) ; 
  212.     while ( link ( q ) != p ) {
  213.       q = link ( q ) ; 
  214.       switch ( info ( q ) ) 
  215.       {case 3 : 
  216.     info ( q ) = 5 ; 
  217.     break ; 
  218.       case 4 : 
  219.     info ( q ) = 6 ; 
  220.     break ; 
  221.       default: 
  222.     break ; 
  223.       } 
  224.     } 
  225.   } else {
  226.     dviout ( o + z0 - down1 ) ; 
  227.     while ( link ( q ) != p ) {
  228.       q = link ( q ) ; 
  229.       switch ( info ( q ) ) 
  230.       {case 3 : 
  231.     info ( q ) = 4 ; 
  232.     break ; 
  233.       case 5 : 
  234.     info ( q ) = 6 ; 
  235.     break ; 
  236.       default: 
  237.     break ; 
  238.       } 
  239.     } 
  240.   }
  241. }
  242.  
  243. #if 0
  244.   static
  245. void prunemovements ( integer l )    /* 615. */
  246. {/* 30 10 */ prunemovements_regmem 
  247.   register halfword p;
  248.   register halfword drp;    /* br */
  249.  
  250.   drp = downptr;
  251.   while ( drp != 0 ) {
  252.     if ( location ( drp ) < l ) 
  253.       goto lab30;
  254.     p = drp;
  255.     drp = link ( p ) ; 
  256.     freenode ( p , movementnodesize ) ; 
  257.   }
  258. lab30:
  259.   downptr = drp;
  260.   drp = rightptr;
  261.   while ( drp != 0 ) {
  262.     if ( location ( drp ) < l ) {
  263.       rightptr = drp;
  264.       break;    /* while */
  265.     }
  266.     p = drp;
  267.     drp = link ( p );
  268.     freenode ( p , movementnodesize );
  269.   }
  270. }
  271. #else
  272.   static
  273. void prunemovements ( integer l )    /* 615. */
  274. { prunemovements_regmem 
  275.   register halfword p;
  276.  
  277.   while ( downptr != 0 ) {
  278.     if ( location ( downptr ) < l ) 
  279.       goto lab30;
  280.     p = downptr;
  281.     downptr = link ( p ) ; 
  282.     freenode ( p , movementnodesize ) ; 
  283.   }
  284. lab30:
  285.   while ( rightptr != 0 ) {
  286.     if ( location ( rightptr ) < l ) {
  287.     return;
  288.     }
  289.     p = rightptr;
  290.     rightptr = link ( p );
  291.     freenode ( p , movementnodesize );
  292.   }
  293. }
  294. #endif
  295.  
  296.   static
  297. void specialout ( halfword p )
  298. { specialout_regmem 
  299.   register integer oldsetting  ; 
  300.   register poolpointer k  ; 
  301.  
  302.   synch_h;  synch_v;
  303.  
  304.   oldsetting = selector ; 
  305.   selector = newstring ; 
  306.   showtokenlist ( link ( writetokens ( p ) ) , 0 , poolsize - poolptr ) ; 
  307.   selector = oldsetting ; 
  308.   strroom ( 1 ) ; 
  309.   if ( curlength < 256 ) {
  310.     dviout ( xxx1 ) ; 
  311.     dviout ( curlength ) ; 
  312.   } else {
  313.     dviout ( xxx4 ) ; 
  314.     dvifour ( curlength ) ; 
  315.   } 
  316.   {register integer for_end; k = strstart [ strptr ] ; for_end = poolptr - 1 
  317.   ; if ( k <= for_end) do 
  318.     dviout ( strpool [ k ] ) ; 
  319.   while ( k++ < for_end ) ; } 
  320.   poolptr = strstart [ strptr ] ; 
  321. }
  322.  
  323.   static
  324. void writeout ( halfword p )
  325. { writeout_regmem 
  326.   register integer oldsetting  ; 
  327.   register integer oldmode  ; 
  328.   register smallnumber j  ; 
  329.   register halfword q, r  ; 
  330.  
  331.   q = getavail () ; 
  332.   info ( q ) = rightbracetoken + 125 ; 
  333.   r = getavail () ; 
  334.   link ( q ) = r ; 
  335.   info ( r ) = cstokenflag + endwrite ; 
  336.   begintokenlist ( q , inserted ) ; 
  337.   begintokenlist ( writetokens ( p ) , writetext ) ; 
  338.   q = getavail () ; 
  339.   info ( q ) = leftbracetoken + 123 ; 
  340.   begintokenlist ( q , inserted ) ; 
  341.   oldmode = curlist .modefield ; 
  342.   curlist .modefield = 0 ; 
  343.   curcs = writeloc ; 
  344.   q = scantoks ( false , true ) ; 
  345.   gettoken () ; 
  346.   if ( curtok != cstokenflag + endwrite ) {
  347.     print_err("Unbalanced write command");
  348.     zhelp2( STR_H_ONTHISPAGE_WRITE, STR_H_ICANT_HANDLE_THAT );
  349.     error();
  350.     do {
  351.     gettoken () ; 
  352.     } while ( ! ( curtok == cstokenflag + endwrite ) ) ; 
  353.   }
  354.   curlist .modefield = oldmode ; 
  355.   endtokenlist () ; 
  356.   oldsetting = selector ; 
  357.   j = writestream ( p ) ; 
  358.   if ( writeopen [ j ] ) 
  359.     selector = j ; 
  360.   else {
  361.     if ( ( j == 17 ) && ( selector == termandlog ) ) 
  362.       selector = logonly ; 
  363.     c_printnl("");
  364.   }
  365.   tokenshow ( defref ) ; 
  366.   println () ; 
  367.   flushlist ( defref ) ; 
  368.   selector = oldsetting ; 
  369. } 
  370.  
  371. void outwhat ( halfword p )
  372. { outwhat_regmem 
  373.   register smallnumber j  ; 
  374.  
  375.   switch ( subtype ( p ) ) 
  376.   {case opennode : 
  377.   case writenode : 
  378.   case closenode : 
  379.     if ( ! doingleaders ) {
  380.       j = writestream ( p ) ; 
  381.       if ( subtype ( p ) == writenode ) 
  382.     writeout ( p ) ; 
  383.       else {
  384.     if ( writeopen [ j ] ) 
  385.       aclose ( writefile [ j ] ) ; 
  386.     if ( subtype ( p ) == closenode ) 
  387.       writeopen [ j ] = false ; 
  388.     else if ( j < 16 ) {
  389.       curname = openname ( p ) ; 
  390.       curarea = openarea ( p ) ; 
  391.       curext = openext ( p ) ; 
  392.       if ( curext == 335 ) 
  393.         curext = STR_DOT_TEX;
  394.       packfilename ( curname , curarea , curext ) ; 
  395.       while ( ! aopenout ( writefile [ j ] ) )
  396.         promptfilename("output file name", STR_DOT_TEX);
  397.       writeopen [ j ] = true;
  398.     } 
  399.       } 
  400.     } 
  401.     break ; 
  402.   case specialnode : 
  403.     specialout ( p ) ; 
  404.     break ; 
  405.   case languagenode : 
  406.     break ; 
  407.   default: 
  408.     confusion("ext4");
  409.     break ; 
  410.   } 
  411. } 
  412.  
  413.  
  414. #ifdef TEXXET
  415.   static
  416. long_halfword reverse ( halfword this_box, halfword t )
  417. { reverse_regmem
  418.  
  419.   register halfword l, p, q;
  420.   register char g_order;
  421.   register char g_sign;
  422.   register halfword m, n;
  423.  
  424.   g_order = glueorder(this_box);  g_sign = gluesign(this_box);
  425.   l = t;
  426.   p = tempptr;
  427.   m = minhalfword;  n = minhalfword;
  428.  
  429.   while( p != 0 ) {
  430.     /* 1393. Move node p to the new list ... */
  431. reswitch:
  432.     if( ischarnode(p) ) {
  433.       do {
  434.     f = font(p);  c = character(p);
  435.     curh += zcharwidth(f, zcharinfo(f, c));
  436.     q = link(p);  link(p) = l;  l = p;  p = q;
  437.       } while( ischarnode(p) );
  438.     } else {
  439.       /* 1394. Move the non-char_node p to the new list. */
  440.       q = link(p);
  441.       rulewd = width(p);
  442.       switch( ztype(p) ) {
  443.     case hlistnode:  case vlistnode:
  444.     case rulenode:  case kernnode:
  445.       break;
  446.     case gluenode:
  447.       g = glueptr(p); rulewd = width(g);
  448.       if( g_sign != normal ) {
  449.         if( g_sign == stretching ) {
  450.           if( stretchorder(g) == g_order )
  451.         rulewd += round(float(glueset(this_box)) * stretch(g));
  452.         } else {
  453.           if( shrinkorder(g) == g_order )
  454.         rulewd -= round(float(glueset(this_box)) * shrink(g));
  455.         }
  456.       }
  457.       tempptr = leaderptr(p);
  458.       if( tempptr == 0 ) {
  459.         deleteglueref(g);  ztype(p) = kernnode;  width(p) = rulewd;
  460.       } else if( ztype(tempptr) == rulenode ) {
  461.         deleteglueref(g);
  462.         freenode(p, smallnodesize);
  463.         p = tempptr;  width(p) = rulewd;
  464.       }
  465.       break;
  466.  
  467.     case ligaturenode:
  468.       flushnodelist(ligptr(p));
  469.       tempptr = p;
  470.       p = getavail();  mem[p] = mem[ligchar(tempptr)];
  471.       link(p) = q;
  472.       freenode(tempptr, smallnodesize);
  473.       goto reswitch;
  474.  
  475.     case mathnode:
  476.       if( end_LR(p) ) {
  477.         if( n > minhalfword ) {
  478.           decr(n);  decr(subtype(p));  /* change after into before */
  479.         } else {
  480.           if( info(LR_ptr) != subtype(p) )
  481.         confusion("LR");
  482.           pop_LR;
  483.           if( m == minhalfword ) {
  484.         /* 1398. Finish ... */
  485.         if( t == 0 )
  486.           confusion("LR");
  487.         freenode(p, smallnodesize);
  488.         link(t) = q;
  489.         width(t) = rulewd;
  490.         edge_dist(t) = - curh - rulewd;
  491.         goto done;
  492.           }
  493.           decr(m);
  494.           ztype(p) = kernnode;
  495.         }
  496.       } else if( n > minhalfword || LR_dir(p) != cur_dir ) {
  497.         incr(n);  incr(subtype(p));  /* change before into after */ 
  498.       } else {
  499.         push_LR(p);  incr(m);
  500.         ztype(p) = kernnode;
  501.       }
  502.       break;
  503.  
  504.     case R_node:  edge_node:
  505.       confusion("LR");
  506.       break;
  507.     default:
  508.       goto next_p;
  509.       break;
  510.       }
  511.       curh += rulewd;
  512. next_p:
  513.       if( (ztype(p) == kernnode) && ((rulewd == 0) || (l == 0)) )
  514.     freenode(p, smallnodesize);
  515.       else {
  516.         link(p) = l;  l = p;
  517.       }
  518.       p = q;
  519.     }
  520.   }
  521.  
  522.   if( t != 0 || m != minhalfword || n != minhalfword ) {
  523.     confusion("LR");
  524.   }
  525. done:
  526.   return(l);
  527. }
  528. #endif
  529.  
  530.  
  531.   static
  532. void hlistout ( halfword thisbox )
  533. {/* 21 13 14 15 */ hlistout_regmem 
  534.  
  535.   register eightbits *hlist_dvibuf = dvibuf;    /* (br) added this one ... */
  536. #define dvibuf hlist_dvibuf
  537.  
  538.   register scaled baseline  ; 
  539.   register scaled leftedge  ; 
  540. /* register scaled saveh, savev  ; */
  541. /* register halfword thisbox  ; */
  542.   register glueord gorder  ; 
  543.   register integer gsign  ; 
  544.   register halfword p  ; 
  545.   register integer saveloc  ; 
  546.   register halfword leaderbox  ; 
  547.   register scaled leaderwd  ; 
  548. /* register scaled lx  ; */
  549. /* boolean outerdoingleaders  ; */
  550.   register scaled edge  ; 
  551. #ifdef TEXXET
  552.   register halfword prev_p;
  553. #endif
  554.  
  555. /*  thisbox = tempptr ; */
  556.   gorder = glueorder ( thisbox ) ; 
  557.   gsign = gluesign ( thisbox ) ; 
  558.   p = listptr ( thisbox ) ; 
  559.   incr ( curs ) ; 
  560.   if ( curs > 0 ) 
  561.     dviout ( push ) ; 
  562.   if ( curs > maxpush ) 
  563.     maxpush = curs ; 
  564.   saveloc = dvioffset + dviptr ; 
  565.   baseline = curv ;
  566.   leftedge = curh ;
  567. #ifdef TEXXET
  568.   prev_p = thisbox + listoffset;
  569.  
  570.   if( cur_dir == right_to_left ) {
  571.     if( ztype(thisbox) == hlistnode ) {
  572.       /* 1390. Reverse the complete hlist and change this node into a R_node */
  573.       scaled saveh;
  574.  
  575.       saveh = curh;
  576.         tempptr = p;  /* Uebergebe `reverse' `p' */
  577.         p = newkern(0);  link(prev_p) = p;
  578.  
  579.         curh = 0;  link(p) = reverse(thisbox, 0);  width(p) = -curh;
  580.       curh = saveh;
  581.       ztype(thisbox) = R_code;
  582.     }
  583.   }
  584. #endif
  585.  
  586.   while ( p != 0 )
  587.     /* 620. Output node p ... */
  588. lab21:
  589.     if ( ischarnode ( p ) ) {
  590.       synch_h;  synch_v;
  591.  
  592.       { /* 620. Output node |p| ...  !! inner loop !! */
  593.     register quarterword tmp_f, tmp_c;
  594.     register scaled tmp_curh = curh;
  595.  
  596.       do {
  597.     tmp_f = font ( p ) ; 
  598.         tmp_c = character ( p ) ; 
  599.         if ( tmp_f != dvif ) {
  600.       if ( ! fontused(tmp_f) ) {
  601.         dvifontdef ( tmp_f ) ; 
  602.         fontused(tmp_f) = true ; 
  603.       }
  604.       if ( tmp_f <= 64 ) 
  605.         dviout ( tmp_f - 1 + fntnum0 ) ; 
  606.       else {
  607.         dviout ( fnt1 ) ; 
  608.         dviout ( tmp_f - 1 ) ; 
  609.       }
  610.       dvif = tmp_f;
  611.         }
  612. #ifdef MLTEX
  613.     if( tmp_c > fontec(tmp_f) ) {
  614.       p = substitute_char_list(p, tmp_f, tmp_c);
  615.     } else {
  616. #endif
  617.     if ( tmp_c >= 128 )
  618.       dviout ( set1 );
  619.     dviout ( tmp_c );
  620.     tmp_curh += zcharwidth(tmp_f, zcharinfo(tmp_f, tmp_c));
  621.     p = link ( p );
  622. #ifdef MLTEX
  623.         }
  624. #endif
  625.       } while ( ischarnode ( p ) );
  626.  
  627.       curh = tmp_curh;
  628.       }
  629.       dvih = curh ; 
  630.  
  631.     } else {
  632.       /* 622. Output the non-charnode p ... */
  633.  
  634.     switch ( ztype ( p ) ) {
  635.     case hlistnode : 
  636.     case vlistnode : 
  637. #ifdef TEXXET
  638.     case R_node:
  639. #endif
  640.       if ( listptr ( p ) == 0 ) 
  641.     curh += width ( p ) ;
  642.       else {
  643.         scaled saveh, savev;
  644.  
  645.     saveh = dvih ; 
  646.     savev = dviv ; 
  647.     curv = baseline + shiftamount ( p ) ; 
  648.     /* tempptr = p ; */
  649. #ifdef TEXXET
  650.     edge = curh + width(p);
  651.     if( cur_dir == right_to_left )
  652.       curh = edge;
  653. #else
  654.     edge = curh ; 
  655. #endif
  656.     if ( ztype ( p ) == vlistnode ) 
  657.       vlistout ( p ) ; 
  658.     else
  659.       hlistout ( p ) ; 
  660.     dvih = saveh ; 
  661.     dviv = savev ;
  662. #ifdef TEXXET
  663.     curh = edge;
  664. #else
  665.     curh = edge + width ( p ) ; 
  666. #endif
  667.     curv = baseline ; 
  668.       }
  669.       break ; 
  670.     case rulenode : 
  671.       {
  672.     ruleht = height ( p ) ; 
  673.     ruledp = depth ( p ) ; 
  674.     rulewd = width ( p ) ; 
  675.     goto lab14 ; 
  676.       } 
  677.       break ; 
  678.     case whatsitnode : 
  679.       outwhat ( p ) ;
  680.       break ; 
  681.     case gluenode : 
  682.       { { halfword g;
  683.     g = glueptr ( p ) ; 
  684.     rulewd = width ( g ) ; 
  685.     if ( gsign != normal ) {
  686.       if ( gsign == stretching ) {
  687.         if ( stretchorder ( g ) == gorder )
  688.           rulewd += round ( glueset ( thisbox ) * stretch ( g ) ) ;
  689.       } else {
  690.         if ( shrinkorder ( g ) == gorder ) 
  691.           rulewd -= round ( glueset ( thisbox ) * shrink ( g ) ) ;
  692.       }
  693.     }
  694.     }
  695.     if ( subtype ( p ) >= aleaders ) {
  696.       /* 626. ... */
  697.       leaderbox = leaderptr ( p ) ;
  698.       if ( ztype ( leaderbox ) == rulenode ) {
  699.         ruleht = height ( leaderbox ) ;
  700.         ruledp = depth ( leaderbox ) ;
  701.         goto lab14 ; 
  702.       }
  703.       leaderwd = width ( leaderbox ) ; 
  704.       if ( ( leaderwd > 0 ) && ( rulewd > 0 ) ) {
  705.         scaled lx;
  706.         scaled saveh, savev;
  707.         boolean outerdoingleaders;
  708.  
  709.         rulewd += 10 ;
  710. #ifdef TEXXET
  711.         if( cur_dir == right_to_left )
  712.         curh -= 10;
  713. #endif
  714.         edge = curh + rulewd ;
  715.         lx = 0 ; 
  716.         if ( subtype ( p ) == aleaders ) {
  717.           saveh = curh ;
  718.           curh = leftedge + leaderwd * ( ( curh - leftedge ) / leaderwd ) ;
  719.           if ( curh < saveh ) 
  720.         curh += leaderwd ;
  721.         } else {
  722.           integer lq, lr;
  723.  
  724.           lq = rulewd / leaderwd ; 
  725.           lr = rulewd % leaderwd ; 
  726.           if ( subtype ( p ) == cleaders ) 
  727.         curh += ( lr / 2 ) ;
  728.           else {
  729.         lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  730.         curh += ( ( lr - ( lq - 1 ) * lx ) / 2 ) ;
  731.           }
  732.         }
  733.         while ( curh + leaderwd <= edge ) {
  734.           curv = baseline + shiftamount ( leaderbox ) ; 
  735.  
  736.           synch_v;  savev = dviv ; 
  737.           synch_h;  saveh = dvih ; 
  738.  
  739.           /* tempptr = leaderbox ; */
  740. #ifdef TEXXET
  741.           if( cur_dir == right_to_left )
  742.         curh += leaderwd;
  743. #endif
  744.           outerdoingleaders = doingleaders ; 
  745.           doingleaders = true ; 
  746.           if ( ztype ( leaderbox ) == vlistnode ) 
  747.         vlistout ( leaderbox ) ; 
  748.           else
  749.         hlistout ( leaderbox ) ; 
  750.           doingleaders = outerdoingleaders ; 
  751.           dviv = savev ; 
  752.           dvih = saveh ; 
  753. #if 0  /* 3.1415 */
  754.           curv = savev ; 
  755. #else
  756.           curv = baseline ; 
  757. #endif
  758.           curh = saveh + leaderwd + lx ; 
  759.         }
  760. #ifdef TEXXET
  761.         if( cur_dir == right_to_left )
  762.         curh = edge;
  763.         else
  764.         curh = edge - 10;
  765. #else
  766.         curh = edge - 10 ; 
  767. #endif
  768.         goto lab15 ; 
  769.       }
  770.     }
  771.     goto lab13 ; 
  772.       }
  773.       break ; 
  774. #ifdef TEXXET
  775.     case kernnode : 
  776.       curh += width ( p ) ;
  777.       break ; 
  778.     case mathnode : 
  779.       /* 1387. Adjust the LR stack ... */
  780.       if( end_LR(p) ) {
  781.     if( info(LR_ptr) != subtype(p) )
  782.       confusion("LR");
  783.     pop_LR;
  784.     ztype(p) = kernnode;
  785.       } else {
  786.     push_LR(p);
  787.     ztype(p) = kernnode;
  788.     if( LR_dir(p) != cur_dir ) {
  789.       /* 1391. Reverse the hlist segment ... */
  790.       scaled saveh;
  791.  
  792.       saveh = curh;
  793.       tempptr = link(p);  rulewd = width(p);
  794.       freenode(p, smallnodesize);
  795.       cur_dir = reflected;
  796.       p = new_edge(cur_dir, rulewd);
  797.       link(prev_p) = p;
  798.       curh = curh - leftedge + rulewd;
  799.       link(p) = reverse(thisbox, new_edge(reflected, 0));
  800.       edge_dist(p) = curh;
  801.       cur_dir = reflected;
  802.       curh = saveh;
  803.  
  804.       goto lab21 /*reswitch*/;
  805.     }
  806.     ztype(p) = kernnode;
  807.       }
  808.       curh += width ( p ) ;
  809.       break ; 
  810. #else
  811.     case kernnode : 
  812.     case mathnode : 
  813.       curh += width ( p ) ;
  814.       break ; 
  815. #endif
  816.     case ligaturenode : 
  817.       {
  818.     mem [ ligtrick ] = mem [ ligchar ( p ) ] ; 
  819.     link ( ligtrick ) = link ( p ) ; 
  820.     p = ligtrick ;
  821.     goto lab21 ;
  822.       }
  823.       break ; 
  824.     default: 
  825.       break ;
  826.     }
  827.     goto lab15 ;
  828.  
  829. lab14:
  830.     if ( isrunning ( ruleht ) )
  831.       ruleht = height ( thisbox ) ;
  832.     if ( isrunning ( ruledp ) )
  833.       ruledp = depth ( thisbox ) ;
  834.     ruleht += ruledp ;
  835.     if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) {
  836.       synch_h;  curv = baseline + ruledp ;  synch_v;
  837.  
  838.       dviout ( setrule ) ;
  839.       dvifour ( ruleht ) ;
  840.       dvifour ( rulewd ) ;
  841.       curv = baseline ;
  842.       dvih += rulewd ;
  843.     }
  844. lab13:
  845.     curh += rulewd ;
  846. lab15:
  847. #ifdef TEXXET
  848.     prev_p = p;
  849. #endif
  850.     p = link(p);
  851.   }
  852.   prunemovements ( saveloc ) ;
  853.   if ( curs > 0 )
  854.     dvipop ( saveloc ) ;
  855.   decr ( curs ) ;
  856. #undef dvibuf
  857. }
  858.  
  859.  
  860.   static
  861. void vlistout ( halfword thisbox )
  862. {/* 13 14 15 */ vlistout_regmem 
  863.   register scaled leftedge  ; 
  864.   register scaled topedge  ; 
  865. /* register scaled saveh, savev  ; */
  866. /* register halfword thisbox  ; */
  867.   register glueord gorder  ; 
  868.   register integer gsign  ; 
  869.   register halfword p  ; 
  870.   register integer saveloc  ; 
  871.   register halfword leaderbox  ; 
  872.   register scaled leaderht  ; 
  873. /* register scaled lx  ; */
  874. /* boolean outerdoingleaders  ; */
  875.   register scaled edge  ;
  876.  
  877.   /* thisbox = tempptr ; */
  878.   gorder = glueorder ( thisbox ) ; 
  879.   gsign = gluesign ( thisbox ) ; 
  880.   p = listptr ( thisbox ) ; 
  881.   incr ( curs ) ; 
  882.   if ( curs > 0 ) 
  883.     dviout ( push ) ; 
  884.   if ( curs > maxpush ) 
  885.     maxpush = curs ; 
  886.   saveloc = dvioffset + dviptr ; 
  887.   leftedge = curh ; 
  888.   curv = curv - height ( thisbox ) ; 
  889.   topedge = curv ; 
  890.   while ( p != 0 ) {
  891.     if ( ischarnode ( p ) ) 
  892.       confusion("vlistout");
  893.     else {
  894.       switch ( ztype ( p ) ) 
  895.       {case hlistnode : 
  896.       case vlistnode : 
  897. #ifdef TEXXET
  898.       case R_node:
  899. #endif
  900.     if ( listptr ( p ) == 0 ) 
  901.       curv = curv + height ( p ) + depth ( p ) ; 
  902.     else {
  903.       scaled saveh, savev;
  904.  
  905.       curv = curv + height ( p ) ; 
  906.  
  907.       synch_v;
  908.  
  909.       saveh = dvih ; 
  910.       savev = dviv ;
  911. #ifdef TEXXET
  912.       if( cur_dir == right_to_left )
  913.         curh = leftedge - shiftamount(p);
  914.       else
  915.         curh = leftedge + shiftamount(p);
  916. #else
  917.       curh = leftedge + shiftamount(p);
  918. #endif
  919.       /* tempptr = p ; */
  920.       if ( ztype ( p ) == vlistnode ) 
  921.         vlistout ( p ) ; 
  922.       else hlistout ( p ) ; 
  923.       dvih = saveh ; 
  924.       dviv = savev ; 
  925.       curv = savev + depth ( p ) ; 
  926.       curh = leftedge ; 
  927.     }
  928.     break ; 
  929.       case rulenode :
  930.     {
  931.       ruleht = height ( p ) ; 
  932.       /* ruledp = depth ( p ) ; */
  933.       ruleht += depth ( p );
  934.       rulewd = width ( p ) ; 
  935.       goto lab14 ; 
  936.     } 
  937.     break ; 
  938.       case whatsitnode : 
  939.     outwhat ( p ) ; 
  940.     break ; 
  941.       case gluenode : 
  942.     { { halfword g;
  943.  
  944.       g = glueptr ( p ) ; 
  945.       ruleht = width ( g ) ; 
  946.       if ( gsign != normal ) {
  947.         if ( gsign == stretching ) {
  948.           if ( stretchorder ( g ) == gorder ) 
  949.           ruleht = ruleht + round ( glueset ( thisbox ) * stretch ( g ) );
  950.         } else {
  951.           if ( shrinkorder ( g ) == gorder ) 
  952.           ruleht = ruleht - round ( glueset ( thisbox ) * shrink ( g ) ) ; 
  953.         } 
  954.       }
  955.       }
  956.       if ( subtype ( p ) >= aleaders ) {
  957.         leaderbox = leaderptr ( p ) ; 
  958.         if ( ztype ( leaderbox ) == rulenode ) {
  959.           rulewd = width ( leaderbox ) ; 
  960.           /* ruledp = 0 ; */
  961.           goto lab14 ; 
  962.         } 
  963.         leaderht = height ( leaderbox ) + depth ( leaderbox ) ; 
  964.         if ( ( leaderht > 0 ) && ( ruleht > 0 ) ) {
  965.           scaled lx;
  966.           scaled saveh, savev;
  967.           boolean outerdoingleaders;
  968.  
  969.           ruleht = ruleht + 10 ; 
  970.           edge = curv + ruleht ; 
  971.           lx = 0 ; 
  972.           if ( subtype ( p ) == aleaders ) {
  973.         savev = curv ; 
  974.         curv = topedge + leaderht * ( ( curv - topedge ) / leaderht );
  975.         if ( curv < savev ) 
  976.         curv = curv + leaderht ; 
  977.           } else {
  978.         integer lq, lr;
  979.  
  980.         lq = ruleht / leaderht ; 
  981.         lr = ruleht % leaderht ; 
  982.         if ( subtype ( p ) == cleaders ) 
  983.           curv = curv + ( lr / 2 ) ; 
  984.         else {
  985.           lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  986.           curv = curv + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ; 
  987.         } 
  988.           } 
  989.           while ( curv + leaderht <= edge ) {
  990.         curh = leftedge + shiftamount ( leaderbox ) ; 
  991.         synch_h;  saveh = dvih ;
  992.         curv = curv + height ( leaderbox ) ; 
  993.         synch_v;  savev = dviv ; 
  994.         /* tempptr = leaderbox ; */
  995.         outerdoingleaders = doingleaders ; 
  996.         doingleaders = true ; 
  997.         if ( ztype ( leaderbox ) == vlistnode ) 
  998.           vlistout ( leaderbox ) ; 
  999.         else hlistout ( leaderbox ) ; 
  1000.         doingleaders = outerdoingleaders ; 
  1001.         dviv = savev ; 
  1002.         dvih = saveh ; 
  1003. #if 0  /* 3.1415 */
  1004.         curh = saveh ; 
  1005. #else
  1006.         curh = leftedge ; 
  1007. #endif
  1008.         curv = savev - height ( leaderbox ) + leaderht + lx ; 
  1009.           }
  1010.           curv = edge - 10 ; 
  1011.           goto lab15 ; 
  1012.         }
  1013.       } 
  1014.       goto lab13 ; 
  1015.     } 
  1016.     break ; 
  1017.       case kernnode : 
  1018.     curv = curv + width ( p ) ; 
  1019.     break ; 
  1020.       default: 
  1021.     break ; 
  1022.       } 
  1023.       goto lab15 ; 
  1024.  
  1025. lab14:
  1026.       if ( isrunning ( rulewd ) ) 
  1027.     rulewd = width ( thisbox ) ; 
  1028.       /* ruleht = ruleht + ruledp ; */
  1029.       curv = curv + ruleht ; 
  1030.       if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) {
  1031. #ifdef TEXXET
  1032.     if( cur_dir == right_to_left )
  1033.       curh -= rulewd;
  1034. #endif
  1035.  
  1036.     synch_h;  synch_v;
  1037.  
  1038.     dviout ( putrule ) ; 
  1039.     dvifour ( ruleht ) ; 
  1040.     dvifour ( rulewd ) ; 
  1041. #ifdef TEXXET
  1042.     curh = leftedge;
  1043. #endif
  1044.       } 
  1045.       goto lab15 ;
  1046. lab13:
  1047.       curv = curv + ruleht ; 
  1048.     }
  1049. lab15:
  1050.     p = link ( p ) ; 
  1051.   } 
  1052.   prunemovements ( saveloc ) ; 
  1053.   if ( curs > 0 ) 
  1054.     dvipop ( saveloc ) ; 
  1055.   decr ( curs ) ; 
  1056. }
  1057.  
  1058.  
  1059. void shipout ( halfword p )
  1060. {/* 30 */ shipout_regmem 
  1061.   register integer pageloc  ; 
  1062.   register schar j, k  ; 
  1063.   register poolpointer s  ; 
  1064.   register integer oldsetting  ; 
  1065.  
  1066.   if ( tracingoutput > 0 ) {
  1067.     c_printnl("");
  1068.     println();
  1069.     c_print("Completed box being shipped out");
  1070.   } 
  1071.   if ( termoffset > maxprintline - 9 ) 
  1072.     println () ; 
  1073.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  1074.     printchar ( 32 ) ; 
  1075.   printchar ( 91 ) ; 
  1076.   j = 9 ; 
  1077.   while ( ( count ( j ) == 0 ) && ( j > 0 ) ) decr ( j ) ; 
  1078.   {register integer for_end; k = 0 ; for_end = j ; if ( k <= for_end) do 
  1079.     {
  1080.       printint ( count ( k ) ) ; 
  1081.       if ( k < j ) 
  1082.       printchar ( 46 ) ; 
  1083.     } 
  1084.   while ( k++ < for_end ) ; } 
  1085.   flush ( stdout ) ; 
  1086.   if ( tracingoutput > 0 ) {
  1087.     printchar ( 93 ) ; 
  1088. #ifdef MLTEX            /* no char_sub's defined print diag now */
  1089.     if( char_sub_def_max == 0 ) {    /* otherwise wait after shipbox */
  1090. #endif
  1091.       begindiagnostic () ; 
  1092.       showbox ( p ) ; 
  1093.       enddiagnostic ( true ) ;
  1094. #ifdef MLTEX
  1095.     }
  1096. #endif
  1097.   }
  1098.  
  1099. #ifdef TEXXET
  1100.   cur_dir = left_to_right; /* L-text at outer level */
  1101.   LR_ptr = getavail();  info(LR_ptr) = before; /* this will never match */
  1102. #endif
  1103.  
  1104.   if ( ( height ( p ) > maxdimen ) || ( depth ( p ) > maxdimen )
  1105.     || ( height ( p ) + depth ( p ) + voffset > maxdimen )
  1106.     || ( width ( p ) + hoffset > maxdimen ) )
  1107.   {
  1108.     print_err("Huge page cannot be shipped out");
  1109.     zhelp1( STR_H_THE_PAGE_JUST );
  1110.     error();
  1111.     if ( tracingoutput <= 0 ) {
  1112.       begindiagnostic () ; 
  1113.       c_printnl("The following box has been deleted:");
  1114.       showbox ( p ) ; 
  1115.       enddiagnostic ( true ) ; 
  1116.     } 
  1117.     goto lab30 ; 
  1118.   } 
  1119.   if ( height ( p ) + depth ( p ) + voffset > maxv ) 
  1120.     maxv = height ( p ) + depth ( p ) + voffset ; 
  1121.   if ( width ( p ) + hoffset > maxh ) 
  1122.     maxh = width ( p ) + hoffset ; 
  1123.   dvih = 0 ; 
  1124.   dviv = 0 ; 
  1125.   curh = hoffset ; 
  1126.   dvif = nullfont ; 
  1127.   if ( outputfilename == 0 ) {
  1128.     if ( jobname == 0 ) 
  1129.       openlogfile () ; 
  1130.     packjobname ( STR_DOT_DVI );
  1131.     while ( ! bopenout ( dvifile ) )
  1132.       promptfilename("file name for output", STR_DOT_DVI);
  1133.     outputfilename = bmakenamestring ( dvifile ) ; 
  1134.   } 
  1135.   if ( totalpages == 0 ) {
  1136.     dviout ( pre ) ; 
  1137.     dviout ( idbyte ) ; 
  1138.     dvifour ( 25400000L ) ; 
  1139.     dvifour ( 473628672L ) ; 
  1140.     preparemag();
  1141.     dvifour ( mag );
  1142.  
  1143.     oldsetting = selector;
  1144.     selector = newstring;
  1145. #if 1
  1146.     /* Fuer TripTest ist es ohne die Aenderung etwas einfacher, die dvi-files
  1147.      * zu vergleichen.
  1148.      */
  1149.     c_print(" TeX output ");
  1150. #else
  1151.  
  1152. #ifdef atarist
  1153.     c_print(" br-TeX output ");
  1154. #else
  1155. # ifdef AMIGA
  1156.     c_print(" Pas-TeX output ");
  1157. # else
  1158.     c_print(" TeX output ");
  1159. # endif
  1160. #endif
  1161.  
  1162. #endif
  1163.     printint ( zyear );
  1164.     printchar ( 46 ) ; 
  1165.     printtwo ( zmonth ) ; 
  1166.     printchar ( 46 ) ; 
  1167.     printtwo ( zday ) ; 
  1168.     printchar ( 58 ) ; 
  1169.     printtwo ( ztime / 60 ) ; 
  1170.     printtwo ( ztime % 60 ) ; 
  1171.     selector = oldsetting ; 
  1172.  
  1173.     dviout ( curlength ) ; 
  1174.     {register integer for_end; s = strstart [ strptr ] ; for_end = poolptr - 
  1175.     1 ; if ( s <= for_end) do 
  1176.       dviout ( strpool [ s ] ) ; 
  1177.     while ( s++ < for_end ) ; } 
  1178.     poolptr = strstart [ strptr ] ; 
  1179.   } 
  1180.   pageloc = dvioffset + dviptr ; 
  1181.   dviout ( bop ) ; 
  1182.   {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do 
  1183.     dvifour ( count ( k ) ) ; 
  1184.   while ( k++ < for_end ) ; } 
  1185.   dvifour ( lastbop ) ; 
  1186.   lastbop = pageloc ; 
  1187.   curv = height ( p ) + voffset ; 
  1188.   /* tempptr = p ; */
  1189.   if ( ztype ( p ) == vlistnode ) 
  1190.     vlistout ( p ) ; 
  1191.   else
  1192.     hlistout ( p ) ; 
  1193.   dviout ( eop ) ; 
  1194.   incr ( totalpages ) ; 
  1195.   curs = -1 ; 
  1196.  
  1197. lab30:
  1198. #ifdef TEXXET
  1199.   if( info(LR_ptr) != before )
  1200.     confusion("LR");
  1201.  
  1202.   freeavail(LR_ptr);  LR_ptr = 0;
  1203. #endif
  1204.  
  1205. #ifdef MLTEX        /* char_sub's not effected until ship out */
  1206.   if( tracingoutput > 0 && char_sub_def_max > 0 ) {
  1207.     begindiagnostic();
  1208.     showbox( p );
  1209.     enddiagnostic( true ); 
  1210.   }
  1211. #endif
  1212.  
  1213.   if ( tracingoutput <= 0 ) 
  1214.     printchar( 93 );
  1215.   deadcycles = 0;
  1216.   flush ( stdout );
  1217.  
  1218.   /* 639. */
  1219. #ifdef STAT
  1220.   if ( tracingstats > 1 ) {
  1221.     c_printnl("Memory usage before: ");
  1222.     printint( varused );  printchar( 38 );
  1223.     printint( dynused );  printchar( 59 );
  1224.   }
  1225. #endif /* STAT */
  1226.   flushnodelist ( p );
  1227.  
  1228. #ifdef STAT
  1229.   if ( tracingstats > 1 ) {
  1230.     c_print(" after: ");
  1231.     printint( varused );
  1232.     printchar( 38 );
  1233.     printint( dynused );
  1234.     c_print("; still untouched: ");
  1235.     printint( himemmin - lomemmax - 1 );
  1236.     println();
  1237.   }
  1238. #endif /* STAT */
  1239. }
  1240.  
  1241.  
  1242. void closefilesandterminate ( void )
  1243. { closefilesandterminate_regmem 
  1244.   register integer k  ; 
  1245.  
  1246.   for( k = 0 ; k <= 15 ; k++ ) {
  1247.     if ( writeopen [ k ] )
  1248.       aclose ( writefile [ k ] ) ;
  1249.   }
  1250. #ifdef STAT
  1251.   if ( tracingstats > 0 ) 
  1252.   if ( logopened ) {
  1253.     (void) fprintf(logfile, "\n\
  1254. Here is how much of TeX's memory you used:\n\
  1255.  %ld string%s out of %ld\n\
  1256.  %ld string characters out of %ld\n\
  1257.  %ld words of memory out of %ld\n",
  1258.     (long)strptr - initstrptr,
  1259.     (strptr != initstrptr + 1) ? "s" : "",
  1260.     (long)maxstrings - initstrptr,
  1261.  
  1262.     (long)poolptr - initpoolptr,
  1263.     (long)poolsize - initpoolptr,
  1264.  
  1265.     (long)lomemmax - memmin + memend - himemmin + 2,
  1266.     (long)memend + 1 - memmin );
  1267.  
  1268.     (void) fprintf(logfile, "\
  1269.  %ld multiletter control sequences out of %ld\n\
  1270.  %ld words of font info for %ld font%s, out of %ld for %ld\n",
  1271.     (long)cscount,
  1272.     (long)hashsize,
  1273.  
  1274.     (long)fmemptr,
  1275.     (long)fontptr - 0,
  1276.     ( fontptr != 1 ) ? "s" : "",
  1277.     (long)fontmemsize,
  1278.     (long)fontmax - 0 );
  1279.  
  1280.     (void) fprintf(logfile, "\
  1281.  %ld hyphenation exception%s out of %ld\n\
  1282.  %ldi,%ldn,%ldp,%ldb,%lds stack positions out of %ldi,%ldn,%ldp,%ldb,%lds\n",
  1283.     (long)hyphcount,
  1284.     ( hyphcount != 1 ) ? "s" : "",
  1285.     (long)hyphsize,
  1286.  
  1287.     (long)maxinstack, (long)maxneststack, (long)maxparamstack,
  1288.     (long)maxbufstack + 1, (long)maxsavestack + 6,
  1289.     (long)stacksize, (long)nestsize, (long)paramsize,
  1290.     (long)bufsize, (long)savesize );
  1291.   }
  1292.  
  1293. #endif /* STAT */
  1294.   wakeupterminal () ; 
  1295.   while ( curs > -1 ) {
  1296.     if ( curs > 0 ) 
  1297.       dviout ( pop ) ; 
  1298.     else {
  1299.       dviout ( eop ) ; 
  1300.       incr ( totalpages ) ; 
  1301.     } 
  1302.     decr ( curs ) ; 
  1303.   } 
  1304.   if ( totalpages == 0 ) 
  1305.     c_printnl("No pages of output.");
  1306.   else {
  1307.     dviout ( post ) ; 
  1308.     dvifour ( lastbop ) ; 
  1309.     lastbop = dvioffset + dviptr - 5 ; 
  1310.     dvifour ( 25400000L ) ; 
  1311.     dvifour ( 473628672L ) ; 
  1312.     preparemag () ; 
  1313.     dvifour ( mag ) ; 
  1314.     dvifour ( maxv ) ; 
  1315.     dvifour ( maxh ) ; 
  1316.     dviout ( maxpush / 256 ) ; 
  1317.     dviout ( maxpush % 256 ) ;
  1318.     dviout ( (totalpages / 256) % 256 ) ;    /* TeX 3.14 2.update */
  1319.     dviout ( totalpages % 256 ) ; 
  1320.     while ( fontptr > 0 ) {
  1321.       if ( fontused(fontptr) ) 
  1322.     dvifontdef ( fontptr ) ; 
  1323.       decr ( fontptr ) ; 
  1324.     }
  1325.     dviout ( postpost ) ; 
  1326.     dvifour ( lastbop ) ; 
  1327.     dviout ( idbyte ) ; 
  1328.     k = 4 + ( ( dvibufsize - dviptr ) % 4 ) ; 
  1329.     while ( k > 0 ) {
  1330.       dviout ( 223 ) ; 
  1331.       decr ( k ) ; 
  1332.     }
  1333.     if ( dvilimit == halfbuf ) 
  1334.       writedvi ( halfbuf , dvibufsize - 1 ) ; 
  1335.     if ( dviptr > 0 ) 
  1336.       writedvi ( 0 , dviptr - 1 ) ; 
  1337.     c_printnl("Output written on ");
  1338.     slowprint ( outputfilename );  /* TeX 3.141 */
  1339.     c_print(" (");
  1340.     printint ( totalpages );
  1341.     c_print(" page");
  1342.     if ( totalpages != 1 )
  1343.       printchar ( 115 );
  1344.     c_print(", ");
  1345.     printint ( dvioffset + dviptr ) ; 
  1346.     c_print(" bytes).");
  1347.     bclose ( dvifile ) ; 
  1348.   }
  1349.   if ( logopened ) {
  1350.     (void) putc('\n',  logfile );
  1351.     aclose ( logfile ) ; 
  1352.     selector = selector - 2 ; 
  1353.     if ( selector == termonly ) {
  1354.       c_printnl("Transcript written on ");
  1355.       slowprint ( logname ); /* TeX 3.141 */
  1356.       printchar ( 46 );
  1357.     }
  1358.   }
  1359.   println();
  1360.   if ( ( editnamestart != 0 ) && ( interaction > batchmode ) )
  1361.     calledit ( strpool , editnamestart , editnamelength , editline );
  1362. }
  1363.  
  1364. /* -- end -- */
  1365.