home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex5.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  20.0 KB  |  1,026 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void scanint ( ) 
  5. {/* 30 */ scanint_regmem 
  6.   boolean negative  ; 
  7.   integer m  ; 
  8.   smallnumber d  ; 
  9.   boolean vacuous  ; 
  10.   boolean OKsofar  ; 
  11.   radix = 0 ; 
  12.   OKsofar = true ; 
  13.   negative = false ; 
  14.   do {
  15.       do { getxtoken () ; 
  16.     } while ( ! ( curcmd != 10 ) ) ; 
  17.     if ( curtok == 3117 ) 
  18.     {
  19.       negative = ! negative ; 
  20.       curtok = 3115 ; 
  21.     } 
  22.   } while ( ! ( curtok != 3115 ) ) ; 
  23.   if ( curtok == 3168 ) 
  24.   {
  25.     gettoken () ; 
  26.     if ( curtok < 4095 ) 
  27.     {
  28.       curval = curchr ; 
  29.       if ( curcmd <= 2 ) 
  30.       if ( curcmd == 2 ) 
  31.       incr ( alignstate ) ; 
  32.       else decr ( alignstate ) ; 
  33.     } 
  34.     else if ( curtok < 4352 ) 
  35.     curval = curtok - 4096 ; 
  36.     else curval = curtok - 4352 ; 
  37.     if ( curval > 255 ) 
  38.     {
  39.       {
  40.     if ( interaction == 3 ) 
  41.     wakeupterminal () ; 
  42.     printnl ( 262 ) ; 
  43.     print ( 694 ) ; 
  44.       } 
  45.       {
  46.     helpptr = 2 ; 
  47.     helpline [ 1 ] = 695 ; 
  48.     helpline [ 0 ] = 696 ; 
  49.       } 
  50.       curval = 48 ; 
  51.       backerror () ; 
  52.     } 
  53.     else {
  54.     
  55.       getxtoken () ; 
  56.       if ( curcmd != 10 ) 
  57.       backinput () ; 
  58.     } 
  59.   } 
  60.   else if ( ( curcmd >= 68 ) && ( curcmd <= 89 ) ) 
  61.   scansomethinginternal ( 0 , false ) ; 
  62.   else {
  63.       
  64.     radix = 10 ; 
  65.     m = 214748364L ; 
  66.     if ( curtok == 3111 ) 
  67.     {
  68.       radix = 8 ; 
  69.       m = 268435456L ; 
  70.       getxtoken () ; 
  71.     } 
  72.     else if ( curtok == 3106 ) 
  73.     {
  74.       radix = 16 ; 
  75.       m = 134217728L ; 
  76.       getxtoken () ; 
  77.     } 
  78.     vacuous = true ; 
  79.     curval = 0 ; 
  80.     while ( true ) {
  81.     
  82.       if ( ( curtok < 3120 + radix ) && ( curtok >= 3120 ) && ( curtok <= 3129 
  83.       ) ) 
  84.       d = curtok - 3120 ; 
  85.       else if ( radix == 16 ) 
  86.       if ( ( curtok <= 2886 ) && ( curtok >= 2881 ) ) 
  87.       d = curtok - 2871 ; 
  88.       else if ( ( curtok <= 3142 ) && ( curtok >= 3137 ) ) 
  89.       d = curtok - 3127 ; 
  90.       else goto lab30 ; 
  91.       else goto lab30 ; 
  92.       vacuous = false ; 
  93.       if ( ( curval >= m ) && ( ( curval > m ) || ( d > 7 ) || ( radix != 10 ) 
  94.       ) ) 
  95.       {
  96.     if ( OKsofar ) 
  97.     {
  98.       {
  99.         if ( interaction == 3 ) 
  100.         wakeupterminal () ; 
  101.         printnl ( 262 ) ; 
  102.         print ( 697 ) ; 
  103.       } 
  104.       {
  105.         helpptr = 2 ; 
  106.         helpline [ 1 ] = 698 ; 
  107.         helpline [ 0 ] = 699 ; 
  108.       } 
  109.       error () ; 
  110.       curval = 2147483647L ; 
  111.       OKsofar = false ; 
  112.     } 
  113.       } 
  114.       else curval = curval * radix + d ; 
  115.       getxtoken () ; 
  116.     } 
  117.     lab30: ; 
  118.     if ( vacuous ) 
  119.     {
  120.       {
  121.     if ( interaction == 3 ) 
  122.     wakeupterminal () ; 
  123.     printnl ( 262 ) ; 
  124.     print ( 660 ) ; 
  125.       } 
  126.       {
  127.     helpptr = 3 ; 
  128.     helpline [ 2 ] = 661 ; 
  129.     helpline [ 1 ] = 662 ; 
  130.     helpline [ 0 ] = 663 ; 
  131.       } 
  132.       backerror () ; 
  133.     } 
  134.     else if ( curcmd != 10 ) 
  135.     backinput () ; 
  136.   } 
  137.   if ( negative ) 
  138.   curval = - (integer) curval ; 
  139. } 
  140. void zscandimen ( mu , inf , shortcut ) 
  141. boolean mu ; 
  142. boolean inf ; 
  143. boolean shortcut ; 
  144. {/* 30 31 32 40 45 88 89 */ scandimen_regmem 
  145.   boolean negative  ; 
  146.   integer f  ; 
  147.   integer num, denom  ; 
  148.   smallnumber k, kk  ; 
  149.   halfword p, q  ; 
  150.   scaled v  ; 
  151.   integer savecurval  ; 
  152.   f = 0 ; 
  153.   aritherror = false ; 
  154.   curorder = 0 ; 
  155.   negative = false ; 
  156.   if ( ! shortcut ) 
  157.   {
  158.     negative = false ; 
  159.     do {
  160.     do { getxtoken () ; 
  161.       } while ( ! ( curcmd != 10 ) ) ; 
  162.       if ( curtok == 3117 ) 
  163.       {
  164.     negative = ! negative ; 
  165.     curtok = 3115 ; 
  166.       } 
  167.     } while ( ! ( curtok != 3115 ) ) ; 
  168.     if ( ( curcmd >= 68 ) && ( curcmd <= 89 ) ) 
  169.     if ( mu ) 
  170.     {
  171.       scansomethinginternal ( 3 , false ) ; 
  172.       if ( curvallevel >= 2 ) 
  173.       {
  174.     v = mem [ curval + 1 ] .cint ; 
  175.     deleteglueref ( curval ) ; 
  176.     curval = v ; 
  177.       } 
  178.       if ( curvallevel == 3 ) 
  179.       goto lab89 ; 
  180.       if ( curvallevel != 0 ) 
  181.       muerror () ; 
  182.     } 
  183.     else {
  184.     
  185.       scansomethinginternal ( 1 , false ) ; 
  186.       if ( curvallevel == 1 ) 
  187.       goto lab89 ; 
  188.     } 
  189.     else {
  190.     
  191.       backinput () ; 
  192.       if ( curtok == 3116 ) 
  193.       curtok = 3118 ; 
  194.       if ( curtok != 3118 ) 
  195.       scanint () ; 
  196.       else {
  197.       
  198.     radix = 10 ; 
  199.     curval = 0 ; 
  200.       } 
  201.       if ( curtok == 3116 ) 
  202.       curtok = 3118 ; 
  203.       if ( ( radix == 10 ) && ( curtok == 3118 ) ) 
  204.       {
  205.     k = 0 ; 
  206.     p = 0 ; 
  207.     gettoken () ; 
  208.     while ( true ) {
  209.         
  210.       getxtoken () ; 
  211.       if ( ( curtok > 3129 ) || ( curtok < 3120 ) ) 
  212.       goto lab31 ; 
  213.       if ( k < 17 ) 
  214.       {
  215.         q = getavail () ; 
  216.         mem [ q ] .hh .v.RH = p ; 
  217.         mem [ q ] .hh .v.LH = curtok - 3120 ; 
  218.         p = q ; 
  219.         incr ( k ) ; 
  220.       } 
  221.     } 
  222.     lab31: {
  223.         register integer for_end; kk = k ; for_end = 1 ; if ( kk >= 
  224.     for_end) do 
  225.       {
  226.         dig [ kk - 1 ] = mem [ p ] .hh .v.LH ; 
  227.         q = p ; 
  228.         p = mem [ p ] .hh .v.RH ; 
  229.         {
  230.           mem [ q ] .hh .v.RH = avail ; 
  231.           avail = q ; 
  232.     ;
  233. #ifdef STAT
  234.           decr ( dynused ) ; 
  235. #endif /* STAT */
  236.         } 
  237.       } 
  238.     while ( kk-- > for_end ) ; } 
  239.     f = rounddecimals ( k ) ; 
  240.     if ( curcmd != 10 ) 
  241.     backinput () ; 
  242.       } 
  243.     } 
  244.   } 
  245.   if ( curval < 0 ) 
  246.   {
  247.     negative = ! negative ; 
  248.     curval = - (integer) curval ; 
  249.   } 
  250.   if ( inf ) 
  251.   if ( scankeyword ( 309 ) ) 
  252.   {
  253.     curorder = 1 ; 
  254.     while ( scankeyword ( 108 ) ) {
  255.     
  256.       if ( curorder == 3 ) 
  257.       {
  258.     {
  259.       if ( interaction == 3 ) 
  260.       wakeupterminal () ; 
  261.       printnl ( 262 ) ; 
  262.       print ( 701 ) ; 
  263.     } 
  264.     print ( 702 ) ; 
  265.     {
  266.       helpptr = 1 ; 
  267.       helpline [ 0 ] = 703 ; 
  268.     } 
  269.     error () ; 
  270.       } 
  271.       else incr ( curorder ) ; 
  272.     } 
  273.     goto lab88 ; 
  274.   } 
  275.   savecurval = curval ; 
  276.   do {
  277.       getxtoken () ; 
  278.   } while ( ! ( curcmd != 10 ) ) ; 
  279.   if ( ( curcmd < 68 ) || ( curcmd > 89 ) ) 
  280.   backinput () ; 
  281.   else {
  282.       
  283.     if ( mu ) 
  284.     {
  285.       scansomethinginternal ( 3 , false ) ; 
  286.       if ( curvallevel >= 2 ) 
  287.       {
  288.     v = mem [ curval + 1 ] .cint ; 
  289.     deleteglueref ( curval ) ; 
  290.     curval = v ; 
  291.       } 
  292.       if ( curvallevel != 3 ) 
  293.       muerror () ; 
  294.     } 
  295.     else scansomethinginternal ( 1 , false ) ; 
  296.     v = curval ; 
  297.     goto lab40 ; 
  298.   } 
  299.   if ( mu ) 
  300.   goto lab45 ; 
  301.   if ( scankeyword ( 704 ) ) 
  302.   v = ( fontinfo [ 6 + parambase [ eqtb [ 4834 ] .hh .v.RH ] ] .cint ) ; 
  303.   else if ( scankeyword ( 705 ) ) 
  304.   v = ( fontinfo [ 5 + parambase [ eqtb [ 4834 ] .hh .v.RH ] ] .cint ) ; 
  305.   else goto lab45 ; 
  306.   {
  307.     getxtoken () ; 
  308.     if ( curcmd != 10 ) 
  309.     backinput () ; 
  310.   } 
  311.   lab40: curval = multandadd ( savecurval , v , xnoverd ( v , f , 65536L ) , 
  312.   1073741823L ) ; 
  313.   goto lab89 ; 
  314.   lab45: ; 
  315.   if ( mu ) 
  316.   if ( scankeyword ( 334 ) ) 
  317.   goto lab88 ; 
  318.   else {
  319.       
  320.     {
  321.       if ( interaction == 3 ) 
  322.       wakeupterminal () ; 
  323.       printnl ( 262 ) ; 
  324.       print ( 701 ) ; 
  325.     } 
  326.     print ( 706 ) ; 
  327.     {
  328.       helpptr = 4 ; 
  329.       helpline [ 3 ] = 707 ; 
  330.       helpline [ 2 ] = 708 ; 
  331.       helpline [ 1 ] = 709 ; 
  332.       helpline [ 0 ] = 710 ; 
  333.     } 
  334.     error () ; 
  335.     goto lab88 ; 
  336.   } 
  337.   if ( scankeyword ( 700 ) ) 
  338.   {
  339.     preparemag () ; 
  340.     if ( eqtb [ 6180 ] .cint != 1000 ) 
  341.     {
  342.       curval = xnoverd ( curval , 1000 , eqtb [ 6180 ] .cint ) ; 
  343.       f = ( 1000 * f + 65536L * remainder ) / eqtb [ 6180 ] .cint ; 
  344.       curval = curval + ( f / 65536L ) ; 
  345.       f = f % 65536L ; 
  346.     } 
  347.   } 
  348.   if ( scankeyword ( 393 ) ) 
  349.   goto lab88 ; 
  350.   if ( scankeyword ( 711 ) ) 
  351.   {
  352.     num = 7227 ; 
  353.     denom = 100 ; 
  354.   } 
  355.   else if ( scankeyword ( 712 ) ) 
  356.   {
  357.     num = 12 ; 
  358.     denom = 1 ; 
  359.   } 
  360.   else if ( scankeyword ( 713 ) ) 
  361.   {
  362.     num = 7227 ; 
  363.     denom = 254 ; 
  364.   } 
  365.   else if ( scankeyword ( 714 ) ) 
  366.   {
  367.     num = 7227 ; 
  368.     denom = 2540 ; 
  369.   } 
  370.   else if ( scankeyword ( 715 ) ) 
  371.   {
  372.     num = 7227 ; 
  373.     denom = 7200 ; 
  374.   } 
  375.   else if ( scankeyword ( 716 ) ) 
  376.   {
  377.     num = 1238 ; 
  378.     denom = 1157 ; 
  379.   } 
  380.   else if ( scankeyword ( 717 ) ) 
  381.   {
  382.     num = 14856 ; 
  383.     denom = 1157 ; 
  384.   } 
  385.   else if ( scankeyword ( 718 ) ) 
  386.   goto lab30 ; 
  387.   else {
  388.       
  389.     {
  390.       if ( interaction == 3 ) 
  391.       wakeupterminal () ; 
  392.       printnl ( 262 ) ; 
  393.       print ( 701 ) ; 
  394.     } 
  395.     print ( 719 ) ; 
  396.     {
  397.       helpptr = 6 ; 
  398.       helpline [ 5 ] = 720 ; 
  399.       helpline [ 4 ] = 721 ; 
  400.       helpline [ 3 ] = 722 ; 
  401.       helpline [ 2 ] = 708 ; 
  402.       helpline [ 1 ] = 709 ; 
  403.       helpline [ 0 ] = 710 ; 
  404.     } 
  405.     error () ; 
  406.     goto lab32 ; 
  407.   } 
  408.   curval = xnoverd ( curval , num , denom ) ; 
  409.   f = ( num * f + 65536L * remainder ) / denom ; 
  410.   curval = curval + ( f / 65536L ) ; 
  411.   f = f % 65536L ; 
  412.   lab32: ; 
  413.   lab88: if ( curval >= 16384 ) 
  414.   aritherror = true ; 
  415.   else curval = curval * 65536L + f ; 
  416.   lab30: ; 
  417.   {
  418.     getxtoken () ; 
  419.     if ( curcmd != 10 ) 
  420.     backinput () ; 
  421.   } 
  422.   lab89: if ( aritherror || ( abs ( curval ) >= 1073741824L ) ) 
  423.   {
  424.     {
  425.       if ( interaction == 3 ) 
  426.       wakeupterminal () ; 
  427.       printnl ( 262 ) ; 
  428.       print ( 723 ) ; 
  429.     } 
  430.     {
  431.       helpptr = 2 ; 
  432.       helpline [ 1 ] = 724 ; 
  433.       helpline [ 0 ] = 725 ; 
  434.     } 
  435.     error () ; 
  436.     curval = 1073741823L ; 
  437.     aritherror = false ; 
  438.   } 
  439.   if ( negative ) 
  440.   curval = - (integer) curval ; 
  441. } 
  442. void zscanglue ( level ) 
  443. smallnumber level ; 
  444. {/* 10 */ scanglue_regmem 
  445.   boolean negative  ; 
  446.   halfword q  ; 
  447.   boolean mu  ; 
  448.   mu = ( level == 3 ) ; 
  449.   negative = false ; 
  450.   do {
  451.       do { getxtoken () ; 
  452.     } while ( ! ( curcmd != 10 ) ) ; 
  453.     if ( curtok == 3117 ) 
  454.     {
  455.       negative = ! negative ; 
  456.       curtok = 3115 ; 
  457.     } 
  458.   } while ( ! ( curtok != 3115 ) ) ; 
  459.   if ( ( curcmd >= 68 ) && ( curcmd <= 89 ) ) 
  460.   {
  461.     scansomethinginternal ( level , negative ) ; 
  462.     if ( curvallevel >= 2 ) 
  463.     {
  464.       if ( curvallevel != level ) 
  465.       muerror () ; 
  466.       return ; 
  467.     } 
  468.     if ( curvallevel == 0 ) 
  469.     scandimen ( mu , false , true ) ; 
  470.     else if ( level == 3 ) 
  471.     muerror () ; 
  472.   } 
  473.   else {
  474.       
  475.     backinput () ; 
  476.     scandimen ( mu , false , false ) ; 
  477.     if ( negative ) 
  478.     curval = - (integer) curval ; 
  479.   } 
  480.   q = newspec ( 0 ) ; 
  481.   mem [ q + 1 ] .cint = curval ; 
  482.   if ( scankeyword ( 726 ) ) 
  483.   {
  484.     scandimen ( mu , true , false ) ; 
  485.     mem [ q + 2 ] .cint = curval ; 
  486.     mem [ q ] .hh.b0 = curorder ; 
  487.   } 
  488.   if ( scankeyword ( 727 ) ) 
  489.   {
  490.     scandimen ( mu , true , false ) ; 
  491.     mem [ q + 3 ] .cint = curval ; 
  492.     mem [ q ] .hh.b1 = curorder ; 
  493.   } 
  494.   curval = q ; 
  495. } 
  496. halfword scanrulespec ( ) 
  497. {/* 21 */ register halfword Result; scanrulespec_regmem 
  498.   halfword q  ; 
  499.   q = newrule () ; 
  500.   if ( curcmd == 35 ) 
  501.   mem [ q + 1 ] .cint = 26214 ; 
  502.   else {
  503.       
  504.     mem [ q + 3 ] .cint = 26214 ; 
  505.     mem [ q + 2 ] .cint = 0 ; 
  506.   } 
  507.   lab21: if ( scankeyword ( 728 ) ) 
  508.   {
  509.     scandimen ( false , false , false ) ; 
  510.     mem [ q + 1 ] .cint = curval ; 
  511.     goto lab21 ; 
  512.   } 
  513.   if ( scankeyword ( 729 ) ) 
  514.   {
  515.     scandimen ( false , false , false ) ; 
  516.     mem [ q + 3 ] .cint = curval ; 
  517.     goto lab21 ; 
  518.   } 
  519.   if ( scankeyword ( 730 ) ) 
  520.   {
  521.     scandimen ( false , false , false ) ; 
  522.     mem [ q + 2 ] .cint = curval ; 
  523.     goto lab21 ; 
  524.   } 
  525.   Result = q ; 
  526.   return(Result) ; 
  527. } 
  528. halfword zstrtoks ( b ) 
  529. poolpointer b ; 
  530. {register halfword Result; strtoks_regmem 
  531.   halfword p  ; 
  532.   halfword q  ; 
  533.   halfword t  ; 
  534.   poolpointer k  ; 
  535.   {
  536.     if ( poolptr + 1 > poolsize ) 
  537.     overflow ( 257 , poolsize - initpoolptr ) ; 
  538.   } 
  539.   p = memtop - 3 ; 
  540.   mem [ p ] .hh .v.RH = 0 ; 
  541.   k = b ; 
  542.   while ( k < poolptr ) {
  543.       
  544.     t = strpool [ k ] ; 
  545.     if ( t == 32 ) 
  546.     t = 2592 ; 
  547.     else t = 3072 + t ; 
  548.     {
  549.       {
  550.     q = avail ; 
  551.     if ( q == 0 ) 
  552.     q = getavail () ; 
  553.     else {
  554.         
  555.       avail = mem [ q ] .hh .v.RH ; 
  556.       mem [ q ] .hh .v.RH = 0 ; 
  557.     ;
  558. #ifdef STAT
  559.       incr ( dynused ) ; 
  560. #endif /* STAT */
  561.     } 
  562.       } 
  563.       mem [ p ] .hh .v.RH = q ; 
  564.       mem [ q ] .hh .v.LH = t ; 
  565.       p = q ; 
  566.     } 
  567.     incr ( k ) ; 
  568.   } 
  569.   poolptr = b ; 
  570.   Result = p ; 
  571.   return(Result) ; 
  572. } 
  573. halfword thetoks ( ) 
  574. {register halfword Result; thetoks_regmem 
  575.   schar oldsetting  ; 
  576.   halfword p, q, r  ; 
  577.   poolpointer b  ; 
  578.   getxtoken () ; 
  579.   scansomethinginternal ( 5 , false ) ; 
  580.   if ( curvallevel >= 4 ) 
  581.   {
  582.     p = memtop - 3 ; 
  583.     mem [ p ] .hh .v.RH = 0 ; 
  584.     if ( curvallevel == 4 ) 
  585.     {
  586.       q = getavail () ; 
  587.       mem [ p ] .hh .v.RH = q ; 
  588.       mem [ q ] .hh .v.LH = 4095 + curval ; 
  589.       p = q ; 
  590.     } 
  591.     else if ( curval != 0 ) 
  592.     {
  593.       r = mem [ curval ] .hh .v.RH ; 
  594.       while ( r != 0 ) {
  595.       
  596.     {
  597.       {
  598.         q = avail ; 
  599.         if ( q == 0 ) 
  600.         q = getavail () ; 
  601.         else {
  602.         
  603.           avail = mem [ q ] .hh .v.RH ; 
  604.           mem [ q ] .hh .v.RH = 0 ; 
  605.     ;
  606. #ifdef STAT
  607.           incr ( dynused ) ; 
  608. #endif /* STAT */
  609.         } 
  610.       } 
  611.       mem [ p ] .hh .v.RH = q ; 
  612.       mem [ q ] .hh .v.LH = mem [ r ] .hh .v.LH ; 
  613.       p = q ; 
  614.     } 
  615.     r = mem [ r ] .hh .v.RH ; 
  616.       } 
  617.     } 
  618.     Result = p ; 
  619.   } 
  620.   else {
  621.       
  622.     oldsetting = selector ; 
  623.     selector = 21 ; 
  624.     b = poolptr ; 
  625.     switch ( curvallevel ) 
  626.     {case 0 : 
  627.       printint ( curval ) ; 
  628.       break ; 
  629.     case 1 : 
  630.       {
  631.     printscaled ( curval ) ; 
  632.     print ( 393 ) ; 
  633.       } 
  634.       break ; 
  635.     case 2 : 
  636.       {
  637.     printspec ( curval , 393 ) ; 
  638.     deleteglueref ( curval ) ; 
  639.       } 
  640.       break ; 
  641.     case 3 : 
  642.       {
  643.     printspec ( curval , 334 ) ; 
  644.     deleteglueref ( curval ) ; 
  645.       } 
  646.       break ; 
  647.     } 
  648.     selector = oldsetting ; 
  649.     Result = strtoks ( b ) ; 
  650.   } 
  651.   return(Result) ; 
  652. } 
  653. void insthetoks ( ) 
  654. {insthetoks_regmem 
  655.   mem [ memtop - 12 ] .hh .v.RH = thetoks () ; 
  656.   begintokenlist ( mem [ memtop - 3 ] .hh .v.RH , 4 ) ; 
  657. } 
  658. void convtoks ( ) 
  659. {convtoks_regmem 
  660.   schar oldsetting  ; 
  661.   schar c  ; 
  662.   smallnumber savescannerstatus  ; 
  663.   poolpointer b  ; 
  664.   c = curchr ; 
  665.   switch ( c ) 
  666.   {case 0 : 
  667.   case 1 : 
  668.     scanint () ; 
  669.     break ; 
  670.   case 2 : 
  671.   case 3 : 
  672.     {
  673.       savescannerstatus = scannerstatus ; 
  674.       scannerstatus = 0 ; 
  675.       gettoken () ; 
  676.       scannerstatus = savescannerstatus ; 
  677.     } 
  678.     break ; 
  679.   case 4 : 
  680.     scanfontident () ; 
  681.     break ; 
  682.   case 5 : 
  683.     if ( jobname == 0 ) 
  684.     openlogfile () ; 
  685.     break ; 
  686.   } 
  687.   oldsetting = selector ; 
  688.   selector = 21 ; 
  689.   b = poolptr ; 
  690.   switch ( c ) 
  691.   {case 0 : 
  692.     printint ( curval ) ; 
  693.     break ; 
  694.   case 1 : 
  695.     printromanint ( curval ) ; 
  696.     break ; 
  697.   case 2 : 
  698.     if ( curcs != 0 ) 
  699.     sprintcs ( curcs ) ; 
  700.     else printchar ( curchr ) ; 
  701.     break ; 
  702.   case 3 : 
  703.     printmeaning () ; 
  704.     break ; 
  705.   case 4 : 
  706.     {
  707.       print ( fontname [ curval ] ) ; 
  708.       if ( fontsize [ curval ] != fontdsize [ curval ] ) 
  709.       {
  710.     print ( 737 ) ; 
  711.     printscaled ( fontsize [ curval ] ) ; 
  712.     print ( 393 ) ; 
  713.       } 
  714.     } 
  715.     break ; 
  716.   case 5 : 
  717.     print ( jobname ) ; 
  718.     break ; 
  719.   } 
  720.   selector = oldsetting ; 
  721.   mem [ memtop - 12 ] .hh .v.RH = strtoks ( b ) ; 
  722.   begintokenlist ( mem [ memtop - 3 ] .hh .v.RH , 4 ) ; 
  723. } 
  724. halfword zscantoks ( macrodef , xpand ) 
  725. boolean macrodef ; 
  726. boolean xpand ; 
  727. {/* 40 30 31 32 */ register halfword Result; scantoks_regmem 
  728.   halfword t  ; 
  729.   halfword s  ; 
  730.   halfword p  ; 
  731.   halfword q  ; 
  732.   halfword unbalance  ; 
  733.   halfword hashbrace  ; 
  734.   if ( macrodef ) 
  735.   scannerstatus = 2 ; 
  736.   else scannerstatus = 5 ; 
  737.   warningindex = curcs ; 
  738.   defref = getavail () ; 
  739.   mem [ defref ] .hh .v.LH = 0 ; 
  740.   p = defref ; 
  741.   hashbrace = 0 ; 
  742.   t = 3120 ; 
  743.   if ( macrodef ) 
  744.   {
  745.     while ( true ) {
  746.     
  747.       gettoken () ; 
  748.       if ( curtok < 768 ) 
  749.       goto lab31 ; 
  750.       if ( curcmd == 6 ) 
  751.       {
  752.     s = 3328 + curchr ; 
  753.     gettoken () ; 
  754.     if ( curcmd == 1 ) 
  755.     {
  756.       hashbrace = curtok ; 
  757.       {
  758.         q = getavail () ; 
  759.         mem [ p ] .hh .v.RH = q ; 
  760.         mem [ q ] .hh .v.LH = curtok ; 
  761.         p = q ; 
  762.       } 
  763.       {
  764.         q = getavail () ; 
  765.         mem [ p ] .hh .v.RH = q ; 
  766.         mem [ q ] .hh .v.LH = 3584 ; 
  767.         p = q ; 
  768.       } 
  769.       goto lab30 ; 
  770.     } 
  771.     if ( t == 3129 ) 
  772.     {
  773.       {
  774.         if ( interaction == 3 ) 
  775.         wakeupterminal () ; 
  776.         printnl ( 262 ) ; 
  777.         print ( 740 ) ; 
  778.       } 
  779.       {
  780.         helpptr = 1 ; 
  781.         helpline [ 0 ] = 741 ; 
  782.       } 
  783.       error () ; 
  784.     } 
  785.     else {
  786.         
  787.       incr ( t ) ; 
  788.       if ( curtok != t ) 
  789.       {
  790.         {
  791.           if ( interaction == 3 ) 
  792.           wakeupterminal () ; 
  793.           printnl ( 262 ) ; 
  794.           print ( 742 ) ; 
  795.         } 
  796.         {
  797.           helpptr = 2 ; 
  798.           helpline [ 1 ] = 743 ; 
  799.           helpline [ 0 ] = 744 ; 
  800.         } 
  801.         backerror () ; 
  802.       } 
  803.       curtok = s ; 
  804.     } 
  805.       } 
  806.       {
  807.     q = getavail () ; 
  808.     mem [ p ] .hh .v.RH = q ; 
  809.     mem [ q ] .hh .v.LH = curtok ; 
  810.     p = q ; 
  811.       } 
  812.     } 
  813.     lab31: {
  814.     
  815.       q = getavail () ; 
  816.       mem [ p ] .hh .v.RH = q ; 
  817.       mem [ q ] .hh .v.LH = 3584 ; 
  818.       p = q ; 
  819.     } 
  820.     if ( curcmd == 2 ) 
  821.     {
  822.       {
  823.     if ( interaction == 3 ) 
  824.     wakeupterminal () ; 
  825.     printnl ( 262 ) ; 
  826.     print ( 653 ) ; 
  827.       } 
  828.       incr ( alignstate ) ; 
  829.       {
  830.     helpptr = 2 ; 
  831.     helpline [ 1 ] = 738 ; 
  832.     helpline [ 0 ] = 739 ; 
  833.       } 
  834.       error () ; 
  835.       goto lab40 ; 
  836.     } 
  837.     lab30: ; 
  838.   } 
  839.   else scanleftbrace () ; 
  840.   unbalance = 1 ; 
  841.   while ( true ) {
  842.       
  843.     if ( xpand ) 
  844.     {
  845.       while ( true ) {
  846.       
  847.     getnext () ; 
  848.     if ( curcmd <= 100 ) 
  849.     goto lab32 ; 
  850.     if ( curcmd != 109 ) 
  851.     expand () ; 
  852.     else {
  853.         
  854.       q = thetoks () ; 
  855.       if ( mem [ memtop - 3 ] .hh .v.RH != 0 ) 
  856.       {
  857.         mem [ p ] .hh .v.RH = mem [ memtop - 3 ] .hh .v.RH ; 
  858.         p = q ; 
  859.       } 
  860.     } 
  861.       } 
  862.       lab32: xtoken () ; 
  863.     } 
  864.     else gettoken () ; 
  865.     if ( curtok < 768 ) 
  866.     if ( curcmd < 2 ) 
  867.     incr ( unbalance ) ; 
  868.     else {
  869.     
  870.       decr ( unbalance ) ; 
  871.       if ( unbalance == 0 ) 
  872.       goto lab40 ; 
  873.     } 
  874.     else if ( curcmd == 6 ) 
  875.     if ( macrodef ) 
  876.     {
  877.       s = curtok ; 
  878.       if ( xpand ) 
  879.       getxtoken () ; 
  880.       else gettoken () ; 
  881.       if ( curcmd != 6 ) 
  882.       if ( ( curtok <= 3120 ) || ( curtok > t ) ) 
  883.       {
  884.     {
  885.       if ( interaction == 3 ) 
  886.       wakeupterminal () ; 
  887.       printnl ( 262 ) ; 
  888.       print ( 745 ) ; 
  889.     } 
  890.     sprintcs ( warningindex ) ; 
  891.     {
  892.       helpptr = 3 ; 
  893.       helpline [ 2 ] = 746 ; 
  894.       helpline [ 1 ] = 747 ; 
  895.       helpline [ 0 ] = 748 ; 
  896.     } 
  897.     backerror () ; 
  898.     curtok = s ; 
  899.       } 
  900.       else curtok = 1232 + curchr ; 
  901.     } 
  902.     {
  903.       q = getavail () ; 
  904.       mem [ p ] .hh .v.RH = q ; 
  905.       mem [ q ] .hh .v.LH = curtok ; 
  906.       p = q ; 
  907.     } 
  908.   } 
  909.   lab40: scannerstatus = 0 ; 
  910.   if ( hashbrace != 0 ) 
  911.   {
  912.     q = getavail () ; 
  913.     mem [ p ] .hh .v.RH = q ; 
  914.     mem [ q ] .hh .v.LH = hashbrace ; 
  915.     p = q ; 
  916.   } 
  917.   Result = p ; 
  918.   return(Result) ; 
  919. } 
  920. void zreadtoks ( n , r ) 
  921. integer n ; 
  922. halfword r ; 
  923. {/* 30 */ readtoks_regmem 
  924.   halfword p  ; 
  925.   halfword q  ; 
  926.   integer s  ; 
  927.   smallnumber m  ; 
  928.   scannerstatus = 2 ; 
  929.   warningindex = r ; 
  930.   defref = getavail () ; 
  931.   mem [ defref ] .hh .v.LH = 0 ; 
  932.   p = defref ; 
  933.   {
  934.     q = getavail () ; 
  935.     mem [ p ] .hh .v.RH = q ; 
  936.     mem [ q ] .hh .v.LH = 3584 ; 
  937.     p = q ; 
  938.   } 
  939.   if ( ( n < 0 ) || ( n > 15 ) ) 
  940.   m = 16 ; 
  941.   else m = n ; 
  942.   s = alignstate ; 
  943.   alignstate = 1000000L ; 
  944.   do {
  945.       beginfilereading () ; 
  946.     curinput .namefield = m + 1 ; 
  947.     if ( readopen [ m ] == 2 ) 
  948.     if ( interaction > 1 ) 
  949.     if ( n < 0 ) 
  950.     {
  951.       wakeupterminal () ; 
  952.       print ( 335 ) ; 
  953.       terminput () ; 
  954.     } 
  955.     else {
  956.     
  957.       wakeupterminal () ; 
  958.       println () ; 
  959.       sprintcs ( r ) ; 
  960.       {
  961.     wakeupterminal () ; 
  962.     print ( 61 ) ; 
  963.     terminput () ; 
  964.       } 
  965.       n = -1 ; 
  966.     } 
  967.     else fatalerror ( 749 ) ; 
  968.     else if ( readopen [ m ] == 1 ) 
  969.     if ( inputln ( readfile [ m ] , false ) ) 
  970.     readopen [ m ] = 0 ; 
  971.     else {
  972.     
  973.       aclose ( readfile [ m ] ) ; 
  974.       readopen [ m ] = 2 ; 
  975.     } 
  976.     else {
  977.     
  978.       if ( ! inputln ( readfile [ m ] , true ) ) 
  979.       {
  980.     aclose ( readfile [ m ] ) ; 
  981.     readopen [ m ] = 2 ; 
  982.     if ( alignstate != 1000000L ) 
  983.     {
  984.       runaway () ; 
  985.       {
  986.         if ( interaction == 3 ) 
  987.         wakeupterminal () ; 
  988.         printnl ( 262 ) ; 
  989.         print ( 750 ) ; 
  990.       } 
  991.       printesc ( 530 ) ; 
  992.       {
  993.         helpptr = 1 ; 
  994.         helpline [ 0 ] = 751 ; 
  995.       } 
  996.       alignstate = 1000000L ; 
  997.       error () ; 
  998.     } 
  999.       } 
  1000.     } 
  1001.     curinput .limitfield = last ; 
  1002.     if ( ( eqtb [ 6211 ] .cint < 0 ) || ( eqtb [ 6211 ] .cint > 255 ) ) 
  1003.     decr ( curinput .limitfield ) ; 
  1004.     else buffer [ curinput .limitfield ] = eqtb [ 6211 ] .cint ; 
  1005.     first = curinput .limitfield + 1 ; 
  1006.     curinput .locfield = curinput .startfield ; 
  1007.     curinput .statefield = 33 ; 
  1008.     while ( true ) {
  1009.     
  1010.       gettoken () ; 
  1011.       if ( curtok == 0 ) 
  1012.       goto lab30 ; 
  1013.       {
  1014.     q = getavail () ; 
  1015.     mem [ p ] .hh .v.RH = q ; 
  1016.     mem [ q ] .hh .v.LH = curtok ; 
  1017.     p = q ; 
  1018.       } 
  1019.     } 
  1020.     lab30: endfilereading () ; 
  1021.   } while ( ! ( alignstate == 1000000L ) ) ; 
  1022.   curval = defref ; 
  1023.   scannerstatus = 0 ; 
  1024.   alignstate = s ; 
  1025. } 
  1026.