home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / texsrc.arc / TEX3.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  44KB  |  2,018 lines
  1. overlay "tex3"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5. scancharnum () { r_scancharnum 
  6.   scanint () ; 
  7.   if ( ( curval < 0 ) || ( curval > 255 ) ) 
  8.   {
  9.     {
  10.       if ( interaction == 3 ) 
  11.       wakeuptermin () ; 
  12.       printnl ( 133 ) ; 
  13.       print ( 543 ) ; 
  14.     } 
  15.     {
  16.       helpptr = 2 ; 
  17.       helpline [ 1 ] = 550 ; 
  18.       helpline [ 0 ] = 545 ; 
  19.     } 
  20.     interror ( curval ) ; 
  21.     curval = 0 ; 
  22.   } 
  23. } 
  24. scanfifteenb () { r_scanfifteenb 
  25.   scanint () ; 
  26.   if ( ( curval < 0 ) || ( curval > 32767 ) ) 
  27.   {
  28.     {
  29.       if ( interaction == 3 ) 
  30.       wakeuptermin () ; 
  31.       printnl ( 133 ) ; 
  32.       print ( 551 ) ; 
  33.     } 
  34.     {
  35.       helpptr = 2 ; 
  36.       helpline [ 1 ] = 552 ; 
  37.       helpline [ 0 ] = 545 ; 
  38.     } 
  39.     interror ( curval ) ; 
  40.     curval = 0 ; 
  41.   } 
  42. } 
  43. scantwentyse () { r_scantwentyse 
  44.   scanint () ; 
  45.   if ( ( curval < 0 ) || ( curval > 134217727 ) ) 
  46.   {
  47.     {
  48.       if ( interaction == 3 ) 
  49.       wakeuptermin () ; 
  50.       printnl ( 133 ) ; 
  51.       print ( 553 ) ; 
  52.     } 
  53.     {
  54.       helpptr = 2 ; 
  55.       helpline [ 1 ] = 554 ; 
  56.       helpline [ 0 ] = 545 ; 
  57.     } 
  58.     interror ( curval ) ; 
  59.     curval = 0 ; 
  60.   } 
  61. } 
  62. scanfontiden () { r_scanfontiden 
  63.   internalfont f ; 
  64.   halfword m ; 
  65.   do { getxtoken () ; 
  66.   } while ( ! ( curcmd != 10 ) ) ; 
  67.   if ( curcmd == 87 ) 
  68.   f = eqtb [ 4578 ] .hh .v.RH ; 
  69.   else if ( curcmd == 86 ) 
  70.   f = curchr ; 
  71.   else if ( curcmd == 85 ) 
  72.   {
  73.     m = curchr ; 
  74.     scanfourbiti () ; 
  75.     f = eqtb [ m + curval ] .hh .v.RH ; 
  76.   } 
  77.   else { 
  78.     {
  79.       if ( interaction == 3 ) 
  80.       wakeuptermin () ; 
  81.       printnl ( 133 ) ; 
  82.       print ( 670 ) ; 
  83.     } 
  84.     {
  85.       helpptr = 2 ; 
  86.       helpline [ 1 ] = 671 ; 
  87.       helpline [ 0 ] = 672 ; 
  88.     } 
  89.     backerror () ; 
  90.     f = 0 ; 
  91.   } 
  92.   curval = f ; 
  93. } 
  94. zfindfontdime ( writing ) 
  95. boolean writing ; 
  96. {r_findfontdime 
  97.   internalfont f ; 
  98.   integer n ; 
  99.   scanint () ; 
  100.   n = curval ; 
  101.   scanfontiden () ; 
  102.   f = curval ; 
  103.   if ( n <= 0 ) 
  104.   curval = fmemptr ; 
  105.   else { 
  106.     if ( writing && ( n <= 4 ) && ( n >= 2 ) && ( fontglue [ f ] != 0 ) ) 
  107.     {
  108.       deletegluere ( fontglue [ f ] ) ; 
  109.       fontglue [ f ] = 0 ; 
  110.     } 
  111.     if ( n > fontparams [ f ] ) 
  112.     if ( f < fontptr ) 
  113.     curval = fmemptr ; 
  114.     else { 
  115.       do { if ( fmemptr == fontmemsize ) 
  116.     overflow ( 677 , fontmemsize ) ; 
  117.     fontinfo [ fmemptr ] .cint = 0 ; 
  118.     incr ( fmemptr ) ; 
  119.     incr ( fontparams [ f ] ) ; 
  120.       } while ( ! ( n == fontparams [ f ] ) ) ; 
  121.       curval = fmemptr - 1 ; 
  122.     } 
  123.     else curval = n + parambase [ f ] ; 
  124.   } 
  125.   if ( curval == fmemptr ) 
  126.   {
  127.     {
  128.       if ( interaction == 3 ) 
  129.       wakeuptermin () ; 
  130.       printnl ( 133 ) ; 
  131.       print ( 655 ) ; 
  132.     } 
  133.     printesc ( hash [ 3268 + f ] .v.RH ) ; 
  134.     print ( 673 ) ; 
  135.     printint ( fontparams [ f ] ) ; 
  136.     print ( 674 ) ; 
  137.     {
  138.       helpptr = 2 ; 
  139.       helpline [ 1 ] = 675 ; 
  140.       helpline [ 0 ] = 676 ; 
  141.     } 
  142.     error () ; 
  143.   } 
  144. } 
  145. zscansomethin ( level , negative ) 
  146. smallnumber level ; 
  147. boolean negative ; 
  148. {r_scansomethin 
  149.   halfword m ; 
  150.   integer p ; 
  151.   m = curchr ; 
  152.   switch ( curcmd ) 
  153.   {case 84 : 
  154.     {
  155.       scansevenbit () ; 
  156.       if ( m == 5139 ) 
  157.       {
  158.     curval = eqtb [ 5139 + curval ] .hh .v.RH ; 
  159.     curvallevel = 0 ; 
  160.       } 
  161.       else if ( m < 5139 ) 
  162.       {
  163.     curval = eqtb [ m + curval ] .hh .v.RH ; 
  164.     curvallevel = 0 ; 
  165.       } 
  166.       else { 
  167.     curval = eqtb [ m + curval ] .cint ; 
  168.     curvallevel = 0 ; 
  169.       } 
  170.     } 
  171.     break ; 
  172.   case 70 : 
  173.   case 71 : 
  174.   case 85 : 
  175.   case 86 : 
  176.   case 87 : 
  177.     if ( level != 5 ) 
  178.     {
  179.       {
  180.     if ( interaction == 3 ) 
  181.     wakeuptermin () ; 
  182.     printnl ( 133 ) ; 
  183.     print ( 522 ) ; 
  184.       } 
  185.       {
  186.     helpptr = 3 ; 
  187.     helpline [ 2 ] = 523 ; 
  188.     helpline [ 1 ] = 524 ; 
  189.     helpline [ 0 ] = 525 ; 
  190.       } 
  191.       backerror () ; 
  192.       {
  193.     curval = 0 ; 
  194.     curvallevel = 1 ; 
  195.       } 
  196.     } 
  197.     else if ( curcmd <= 71 ) 
  198.     {
  199.       if ( curcmd < 71 ) 
  200.       {
  201.     scaneightbit () ; 
  202.     m = 4066 + curval ; 
  203.       } 
  204.       {
  205.     curval = eqtb [ m ] .hh .v.RH ; 
  206.     curvallevel = 5 ; 
  207.       } 
  208.     } 
  209.     else { 
  210.       backinput () ; 
  211.       scanfontiden () ; 
  212.       {
  213.     curval = 3268 + curval ; 
  214.     curvallevel = 4 ; 
  215.       } 
  216.     } 
  217.     break ; 
  218.   case 72 : 
  219.     {
  220.       curval = eqtb [ m ] .cint ; 
  221.       curvallevel = 0 ; 
  222.     } 
  223.     break ; 
  224.   case 73 : 
  225.     {
  226.       curval = eqtb [ m ] .cint ; 
  227.       curvallevel = 1 ; 
  228.     } 
  229.     break ; 
  230.   case 74 : 
  231.     {
  232.       curval = eqtb [ m ] .hh .v.RH ; 
  233.       curvallevel = 2 ; 
  234.     } 
  235.     break ; 
  236.   case 75 : 
  237.     {
  238.       curval = eqtb [ m ] .hh .v.RH ; 
  239.       curvallevel = 3 ; 
  240.     } 
  241.     break ; 
  242.   case 78 : 
  243.     if ( abs ( curlist .modefield ) != m ) 
  244.     {
  245.       {
  246.     if ( interaction == 3 ) 
  247.     wakeuptermin () ; 
  248.     printnl ( 133 ) ; 
  249.     print ( 536 ) ; 
  250.       } 
  251.       printcmdchr ( 78 , m ) ; 
  252.       {
  253.     helpptr = 4 ; 
  254.     helpline [ 3 ] = 537 ; 
  255.     helpline [ 2 ] = 538 ; 
  256.     helpline [ 1 ] = 539 ; 
  257.     helpline [ 0 ] = 540 ; 
  258.       } 
  259.       error () ; 
  260.       if ( level != 5 ) 
  261.       {
  262.     curval = 0 ; 
  263.     curvallevel = 1 ; 
  264.       } 
  265.       else { 
  266.     curval = 0 ; 
  267.     curvallevel = 0 ; 
  268.       } 
  269.     } 
  270.     else { 
  271.       curval = curlist .auxfield ; 
  272.       if ( m == 1 ) 
  273.       curvallevel = 1 ; 
  274.       else curvallevel = 0 ; 
  275.     } 
  276.     break ; 
  277.   case 79 : 
  278.     {
  279.       nest [ nestptr ] = curlist ; 
  280.       p = nestptr ; 
  281.       while ( abs ( nest [ p ] .modefield ) != 1 ) decr ( p ) ; 
  282.       {
  283.     curval = nest [ p ] .pgfield ; 
  284.     curvallevel = 0 ; 
  285.       } 
  286.     } 
  287.     break ; 
  288.   case 81 : 
  289.     {
  290.       if ( m == 0 ) 
  291.       curval = deadcycles ; 
  292.       else curval = insertpenalt ; 
  293.       curvallevel = 0 ; 
  294.     } 
  295.     break ; 
  296.   case 80 : 
  297.     {
  298.       if ( pagecontents == 0 ) 
  299.       if ( m == 0 ) 
  300.       curval = 1073741823 ; 
  301.       else curval = 0 ; 
  302.       else curval = pagesofar [ m ] ; 
  303.       curvallevel = 1 ; 
  304.     } 
  305.     break ; 
  306.   case 83 : 
  307.     {
  308.       if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  309.       curval = 0 ; 
  310.       else curval = mem [(long) eqtb [ 4056 ] .hh .v.RH ] .hh .v.LH ; 
  311.       curvallevel = 0 ; 
  312.     } 
  313.     break ; 
  314.   case 82 : 
  315.     {
  316.       scaneightbit () ; 
  317.       if ( eqtb [ 4322 + curval ] .hh .v.RH == 0 ) 
  318.       curval = 0 ; 
  319.       else curval = mem [(long) eqtb [ 4322 + curval ] .hh .v.RH + m ] .cint ; 
  320.       curvallevel = 1 ; 
  321.     } 
  322.     break ; 
  323.   case 67 : 
  324.   case 68 : 
  325.     {
  326.       curval = curchr ; 
  327.       curvallevel = 0 ; 
  328.     } 
  329.     break ; 
  330.   case 76 : 
  331.     {
  332.       findfontdime ( false ) ; 
  333.       fontinfo [ fmemptr ] .cint = 0 ; 
  334.       {
  335.     curval = fontinfo [ curval ] .cint ; 
  336.     curvallevel = 1 ; 
  337.       } 
  338.     } 
  339.     break ; 
  340.   case 77 : 
  341.     {
  342.       scanfontiden () ; 
  343.       if ( m == 0 ) 
  344.       {
  345.     curval = hyphenchar [ curval ] ; 
  346.     curvallevel = 0 ; 
  347.       } 
  348.       else { 
  349.     curval = skewchar [ curval ] ; 
  350.     curvallevel = 0 ; 
  351.       } 
  352.     } 
  353.     break ; 
  354.   case 88 : 
  355.     {
  356.       scaneightbit () ; 
  357.       switch ( m ) 
  358.       {case 0 : 
  359.     curval = eqtb [ 5317 + curval ] .cint ; 
  360.     break ; 
  361.       case 1 : 
  362.     curval = eqtb [ 5721 + curval ] .cint ; 
  363.     break ; 
  364.       case 2 : 
  365.     curval = eqtb [ 3544 + curval ] .hh .v.RH ; 
  366.     break ; 
  367.       case 3 : 
  368.     curval = eqtb [ 3800 + curval ] .hh .v.RH ; 
  369.     break ; 
  370.       } 
  371.       curvallevel = m ; 
  372.     } 
  373.     break ; 
  374.   case 69 : 
  375.     {
  376.       if ( curchr == 2 ) 
  377.       curval = 0 ; 
  378.       else curval = 0 ; 
  379.       curvallevel = curchr ; 
  380.       if ( ! ( curlist .tailfield >= himemmin ) && ( curlist .modefield != 0 ) 
  381.       ) 
  382.       switch ( curchr ) 
  383.       {case 0 : 
  384.     if ( mem [(long) curlist .tailfield ] .hh.b0 == 12 ) 
  385.     curval = mem [(long) curlist .tailfield + 1 ] .cint ; 
  386.     break ; 
  387.       case 1 : 
  388.     if ( mem [(long) curlist .tailfield ] .hh.b0 == 11 ) 
  389.     curval = mem [(long) curlist .tailfield + 1 ] .cint ; 
  390.     break ; 
  391.       case 2 : 
  392.     if ( mem [(long) curlist .tailfield ] .hh.b0 == 10 ) 
  393.     {
  394.       curval = mem [(long) curlist .tailfield + 1 ] .hh .v.LH ; 
  395.       if ( mem [(long) curlist .tailfield ] .hh.b1 == 99 ) 
  396.       curvallevel = 3 ; 
  397.     } 
  398.     break ; 
  399.       } 
  400.       else if ( ( curlist .modefield == 1 ) && ( curlist .tailfield == curlist 
  401.       .headfield ) ) 
  402.       switch ( curchr ) 
  403.       {case 0 : 
  404.     curval = lastpenalty ; 
  405.     break ; 
  406.       case 1 : 
  407.     curval = lastkern ; 
  408.     break ; 
  409.       case 2 : 
  410.     if ( lastglue != 65535L ) 
  411.     curval = lastglue ; 
  412.     break ; 
  413.       } 
  414.     } 
  415.     break ; 
  416.   default : 
  417.     {
  418.       {
  419.     if ( interaction == 3 ) 
  420.     wakeuptermin () ; 
  421.     printnl ( 133 ) ; 
  422.     print ( 541 ) ; 
  423.       } 
  424.       printcmdchr ( curcmd , curchr ) ; 
  425.       print ( 542 ) ; 
  426.       printesc ( 395 ) ; 
  427.       {
  428.     helpptr = 1 ; 
  429.     helpline [ 0 ] = 540 ; 
  430.       } 
  431.       error () ; 
  432.       if ( level != 5 ) 
  433.       {
  434.     curval = 0 ; 
  435.     curvallevel = 1 ; 
  436.       } 
  437.       else { 
  438.     curval = 0 ; 
  439.     curvallevel = 0 ; 
  440.       } 
  441.     } 
  442.     break ; 
  443.   } 
  444.   while ( curvallevel > level ) { 
  445.     if ( curvallevel == 2 ) 
  446.     curval = mem [(long) curval + 1 ] .cint ; 
  447.     else if ( curvallevel == 3 ) 
  448.     muerror () ; 
  449.     decr ( curvallevel ) ; 
  450.   } 
  451.   if ( negative ) 
  452.   if ( curvallevel >= 2 ) 
  453.   {
  454.     curval = newspec ( curval ) ; 
  455.     {
  456.       mem [(long) curval + 1 ] .cint = - mem [(long) curval + 1 ] .cint ; 
  457.       mem [(long) curval + 2 ] .cint = - mem [(long) curval + 2 ] .cint ; 
  458.       mem [(long) curval + 3 ] .cint = - mem [(long) curval + 3 ] .cint ; 
  459.     } 
  460.   } 
  461.   else curval = - curval ; 
  462.   else if ( ( curvallevel >= 2 ) && ( curvallevel <= 3 ) ) 
  463.   incr ( mem [(long) curval ] .hh .v.RH ) ; 
  464. } 
  465. scanint () { /* 30 */ r_scanint 
  466.   boolean negative ; 
  467.   integer m ; 
  468.   smallnumber d ; 
  469.   boolean vacuous ; 
  470.   boolean OKsofar ; 
  471.   radix = 0 ; 
  472.   OKsofar = true ; 
  473.   negative = false ; 
  474.   do { do { getxtoken () ; 
  475.     } while ( ! ( curcmd != 10 ) ) ; 
  476.     if ( curtok == 3117 ) 
  477.     {
  478.       negative = ! negative ; 
  479.       curtok = 3115 ; 
  480.     } 
  481.   } while ( ! ( curtok != 3115 ) ) ; 
  482.   if ( curtok == 3168 ) 
  483.   {
  484.     gettoken () ; 
  485.     if ( curtok < 4096 ) 
  486.     {
  487.       curval = curchr ; 
  488.       if ( curcmd <= 2 ) 
  489.       if ( curcmd == 2 ) 
  490.       incr ( alignstate ) ; 
  491.       else decr ( alignstate ) ; 
  492.     } 
  493.     else if ( curtok < 4225 ) 
  494.     curval = curtok - 4097 ; 
  495.     else curval = curtok - 4225 ; 
  496.     if ( curval > 127 ) 
  497.     {
  498.       {
  499.     if ( interaction == 3 ) 
  500.     wakeuptermin () ; 
  501.     printnl ( 133 ) ; 
  502.     print ( 555 ) ; 
  503.       } 
  504.       {
  505.     helpptr = 2 ; 
  506.     helpline [ 1 ] = 556 ; 
  507.     helpline [ 0 ] = 557 ; 
  508.       } 
  509.       curval = 48 ; 
  510.       backerror () ; 
  511.     } 
  512.     else { 
  513.       getxtoken () ; 
  514.       if ( curcmd != 10 ) 
  515.       backinput () ; 
  516.     } 
  517.   } 
  518.   else if ( ( curcmd >= 67 ) && ( curcmd <= 88 ) ) 
  519.   scansomethin ( 0 , false ) ; 
  520.   else { 
  521.     radix = 10 ; 
  522.     m = 214748364 ; 
  523.     if ( curtok == 3111 ) 
  524.     {
  525.       radix = 8 ; 
  526.       m = 268435456 ; 
  527.       getxtoken () ; 
  528.     } 
  529.     else if ( curtok == 3106 ) 
  530.     {
  531.       radix = 16 ; 
  532.       m = 134217728 ; 
  533.       getxtoken () ; 
  534.     } 
  535.     vacuous = true ; 
  536.     curval = 0 ; 
  537.     while ( true ) { 
  538.       if ( ( curtok < 3120 + radix ) && ( curtok >= 3120 ) && ( curtok <= 3129 
  539.       ) ) 
  540.       d = curtok - 3120 ; 
  541.       else if ( radix == 16 ) 
  542.       if ( ( curtok <= 2886 ) && ( curtok >= 2881 ) ) 
  543.       d = curtok - 2871 ; 
  544.       else if ( ( curtok <= 3142 ) && ( curtok >= 3137 ) ) 
  545.       d = curtok - 3127 ; 
  546.       else goto lab30 ; 
  547.       else goto lab30 ; 
  548.       vacuous = false ; 
  549.       if ( ( curval >= m ) && ( ( curval > m ) || ( d > 7 ) || ( radix != 10 ) 
  550.       ) ) 
  551.       {
  552.     if ( OKsofar ) 
  553.     {
  554.       {
  555.         if ( interaction == 3 ) 
  556.         wakeuptermin () ; 
  557.         printnl ( 133 ) ; 
  558.         print ( 558 ) ; 
  559.       } 
  560.       {
  561.         helpptr = 2 ; 
  562.         helpline [ 1 ] = 559 ; 
  563.         helpline [ 0 ] = 560 ; 
  564.       } 
  565.       error () ; 
  566.       curval = 2147483647 ; 
  567.       OKsofar = false ; 
  568.     } 
  569.       } 
  570.       else curval = curval * radix + d ; 
  571.       getxtoken () ; 
  572.     } 
  573.     lab30: ; 
  574.     if ( vacuous ) 
  575.     {
  576.       {
  577.     if ( interaction == 3 ) 
  578.     wakeuptermin () ; 
  579.     printnl ( 133 ) ; 
  580.     print ( 522 ) ; 
  581.       } 
  582.       {
  583.     helpptr = 3 ; 
  584.     helpline [ 2 ] = 523 ; 
  585.     helpline [ 1 ] = 524 ; 
  586.     helpline [ 0 ] = 525 ; 
  587.       } 
  588.       backerror () ; 
  589.     } 
  590.     else if ( curcmd != 10 ) 
  591.     backinput () ; 
  592.   } 
  593.   if ( negative ) 
  594.   curval = - curval ; 
  595. } 
  596. zscandimen ( mu , inf , shortcut ) 
  597. boolean mu , inf , shortcut ; 
  598. {/* 30 31 32 40 45 88 89 */ r_scandimen 
  599.   boolean negative ; 
  600.   integer f ; 
  601.   integer num, denom ; 
  602.   smallnumber k ; 
  603.   scaled v ; 
  604.   integer savecurval ; 
  605.   f = 0 ; 
  606.   aritherror = false ; 
  607.   curorder = 0 ; 
  608.   negative = false ; 
  609.   if ( ! shortcut ) 
  610.   {
  611.     negative = false ; 
  612.     do { do { getxtoken () ; 
  613.       } while ( ! ( curcmd != 10 ) ) ; 
  614.       if ( curtok == 3117 ) 
  615.       {
  616.     negative = ! negative ; 
  617.     curtok = 3115 ; 
  618.       } 
  619.     } while ( ! ( curtok != 3115 ) ) ; 
  620.     if ( ( curcmd >= 67 ) && ( curcmd <= 88 ) ) 
  621.     if ( mu ) 
  622.     {
  623.       scansomethin ( 3 , false ) ; 
  624.       if ( curvallevel >= 2 ) 
  625.       {
  626.     v = mem [(long) curval + 1 ] .cint ; 
  627.     deletegluere ( curval ) ; 
  628.     curval = v ; 
  629.       } 
  630.       if ( curvallevel == 3 ) 
  631.       goto lab89 ; 
  632.       if ( curvallevel != 0 ) 
  633.       muerror () ; 
  634.     } 
  635.     else { 
  636.       scansomethin ( 1 , false ) ; 
  637.       if ( curvallevel == 1 ) 
  638.       goto lab89 ; 
  639.     } 
  640.     else { 
  641.       backinput () ; 
  642.       if ( curtok == 3116 ) 
  643.       curtok = 3118 ; 
  644.       if ( curtok != 3118 ) 
  645.       scanint () ; 
  646.       else { 
  647.     radix = 10 ; 
  648.     curval = 0 ; 
  649.       } 
  650.       if ( curtok == 3116 ) 
  651.       curtok = 3118 ; 
  652.       if ( ( radix == 10 ) && ( curtok == 3118 ) ) 
  653.       {
  654.     k = 0 ; 
  655.     gettoken () ; 
  656.     while ( true ) { 
  657.       getxtoken () ; 
  658.       if ( ( curtok > 3129 ) || ( curtok < 3120 ) ) 
  659.       goto lab31 ; 
  660.       if ( k < 17 ) 
  661.       {
  662.         dig [ k ] = curtok - 3120 ; 
  663.         incr ( k ) ; 
  664.       } 
  665.     } 
  666.     lab31: f = rounddecimal ( k ) ; 
  667.     if ( curcmd != 10 ) 
  668.     backinput () ; 
  669.       } 
  670.     } 
  671.   } 
  672.   if ( curval < 0 ) 
  673.   {
  674.     negative = ! negative ; 
  675.     curval = - curval ; 
  676.   } 
  677.   if ( inf ) 
  678.   if ( scankeyword ( 180 ) ) 
  679.   {
  680.     curorder = 1 ; 
  681.     while ( scankeyword ( 108 ) ) { 
  682.       if ( curorder == 3 ) 
  683.       {
  684.     {
  685.       if ( interaction == 3 ) 
  686.       wakeuptermin () ; 
  687.       printnl ( 133 ) ; 
  688.       print ( 562 ) ; 
  689.     } 
  690.     print ( 563 ) ; 
  691.     {
  692.       helpptr = 1 ; 
  693.       helpline [ 0 ] = 564 ; 
  694.     } 
  695.     error () ; 
  696.       } 
  697.       else incr ( curorder ) ; 
  698.     } 
  699.     goto lab88 ; 
  700.   } 
  701.   savecurval = curval ; 
  702.   do { getxtoken () ; 
  703.   } while ( ! ( curcmd != 10 ) ) ; 
  704.   if ( ( curcmd < 67 ) || ( curcmd > 88 ) ) 
  705.   backinput () ; 
  706.   else { 
  707.     if ( mu ) 
  708.     {
  709.       scansomethin ( 3 , false ) ; 
  710.       if ( curvallevel >= 2 ) 
  711.       {
  712.     v = mem [(long) curval + 1 ] .cint ; 
  713.     deletegluere ( curval ) ; 
  714.     curval = v ; 
  715.       } 
  716.       if ( curvallevel != 3 ) 
  717.       muerror () ; 
  718.     } 
  719.     else scansomethin ( 1 , false ) ; 
  720.     v = curval ; 
  721.     goto lab40 ; 
  722.   } 
  723.   if ( mu ) 
  724.   goto lab45 ; 
  725.   if ( scankeyword ( 565 ) ) 
  726.   v = ( fontinfo [ 6 + parambase [ eqtb [ 4578 ] .hh .v.RH ] ] .cint ) ; 
  727.   else if ( scankeyword ( 566 ) ) 
  728.   v = ( fontinfo [ 5 + parambase [ eqtb [ 4578 ] .hh .v.RH ] ] .cint ) ; 
  729.   else goto lab45 ; 
  730.   {
  731.     getxtoken () ; 
  732.     if ( curcmd != 10 ) 
  733.     backinput () ; 
  734.   } 
  735.   lab40: curval = nxplusy ( savecurval , v , xnoverd ( v , f , 65536 ) ) ; 
  736.   goto lab89 ; 
  737.   lab45: ; 
  738.   if ( mu ) 
  739.   if ( scankeyword ( 205 ) ) 
  740.   goto lab88 ; 
  741.   else { 
  742.     {
  743.       if ( interaction == 3 ) 
  744.       wakeuptermin () ; 
  745.       printnl ( 133 ) ; 
  746.       print ( 562 ) ; 
  747.     } 
  748.     print ( 567 ) ; 
  749.     {
  750.       helpptr = 4 ; 
  751.       helpline [ 3 ] = 568 ; 
  752.       helpline [ 2 ] = 569 ; 
  753.       helpline [ 1 ] = 570 ; 
  754.       helpline [ 0 ] = 571 ; 
  755.     } 
  756.     error () ; 
  757.     goto lab88 ; 
  758.   } 
  759.   if ( scankeyword ( 561 ) ) 
  760.   {
  761.     preparemag () ; 
  762.     if ( eqtb [ 5284 ] .cint != 1000 ) 
  763.     {
  764.       curval = xnoverd ( curval , 1000 , eqtb [ 5284 ] .cint ) ; 
  765.       f = ( 1000 * f + 65536 * remainder ) / eqtb [ 5284 ] .cint ; 
  766.       curval = curval + ( f / 65536 ) ; 
  767.       f = f % 65536 ; 
  768.     } 
  769.   } 
  770.   if ( scankeyword ( 262 ) ) 
  771.   goto lab88 ; 
  772.   if ( scankeyword ( 572 ) ) 
  773.   {
  774.     num = 7227 ; 
  775.     denom = 100 ; 
  776.   } 
  777.   else if ( scankeyword ( 573 ) ) 
  778.   {
  779.     num = 12 ; 
  780.     denom = 1 ; 
  781.   } 
  782.   else if ( scankeyword ( 574 ) ) 
  783.   {
  784.     num = 7227 ; 
  785.     denom = 254 ; 
  786.   } 
  787.   else if ( scankeyword ( 575 ) ) 
  788.   {
  789.     num = 7227 ; 
  790.     denom = 2540 ; 
  791.   } 
  792.   else if ( scankeyword ( 576 ) ) 
  793.   {
  794.     num = 7227 ; 
  795.     denom = 7200 ; 
  796.   } 
  797.   else if ( scankeyword ( 577 ) ) 
  798.   {
  799.     num = 1238 ; 
  800.     denom = 1157 ; 
  801.   } 
  802.   else if ( scankeyword ( 578 ) ) 
  803.   {
  804.     num = 14856 ; 
  805.     denom = 1157 ; 
  806.   } 
  807.   else if ( scankeyword ( 579 ) ) 
  808.   goto lab30 ; 
  809.   else { 
  810.     {
  811.       if ( interaction == 3 ) 
  812.       wakeuptermin () ; 
  813.       printnl ( 133 ) ; 
  814.       print ( 562 ) ; 
  815.     } 
  816.     print ( 580 ) ; 
  817.     {
  818.       helpptr = 6 ; 
  819.       helpline [ 5 ] = 581 ; 
  820.       helpline [ 4 ] = 582 ; 
  821.       helpline [ 3 ] = 583 ; 
  822.       helpline [ 2 ] = 569 ; 
  823.       helpline [ 1 ] = 570 ; 
  824.       helpline [ 0 ] = 571 ; 
  825.     } 
  826.     error () ; 
  827.     goto lab32 ; 
  828.   } 
  829.   curval = xnoverd ( curval , num , denom ) ; 
  830.   f = ( num * f + 65536 * remainder ) / denom ; 
  831.   curval = curval + ( f / 65536 ) ; 
  832.   f = f % 65536 ; 
  833.   lab32: ; 
  834.   lab88: if ( curval >= 16384 ) 
  835.   aritherror = true ; 
  836.   else curval = curval * 65536 + f ; 
  837.   lab30: ; 
  838.   {
  839.     getxtoken () ; 
  840.     if ( curcmd != 10 ) 
  841.     backinput () ; 
  842.   } 
  843.   lab89: if ( aritherror || ( abs ( curval ) >= 1073741824 ) ) 
  844.   {
  845.     {
  846.       if ( interaction == 3 ) 
  847.       wakeuptermin () ; 
  848.       printnl ( 133 ) ; 
  849.       print ( 584 ) ; 
  850.     } 
  851.     {
  852.       helpptr = 2 ; 
  853.       helpline [ 1 ] = 585 ; 
  854.       helpline [ 0 ] = 586 ; 
  855.     } 
  856.     error () ; 
  857.     curval = 1073741823 ; 
  858.     aritherror = false ; 
  859.   } 
  860.   if ( negative ) 
  861.   curval = - curval ; 
  862. } 
  863. zscanglue ( level ) 
  864. smallnumber level ; 
  865. {/* 10 */ r_scanglue 
  866.   boolean negative ; 
  867.   halfword q ; 
  868.   boolean mu ; 
  869.   mu = ( level == 3 ) ; 
  870.   negative = false ; 
  871.   do { do { getxtoken () ; 
  872.     } while ( ! ( curcmd != 10 ) ) ; 
  873.     if ( curtok == 3117 ) 
  874.     {
  875.       negative = ! negative ; 
  876.       curtok = 3115 ; 
  877.     } 
  878.   } while ( ! ( curtok != 3115 ) ) ; 
  879.   if ( ( curcmd >= 67 ) && ( curcmd <= 88 ) ) 
  880.   {
  881.     scansomethin ( level , negative ) ; 
  882.     if ( curvallevel >= 2 ) 
  883.     {
  884.       if ( curvallevel != level ) 
  885.       muerror () ; 
  886.       return ; 
  887.     } 
  888.     if ( curvallevel == 0 ) 
  889.     scandimen ( mu , false , true ) ; 
  890.     else if ( level == 3 ) 
  891.     muerror () ; 
  892.   } 
  893.   else { 
  894.     backinput () ; 
  895.     scandimen ( mu , false , false ) ; 
  896.     if ( negative ) 
  897.     curval = - curval ; 
  898.   } 
  899.   q = newspec ( 0 ) ; 
  900.   mem [(long) q + 1 ] .cint = curval ; 
  901.   if ( scankeyword ( 587 ) ) 
  902.   {
  903.     scandimen ( mu , true , false ) ; 
  904.     mem [(long) q + 2 ] .cint = curval ; 
  905.     mem [(long) q ] .hh.b0 = curorder ; 
  906.   } 
  907.   if ( scankeyword ( 588 ) ) 
  908.   {
  909.     scandimen ( mu , true , false ) ; 
  910.     mem [(long) q + 3 ] .cint = curval ; 
  911.     mem [(long) q ] .hh.b1 = curorder ; 
  912.   } 
  913.   curval = q ; 
  914. } 
  915. halfword scanrulespec () { /* 21 */ register halfword Result; 
  916.   r_scanrulespec 
  917.   halfword q ; 
  918.   q = newrule () ; 
  919.   if ( curcmd == 35 ) 
  920.   mem [(long) q + 1 ] .cint = 26214 ; 
  921.   else { 
  922.     mem [(long) q + 3 ] .cint = 26214 ; 
  923.     mem [(long) q + 2 ] .cint = 0 ; 
  924.   } 
  925.   lab21: if ( scankeyword ( 589 ) ) 
  926.   {
  927.     scandimen ( false , false , false ) ; 
  928.     mem [(long) q + 1 ] .cint = curval ; 
  929.     goto lab21 ; 
  930.   } 
  931.   if ( scankeyword ( 590 ) ) 
  932.   {
  933.     scandimen ( false , false , false ) ; 
  934.     mem [(long) q + 3 ] .cint = curval ; 
  935.     goto lab21 ; 
  936.   } 
  937.   if ( scankeyword ( 591 ) ) 
  938.   {
  939.     scandimen ( false , false , false ) ; 
  940.     mem [(long) q + 2 ] .cint = curval ; 
  941.     goto lab21 ; 
  942.   } 
  943.   Result = q ; 
  944.   return(Result) ; 
  945. } 
  946. halfword strtoks () { register halfword Result; r_strtoks 
  947.   halfword p ; 
  948.   halfword q ; 
  949.   halfword t ; 
  950.   poolpointer k ; 
  951.   {
  952.     if ( poolptr + 1 > poolsize ) 
  953.     overflow ( 128 , poolsize - initpoolptr ) ; 
  954.   } 
  955.   p = memtop - 3 ; 
  956.   mem [(long) p ] .hh .v.RH = 0 ; 
  957.   k = strstart [ strptr ] ; 
  958.   while ( k < poolptr ) { 
  959.     t = strpool [ k ] ; 
  960.     if ( t == 32 ) 
  961.     t = 2592 ; 
  962.     else t = 3072 + t ; 
  963.     {
  964.       {
  965.     q = avail ; 
  966.     if ( q == 0 ) 
  967.     q = getavail () ; 
  968.     else { 
  969.       avail = mem [(long) q ] .hh .v.RH ; 
  970.       mem [(long) q ] .hh .v.RH = 0 ; 
  971.  
  972. #ifdef STAT
  973.       incr ( dynused ) ; 
  974. #endif /* STAT */
  975.     } 
  976.       } 
  977.       mem [(long) p ] .hh .v.RH = q ; 
  978.       mem [(long) q ] .hh .v.LH = t ; 
  979.       p = q ; 
  980.     } 
  981.     incr ( k ) ; 
  982.   } 
  983.   poolptr = strstart [ strptr ] ; 
  984.   Result = p ; 
  985.   return(Result) ; 
  986. } 
  987. halfword thetoks () { register halfword Result; r_thetoks 
  988.   quarterword oldsetting ; 
  989.   halfword p, q, r ; 
  990.   getxtoken () ; 
  991.   scansomethin ( 5 , false ) ; 
  992.   if ( curvallevel >= 4 ) 
  993.   {
  994.     p = memtop - 3 ; 
  995.     mem [(long) p ] .hh .v.RH = 0 ; 
  996.     if ( curvallevel == 4 ) 
  997.     {
  998.       q = getavail () ; 
  999.       mem [(long) p ] .hh .v.RH = q ; 
  1000.       mem [(long) q ] .hh .v.LH = 4096 + curval ; 
  1001.       p = q ; 
  1002.     } 
  1003.     else if ( curval != 0 ) 
  1004.     {
  1005.       r = mem [(long) curval ] .hh .v.RH ; 
  1006.       while ( r != 0 ) { 
  1007.     {
  1008.       {
  1009.         q = avail ; 
  1010.         if ( q == 0 ) 
  1011.         q = getavail () ; 
  1012.         else { 
  1013.           avail = mem [(long) q ] .hh .v.RH ; 
  1014.           mem [(long) q ] .hh .v.RH = 0 ; 
  1015.  
  1016. #ifdef STAT
  1017.           incr ( dynused ) ; 
  1018. #endif /* STAT */
  1019.         } 
  1020.       } 
  1021.       mem [(long) p ] .hh .v.RH = q ; 
  1022.       mem [(long) q ] .hh .v.LH = mem [(long) r ] .hh .v.LH ; 
  1023.       p = q ; 
  1024.     } 
  1025.     r = mem [(long) r ] .hh .v.RH ; 
  1026.       } 
  1027.     } 
  1028.     Result = p ; 
  1029.   } 
  1030.   else { 
  1031.     oldsetting = selector ; 
  1032.     selector = 21 ; 
  1033.     switch ( curvallevel ) 
  1034.     {case 0 : 
  1035.       printint ( curval ) ; 
  1036.       break ; 
  1037.     case 1 : 
  1038.       {
  1039.     printscaled ( curval ) ; 
  1040.     print ( 262 ) ; 
  1041.       } 
  1042.       break ; 
  1043.     case 2 : 
  1044.       {
  1045.     printspec ( curval , 262 ) ; 
  1046.     deletegluere ( curval ) ; 
  1047.       } 
  1048.       break ; 
  1049.     case 3 : 
  1050.       {
  1051.     printspec ( curval , 205 ) ; 
  1052.     deletegluere ( curval ) ; 
  1053.       } 
  1054.       break ; 
  1055.     } 
  1056.     selector = oldsetting ; 
  1057.     Result = strtoks () ; 
  1058.   } 
  1059.   return(Result) ; 
  1060. } 
  1061. insthetoks () { r_insthetoks 
  1062.   mem [(long) memtop - 12 ] .hh .v.RH = thetoks () ; 
  1063.   begintokenli ( mem [(long) memtop - 3 ] .hh .v.RH , 4 ) ; 
  1064. } 
  1065. convtoks () { r_convtoks 
  1066.   quarterword oldsetting ; 
  1067.   quarterword c ; 
  1068.   smallnumber savescanners ; 
  1069.   c = curchr ; 
  1070.   switch ( c ) 
  1071.   {case 0 : 
  1072.   case 1 : 
  1073.     scanint () ; 
  1074.     break ; 
  1075.   case 2 : 
  1076.   case 3 : 
  1077.     {
  1078.       savescanners = scannerstatu ; 
  1079.       scannerstatu = 0 ; 
  1080.       gettoken () ; 
  1081.       scannerstatu = savescanners ; 
  1082.     } 
  1083.     break ; 
  1084.   case 4 : 
  1085.     scanfontiden () ; 
  1086.     break ; 
  1087.   case 5 : 
  1088.     if ( jobname == 0 ) 
  1089.     openlogfile () ; 
  1090.     break ; 
  1091.   } 
  1092.   oldsetting = selector ; 
  1093.   selector = 21 ; 
  1094.   switch ( c ) 
  1095.   {case 0 : 
  1096.     printint ( curval ) ; 
  1097.     break ; 
  1098.   case 1 : 
  1099.     printromanin ( curval ) ; 
  1100.     break ; 
  1101.   case 2 : 
  1102.     if ( curcs != 0 ) 
  1103.     sprintcs ( curcs ) ; 
  1104.     else printchar ( curchr ) ; 
  1105.     break ; 
  1106.   case 3 : 
  1107.     printmeaning () ; 
  1108.     break ; 
  1109.   case 4 : 
  1110.     {
  1111.       print ( fontname [ curval ] ) ; 
  1112.       if ( fontsize [ curval ] != fontdsize [ curval ] ) 
  1113.       {
  1114.     print ( 598 ) ; 
  1115.     printscaled ( fontsize [ curval ] ) ; 
  1116.     print ( 262 ) ; 
  1117.       } 
  1118.     } 
  1119.     break ; 
  1120.   case 5 : 
  1121.     print ( jobname ) ; 
  1122.     break ; 
  1123.   } 
  1124.   selector = oldsetting ; 
  1125.   mem [(long) memtop - 12 ] .hh .v.RH = strtoks () ; 
  1126.   begintokenli ( mem [(long) memtop - 3 ] .hh .v.RH , 4 ) ; 
  1127. } 
  1128. halfword zscantoks ( macrodef , xpand ) 
  1129. boolean macrodef , xpand ; 
  1130. {/* 40 30 31 32 */ register halfword Result; r_scantoks 
  1131.   halfword t ; 
  1132.   halfword s ; 
  1133.   halfword p ; 
  1134.   halfword q ; 
  1135.   halfword unbalance ; 
  1136.   halfword hashbrace ; 
  1137.   if ( macrodef ) 
  1138.   scannerstatu = 2 ; 
  1139.   else scannerstatu = 5 ; 
  1140.   warningindex = curcs ; 
  1141.   defref = getavail () ; 
  1142.   mem [(long) defref ] .hh .v.LH = 0 ; 
  1143.   p = defref ; 
  1144.   hashbrace = 0 ; 
  1145.   t = 3120 ; 
  1146.   if ( macrodef ) 
  1147.   {
  1148.     while ( true ) { 
  1149.       gettoken () ; 
  1150.       if ( curtok < 768 ) 
  1151.       goto lab31 ; 
  1152.       if ( curcmd == 6 ) 
  1153.       {
  1154.     s = 3328 + curchr ; 
  1155.     gettoken () ; 
  1156.     if ( curcmd == 1 ) 
  1157.     {
  1158.       hashbrace = curtok ; 
  1159.       {
  1160.         q = getavail () ; 
  1161.         mem [(long) p ] .hh .v.RH = q ; 
  1162.         mem [(long) q ] .hh .v.LH = curtok ; 
  1163.         p = q ; 
  1164.       } 
  1165.       {
  1166.         q = getavail () ; 
  1167.         mem [(long) p ] .hh .v.RH = q ; 
  1168.         mem [(long) q ] .hh .v.LH = 3584 ; 
  1169.         p = q ; 
  1170.       } 
  1171.       goto lab30 ; 
  1172.     } 
  1173.     if ( t == 3129 ) 
  1174.     {
  1175.       {
  1176.         if ( interaction == 3 ) 
  1177.         wakeuptermin () ; 
  1178.         printnl ( 133 ) ; 
  1179.         print ( 601 ) ; 
  1180.       } 
  1181.       {
  1182.         helpptr = 1 ; 
  1183.         helpline [ 0 ] = 602 ; 
  1184.       } 
  1185.       error () ; 
  1186.     } 
  1187.     else { 
  1188.       incr ( t ) ; 
  1189.       if ( curtok != t ) 
  1190.       {
  1191.         {
  1192.           if ( interaction == 3 ) 
  1193.           wakeuptermin () ; 
  1194.           printnl ( 133 ) ; 
  1195.           print ( 603 ) ; 
  1196.         } 
  1197.         {
  1198.           helpptr = 2 ; 
  1199.           helpline [ 1 ] = 604 ; 
  1200.           helpline [ 0 ] = 605 ; 
  1201.         } 
  1202.         backerror () ; 
  1203.       } 
  1204.       curtok = s ; 
  1205.     } 
  1206.       } 
  1207.       {
  1208.     q = getavail () ; 
  1209.     mem [(long) p ] .hh .v.RH = q ; 
  1210.     mem [(long) q ] .hh .v.LH = curtok ; 
  1211.     p = q ; 
  1212.       } 
  1213.     } 
  1214.     lab31: { 
  1215.       q = getavail () ; 
  1216.       mem [(long) p ] .hh .v.RH = q ; 
  1217.       mem [(long) q ] .hh .v.LH = 3584 ; 
  1218.       p = q ; 
  1219.     } 
  1220.     if ( curcmd == 2 ) 
  1221.     {
  1222.       {
  1223.     if ( interaction == 3 ) 
  1224.     wakeuptermin () ; 
  1225.     printnl ( 133 ) ; 
  1226.     print ( 515 ) ; 
  1227.       } 
  1228.       incr ( alignstate ) ; 
  1229.       {
  1230.     helpptr = 2 ; 
  1231.     helpline [ 1 ] = 599 ; 
  1232.     helpline [ 0 ] = 600 ; 
  1233.       } 
  1234.       error () ; 
  1235.       goto lab40 ; 
  1236.     } 
  1237.     lab30: ; 
  1238.   } 
  1239.   else scanleftbrac () ; 
  1240.   unbalance = 1 ; 
  1241.   while ( true ) { 
  1242.     if ( xpand ) 
  1243.     {
  1244.       while ( true ) { 
  1245.     getnext () ; 
  1246.     if ( curcmd <= 99 ) 
  1247.     goto lab32 ; 
  1248.     if ( curcmd != 108 ) 
  1249.     expand () ; 
  1250.     else { 
  1251.       q = thetoks () ; 
  1252.       if ( mem [(long) memtop - 3 ] .hh .v.RH != 0 ) 
  1253.       {
  1254.         mem [(long) p ] .hh .v.RH = mem [(long) memtop - 3 ] .hh .v.RH ; 
  1255.         p = q ; 
  1256.       } 
  1257.     } 
  1258.       } 
  1259.       lab32: xtoken () ; 
  1260.     } 
  1261.     else gettoken () ; 
  1262.     if ( curtok < 768 ) 
  1263.     if ( curcmd < 2 ) 
  1264.     incr ( unbalance ) ; 
  1265.     else { 
  1266.       decr ( unbalance ) ; 
  1267.       if ( unbalance == 0 ) 
  1268.       goto lab40 ; 
  1269.     } 
  1270.     else if ( curcmd == 6 ) 
  1271.     if ( macrodef ) 
  1272.     {
  1273.       s = curtok ; 
  1274.       if ( xpand ) 
  1275.       getxtoken () ; 
  1276.       else gettoken () ; 
  1277.       if ( curcmd != 6 ) 
  1278.       if ( ( curtok <= 3120 ) || ( curtok > t ) ) 
  1279.       {
  1280.     {
  1281.       if ( interaction == 3 ) 
  1282.       wakeuptermin () ; 
  1283.       printnl ( 133 ) ; 
  1284.       print ( 606 ) ; 
  1285.     } 
  1286.     sprintcs ( warningindex ) ; 
  1287.     {
  1288.       helpptr = 3 ; 
  1289.       helpline [ 2 ] = 607 ; 
  1290.       helpline [ 1 ] = 608 ; 
  1291.       helpline [ 0 ] = 609 ; 
  1292.     } 
  1293.     backerror () ; 
  1294.     curtok = s ; 
  1295.       } 
  1296.       else curtok = 1232 + curchr ; 
  1297.     } 
  1298.     {
  1299.       q = getavail () ; 
  1300.       mem [(long) p ] .hh .v.RH = q ; 
  1301.       mem [(long) q ] .hh .v.LH = curtok ; 
  1302.       p = q ; 
  1303.     } 
  1304.   } 
  1305.   lab40: scannerstatu = 0 ; 
  1306.   if ( hashbrace != 0 ) 
  1307.   {
  1308.     q = getavail () ; 
  1309.     mem [(long) p ] .hh .v.RH = q ; 
  1310.     mem [(long) q ] .hh .v.LH = hashbrace ; 
  1311.     p = q ; 
  1312.   } 
  1313.   Result = p ; 
  1314.   return(Result) ; 
  1315. } 
  1316. zreadtoks ( n , r ) 
  1317. integer n ; 
  1318. halfword r ; 
  1319. {/* 30 */ r_readtoks 
  1320.   halfword p ; 
  1321.   halfword q ; 
  1322.   integer s ; 
  1323.   smallnumber m ; 
  1324.   scannerstatu = 2 ; 
  1325.   warningindex = r ; 
  1326.   defref = getavail () ; 
  1327.   mem [(long) defref ] .hh .v.LH = 0 ; 
  1328.   p = defref ; 
  1329.   {
  1330.     q = getavail () ; 
  1331.     mem [(long) p ] .hh .v.RH = q ; 
  1332.     mem [(long) q ] .hh .v.LH = 3584 ; 
  1333.     p = q ; 
  1334.   } 
  1335.   if ( ( n < 0 ) || ( n > 15 ) ) 
  1336.   m = 16 ; 
  1337.   else m = n ; 
  1338.   s = alignstate ; 
  1339.   alignstate = 1000000 ; 
  1340.   do { beginfilerea () ; 
  1341.     curinput .namefield = m + 1 ; 
  1342.     if ( readopen [ m ] == 2 ) 
  1343.     if ( interaction > 1 ) 
  1344.     if ( n < 0 ) 
  1345.     {
  1346.       wakeuptermin () ; 
  1347.       print ( 206 ) ; 
  1348.       terminput () ; 
  1349.     } 
  1350.     else { 
  1351.       wakeuptermin () ; 
  1352.       println () ; 
  1353.       sprintcs ( r ) ; 
  1354.       {
  1355.     wakeuptermin () ; 
  1356.     print ( 61 ) ; 
  1357.     terminput () ; 
  1358.       } 
  1359.       n = - 1 ; 
  1360.     } 
  1361.     else fatalerror ( 610 ) ; 
  1362.     else if ( readopen [ m ] == 1 ) 
  1363.     if ( inputln ( readfile [ m ] , false ) ) 
  1364.     readopen [ m ] = 0 ; 
  1365.     else { 
  1366.       aclose ( readfile [ m ] ) ; 
  1367.       readopen [ m ] = 2 ; 
  1368.     } 
  1369.     else { 
  1370.       if ( ! inputln ( readfile [ m ] , true ) ) 
  1371.       {
  1372.     aclose ( readfile [ m ] ) ; 
  1373.     readopen [ m ] = 2 ; 
  1374.     if ( alignstate != 1000000 ) 
  1375.     {
  1376.       runaway () ; 
  1377.       {
  1378.         if ( interaction == 3 ) 
  1379.         wakeuptermin () ; 
  1380.         printnl ( 133 ) ; 
  1381.         print ( 611 ) ; 
  1382.       } 
  1383.       printesc ( 392 ) ; 
  1384.       {
  1385.         helpptr = 1 ; 
  1386.         helpline [ 0 ] = 612 ; 
  1387.       } 
  1388.       alignstate = 1000000 ; 
  1389.       error () ; 
  1390.     } 
  1391.       } 
  1392.     } 
  1393.     curinput .limitfield = last ; 
  1394.     if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  1395.     decr ( curinput .limitfield ) ; 
  1396.     else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  1397.     first = curinput .limitfield + 1 ; 
  1398.     curinput .locfield = curinput .startfield ; 
  1399.     curinput .statefield = 33 ; 
  1400.     while ( true ) { 
  1401.       gettoken () ; 
  1402.       if ( curtok == 0 ) 
  1403.       goto lab30 ; 
  1404.       {
  1405.     q = getavail () ; 
  1406.     mem [(long) p ] .hh .v.RH = q ; 
  1407.     mem [(long) q ] .hh .v.LH = curtok ; 
  1408.     p = q ; 
  1409.       } 
  1410.     } 
  1411.     lab30: endfilereadi () ; 
  1412.   } while ( ! ( alignstate == 1000000 ) ) ; 
  1413.   curval = defref ; 
  1414.   scannerstatu = 0 ; 
  1415.   alignstate = s ; 
  1416. } 
  1417. passtext () { /* 30 */ r_passtext 
  1418.   integer l ; 
  1419.   smallnumber savescanners ; 
  1420.   savescanners = scannerstatu ; 
  1421.   scannerstatu = 1 ; 
  1422.   l = 0 ; 
  1423.   skipline = line ; 
  1424.   while ( true ) { 
  1425.     getnext () ; 
  1426.     if ( curcmd == 105 ) 
  1427.     {
  1428.       if ( l == 0 ) 
  1429.       goto lab30 ; 
  1430.       if ( curchr == 2 ) 
  1431.       decr ( l ) ; 
  1432.     } 
  1433.     else if ( curcmd == 104 ) 
  1434.     incr ( l ) ; 
  1435.   } 
  1436.   lab30: scannerstatu = savescanners ; 
  1437. } 
  1438. zchangeiflimi ( l , p ) 
  1439. smallnumber l ; 
  1440. halfword p ; 
  1441. {/* 10 */ r_changeiflimi 
  1442.   halfword q ; 
  1443.   if ( p == condptr ) 
  1444.   iflimit = l ; 
  1445.   else { 
  1446.     q = condptr ; 
  1447.     while ( true ) { 
  1448.       if ( q == 0 ) 
  1449.       confusion ( 613 ) ; 
  1450.       if ( mem [(long) q ] .hh .v.RH == p ) 
  1451.       {
  1452.     mem [(long) q ] .hh.b0 = l ; 
  1453.     return ; 
  1454.       } 
  1455.       q = mem [(long) q ] .hh .v.RH ; 
  1456.     } 
  1457.   } 
  1458. } 
  1459. conditional () { /* 10 50 */ r_conditional 
  1460.   boolean b ; 
  1461.   quarterword r ; 
  1462.   integer m, n ; 
  1463.   halfword p, q ; 
  1464.   smallnumber savescanners ; 
  1465.   halfword savecondptr ; 
  1466.   smallnumber thisif ; 
  1467.   {
  1468.     p = getnode ( 2 ) ; 
  1469.     mem [(long) p ] .hh .v.RH = condptr ; 
  1470.     mem [(long) p ] .hh.b0 = iflimit ; 
  1471.     mem [(long) p ] .hh.b1 = curif ; 
  1472.     mem [(long) p + 1 ] .cint = ifline ; 
  1473.     condptr = p ; 
  1474.     curif = curchr ; 
  1475.     iflimit = 1 ; 
  1476.     ifline = line ; 
  1477.   } 
  1478.   savecondptr = condptr ; 
  1479.   thisif = curchr ; 
  1480.   switch ( thisif ) 
  1481.   {case 0 : 
  1482.   case 1 : 
  1483.     {
  1484.       {
  1485.     getxtoken () ; 
  1486.     if ( curcmd == 0 ) 
  1487.     if ( curchr == 257 ) 
  1488.     {
  1489.       curcmd = 13 ; 
  1490.       curchr = curtok - 4097 ; 
  1491.     } 
  1492.       } 
  1493.       if ( ( curcmd > 13 ) || ( curchr > 127 ) ) 
  1494.       {
  1495.     m = 0 ; 
  1496.     n = 256 ; 
  1497.       } 
  1498.       else { 
  1499.     m = curcmd ; 
  1500.     n = curchr ; 
  1501.       } 
  1502.       {
  1503.     getxtoken () ; 
  1504.     if ( curcmd == 0 ) 
  1505.     if ( curchr == 257 ) 
  1506.     {
  1507.       curcmd = 13 ; 
  1508.       curchr = curtok - 4097 ; 
  1509.     } 
  1510.       } 
  1511.       if ( ( curcmd > 13 ) || ( curchr > 127 ) ) 
  1512.       {
  1513.     curcmd = 0 ; 
  1514.     curchr = 256 ; 
  1515.       } 
  1516.       if ( thisif == 0 ) 
  1517.       b = ( n == curchr ) ; 
  1518.       else b = ( m == curcmd ) ; 
  1519.     } 
  1520.     break ; 
  1521.   case 2 : 
  1522.   case 3 : 
  1523.     {
  1524.       if ( thisif == 2 ) 
  1525.       scanint () ; 
  1526.       else scandimen ( false , false , false ) ; 
  1527.       n = curval ; 
  1528.       do { getxtoken () ; 
  1529.       } while ( ! ( curcmd != 10 ) ) ; 
  1530.       if ( ( curtok >= 3132 ) && ( curtok <= 3134 ) ) 
  1531.       r = curtok - 3072 ; 
  1532.       else { 
  1533.     {
  1534.       if ( interaction == 3 ) 
  1535.       wakeuptermin () ; 
  1536.       printnl ( 133 ) ; 
  1537.       print ( 637 ) ; 
  1538.     } 
  1539.     printcmdchr ( 104 , thisif ) ; 
  1540.     {
  1541.       helpptr = 1 ; 
  1542.       helpline [ 0 ] = 638 ; 
  1543.     } 
  1544.     backerror () ; 
  1545.     r = 61 ; 
  1546.       } 
  1547.       if ( thisif == 2 ) 
  1548.       scanint () ; 
  1549.       else scandimen ( false , false , false ) ; 
  1550.       switch ( r ) 
  1551.       {case 60 : 
  1552.     b = ( n < curval ) ; 
  1553.     break ; 
  1554.       case 61 : 
  1555.     b = ( n == curval ) ; 
  1556.     break ; 
  1557.       case 62 : 
  1558.     b = ( n > curval ) ; 
  1559.     break ; 
  1560.       } 
  1561.     } 
  1562.     break ; 
  1563.   case 4 : 
  1564.     {
  1565.       scanint () ; 
  1566.       b = odd ( curval ) ; 
  1567.     } 
  1568.     break ; 
  1569.   case 5 : 
  1570.     b = ( abs ( curlist .modefield ) == 1 ) ; 
  1571.     break ; 
  1572.   case 6 : 
  1573.     b = ( abs ( curlist .modefield ) == 101 ) ; 
  1574.     break ; 
  1575.   case 7 : 
  1576.     b = ( abs ( curlist .modefield ) == 201 ) ; 
  1577.     break ; 
  1578.   case 8 : 
  1579.     b = ( curlist .modefield < 0 ) ; 
  1580.     break ; 
  1581.   case 9 : 
  1582.   case 10 : 
  1583.   case 11 : 
  1584.     {
  1585.       scaneightbit () ; 
  1586.       p = eqtb [ 4322 + curval ] .hh .v.RH ; 
  1587.       if ( thisif == 9 ) 
  1588.       b = ( p == 0 ) ; 
  1589.       else if ( p == 0 ) 
  1590.       b = false ; 
  1591.       else if ( thisif == 10 ) 
  1592.       b = ( mem [(long) p ] .hh.b0 == 0 ) ; 
  1593.       else b = ( mem [(long) p ] .hh.b0 == 1 ) ; 
  1594.     } 
  1595.     break ; 
  1596.   case 12 : 
  1597.     {
  1598.       savescanners = scannerstatu ; 
  1599.       scannerstatu = 0 ; 
  1600.       getnext () ; 
  1601.       n = curcs ; 
  1602.       p = curcmd ; 
  1603.       q = curchr ; 
  1604.       getnext () ; 
  1605.       if ( curcmd != p ) 
  1606.       b = false ; 
  1607.       else if ( curcmd < 110 ) 
  1608.       b = ( curchr == q ) ; 
  1609.       else { 
  1610.     p = mem [(long) curchr ] .hh .v.RH ; 
  1611.     q = mem [(long) eqtb [ n ] .hh .v.RH ] .hh .v.RH ; 
  1612.     while ( ( p != 0 ) && ( q != 0 ) ) if ( mem [(long) p ] .hh .v.LH != mem [(long) q 
  1613.     ] .hh .v.LH ) 
  1614.     p = 0 ; 
  1615.     else { 
  1616.       p = mem [(long) p ] .hh .v.RH ; 
  1617.       q = mem [(long) q ] .hh .v.RH ; 
  1618.     } 
  1619.     b = ( ( p == 0 ) && ( q == 0 ) ) ; 
  1620.       } 
  1621.       scannerstatu = savescanners ; 
  1622.     } 
  1623.     break ; 
  1624.   case 13 : 
  1625.     {
  1626.       scanfourbiti () ; 
  1627.       b = ( readopen [ curval ] == 2 ) ; 
  1628.     } 
  1629.     break ; 
  1630.   case 14 : 
  1631.     b = true ; 
  1632.     break ; 
  1633.   case 15 : 
  1634.     b = false ; 
  1635.     break ; 
  1636.   case 16 : 
  1637.     {
  1638.       scanint () ; 
  1639.       n = curval ; 
  1640.       if ( eqtb [ 5303 ] .cint > 1 ) 
  1641.       {
  1642.     begindiagnos () ; 
  1643.     print ( 639 ) ; 
  1644.     printint ( n ) ; 
  1645.     printchar ( 125 ) ; 
  1646.     enddiagnosti ( false ) ; 
  1647.       } 
  1648.       while ( n != 0 ) { 
  1649.     passtext () ; 
  1650.     if ( condptr == savecondptr ) 
  1651.     if ( curchr == 4 ) 
  1652.     decr ( n ) ; 
  1653.     else goto lab50 ; 
  1654.     else if ( curchr == 2 ) 
  1655.     {
  1656.       p = condptr ; 
  1657.       ifline = mem [(long) p + 1 ] .cint ; 
  1658.       curif = mem [(long) p ] .hh.b1 ; 
  1659.       iflimit = mem [(long) p ] .hh.b0 ; 
  1660.       condptr = mem [(long) p ] .hh .v.RH ; 
  1661.       freenode ( p , 2 ) ; 
  1662.     } 
  1663.       } 
  1664.       changeiflimi ( 4 , savecondptr ) ; 
  1665.       return ; 
  1666.     } 
  1667.     break ; 
  1668.   } 
  1669.   if ( eqtb [ 5303 ] .cint > 1 ) 
  1670.   {
  1671.     begindiagnos () ; 
  1672.     if ( b ) 
  1673.     print ( 635 ) ; 
  1674.     else print ( 636 ) ; 
  1675.     enddiagnosti ( false ) ; 
  1676.   } 
  1677.   if ( b ) 
  1678.   {
  1679.     changeiflimi ( 3 , savecondptr ) ; 
  1680.     return ; 
  1681.   } 
  1682.   while ( true ) { 
  1683.     passtext () ; 
  1684.     if ( condptr == savecondptr ) 
  1685.     {
  1686.       if ( curchr != 4 ) 
  1687.       goto lab50 ; 
  1688.       {
  1689.     if ( interaction == 3 ) 
  1690.     wakeuptermin () ; 
  1691.     printnl ( 133 ) ; 
  1692.     print ( 633 ) ; 
  1693.       } 
  1694.       printesc ( 631 ) ; 
  1695.       {
  1696.     helpptr = 1 ; 
  1697.     helpline [ 0 ] = 634 ; 
  1698.       } 
  1699.       error () ; 
  1700.     } 
  1701.     else if ( curchr == 2 ) 
  1702.     {
  1703.       p = condptr ; 
  1704.       ifline = mem [(long) p + 1 ] .cint ; 
  1705.       curif = mem [(long) p ] .hh.b1 ; 
  1706.       iflimit = mem [(long) p ] .hh.b0 ; 
  1707.       condptr = mem [(long) p ] .hh .v.RH ; 
  1708.       freenode ( p , 2 ) ; 
  1709.     } 
  1710.   } 
  1711.   lab50: if ( curchr == 2 ) 
  1712.   {
  1713.     p = condptr ; 
  1714.     ifline = mem [(long) p + 1 ] .cint ; 
  1715.     curif = mem [(long) p ] .hh.b1 ; 
  1716.     iflimit = mem [(long) p ] .hh.b0 ; 
  1717.     condptr = mem [(long) p ] .hh .v.RH ; 
  1718.     freenode ( p , 2 ) ; 
  1719.   } 
  1720.   else iflimit = 2 ; 
  1721. } 
  1722. beginname () { r_beginname 
  1723.   areadelimite = 0 ; 
  1724.   extdelimiter = 0 ; 
  1725. } 
  1726. boolean zmorename ( c ) 
  1727. ASCIIcode c ; 
  1728. {register boolean Result; r_morename 
  1729.   if ( c == 32 ) 
  1730.   Result = false ; 
  1731.   else { 
  1732.     if ( ( c == 47 ) ) 
  1733.     {
  1734.       areadelimite = poolptr ; 
  1735.       extdelimiter = 0 ; 
  1736.     } 
  1737.     else if ( ( c == 46 ) && ( extdelimiter == 0 ) ) 
  1738.     extdelimiter = poolptr ; 
  1739.     {
  1740.       if ( poolptr + 1 > poolsize ) 
  1741.       overflow ( 128 , poolsize - initpoolptr ) ; 
  1742.     } 
  1743.     {
  1744.       strpool [ poolptr ] = c ; 
  1745.       incr ( poolptr ) ; 
  1746.     } 
  1747.     Result = true ; 
  1748.   } 
  1749.   return(Result) ; 
  1750. } 
  1751. endname () { r_endname 
  1752.   if ( strptr + 3 > maxstrings ) 
  1753.   overflow ( 129 , maxstrings - initstrptr ) ; 
  1754.   if ( areadelimite == 0 ) 
  1755.   curarea = 206 ; 
  1756.   else { 
  1757.     curarea = strptr ; 
  1758.     incr ( strptr ) ; 
  1759.     strstart [ strptr ] = areadelimite + 1 ; 
  1760.   } 
  1761.   if ( extdelimiter == 0 ) 
  1762.   {
  1763.     curext = 206 ; 
  1764.     curname = makestring () ; 
  1765.   } 
  1766.   else { 
  1767.     curname = strptr ; 
  1768.     incr ( strptr ) ; 
  1769.     strstart [ strptr ] = extdelimiter ; 
  1770.     curext = makestring () ; 
  1771.   } 
  1772. } 
  1773. zpackfilename ( n , a , e ) 
  1774. strnumber n , a , e ; 
  1775. {r_packfilename 
  1776.   integer k ; 
  1777.   ASCIIcode c ; 
  1778.   poolpointer j ; 
  1779.   k = 0 ; 
  1780.   for ( j = strstart [ a ] ; j <= strstart [ a + 1 ] - 1 ; j ++ ) 
  1781.   {
  1782.     c = strpool [ j ] ; 
  1783.     incr ( k ) ; 
  1784.     if ( k <= filenamesize ) 
  1785.     nameoffile [ k ] = xchr [ c ] ; 
  1786.   } 
  1787.   for ( j = strstart [ n ] ; j <= strstart [ n + 1 ] - 1 ; j ++ ) 
  1788.   {
  1789.     c = strpool [ j ] ; 
  1790.     incr ( k ) ; 
  1791.     if ( k <= filenamesize ) 
  1792.     nameoffile [ k ] = xchr [ c ] ; 
  1793.   } 
  1794.   for ( j = strstart [ e ] ; j <= strstart [ e + 1 ] - 1 ; j ++ ) 
  1795.   {
  1796.     c = strpool [ j ] ; 
  1797.     incr ( k ) ; 
  1798.     if ( k <= filenamesize ) 
  1799.     nameoffile [ k ] = xchr [ c ] ; 
  1800.   } 
  1801.   if ( k <= filenamesize ) 
  1802.   namelength = k ; 
  1803.   else namelength = filenamesize ; 
  1804.   for ( k = namelength + 1 ; k <= filenamesize ; k ++ ) 
  1805.   nameoffile [ k ] = ' ' ; 
  1806. } 
  1807. zpackbuffered ( n , a , b ) 
  1808. smallnumber n ; 
  1809. integer a , b ; 
  1810. {r_packbuffered 
  1811.   integer k ; 
  1812.   ASCIIcode c ; 
  1813.   integer j ; 
  1814.   if ( n + b - a + 5 > filenamesize ) 
  1815.   b = a + filenamesize - n - 5 ; 
  1816.   k = 0 ; 
  1817.   for ( j = 1 ; j <= n ; j ++ ) 
  1818.   {
  1819.     c = xord [ TEXformatdef [ j ] ] ; 
  1820.     incr ( k ) ; 
  1821.     if ( k <= filenamesize ) 
  1822.     nameoffile [ k ] = xchr [ c ] ; 
  1823.   } 
  1824.   for ( j = a ; j <= b ; j ++ ) 
  1825.   {
  1826.     c = buffer [ j ] ; 
  1827.     incr ( k ) ; 
  1828.     if ( k <= filenamesize ) 
  1829.     nameoffile [ k ] = xchr [ c ] ; 
  1830.   } 
  1831.   for ( j = 6 ; j <= 9 ; j ++ ) 
  1832.   {
  1833.     c = xord [ TEXformatdef [ j ] ] ; 
  1834.     incr ( k ) ; 
  1835.     if ( k <= filenamesize ) 
  1836.     nameoffile [ k ] = xchr [ c ] ; 
  1837.   } 
  1838.   if ( k <= filenamesize ) 
  1839.   namelength = k ; 
  1840.   else namelength = filenamesize ; 
  1841.   for ( k = namelength + 1 ; k <= filenamesize ; k ++ ) 
  1842.   nameoffile [ k ] = ' ' ; 
  1843. } 
  1844. strnumber makenamestri () { register strnumber Result; r_makenamestri 
  1845.   integer k, kstart ; 
  1846.   k = 1 ; 
  1847.   while ( ( k < filenamesize ) && ( xord [ realnameoffi [ k ] ] != 32 ) ) incr 
  1848.   ( k ) ; 
  1849.   namelength = k - 1 ; 
  1850.   {
  1851.     if ( poolptr + namelength > poolsize ) 
  1852.     overflow ( 128 , poolsize - initpoolptr ) ; 
  1853.   } 
  1854.   if ( ( xord [ realnameoffi [ 1 ] ] == 46 ) && ( xord [ realnameoffi [ 2 ] ] 
  1855.   == 47 ) ) 
  1856.   kstart = 3 ; 
  1857.   else kstart = 1 ; 
  1858.   for ( k = kstart ; k <= namelength ; k ++ ) 
  1859.   {
  1860.     strpool [ poolptr ] = xord [ realnameoffi [ k ] ] ; 
  1861.     incr ( poolptr ) ; 
  1862.   } 
  1863.   Result = makestring () ; 
  1864.   return(Result) ; 
  1865. } 
  1866. strnumber zamakenamestr ( f ) 
  1867. alphafile f ; 
  1868. {register strnumber Result; r_amakenamestr 
  1869.   Result = makenamestri () ; 
  1870.   return(Result) ; 
  1871. } 
  1872. strnumber zbmakenamestr ( f ) 
  1873. bytefile f ; 
  1874. {register strnumber Result; r_bmakenamestr 
  1875.   Result = makenamestri () ; 
  1876.   return(Result) ; 
  1877. } 
  1878.  
  1879. #ifdef INITEX
  1880. strnumber zwmakenamestr ( f ) 
  1881. wordfile f ; 
  1882. {register strnumber Result; r_wmakenamestr 
  1883.   Result = makenamestri () ; 
  1884.   return(Result) ; 
  1885. } 
  1886. #endif /* INITEX */
  1887. scanfilename () { /* 30 */ r_scanfilename 
  1888.   nameinprogre = true ; 
  1889.   beginname () ; 
  1890.   do { getxtoken () ; 
  1891.   } while ( ! ( curcmd != 10 ) ) ; 
  1892.   while ( true ) { 
  1893.     if ( ( curcmd > 12 ) || ( curchr > 127 ) ) 
  1894.     {
  1895.       backinput () ; 
  1896.       goto lab30 ; 
  1897.     } 
  1898.     if ( ! morename ( curchr ) ) 
  1899.     goto lab30 ; 
  1900.     getxtoken () ; 
  1901.   } 
  1902.   lab30: endname () ; 
  1903.   nameinprogre = false ; 
  1904. } 
  1905. zpackjobname ( s ) 
  1906. strnumber s ; 
  1907. {r_packjobname 
  1908.   curarea = 206 ; 
  1909.   curext = s ; 
  1910.   curname = jobname ; 
  1911.   packfilename ( curname , curarea , curext ) ; 
  1912. } 
  1913. zpromptfilena ( s , e ) 
  1914. strnumber s , e ; 
  1915. {/* 30 */ r_promptfilena 
  1916.   integer k ; 
  1917.   if ( interaction == 2 ) 
  1918.   wakeuptermin () ; 
  1919.   if ( s == 640 ) 
  1920.   {
  1921.     if ( interaction == 3 ) 
  1922.     wakeuptermin () ; 
  1923.     printnl ( 133 ) ; 
  1924.     print ( 641 ) ; 
  1925.   } 
  1926.   else { 
  1927.     if ( interaction == 3 ) 
  1928.     wakeuptermin () ; 
  1929.     printnl ( 133 ) ; 
  1930.     print ( 642 ) ; 
  1931.   } 
  1932.   printfilenam ( curname , curarea , curext ) ; 
  1933.   print ( 643 ) ; 
  1934.   if ( e == 644 ) 
  1935.   showcontext () ; 
  1936.   printnl ( 645 ) ; 
  1937.   print ( s ) ; 
  1938.   if ( interaction < 2 ) 
  1939.   fatalerror ( 646 ) ; 
  1940.   cleartermina () ; 
  1941.   {
  1942.     wakeuptermin () ; 
  1943.     print ( 426 ) ; 
  1944.     terminput () ; 
  1945.   } 
  1946.   {
  1947.     beginname () ; 
  1948.     k = first ; 
  1949.     while ( ( buffer [ k ] == 32 ) && ( k < last ) ) incr ( k ) ; 
  1950.     while ( true ) { 
  1951.       if ( k == last ) 
  1952.       goto lab30 ; 
  1953.       if ( ! morename ( buffer [ k ] ) ) 
  1954.       goto lab30 ; 
  1955.       incr ( k ) ; 
  1956.     } 
  1957.     lab30: endname () ; 
  1958.   } 
  1959.   if ( curext == 206 ) 
  1960.   curext = e ; 
  1961.   packfilename ( curname , curarea , curext ) ; 
  1962. } 
  1963. openlogfile () { r_openlogfile 
  1964.   quarterword oldsetting ; 
  1965.   integer k ; 
  1966.   integer l ; 
  1967.   ccharpointer months ; 
  1968.   oldsetting = selector ; 
  1969.   if ( jobname == 0 ) 
  1970.   jobname = 649 ; 
  1971.   packjobname ( 650 ) ; 
  1972.   while ( ! aopenout ( logfile ) ) { 
  1973.     if ( interaction < 2 ) 
  1974.     {
  1975.       {
  1976.     if ( interaction == 3 ) 
  1977.     wakeuptermin () ; 
  1978.     printnl ( 133 ) ; 
  1979.     print ( 642 ) ; 
  1980.       } 
  1981.       printfilenam ( curname , curarea , curext ) ; 
  1982.       print ( 643 ) ; 
  1983.       jobname = 0 ; 
  1984.       history = 3 ; 
  1985.       jumpout () ; 
  1986.     } 
  1987.     promptfilena ( 652 , 650 ) ; 
  1988.   } 
  1989.   logname = amakenamestr ( logfile ) ; 
  1990.   selector = 18 ; 
  1991.   {
  1992.     Fputs( logfile ,  "This is TeX, C Version 2.9" ) ; 
  1993.     print ( formatident ) ; 
  1994.     print ( 653 ) ; 
  1995.     printint ( eqtb [ 5288 ] .cint ) ; 
  1996.     printchar ( 32 ) ; 
  1997.     months = " JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC" ; 
  1998.     for ( k = 3 * eqtb [ 5289 ] .cint - 2 ; k <= 3 * eqtb [ 5289 ] .cint ; k 
  1999.     ++ ) 
  2000.     putc( months [ k ] ,  logfile );
  2001.     printchar ( 32 ) ; 
  2002.     printint ( eqtb [ 5290 ] .cint ) ; 
  2003.     printchar ( 32 ) ; 
  2004.     printtwo ( eqtb [ 5287 ] .cint / 60 ) ; 
  2005.     printchar ( 58 ) ; 
  2006.     printtwo ( eqtb [ 5287 ] .cint % 60 ) ; 
  2007.   } 
  2008.   inputstack [ inputptr ] = curinput ; 
  2009.   printnl ( 651 ) ; 
  2010.   l = inputstack [ 0 ] .limitfield ; 
  2011.   if ( buffer [ l ] == eqtb [ 5315 ] .cint ) 
  2012.   decr ( l ) ; 
  2013.   for ( k = 1 ; k <= l ; k ++ ) 
  2014.   print ( buffer [ k ] ) ; 
  2015.   println () ; 
  2016.   selector = oldsetting + 2 ; 
  2017. } 
  2018.