home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / unixtex-6.1b-src.tgz / tar.out / contrib / unixtex / web2c / web / tangleboot.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  69KB  |  3,196 lines
  1. #include "cpascal.h"
  2. /* 9999 */ 
  3. #define bufsize 100 
  4. #define maxbytes 45000L 
  5. #define maxtoks 50000L 
  6. #define maxnames 5000 
  7. #define maxtexts 2000 
  8. #define hashsize 353 
  9. #define longestname 400 
  10. #define linelength 72 
  11. #define outbufsize 144 
  12. #define stacksize 100 
  13. #define maxidlength 50 
  14. #define unambiglength 20 
  15. typedef unsigned char ASCIIcode  ; 
  16. typedef file_ptr /* of  ASCIIcode */ textfile  ; 
  17. typedef unsigned char eightbits  ; 
  18. typedef unsigned short sixteenbits  ; 
  19. typedef integer namepointer  ; 
  20. typedef integer textpointer  ; 
  21. typedef struct {
  22.     sixteenbits endfield ; 
  23.   sixteenbits bytefield ; 
  24.   namepointer namefield ; 
  25.   textpointer replfield ; 
  26.   short modfield ; 
  27. } outputstate  ; 
  28. char history  ; 
  29. ASCIIcode xord[256]  ; 
  30. ASCIIcode xchr[256]  ; 
  31. textfile webfile  ; 
  32. textfile changefile  ; 
  33. textfile Pascalfile  ; 
  34. textfile pool  ; 
  35. ASCIIcode buffer[bufsize + 1]  ; 
  36. boolean phaseone  ; 
  37. ASCIIcode bytemem[3][maxbytes + 1]  ; 
  38. eightbits tokmem[4][maxtoks + 1]  ; 
  39. sixteenbits bytestart[maxnames + 1]  ; 
  40. sixteenbits tokstart[maxtexts + 1]  ; 
  41. sixteenbits link[maxnames + 1]  ; 
  42. sixteenbits ilk[maxnames + 1]  ; 
  43. sixteenbits equiv[maxnames + 1]  ; 
  44. sixteenbits textlink[maxtexts + 1]  ; 
  45. namepointer nameptr  ; 
  46. namepointer stringptr  ; 
  47. integer byteptr[3]  ; 
  48. integer poolchecksum  ; 
  49. textpointer textptr  ; 
  50. integer tokptr[4]  ; 
  51. char z  ; 
  52. integer idfirst  ; 
  53. integer idloc  ; 
  54. integer doublechars  ; 
  55. sixteenbits hash[hashsize + 1], chophash[hashsize + 1]  ; 
  56. ASCIIcode choppedid[unambiglength + 1]  ; 
  57. ASCIIcode modtext[longestname + 1]  ; 
  58. textpointer lastunnamed  ; 
  59. outputstate curstate  ; 
  60. outputstate stack[stacksize + 1]  ; 
  61. integer stackptr  ; 
  62. char zo  ; 
  63. eightbits bracelevel  ; 
  64. integer curval  ; 
  65. ASCIIcode outbuf[outbufsize + 1]  ; 
  66. integer outptr  ; 
  67. integer breakptr  ; 
  68. integer semiptr  ; 
  69. eightbits outstate  ; 
  70. integer outval, outapp  ; 
  71. ASCIIcode outsign  ; 
  72. schar lastsign  ; 
  73. ASCIIcode outcontrib[linelength + 1]  ; 
  74. integer ii  ; 
  75. integer line  ; 
  76. integer otherline  ; 
  77. integer templine  ; 
  78. integer limit  ; 
  79. integer loc  ; 
  80. boolean inputhasended  ; 
  81. boolean changing  ; 
  82. ASCIIcode changebuffer[bufsize + 1]  ; 
  83. integer changelimit  ; 
  84. namepointer curmodule  ; 
  85. boolean scanninghex  ; 
  86. eightbits nextcontrol  ; 
  87. textpointer currepltext  ; 
  88. short modulecount  ; 
  89. char webname[PATHMAX + 1], chgname[PATHMAX + 1], pascalfilename[PATHMAX + 1], 
  90. poolfilename[PATHMAX + 1]  ; 
  91.  
  92. #include "tangleboot.h"
  93. void error ( ) 
  94. {integer j  ; 
  95.   integer k, l  ; 
  96.   if ( phaseone ) 
  97.   {
  98.     if ( changing ) 
  99.     Fputs( stdout ,  ". (change file " ) ; 
  100.     else
  101.     Fputs( stdout ,  ". (" ) ; 
  102.     fprintf( stdout , "%s%ld%c\n",  "l." , (long)line , ')' ) ; 
  103.     if ( loc >= limit ) 
  104.     l = limit ; 
  105.     else l = loc ; 
  106.     {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  107.       if ( buffer [ k - 1 ] == 9 ) 
  108.       putc ( ' ' ,  stdout );
  109.       else
  110.       putc ( xchr [ buffer [ k - 1 ] ] ,  stdout );
  111.     while ( k++ < for_end ) ; } 
  112.     putc ('\n',  stdout );
  113.     {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  114.       putc ( ' ' ,  stdout );
  115.     while ( k++ < for_end ) ; } 
  116.     {register integer for_end; k = l + 1 ; for_end = limit ; if ( k <= 
  117.     for_end) do 
  118.       putc ( xchr [ buffer [ k - 1 ] ] ,  stdout );
  119.     while ( k++ < for_end ) ; } 
  120.     putc ( ' ' ,  stdout );
  121.   } 
  122.   else {
  123.       
  124.     fprintf( stdout , "%s%ld%c\n",  ". (l." , (long)line , ')' ) ; 
  125.     {register integer for_end; j = 1 ; for_end = outptr ; if ( j <= for_end) 
  126.     do 
  127.       putc ( xchr [ outbuf [ j - 1 ] ] ,  stdout );
  128.     while ( j++ < for_end ) ; } 
  129.     Fputs( stdout ,  "... " ) ; 
  130.   } 
  131.   flush ( stdout ) ; 
  132.   history = 2 ; 
  133. } 
  134. void scanargs ( ) 
  135. {integer dotpos, slashpos, i, a  ; 
  136.   char c  ; 
  137.   char fname[PATHMAX + 1]  ; 
  138.   boolean foundweb, foundchange  ; 
  139.   foundweb = false ; 
  140.   foundchange = false ; 
  141.   {register integer for_end; a = 1 ; for_end = argc - 1 ; if ( a <= for_end) 
  142.   do 
  143.     {
  144.       argv ( a , fname ) ; 
  145.       if ( fname [ 1 ] != '-' ) 
  146.       {
  147.     if ( ! foundweb ) 
  148.     {
  149.       dotpos = -1 ; 
  150.       slashpos = -1 ; 
  151.       i = 1 ; 
  152.       while ( ( fname [ i ] != ' ' ) && ( i <= PATHMAX - 5 ) ) {
  153.           
  154.         webname [ i ] = fname [ i ] ; 
  155.         if ( fname [ i ] == '.' ) 
  156.         dotpos = i ; 
  157.         if ( fname [ i ] == '/' ) 
  158.         slashpos = i ; 
  159.         i = i + 1 ; 
  160.       } 
  161.       webname [ i ] = ' ' ; 
  162.       if ( ( dotpos == -1 ) || ( dotpos < slashpos ) ) 
  163.       {
  164.         dotpos = i ; 
  165.         webname [ dotpos ] = '.' ; 
  166.         webname [ dotpos + 1 ] = 'w' ; 
  167.         webname [ dotpos + 2 ] = 'e' ; 
  168.         webname [ dotpos + 3 ] = 'b' ; 
  169.         webname [ dotpos + 4 ] = ' ' ; 
  170.       } 
  171.       {register integer for_end; i = 1 ; for_end = dotpos ; if ( i <= 
  172.       for_end) do 
  173.         {
  174.           c = webname [ i ] ; 
  175.           pascalfilename [ i ] = c ; 
  176.           poolfilename [ i ] = c ; 
  177.         } 
  178.       while ( i++ < for_end ) ; } 
  179.       pascalfilename [ dotpos + 1 ] = 'p' ; 
  180.       pascalfilename [ dotpos + 2 ] = ' ' ; 
  181.       poolfilename [ dotpos + 1 ] = 'p' ; 
  182.       poolfilename [ dotpos + 2 ] = 'o' ; 
  183.       poolfilename [ dotpos + 3 ] = 'o' ; 
  184.       poolfilename [ dotpos + 4 ] = 'l' ; 
  185.       poolfilename [ dotpos + 5 ] = ' ' ; 
  186.       foundweb = true ; 
  187.     } 
  188.     else if ( ! foundchange ) 
  189.     {
  190.       dotpos = -1 ; 
  191.       slashpos = -1 ; 
  192.       i = 1 ; 
  193.       while ( ( fname [ i ] != ' ' ) && ( i <= PATHMAX - 5 ) ) {
  194.           
  195.         chgname [ i ] = fname [ i ] ; 
  196.         if ( fname [ i ] == '.' ) 
  197.         dotpos = i ; 
  198.         if ( fname [ i ] == '/' ) 
  199.         slashpos = i ; 
  200.         i = i + 1 ; 
  201.       } 
  202.       chgname [ i ] = ' ' ; 
  203.       if ( ( dotpos == -1 ) || ( dotpos < slashpos ) ) 
  204.       {
  205.         dotpos = i ; 
  206.         chgname [ dotpos ] = '.' ; 
  207.         chgname [ dotpos + 1 ] = 'c' ; 
  208.         chgname [ dotpos + 2 ] = 'h' ; 
  209.         chgname [ dotpos + 3 ] = ' ' ; 
  210.       } 
  211.       foundchange = true ; 
  212.     } 
  213.     else {
  214.         
  215.       fprintf( stdout , "%s\n",  "Usage: tangle webfile[.web] [changefile[.ch]]."           ) ; 
  216.       uexit ( 1 ) ; 
  217.     } 
  218.       } 
  219.       else {
  220.       
  221.     {
  222.       fprintf( stdout , "%s\n",  "Usage: tangle webfile[.web] [changefile[.ch]]."           ) ; 
  223.       uexit ( 1 ) ; 
  224.     } 
  225.       } 
  226.     } 
  227.   while ( a++ < for_end ) ; } 
  228.   if ( ! foundweb ) 
  229.   {
  230.     fprintf( stdout , "%s\n",  "Usage: tangle webfile[.web] [changefile[.ch]]." ) ; 
  231.     uexit ( 1 ) ; 
  232.   } 
  233.   if ( ! foundchange ) 
  234.   {
  235.     chgname [ 1 ] = '/' ; 
  236.     chgname [ 2 ] = 'd' ; 
  237.     chgname [ 3 ] = 'e' ; 
  238.     chgname [ 4 ] = 'v' ; 
  239.     chgname [ 5 ] = '/' ; 
  240.     chgname [ 6 ] = 'n' ; 
  241.     chgname [ 7 ] = 'u' ; 
  242.     chgname [ 8 ] = 'l' ; 
  243.     chgname [ 9 ] = 'l' ; 
  244.     chgname [ 10 ] = ' ' ; 
  245.   } 
  246. } 
  247. void initialize ( ) 
  248. {unsigned char i  ; 
  249.   char wi  ; 
  250.   char zi  ; 
  251.   integer h  ; 
  252.   history = 0 ; 
  253.   xchr [ 32 ] = ' ' ; 
  254.   xchr [ 33 ] = '!' ; 
  255.   xchr [ 34 ] = '"' ; 
  256.   xchr [ 35 ] = '#' ; 
  257.   xchr [ 36 ] = '$' ; 
  258.   xchr [ 37 ] = '%' ; 
  259.   xchr [ 38 ] = '&' ; 
  260.   xchr [ 39 ] = '\'' ; 
  261.   xchr [ 40 ] = '(' ; 
  262.   xchr [ 41 ] = ')' ; 
  263.   xchr [ 42 ] = '*' ; 
  264.   xchr [ 43 ] = '+' ; 
  265.   xchr [ 44 ] = ',' ; 
  266.   xchr [ 45 ] = '-' ; 
  267.   xchr [ 46 ] = '.' ; 
  268.   xchr [ 47 ] = '/' ; 
  269.   xchr [ 48 ] = '0' ; 
  270.   xchr [ 49 ] = '1' ; 
  271.   xchr [ 50 ] = '2' ; 
  272.   xchr [ 51 ] = '3' ; 
  273.   xchr [ 52 ] = '4' ; 
  274.   xchr [ 53 ] = '5' ; 
  275.   xchr [ 54 ] = '6' ; 
  276.   xchr [ 55 ] = '7' ; 
  277.   xchr [ 56 ] = '8' ; 
  278.   xchr [ 57 ] = '9' ; 
  279.   xchr [ 58 ] = ':' ; 
  280.   xchr [ 59 ] = ';' ; 
  281.   xchr [ 60 ] = '<' ; 
  282.   xchr [ 61 ] = '=' ; 
  283.   xchr [ 62 ] = '>' ; 
  284.   xchr [ 63 ] = '?' ; 
  285.   xchr [ 64 ] = '@' ; 
  286.   xchr [ 65 ] = 'A' ; 
  287.   xchr [ 66 ] = 'B' ; 
  288.   xchr [ 67 ] = 'C' ; 
  289.   xchr [ 68 ] = 'D' ; 
  290.   xchr [ 69 ] = 'E' ; 
  291.   xchr [ 70 ] = 'F' ; 
  292.   xchr [ 71 ] = 'G' ; 
  293.   xchr [ 72 ] = 'H' ; 
  294.   xchr [ 73 ] = 'I' ; 
  295.   xchr [ 74 ] = 'J' ; 
  296.   xchr [ 75 ] = 'K' ; 
  297.   xchr [ 76 ] = 'L' ; 
  298.   xchr [ 77 ] = 'M' ; 
  299.   xchr [ 78 ] = 'N' ; 
  300.   xchr [ 79 ] = 'O' ; 
  301.   xchr [ 80 ] = 'P' ; 
  302.   xchr [ 81 ] = 'Q' ; 
  303.   xchr [ 82 ] = 'R' ; 
  304.   xchr [ 83 ] = 'S' ; 
  305.   xchr [ 84 ] = 'T' ; 
  306.   xchr [ 85 ] = 'U' ; 
  307.   xchr [ 86 ] = 'V' ; 
  308.   xchr [ 87 ] = 'W' ; 
  309.   xchr [ 88 ] = 'X' ; 
  310.   xchr [ 89 ] = 'Y' ; 
  311.   xchr [ 90 ] = 'Z' ; 
  312.   xchr [ 91 ] = '[' ; 
  313.   xchr [ 92 ] = '\\' ; 
  314.   xchr [ 93 ] = ']' ; 
  315.   xchr [ 94 ] = '^' ; 
  316.   xchr [ 95 ] = '_' ; 
  317.   xchr [ 96 ] = '`' ; 
  318.   xchr [ 97 ] = 'a' ; 
  319.   xchr [ 98 ] = 'b' ; 
  320.   xchr [ 99 ] = 'c' ; 
  321.   xchr [ 100 ] = 'd' ; 
  322.   xchr [ 101 ] = 'e' ; 
  323.   xchr [ 102 ] = 'f' ; 
  324.   xchr [ 103 ] = 'g' ; 
  325.   xchr [ 104 ] = 'h' ; 
  326.   xchr [ 105 ] = 'i' ; 
  327.   xchr [ 106 ] = 'j' ; 
  328.   xchr [ 107 ] = 'k' ; 
  329.   xchr [ 108 ] = 'l' ; 
  330.   xchr [ 109 ] = 'm' ; 
  331.   xchr [ 110 ] = 'n' ; 
  332.   xchr [ 111 ] = 'o' ; 
  333.   xchr [ 112 ] = 'p' ; 
  334.   xchr [ 113 ] = 'q' ; 
  335.   xchr [ 114 ] = 'r' ; 
  336.   xchr [ 115 ] = 's' ; 
  337.   xchr [ 116 ] = 't' ; 
  338.   xchr [ 117 ] = 'u' ; 
  339.   xchr [ 118 ] = 'v' ; 
  340.   xchr [ 119 ] = 'w' ; 
  341.   xchr [ 120 ] = 'x' ; 
  342.   xchr [ 121 ] = 'y' ; 
  343.   xchr [ 122 ] = 'z' ; 
  344.   xchr [ 123 ] = '{' ; 
  345.   xchr [ 124 ] = '|' ; 
  346.   xchr [ 125 ] = '}' ; 
  347.   xchr [ 126 ] = '~' ; 
  348.   xchr [ 0 ] = ' ' ; 
  349.   xchr [ 127 ] = ' ' ; 
  350.   {register integer for_end; i = 1 ; for_end = 31 ; if ( i <= for_end) do 
  351.     xchr [ i ] = chr ( i ) ; 
  352.   while ( i++ < for_end ) ; } 
  353.   {register integer for_end; i = 128 ; for_end = 255 ; if ( i <= for_end) do 
  354.     xchr [ i ] = chr ( i ) ; 
  355.   while ( i++ < for_end ) ; } 
  356.   {register integer for_end; i = 0 ; for_end = 255 ; if ( i <= for_end) do 
  357.     xord [ chr ( i ) ] = 32 ; 
  358.   while ( i++ < for_end ) ; } 
  359.   {register integer for_end; i = 1 ; for_end = 255 ; if ( i <= for_end) do 
  360.     xord [ xchr [ i ] ] = i ; 
  361.   while ( i++ < for_end ) ; } 
  362.   xord [ ' ' ] = 32 ; 
  363.   scanargs () ; 
  364.   rewrite ( Pascalfile , pascalfilename ) ; 
  365.   {register integer for_end; wi = 0 ; for_end = 2 ; if ( wi <= for_end) do 
  366.     {
  367.       bytestart [ wi ] = 0 ; 
  368.       byteptr [ wi ] = 0 ; 
  369.     } 
  370.   while ( wi++ < for_end ) ; } 
  371.   bytestart [ 3 ] = 0 ; 
  372.   nameptr = 1 ; 
  373.   stringptr = 256 ; 
  374.   poolchecksum = 271828L ; 
  375.   {register integer for_end; zi = 0 ; for_end = 3 ; if ( zi <= for_end) do 
  376.     {
  377.       tokstart [ zi ] = 0 ; 
  378.       tokptr [ zi ] = 0 ; 
  379.     } 
  380.   while ( zi++ < for_end ) ; } 
  381.   tokstart [ 4 ] = 0 ; 
  382.   textptr = 1 ; 
  383.   z = 1 % 4 ; 
  384.   ilk [ 0 ] = 0 ; 
  385.   equiv [ 0 ] = 0 ; 
  386.   {register integer for_end; h = 0 ; for_end = hashsize - 1 ; if ( h <= 
  387.   for_end) do 
  388.     {
  389.       hash [ h ] = 0 ; 
  390.       chophash [ h ] = 0 ; 
  391.     } 
  392.   while ( h++ < for_end ) ; } 
  393.   lastunnamed = 0 ; 
  394.   textlink [ 0 ] = 0 ; 
  395.   scanninghex = false ; 
  396.   modtext [ 0 ] = 32 ; 
  397. } 
  398. void openinput ( ) 
  399. {reset ( webfile , webname ) ; 
  400.   reset ( changefile , chgname ) ; 
  401. } 
  402. boolean zinputln ( f ) 
  403. textfile f ; 
  404. {register boolean Result; integer finallimit  ; 
  405.   limit = 0 ; 
  406.   finallimit = 0 ; 
  407.   if ( eof ( f ) ) 
  408.   Result = false ; 
  409.   else {
  410.       
  411.     while ( ! eoln ( f ) ) {
  412.     
  413.       buffer [ limit ] = xord [ getc ( f ) ] ; 
  414.       limit = limit + 1 ; 
  415.       if ( buffer [ limit - 1 ] != 32 ) 
  416.       finallimit = limit ; 
  417.       if ( limit == bufsize ) 
  418.       {
  419.     while ( ! eoln ( f ) ) vgetc ( f ) ; 
  420.     limit = limit - 1 ; 
  421.     if ( finallimit > limit ) 
  422.     finallimit = limit ; 
  423.     {
  424.       putc ('\n',  stdout );
  425.       Fputs( stdout ,  "! Input line too long" ) ; 
  426.     } 
  427.     loc = 0 ; 
  428.     error () ; 
  429.       } 
  430.     } 
  431.     readln ( f ) ; 
  432.     limit = finallimit ; 
  433.     Result = true ; 
  434.   } 
  435.   return(Result) ; 
  436. } 
  437. void zprintid ( p ) 
  438. namepointer p ; 
  439. {integer k  ; 
  440.   char w  ; 
  441.   if ( p >= nameptr ) 
  442.   Fputs( stdout ,  "IMPOSSIBLE" ) ; 
  443.   else {
  444.       
  445.     w = p % 3 ; 
  446.     {register integer for_end; k = bytestart [ p ] ; for_end = bytestart [ p 
  447.     + 3 ] - 1 ; if ( k <= for_end) do 
  448.       putc ( xchr [ bytemem [ w ][ k ] ] ,  stdout );
  449.     while ( k++ < for_end ) ; } 
  450.   } 
  451. } 
  452. namepointer zidlookup ( t ) 
  453. eightbits t ; 
  454. {/* 31 32 */ register namepointer Result; eightbits c  ; 
  455.   integer i  ; 
  456.   integer h  ; 
  457.   integer k  ; 
  458.   char w  ; 
  459.   integer l  ; 
  460.   namepointer p, q  ; 
  461.   integer s  ; 
  462.   l = idloc - idfirst ; 
  463.   h = buffer [ idfirst ] ; 
  464.   i = idfirst + 1 ; 
  465.   while ( i < idloc ) {
  466.       
  467.     h = ( h + h + buffer [ i ] ) % hashsize ; 
  468.     i = i + 1 ; 
  469.   } 
  470.   p = hash [ h ] ; 
  471.   while ( p != 0 ) {
  472.       
  473.     if ( bytestart [ p + 3 ] - bytestart [ p ] == l ) 
  474.     {
  475.       i = idfirst ; 
  476.       k = bytestart [ p ] ; 
  477.       w = p % 3 ; 
  478.       while ( ( i < idloc ) && ( buffer [ i ] == bytemem [ w ][ k ] ) ) {
  479.       
  480.     i = i + 1 ; 
  481.     k = k + 1 ; 
  482.       } 
  483.       if ( i == idloc ) 
  484.       goto lab31 ; 
  485.     } 
  486.     p = link [ p ] ; 
  487.   } 
  488.   p = nameptr ; 
  489.   link [ p ] = hash [ h ] ; 
  490.   hash [ h ] = p ; 
  491.   lab31: ; 
  492.   if ( ( p == nameptr ) || ( t != 0 ) ) 
  493.   {
  494.     if ( ( ( p != nameptr ) && ( t != 0 ) && ( ilk [ p ] == 0 ) ) || ( ( p == 
  495.     nameptr ) && ( t == 0 ) && ( buffer [ idfirst ] != 34 ) ) ) 
  496.     {
  497.       i = idfirst ; 
  498.       s = 0 ; 
  499.       h = 0 ; 
  500.       while ( ( i < idloc ) && ( s < unambiglength ) ) {
  501.       
  502.     if ( buffer [ i ] != 95 ) 
  503.     {
  504.       if ( buffer [ i ] >= 97 ) 
  505.       choppedid [ s ] = buffer [ i ] - 32 ; 
  506.       else choppedid [ s ] = buffer [ i ] ; 
  507.       h = ( h + h + choppedid [ s ] ) % hashsize ; 
  508.       s = s + 1 ; 
  509.     } 
  510.     i = i + 1 ; 
  511.       } 
  512.       choppedid [ s ] = 0 ; 
  513.     } 
  514.     if ( p != nameptr ) 
  515.     {
  516.       if ( ilk [ p ] == 0 ) 
  517.       {
  518.     if ( t == 1 ) 
  519.     {
  520.       putc ('\n',  stdout );
  521.       Fputs( stdout ,  "! This identifier has already appeared" ) ; 
  522.       error () ; 
  523.     } 
  524.     q = chophash [ h ] ; 
  525.     if ( q == p ) 
  526.     chophash [ h ] = equiv [ p ] ; 
  527.     else {
  528.         
  529.       while ( equiv [ q ] != p ) q = equiv [ q ] ; 
  530.       equiv [ q ] = equiv [ p ] ; 
  531.     } 
  532.       } 
  533.       else {
  534.       
  535.     putc ('\n',  stdout );
  536.     Fputs( stdout ,  "! This identifier was defined before" ) ; 
  537.     error () ; 
  538.       } 
  539.       ilk [ p ] = t ; 
  540.     } 
  541.     else {
  542.     
  543.       if ( ( t == 0 ) && ( buffer [ idfirst ] != 34 ) ) 
  544.       {
  545.     q = chophash [ h ] ; 
  546.     while ( q != 0 ) {
  547.         
  548.       {
  549.         k = bytestart [ q ] ; 
  550.         s = 0 ; 
  551.         w = q % 3 ; 
  552.         while ( ( k < bytestart [ q + 3 ] ) && ( s < unambiglength ) ) {
  553.         
  554.           c = bytemem [ w ][ k ] ; 
  555.           if ( c != 95 ) 
  556.           {
  557.         if ( choppedid [ s ] != c ) 
  558.         goto lab32 ; 
  559.         s = s + 1 ; 
  560.           } 
  561.           k = k + 1 ; 
  562.         } 
  563.         if ( ( k == bytestart [ q + 3 ] ) && ( choppedid [ s ] != 0 ) ) 
  564.         goto lab32 ; 
  565.         {
  566.           putc ('\n',  stdout );
  567.           Fputs( stdout ,  "! Identifier conflict with " ) ; 
  568.         } 
  569.         {register integer for_end; k = bytestart [ q ] ; for_end = 
  570.         bytestart [ q + 3 ] - 1 ; if ( k <= for_end) do 
  571.           putc ( xchr [ bytemem [ w ][ k ] ] ,  stdout );
  572.         while ( k++ < for_end ) ; } 
  573.         error () ; 
  574.         q = 0 ; 
  575.         lab32: ; 
  576.       } 
  577.       q = equiv [ q ] ; 
  578.     } 
  579.     equiv [ p ] = chophash [ h ] ; 
  580.     chophash [ h ] = p ; 
  581.       } 
  582.       w = nameptr % 3 ; 
  583.       k = byteptr [ w ] ; 
  584.       if ( k + l > maxbytes ) 
  585.       {
  586.     putc ('\n',  stdout );
  587.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "byte memory" , " capacity exceeded" ) 
  588.     ; 
  589.     error () ; 
  590.     history = 3 ; 
  591.     uexit ( 1 ) ; 
  592.       } 
  593.       if ( nameptr > maxnames - 3 ) 
  594.       {
  595.     putc ('\n',  stdout );
  596.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "name" , " capacity exceeded" ) ; 
  597.     error () ; 
  598.     history = 3 ; 
  599.     uexit ( 1 ) ; 
  600.       } 
  601.       i = idfirst ; 
  602.       while ( i < idloc ) {
  603.       
  604.     bytemem [ w ][ k ] = buffer [ i ] ; 
  605.     k = k + 1 ; 
  606.     i = i + 1 ; 
  607.       } 
  608.       byteptr [ w ] = k ; 
  609.       bytestart [ nameptr + 3 ] = k ; 
  610.       nameptr = nameptr + 1 ; 
  611.       if ( buffer [ idfirst ] != 34 ) 
  612.       ilk [ p ] = t ; 
  613.       else {
  614.       
  615.     ilk [ p ] = 1 ; 
  616.     if ( l - doublechars == 2 ) 
  617.     equiv [ p ] = buffer [ idfirst + 1 ] + 32768L ; 
  618.     else {
  619.         
  620.       if ( stringptr == 256 ) 
  621.       rewrite ( pool , poolfilename ) ; 
  622.       equiv [ p ] = stringptr + 32768L ; 
  623.       l = l - doublechars - 1 ; 
  624.       if ( l > 99 ) 
  625.       {
  626.         putc ('\n',  stdout );
  627.         Fputs( stdout ,  "! Preprocessed string is too long" ) ; 
  628.         error () ; 
  629.       } 
  630.       stringptr = stringptr + 1 ; 
  631.       fprintf( pool , "%c%c",  xchr [ 48 + l / 10 ] , xchr [ 48 + l % 10 ] ) ; 
  632.       poolchecksum = poolchecksum + poolchecksum + l ; 
  633.       while ( poolchecksum > 536870839L ) poolchecksum = poolchecksum - 
  634.       536870839L ; 
  635.       i = idfirst + 1 ; 
  636.       while ( i < idloc ) {
  637.           
  638.         putc ( xchr [ buffer [ i ] ] ,  pool );
  639.         poolchecksum = poolchecksum + poolchecksum + buffer [ i ] ; 
  640.         while ( poolchecksum > 536870839L ) poolchecksum = poolchecksum - 
  641.         536870839L ; 
  642.         if ( ( buffer [ i ] == 34 ) || ( buffer [ i ] == 64 ) ) 
  643.         i = i + 2 ; 
  644.         else i = i + 1 ; 
  645.       } 
  646.       putc ('\n',  pool );
  647.     } 
  648.       } 
  649.     } 
  650.   } 
  651.   Result = p ; 
  652.   return(Result) ; 
  653. } 
  654. namepointer zmodlookup ( l ) 
  655. sixteenbits l ; 
  656. {/* 31 */ register namepointer Result; char c  ; 
  657.   integer j  ; 
  658.   integer k  ; 
  659.   char w  ; 
  660.   namepointer p  ; 
  661.   namepointer q  ; 
  662.   c = 2 ; 
  663.   q = 0 ; 
  664.   p = ilk [ 0 ] ; 
  665.   while ( p != 0 ) {
  666.       
  667.     {
  668.       k = bytestart [ p ] ; 
  669.       w = p % 3 ; 
  670.       c = 1 ; 
  671.       j = 1 ; 
  672.       while ( ( k < bytestart [ p + 3 ] ) && ( j <= l ) && ( modtext [ j ] == 
  673.       bytemem [ w ][ k ] ) ) {
  674.       
  675.     k = k + 1 ; 
  676.     j = j + 1 ; 
  677.       } 
  678.       if ( k == bytestart [ p + 3 ] ) 
  679.       if ( j > l ) 
  680.       c = 1 ; 
  681.       else c = 4 ; 
  682.       else if ( j > l ) 
  683.       c = 3 ; 
  684.       else if ( modtext [ j ] < bytemem [ w ][ k ] ) 
  685.       c = 0 ; 
  686.       else c = 2 ; 
  687.     } 
  688.     q = p ; 
  689.     if ( c == 0 ) 
  690.     p = link [ q ] ; 
  691.     else if ( c == 2 ) 
  692.     p = ilk [ q ] ; 
  693.     else goto lab31 ; 
  694.   } 
  695.   w = nameptr % 3 ; 
  696.   k = byteptr [ w ] ; 
  697.   if ( k + l > maxbytes ) 
  698.   {
  699.     putc ('\n',  stdout );
  700.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "byte memory" , " capacity exceeded" ) ; 
  701.     error () ; 
  702.     history = 3 ; 
  703.     uexit ( 1 ) ; 
  704.   } 
  705.   if ( nameptr > maxnames - 3 ) 
  706.   {
  707.     putc ('\n',  stdout );
  708.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "name" , " capacity exceeded" ) ; 
  709.     error () ; 
  710.     history = 3 ; 
  711.     uexit ( 1 ) ; 
  712.   } 
  713.   p = nameptr ; 
  714.   if ( c == 0 ) 
  715.   link [ q ] = p ; 
  716.   else ilk [ q ] = p ; 
  717.   link [ p ] = 0 ; 
  718.   ilk [ p ] = 0 ; 
  719.   c = 1 ; 
  720.   equiv [ p ] = 0 ; 
  721.   {register integer for_end; j = 1 ; for_end = l ; if ( j <= for_end) do 
  722.     bytemem [ w ][ k + j - 1 ] = modtext [ j ] ; 
  723.   while ( j++ < for_end ) ; } 
  724.   byteptr [ w ] = k + l ; 
  725.   bytestart [ nameptr + 3 ] = k + l ; 
  726.   nameptr = nameptr + 1 ; 
  727.   lab31: if ( c != 1 ) 
  728.   {
  729.     {
  730.       putc ('\n',  stdout );
  731.       Fputs( stdout ,  "! Incompatible section names" ) ; 
  732.       error () ; 
  733.     } 
  734.     p = 0 ; 
  735.   } 
  736.   Result = p ; 
  737.   return(Result) ; 
  738. } 
  739. namepointer zprefixlookup ( l ) 
  740. sixteenbits l ; 
  741. {register namepointer Result; char c  ; 
  742.   integer count  ; 
  743.   integer j  ; 
  744.   integer k  ; 
  745.   char w  ; 
  746.   namepointer p  ; 
  747.   namepointer q  ; 
  748.   namepointer r  ; 
  749.   q = 0 ; 
  750.   p = ilk [ 0 ] ; 
  751.   count = 0 ; 
  752.   r = 0 ; 
  753.   while ( p != 0 ) {
  754.       
  755.     {
  756.       k = bytestart [ p ] ; 
  757.       w = p % 3 ; 
  758.       c = 1 ; 
  759.       j = 1 ; 
  760.       while ( ( k < bytestart [ p + 3 ] ) && ( j <= l ) && ( modtext [ j ] == 
  761.       bytemem [ w ][ k ] ) ) {
  762.       
  763.     k = k + 1 ; 
  764.     j = j + 1 ; 
  765.       } 
  766.       if ( k == bytestart [ p + 3 ] ) 
  767.       if ( j > l ) 
  768.       c = 1 ; 
  769.       else c = 4 ; 
  770.       else if ( j > l ) 
  771.       c = 3 ; 
  772.       else if ( modtext [ j ] < bytemem [ w ][ k ] ) 
  773.       c = 0 ; 
  774.       else c = 2 ; 
  775.     } 
  776.     if ( c == 0 ) 
  777.     p = link [ p ] ; 
  778.     else if ( c == 2 ) 
  779.     p = ilk [ p ] ; 
  780.     else {
  781.     
  782.       r = p ; 
  783.       count = count + 1 ; 
  784.       q = ilk [ p ] ; 
  785.       p = link [ p ] ; 
  786.     } 
  787.     if ( p == 0 ) 
  788.     {
  789.       p = q ; 
  790.       q = 0 ; 
  791.     } 
  792.   } 
  793.   if ( count != 1 ) 
  794.   if ( count == 0 ) 
  795.   {
  796.     putc ('\n',  stdout );
  797.     Fputs( stdout ,  "! Name does not match" ) ; 
  798.     error () ; 
  799.   } 
  800.   else {
  801.       
  802.     putc ('\n',  stdout );
  803.     Fputs( stdout ,  "! Ambiguous prefix" ) ; 
  804.     error () ; 
  805.   } 
  806.   Result = r ; 
  807.   return(Result) ; 
  808. } 
  809. void zstoretwobytes ( x ) 
  810. sixteenbits x ; 
  811. {if ( tokptr [ z ] + 2 > maxtoks ) 
  812.   {
  813.     putc ('\n',  stdout );
  814.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  815.     error () ; 
  816.     history = 3 ; 
  817.     uexit ( 1 ) ; 
  818.   } 
  819.   tokmem [ z ][ tokptr [ z ] ] = x / 256 ; 
  820.   tokmem [ z ][ tokptr [ z ] + 1 ] = x % 256 ; 
  821.   tokptr [ z ] = tokptr [ z ] + 2 ; 
  822. } 
  823. void zpushlevel ( p ) 
  824. namepointer p ; 
  825. {if ( stackptr == stacksize ) 
  826.   {
  827.     putc ('\n',  stdout );
  828.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "stack" , " capacity exceeded" ) ; 
  829.     error () ; 
  830.     history = 3 ; 
  831.     uexit ( 1 ) ; 
  832.   } 
  833.   else {
  834.       
  835.     stack [ stackptr ] = curstate ; 
  836.     stackptr = stackptr + 1 ; 
  837.     curstate .namefield = p ; 
  838.     curstate .replfield = equiv [ p ] ; 
  839.     zo = curstate .replfield % 4 ; 
  840.     curstate .bytefield = tokstart [ curstate .replfield ] ; 
  841.     curstate .endfield = tokstart [ curstate .replfield + 4 ] ; 
  842.     curstate .modfield = 0 ; 
  843.   } 
  844. } 
  845. void poplevel ( ) 
  846. {/* 10 */ if ( textlink [ curstate .replfield ] == 0 ) 
  847.   {
  848.     if ( ilk [ curstate .namefield ] == 3 ) 
  849.     {
  850.       nameptr = nameptr - 1 ; 
  851.       textptr = textptr - 1 ; 
  852.       z = textptr % 4 ; 
  853.       tokptr [ z ] = tokstart [ textptr ] ; 
  854.     } 
  855.   } 
  856.   else if ( textlink [ curstate .replfield ] < maxtexts ) 
  857.   {
  858.     curstate .replfield = textlink [ curstate .replfield ] ; 
  859.     zo = curstate .replfield % 4 ; 
  860.     curstate .bytefield = tokstart [ curstate .replfield ] ; 
  861.     curstate .endfield = tokstart [ curstate .replfield + 4 ] ; 
  862.     goto lab10 ; 
  863.   } 
  864.   stackptr = stackptr - 1 ; 
  865.   if ( stackptr > 0 ) 
  866.   {
  867.     curstate = stack [ stackptr ] ; 
  868.     zo = curstate .replfield % 4 ; 
  869.   } 
  870.   lab10: ; 
  871. } 
  872. sixteenbits getoutput ( ) 
  873. {/* 20 30 31 */ register sixteenbits Result; sixteenbits a  ; 
  874.   eightbits b  ; 
  875.   sixteenbits bal  ; 
  876.   integer k  ; 
  877.   char w  ; 
  878.   lab20: if ( stackptr == 0 ) 
  879.   {
  880.     a = 0 ; 
  881.     goto lab31 ; 
  882.   } 
  883.   if ( curstate .bytefield == curstate .endfield ) 
  884.   {
  885.     curval = - (integer) curstate .modfield ; 
  886.     poplevel () ; 
  887.     if ( curval == 0 ) 
  888.     goto lab20 ; 
  889.     a = 129 ; 
  890.     goto lab31 ; 
  891.   } 
  892.   a = tokmem [ zo ][ curstate .bytefield ] ; 
  893.   curstate .bytefield = curstate .bytefield + 1 ; 
  894.   if ( a < 128 ) 
  895.   if ( a == 0 ) 
  896.   {
  897.     pushlevel ( nameptr - 1 ) ; 
  898.     goto lab20 ; 
  899.   } 
  900.   else goto lab31 ; 
  901.   a = ( a - 128 ) * 256 + tokmem [ zo ][ curstate .bytefield ] ; 
  902.   curstate .bytefield = curstate .bytefield + 1 ; 
  903.   if ( a < 10240 ) 
  904.   {
  905.     switch ( ilk [ a ] ) 
  906.     {case 0 : 
  907.       {
  908.     curval = a ; 
  909.     a = 130 ; 
  910.       } 
  911.       break ; 
  912.     case 1 : 
  913.       {
  914.     curval = equiv [ a ] - 32768L ; 
  915.     a = 128 ; 
  916.       } 
  917.       break ; 
  918.     case 2 : 
  919.       {
  920.     pushlevel ( a ) ; 
  921.     goto lab20 ; 
  922.       } 
  923.       break ; 
  924.     case 3 : 
  925.       {
  926.     while ( ( curstate .bytefield == curstate .endfield ) && ( stackptr > 
  927.     0 ) ) poplevel () ; 
  928.     if ( ( stackptr == 0 ) || ( tokmem [ zo ][ curstate .bytefield ] != 40 
  929.     ) ) 
  930.     {
  931.       {
  932.         putc ('\n',  stdout );
  933.         Fputs( stdout ,  "! No parameter given for " ) ; 
  934.       } 
  935.       printid ( a ) ; 
  936.       error () ; 
  937.       goto lab20 ; 
  938.     } 
  939.     bal = 1 ; 
  940.     curstate .bytefield = curstate .bytefield + 1 ; 
  941.     while ( true ) {
  942.         
  943.       b = tokmem [ zo ][ curstate .bytefield ] ; 
  944.       curstate .bytefield = curstate .bytefield + 1 ; 
  945.       if ( b == 0 ) 
  946.       storetwobytes ( nameptr + 32767 ) ; 
  947.       else {
  948.           
  949.         if ( b >= 128 ) 
  950.         {
  951.           {
  952.         if ( tokptr [ z ] == maxtoks ) 
  953.         {
  954.           putc ('\n',  stdout );
  955.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" ,                   " capacity exceeded" ) ; 
  956.           error () ; 
  957.           history = 3 ; 
  958.           uexit ( 1 ) ; 
  959.         } 
  960.         tokmem [ z ][ tokptr [ z ] ] = b ; 
  961.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  962.           } 
  963.           b = tokmem [ zo ][ curstate .bytefield ] ; 
  964.           curstate .bytefield = curstate .bytefield + 1 ; 
  965.         } 
  966.         else switch ( b ) 
  967.         {case 40 : 
  968.           bal = bal + 1 ; 
  969.           break ; 
  970.         case 41 : 
  971.           {
  972.         bal = bal - 1 ; 
  973.         if ( bal == 0 ) 
  974.         goto lab30 ; 
  975.           } 
  976.           break ; 
  977.         case 39 : 
  978.           do {
  979.           { 
  980.           if ( tokptr [ z ] == maxtoks ) 
  981.           {
  982.             putc ('\n',  stdout );
  983.             fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" ,                     " capacity exceeded" ) ; 
  984.             error () ; 
  985.             history = 3 ; 
  986.             uexit ( 1 ) ; 
  987.           } 
  988.           tokmem [ z ][ tokptr [ z ] ] = b ; 
  989.           tokptr [ z ] = tokptr [ z ] + 1 ; 
  990.         } 
  991.         b = tokmem [ zo ][ curstate .bytefield ] ; 
  992.         curstate .bytefield = curstate .bytefield + 1 ; 
  993.           } while ( ! ( b == 39 ) ) ; 
  994.           break ; 
  995.           default: 
  996.           ; 
  997.           break ; 
  998.         } 
  999.         {
  1000.           if ( tokptr [ z ] == maxtoks ) 
  1001.           {
  1002.         putc ('\n',  stdout );
  1003.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded"                 ) ; 
  1004.         error () ; 
  1005.         history = 3 ; 
  1006.         uexit ( 1 ) ; 
  1007.           } 
  1008.           tokmem [ z ][ tokptr [ z ] ] = b ; 
  1009.           tokptr [ z ] = tokptr [ z ] + 1 ; 
  1010.         } 
  1011.       } 
  1012.     } 
  1013.     lab30: ; 
  1014.     equiv [ nameptr ] = textptr ; 
  1015.     ilk [ nameptr ] = 2 ; 
  1016.     w = nameptr % 3 ; 
  1017.     k = byteptr [ w ] ; 
  1018.     if ( nameptr > maxnames - 3 ) 
  1019.     {
  1020.       putc ('\n',  stdout );
  1021.       fprintf( stdout , "%s%s%s",  "! Sorry, " , "name" , " capacity exceeded" ) ; 
  1022.       error () ; 
  1023.       history = 3 ; 
  1024.       uexit ( 1 ) ; 
  1025.     } 
  1026.     bytestart [ nameptr + 3 ] = k ; 
  1027.     nameptr = nameptr + 1 ; 
  1028.     if ( textptr > maxtexts - 4 ) 
  1029.     {
  1030.       putc ('\n',  stdout );
  1031.       fprintf( stdout , "%s%s%s",  "! Sorry, " , "text" , " capacity exceeded" ) ; 
  1032.       error () ; 
  1033.       history = 3 ; 
  1034.       uexit ( 1 ) ; 
  1035.     } 
  1036.     textlink [ textptr ] = 0 ; 
  1037.     tokstart [ textptr + 4 ] = tokptr [ z ] ; 
  1038.     textptr = textptr + 1 ; 
  1039.     z = textptr % 4 ; 
  1040.     pushlevel ( a ) ; 
  1041.     goto lab20 ; 
  1042.       } 
  1043.       break ; 
  1044.       default: 
  1045.       {
  1046.     putc ('\n',  stdout );
  1047.     fprintf( stdout , "%s%s%c",  "! This can't happen (" , "output" , ')' ) ; 
  1048.     error () ; 
  1049.     history = 3 ; 
  1050.     uexit ( 1 ) ; 
  1051.       } 
  1052.       break ; 
  1053.     } 
  1054.     goto lab31 ; 
  1055.   } 
  1056.   if ( a < 20480 ) 
  1057.   {
  1058.     a = a - 10240 ; 
  1059.     if ( equiv [ a ] != 0 ) 
  1060.     pushlevel ( a ) ; 
  1061.     else if ( a != 0 ) 
  1062.     {
  1063.       {
  1064.     putc ('\n',  stdout );
  1065.     Fputs( stdout ,  "! Not present: <" ) ; 
  1066.       } 
  1067.       printid ( a ) ; 
  1068.       putc ( '>' ,  stdout );
  1069.       error () ; 
  1070.     } 
  1071.     goto lab20 ; 
  1072.   } 
  1073.   curval = a - 20480 ; 
  1074.   a = 129 ; 
  1075.   curstate .modfield = curval ; 
  1076.   lab31: Result = a ; 
  1077.   return(Result) ; 
  1078. } 
  1079. void flushbuffer ( ) 
  1080. {integer k  ; 
  1081.   integer b  ; 
  1082.   b = breakptr ; 
  1083.   if ( ( semiptr != 0 ) && ( outptr - semiptr <= linelength ) ) 
  1084.   breakptr = semiptr ; 
  1085.   {register integer for_end; k = 1 ; for_end = breakptr ; if ( k <= for_end) 
  1086.   do 
  1087.     putc ( xchr [ outbuf [ k - 1 ] ] ,  Pascalfile );
  1088.   while ( k++ < for_end ) ; } 
  1089.   putc ('\n',  Pascalfile );
  1090.   line = line + 1 ; 
  1091.   if ( line % 100 == 0 ) 
  1092.   {
  1093.     putc ( '.' ,  stdout );
  1094.     if ( line % 500 == 0 ) 
  1095.     fprintf( stdout , "%ld",  (long)line ) ; 
  1096.     flush ( stdout ) ; 
  1097.   } 
  1098.   if ( breakptr < outptr ) 
  1099.   {
  1100.     if ( outbuf [ breakptr ] == 32 ) 
  1101.     {
  1102.       breakptr = breakptr + 1 ; 
  1103.       if ( breakptr > b ) 
  1104.       b = breakptr ; 
  1105.     } 
  1106.     {register integer for_end; k = breakptr ; for_end = outptr - 1 ; if ( k 
  1107.     <= for_end) do 
  1108.       outbuf [ k - breakptr ] = outbuf [ k ] ; 
  1109.     while ( k++ < for_end ) ; } 
  1110.   } 
  1111.   outptr = outptr - breakptr ; 
  1112.   breakptr = b - breakptr ; 
  1113.   semiptr = 0 ; 
  1114.   if ( outptr > linelength ) 
  1115.   {
  1116.     {
  1117.       putc ('\n',  stdout );
  1118.       Fputs( stdout ,  "! Long line must be truncated" ) ; 
  1119.       error () ; 
  1120.     } 
  1121.     outptr = linelength ; 
  1122.   } 
  1123. } 
  1124. void zappval ( v ) 
  1125. integer v ; 
  1126. {integer k  ; 
  1127.   k = outbufsize ; 
  1128.   do {
  1129.       outbuf [ k ] = v % 10 ; 
  1130.     v = v / 10 ; 
  1131.     k = k - 1 ; 
  1132.   } while ( ! ( v == 0 ) ) ; 
  1133.   do {
  1134.       k = k + 1 ; 
  1135.     {
  1136.       outbuf [ outptr ] = outbuf [ k ] + 48 ; 
  1137.       outptr = outptr + 1 ; 
  1138.     } 
  1139.   } while ( ! ( k == outbufsize ) ) ; 
  1140. } 
  1141. void zsendout ( t , v ) 
  1142. eightbits t ; 
  1143. sixteenbits v ; 
  1144. {/* 20 */ integer k  ; 
  1145.   lab20: switch ( outstate ) 
  1146.   {case 1 : 
  1147.     if ( t != 3 ) 
  1148.     {
  1149.       breakptr = outptr ; 
  1150.       if ( t == 2 ) 
  1151.       {
  1152.     outbuf [ outptr ] = 32 ; 
  1153.     outptr = outptr + 1 ; 
  1154.       } 
  1155.     } 
  1156.     break ; 
  1157.   case 2 : 
  1158.     {
  1159.       {
  1160.     outbuf [ outptr ] = 44 - outapp ; 
  1161.     outptr = outptr + 1 ; 
  1162.       } 
  1163.       if ( outptr > linelength ) 
  1164.       flushbuffer () ; 
  1165.       breakptr = outptr ; 
  1166.     } 
  1167.     break ; 
  1168.   case 3 : 
  1169.   case 4 : 
  1170.     {
  1171.       if ( ( outval < 0 ) || ( ( outval == 0 ) && ( lastsign < 0 ) ) ) 
  1172.       {
  1173.     outbuf [ outptr ] = 45 ; 
  1174.     outptr = outptr + 1 ; 
  1175.       } 
  1176.       else if ( outsign > 0 ) 
  1177.       {
  1178.     outbuf [ outptr ] = outsign ; 
  1179.     outptr = outptr + 1 ; 
  1180.       } 
  1181.       appval ( abs ( outval ) ) ; 
  1182.       if ( outptr > linelength ) 
  1183.       flushbuffer () ; 
  1184.       outstate = outstate - 2 ; 
  1185.       goto lab20 ; 
  1186.     } 
  1187.     break ; 
  1188.   case 5 : 
  1189.     {
  1190.       if ( ( t == 3 ) || ( ( ( t == 2 ) && ( v == 3 ) && ( ( ( outcontrib [ 1 
  1191.       ] == 68 ) && ( outcontrib [ 2 ] == 73 ) && ( outcontrib [ 3 ] == 86 ) ) 
  1192.       || ( ( outcontrib [ 1 ] == 100 ) && ( outcontrib [ 2 ] == 105 ) && ( 
  1193.       outcontrib [ 3 ] == 118 ) ) || ( ( outcontrib [ 1 ] == 77 ) && ( 
  1194.       outcontrib [ 2 ] == 79 ) && ( outcontrib [ 3 ] == 68 ) ) || ( ( 
  1195.       outcontrib [ 1 ] == 109 ) && ( outcontrib [ 2 ] == 111 ) && ( outcontrib 
  1196.       [ 3 ] == 100 ) ) ) ) || ( ( t == 0 ) && ( ( v == 42 ) || ( v == 47 ) ) ) 
  1197.       ) ) 
  1198.       {
  1199.     if ( ( outval < 0 ) || ( ( outval == 0 ) && ( lastsign < 0 ) ) ) 
  1200.     {
  1201.       outbuf [ outptr ] = 45 ; 
  1202.       outptr = outptr + 1 ; 
  1203.     } 
  1204.     else if ( outsign > 0 ) 
  1205.     {
  1206.       outbuf [ outptr ] = outsign ; 
  1207.       outptr = outptr + 1 ; 
  1208.     } 
  1209.     appval ( abs ( outval ) ) ; 
  1210.     if ( outptr > linelength ) 
  1211.     flushbuffer () ; 
  1212.     outsign = 43 ; 
  1213.     outval = outapp ; 
  1214.       } 
  1215.       else outval = outval + outapp ; 
  1216.       outstate = 3 ; 
  1217.       goto lab20 ; 
  1218.     } 
  1219.     break ; 
  1220.   case 0 : 
  1221.     if ( t != 3 ) 
  1222.     breakptr = outptr ; 
  1223.     break ; 
  1224.     default: 
  1225.     ; 
  1226.     break ; 
  1227.   } 
  1228.   if ( t != 0 ) 
  1229.   {register integer for_end; k = 1 ; for_end = v ; if ( k <= for_end) do 
  1230.     {
  1231.       outbuf [ outptr ] = outcontrib [ k ] ; 
  1232.       outptr = outptr + 1 ; 
  1233.     } 
  1234.   while ( k++ < for_end ) ; } 
  1235.   else {
  1236.       
  1237.     outbuf [ outptr ] = v ; 
  1238.     outptr = outptr + 1 ; 
  1239.   } 
  1240.   if ( outptr > linelength ) 
  1241.   flushbuffer () ; 
  1242.   if ( ( t == 0 ) && ( ( v == 59 ) || ( v == 125 ) ) ) 
  1243.   {
  1244.     semiptr = outptr ; 
  1245.     breakptr = outptr ; 
  1246.   } 
  1247.   if ( t >= 2 ) 
  1248.   outstate = 1 ; 
  1249.   else outstate = 0 ; 
  1250. } 
  1251. void zsendsign ( v ) 
  1252. integer v ; 
  1253. {switch ( outstate ) 
  1254.   {case 2 : 
  1255.   case 4 : 
  1256.     outapp = outapp * v ; 
  1257.     break ; 
  1258.   case 3 : 
  1259.     {
  1260.       outapp = v ; 
  1261.       outstate = 4 ; 
  1262.     } 
  1263.     break ; 
  1264.   case 5 : 
  1265.     {
  1266.       outval = outval + outapp ; 
  1267.       outapp = v ; 
  1268.       outstate = 4 ; 
  1269.     } 
  1270.     break ; 
  1271.     default: 
  1272.     {
  1273.       breakptr = outptr ; 
  1274.       outapp = v ; 
  1275.       outstate = 2 ; 
  1276.     } 
  1277.     break ; 
  1278.   } 
  1279.   lastsign = outapp ; 
  1280. } 
  1281. void zsendval ( v ) 
  1282. integer v ; 
  1283. {/* 666 10 */ switch ( outstate ) 
  1284.   {case 1 : 
  1285.     {
  1286.       if ( ( outptr == breakptr + 3 ) || ( ( outptr == breakptr + 4 ) && ( 
  1287.       outbuf [ breakptr ] == 32 ) ) ) 
  1288.       if ( ( ( outbuf [ outptr - 3 ] == 68 ) && ( outbuf [ outptr - 2 ] == 73 
  1289.       ) && ( outbuf [ outptr - 1 ] == 86 ) ) || ( ( outbuf [ outptr - 3 ] == 
  1290.       100 ) && ( outbuf [ outptr - 2 ] == 105 ) && ( outbuf [ outptr - 1 ] == 
  1291.       118 ) ) || ( ( outbuf [ outptr - 3 ] == 77 ) && ( outbuf [ outptr - 2 ] 
  1292.       == 79 ) && ( outbuf [ outptr - 1 ] == 68 ) ) || ( ( outbuf [ outptr - 3 
  1293.       ] == 109 ) && ( outbuf [ outptr - 2 ] == 111 ) && ( outbuf [ outptr - 1 
  1294.       ] == 100 ) ) ) 
  1295.       goto lab666 ; 
  1296.       outsign = 32 ; 
  1297.       outstate = 3 ; 
  1298.       outval = v ; 
  1299.       breakptr = outptr ; 
  1300.       lastsign = 1 ; 
  1301.     } 
  1302.     break ; 
  1303.   case 0 : 
  1304.     {
  1305.       if ( ( outptr == breakptr + 1 ) && ( ( outbuf [ breakptr ] == 42 ) || ( 
  1306.       outbuf [ breakptr ] == 47 ) ) ) 
  1307.       goto lab666 ; 
  1308.       outsign = 0 ; 
  1309.       outstate = 3 ; 
  1310.       outval = v ; 
  1311.       breakptr = outptr ; 
  1312.       lastsign = 1 ; 
  1313.     } 
  1314.     break ; 
  1315.   case 2 : 
  1316.     {
  1317.       outsign = 43 ; 
  1318.       outstate = 3 ; 
  1319.       outval = outapp * v ; 
  1320.     } 
  1321.     break ; 
  1322.   case 3 : 
  1323.     {
  1324.       outstate = 5 ; 
  1325.       outapp = v ; 
  1326.       {
  1327.     putc ('\n',  stdout );
  1328.     Fputs( stdout ,  "! Two numbers occurred without a sign between them"         ) ; 
  1329.     error () ; 
  1330.       } 
  1331.     } 
  1332.     break ; 
  1333.   case 4 : 
  1334.     {
  1335.       outstate = 5 ; 
  1336.       outapp = outapp * v ; 
  1337.     } 
  1338.     break ; 
  1339.   case 5 : 
  1340.     {
  1341.       outval = outval + outapp ; 
  1342.       outapp = v ; 
  1343.       {
  1344.     putc ('\n',  stdout );
  1345.     Fputs( stdout ,  "! Two numbers occurred without a sign between them"         ) ; 
  1346.     error () ; 
  1347.       } 
  1348.     } 
  1349.     break ; 
  1350.     default: 
  1351.     goto lab666 ; 
  1352.     break ; 
  1353.   } 
  1354.   goto lab10 ; 
  1355.   lab666: if ( v >= 0 ) 
  1356.   {
  1357.     if ( outstate == 1 ) 
  1358.     {
  1359.       breakptr = outptr ; 
  1360.       {
  1361.     outbuf [ outptr ] = 32 ; 
  1362.     outptr = outptr + 1 ; 
  1363.       } 
  1364.     } 
  1365.     appval ( v ) ; 
  1366.     if ( outptr > linelength ) 
  1367.     flushbuffer () ; 
  1368.     outstate = 1 ; 
  1369.   } 
  1370.   else {
  1371.       
  1372.     {
  1373.       outbuf [ outptr ] = 40 ; 
  1374.       outptr = outptr + 1 ; 
  1375.     } 
  1376.     {
  1377.       outbuf [ outptr ] = 45 ; 
  1378.       outptr = outptr + 1 ; 
  1379.     } 
  1380.     appval ( - (integer) v ) ; 
  1381.     {
  1382.       outbuf [ outptr ] = 41 ; 
  1383.       outptr = outptr + 1 ; 
  1384.     } 
  1385.     if ( outptr > linelength ) 
  1386.     flushbuffer () ; 
  1387.     outstate = 0 ; 
  1388.   } 
  1389.   lab10: ; 
  1390. } 
  1391. void sendtheoutput ( ) 
  1392. {/* 2 21 22 */ eightbits curchar  ; 
  1393.   integer k  ; 
  1394.   integer j  ; 
  1395.   char w  ; 
  1396.   integer n  ; 
  1397.   while ( stackptr > 0 ) {
  1398.       
  1399.     curchar = getoutput () ; 
  1400.     lab21: switch ( curchar ) 
  1401.     {case 0 : 
  1402.       ; 
  1403.       break ; 
  1404.     case 65 : 
  1405.     case 66 : 
  1406.     case 67 : 
  1407.     case 68 : 
  1408.     case 69 : 
  1409.     case 70 : 
  1410.     case 71 : 
  1411.     case 72 : 
  1412.     case 73 : 
  1413.     case 74 : 
  1414.     case 75 : 
  1415.     case 76 : 
  1416.     case 77 : 
  1417.     case 78 : 
  1418.     case 79 : 
  1419.     case 80 : 
  1420.     case 81 : 
  1421.     case 82 : 
  1422.     case 83 : 
  1423.     case 84 : 
  1424.     case 85 : 
  1425.     case 86 : 
  1426.     case 87 : 
  1427.     case 88 : 
  1428.     case 89 : 
  1429.     case 90 : 
  1430.     case 97 : 
  1431.     case 98 : 
  1432.     case 99 : 
  1433.     case 100 : 
  1434.     case 101 : 
  1435.     case 102 : 
  1436.     case 103 : 
  1437.     case 104 : 
  1438.     case 105 : 
  1439.     case 106 : 
  1440.     case 107 : 
  1441.     case 108 : 
  1442.     case 109 : 
  1443.     case 110 : 
  1444.     case 111 : 
  1445.     case 112 : 
  1446.     case 113 : 
  1447.     case 114 : 
  1448.     case 115 : 
  1449.     case 116 : 
  1450.     case 117 : 
  1451.     case 118 : 
  1452.     case 119 : 
  1453.     case 120 : 
  1454.     case 121 : 
  1455.     case 122 : 
  1456.       {
  1457.     outcontrib [ 1 ] = curchar ; 
  1458.     sendout ( 2 , 1 ) ; 
  1459.       } 
  1460.       break ; 
  1461.     case 130 : 
  1462.       {
  1463.     k = 0 ; 
  1464.     j = bytestart [ curval ] ; 
  1465.     w = curval % 3 ; 
  1466.     while ( ( k < maxidlength ) && ( j < bytestart [ curval + 3 ] ) ) {
  1467.         
  1468.       k = k + 1 ; 
  1469.       outcontrib [ k ] = bytemem [ w ][ j ] ; 
  1470.       j = j + 1 ; 
  1471.       if ( outcontrib [ k ] == 95 ) 
  1472.       k = k - 1 ; 
  1473.     } 
  1474.     sendout ( 2 , k ) ; 
  1475.       } 
  1476.       break ; 
  1477.     case 48 : 
  1478.     case 49 : 
  1479.     case 50 : 
  1480.     case 51 : 
  1481.     case 52 : 
  1482.     case 53 : 
  1483.     case 54 : 
  1484.     case 55 : 
  1485.     case 56 : 
  1486.     case 57 : 
  1487.       {
  1488.     n = 0 ; 
  1489.     do {
  1490.         curchar = curchar - 48 ; 
  1491.       if ( n >= 214748364L ) 
  1492.       {
  1493.         putc ('\n',  stdout );
  1494.         Fputs( stdout ,  "! Constant too big" ) ; 
  1495.         error () ; 
  1496.       } 
  1497.       else n = 10 * n + curchar ; 
  1498.       curchar = getoutput () ; 
  1499.     } while ( ! ( ( curchar > 57 ) || ( curchar < 48 ) ) ) ; 
  1500.     sendval ( n ) ; 
  1501.     k = 0 ; 
  1502.     if ( curchar == 101 ) 
  1503.     curchar = 69 ; 
  1504.     if ( curchar == 69 ) 
  1505.     goto lab2 ; 
  1506.     else goto lab21 ; 
  1507.       } 
  1508.       break ; 
  1509.     case 125 : 
  1510.       sendval ( poolchecksum ) ; 
  1511.       break ; 
  1512.     case 12 : 
  1513.       {
  1514.     n = 0 ; 
  1515.     curchar = 48 ; 
  1516.     do {
  1517.         curchar = curchar - 48 ; 
  1518.       if ( n >= 268435456L ) 
  1519.       {
  1520.         putc ('\n',  stdout );
  1521.         Fputs( stdout ,  "! Constant too big" ) ; 
  1522.         error () ; 
  1523.       } 
  1524.       else n = 8 * n + curchar ; 
  1525.       curchar = getoutput () ; 
  1526.     } while ( ! ( ( curchar > 55 ) || ( curchar < 48 ) ) ) ; 
  1527.     sendval ( n ) ; 
  1528.     goto lab21 ; 
  1529.       } 
  1530.       break ; 
  1531.     case 13 : 
  1532.       {
  1533.     n = 0 ; 
  1534.     curchar = 48 ; 
  1535.     do {
  1536.         if ( curchar >= 65 ) 
  1537.       curchar = curchar - 55 ; 
  1538.       else curchar = curchar - 48 ; 
  1539.       if ( n >= 134217728L ) 
  1540.       {
  1541.         putc ('\n',  stdout );
  1542.         Fputs( stdout ,  "! Constant too big" ) ; 
  1543.         error () ; 
  1544.       } 
  1545.       else n = 16 * n + curchar ; 
  1546.       curchar = getoutput () ; 
  1547.     } while ( ! ( ( curchar > 70 ) || ( curchar < 48 ) || ( ( curchar > 57 
  1548.     ) && ( curchar < 65 ) ) ) ) ; 
  1549.     sendval ( n ) ; 
  1550.     goto lab21 ; 
  1551.       } 
  1552.       break ; 
  1553.     case 128 : 
  1554.       sendval ( curval ) ; 
  1555.       break ; 
  1556.     case 46 : 
  1557.       {
  1558.     k = 1 ; 
  1559.     outcontrib [ 1 ] = 46 ; 
  1560.     curchar = getoutput () ; 
  1561.     if ( curchar == 46 ) 
  1562.     {
  1563.       outcontrib [ 2 ] = 46 ; 
  1564.       sendout ( 1 , 2 ) ; 
  1565.     } 
  1566.     else if ( ( curchar >= 48 ) && ( curchar <= 57 ) ) 
  1567.     goto lab2 ; 
  1568.     else {
  1569.         
  1570.       sendout ( 0 , 46 ) ; 
  1571.       goto lab21 ; 
  1572.     } 
  1573.       } 
  1574.       break ; 
  1575.     case 43 : 
  1576.     case 45 : 
  1577.       sendsign ( 44 - curchar ) ; 
  1578.       break ; 
  1579.     case 4 : 
  1580.       {
  1581.     outcontrib [ 1 ] = 97 ; 
  1582.     outcontrib [ 2 ] = 110 ; 
  1583.     outcontrib [ 3 ] = 100 ; 
  1584.     sendout ( 2 , 3 ) ; 
  1585.       } 
  1586.       break ; 
  1587.     case 5 : 
  1588.       {
  1589.     outcontrib [ 1 ] = 110 ; 
  1590.     outcontrib [ 2 ] = 111 ; 
  1591.     outcontrib [ 3 ] = 116 ; 
  1592.     sendout ( 2 , 3 ) ; 
  1593.       } 
  1594.       break ; 
  1595.     case 6 : 
  1596.       {
  1597.     outcontrib [ 1 ] = 105 ; 
  1598.     outcontrib [ 2 ] = 110 ; 
  1599.     sendout ( 2 , 2 ) ; 
  1600.       } 
  1601.       break ; 
  1602.     case 31 : 
  1603.       {
  1604.     outcontrib [ 1 ] = 111 ; 
  1605.     outcontrib [ 2 ] = 114 ; 
  1606.     sendout ( 2 , 2 ) ; 
  1607.       } 
  1608.       break ; 
  1609.     case 24 : 
  1610.       {
  1611.     outcontrib [ 1 ] = 58 ; 
  1612.     outcontrib [ 2 ] = 61 ; 
  1613.     sendout ( 1 , 2 ) ; 
  1614.       } 
  1615.       break ; 
  1616.     case 26 : 
  1617.       {
  1618.     outcontrib [ 1 ] = 60 ; 
  1619.     outcontrib [ 2 ] = 62 ; 
  1620.     sendout ( 1 , 2 ) ; 
  1621.       } 
  1622.       break ; 
  1623.     case 28 : 
  1624.       {
  1625.     outcontrib [ 1 ] = 60 ; 
  1626.     outcontrib [ 2 ] = 61 ; 
  1627.     sendout ( 1 , 2 ) ; 
  1628.       } 
  1629.       break ; 
  1630.     case 29 : 
  1631.       {
  1632.     outcontrib [ 1 ] = 62 ; 
  1633.     outcontrib [ 2 ] = 61 ; 
  1634.     sendout ( 1 , 2 ) ; 
  1635.       } 
  1636.       break ; 
  1637.     case 30 : 
  1638.       {
  1639.     outcontrib [ 1 ] = 61 ; 
  1640.     outcontrib [ 2 ] = 61 ; 
  1641.     sendout ( 1 , 2 ) ; 
  1642.       } 
  1643.       break ; 
  1644.     case 32 : 
  1645.       {
  1646.     outcontrib [ 1 ] = 46 ; 
  1647.     outcontrib [ 2 ] = 46 ; 
  1648.     sendout ( 1 , 2 ) ; 
  1649.       } 
  1650.       break ; 
  1651.     case 39 : 
  1652.       {
  1653.     k = 1 ; 
  1654.     outcontrib [ 1 ] = 39 ; 
  1655.     do {
  1656.         if ( k < linelength ) 
  1657.       k = k + 1 ; 
  1658.       outcontrib [ k ] = getoutput () ; 
  1659.     } while ( ! ( ( outcontrib [ k ] == 39 ) || ( stackptr == 0 ) ) ) ; 
  1660.     if ( k == linelength ) 
  1661.     {
  1662.       putc ('\n',  stdout );
  1663.       Fputs( stdout ,  "! String too long" ) ; 
  1664.       error () ; 
  1665.     } 
  1666.     sendout ( 1 , k ) ; 
  1667.     curchar = getoutput () ; 
  1668.     if ( curchar == 39 ) 
  1669.     outstate = 6 ; 
  1670.     goto lab21 ; 
  1671.       } 
  1672.       break ; 
  1673.     case 33 : 
  1674.     case 34 : 
  1675.     case 35 : 
  1676.     case 36 : 
  1677.     case 37 : 
  1678.     case 38 : 
  1679.     case 40 : 
  1680.     case 41 : 
  1681.     case 42 : 
  1682.     case 44 : 
  1683.     case 47 : 
  1684.     case 58 : 
  1685.     case 59 : 
  1686.     case 60 : 
  1687.     case 61 : 
  1688.     case 62 : 
  1689.     case 63 : 
  1690.     case 64 : 
  1691.     case 91 : 
  1692.     case 92 : 
  1693.     case 93 : 
  1694.     case 94 : 
  1695.     case 95 : 
  1696.     case 96 : 
  1697.     case 123 : 
  1698.     case 124 : 
  1699.       sendout ( 0 , curchar ) ; 
  1700.       break ; 
  1701.     case 9 : 
  1702.       {
  1703.     if ( bracelevel == 0 ) 
  1704.     sendout ( 0 , 123 ) ; 
  1705.     else sendout ( 0 , 91 ) ; 
  1706.     bracelevel = bracelevel + 1 ; 
  1707.       } 
  1708.       break ; 
  1709.     case 10 : 
  1710.       if ( bracelevel > 0 ) 
  1711.       {
  1712.     bracelevel = bracelevel - 1 ; 
  1713.     if ( bracelevel == 0 ) 
  1714.     sendout ( 0 , 125 ) ; 
  1715.     else sendout ( 0 , 93 ) ; 
  1716.       } 
  1717.       else {
  1718.       
  1719.     putc ('\n',  stdout );
  1720.     Fputs( stdout ,  "! Extra @}" ) ; 
  1721.     error () ; 
  1722.       } 
  1723.       break ; 
  1724.     case 129 : 
  1725.       {
  1726.     if ( bracelevel == 0 ) 
  1727.     sendout ( 0 , 123 ) ; 
  1728.     else sendout ( 0 , 91 ) ; 
  1729.     if ( curval < 0 ) 
  1730.     {
  1731.       sendout ( 0 , 58 ) ; 
  1732.       sendval ( - (integer) curval ) ; 
  1733.     } 
  1734.     else {
  1735.         
  1736.       sendval ( curval ) ; 
  1737.       sendout ( 0 , 58 ) ; 
  1738.     } 
  1739.     if ( bracelevel == 0 ) 
  1740.     sendout ( 0 , 125 ) ; 
  1741.     else sendout ( 0 , 93 ) ; 
  1742.       } 
  1743.       break ; 
  1744.     case 127 : 
  1745.       {
  1746.     sendout ( 3 , 0 ) ; 
  1747.     outstate = 6 ; 
  1748.       } 
  1749.       break ; 
  1750.     case 2 : 
  1751.       {
  1752.     k = 0 ; 
  1753.     do {
  1754.         if ( k < linelength ) 
  1755.       k = k + 1 ; 
  1756.       outcontrib [ k ] = getoutput () ; 
  1757.     } while ( ! ( ( outcontrib [ k ] == 2 ) || ( stackptr == 0 ) ) ) ; 
  1758.     if ( k == linelength ) 
  1759.     {
  1760.       putc ('\n',  stdout );
  1761.       Fputs( stdout ,  "! Verbatim string too long" ) ; 
  1762.       error () ; 
  1763.     } 
  1764.     sendout ( 1 , k - 1 ) ; 
  1765.       } 
  1766.       break ; 
  1767.     case 3 : 
  1768.       {
  1769.     sendout ( 1 , 0 ) ; 
  1770.     while ( outptr > 0 ) {
  1771.         
  1772.       if ( outptr <= linelength ) 
  1773.       breakptr = outptr ; 
  1774.       flushbuffer () ; 
  1775.     } 
  1776.     outstate = 0 ; 
  1777.       } 
  1778.       break ; 
  1779.       default: 
  1780.       {
  1781.     putc ('\n',  stdout );
  1782.     fprintf( stdout , "%s%ld",  "! Can't output ASCII code " , (long)curchar ) ; 
  1783.     error () ; 
  1784.       } 
  1785.       break ; 
  1786.     } 
  1787.     goto lab22 ; 
  1788.     lab2: do {
  1789.     if ( k < linelength ) 
  1790.       k = k + 1 ; 
  1791.       outcontrib [ k ] = curchar ; 
  1792.       curchar = getoutput () ; 
  1793.       if ( ( outcontrib [ k ] == 69 ) && ( ( curchar == 43 ) || ( curchar == 
  1794.       45 ) ) ) 
  1795.       {
  1796.     if ( k < linelength ) 
  1797.     k = k + 1 ; 
  1798.     outcontrib [ k ] = curchar ; 
  1799.     curchar = getoutput () ; 
  1800.       } 
  1801.       else if ( curchar == 101 ) 
  1802.       curchar = 69 ; 
  1803.     } while ( ! ( ( curchar != 69 ) && ( ( curchar < 48 ) || ( curchar > 57 ) 
  1804.     ) ) ) ; 
  1805.     if ( k == linelength ) 
  1806.     {
  1807.       putc ('\n',  stdout );
  1808.       Fputs( stdout ,  "! Fraction too long" ) ; 
  1809.       error () ; 
  1810.     } 
  1811.     sendout ( 3 , k ) ; 
  1812.     goto lab21 ; 
  1813.     lab22: ; 
  1814.   } 
  1815. } 
  1816. boolean linesdontmatch ( ) 
  1817. {/* 10 */ register boolean Result; integer k  ; 
  1818.   Result = true ; 
  1819.   if ( changelimit != limit ) 
  1820.   goto lab10 ; 
  1821.   if ( limit > 0 ) 
  1822.   {register integer for_end; k = 0 ; for_end = limit - 1 ; if ( k <= for_end) 
  1823.   do 
  1824.     if ( changebuffer [ k ] != buffer [ k ] ) 
  1825.     goto lab10 ; 
  1826.   while ( k++ < for_end ) ; } 
  1827.   Result = false ; 
  1828.   lab10: ; 
  1829.   return(Result) ; 
  1830. } 
  1831. void primethechangebuffer ( ) 
  1832. {/* 22 30 10 */ integer k  ; 
  1833.   changelimit = 0 ; 
  1834.   while ( true ) {
  1835.       
  1836.     line = line + 1 ; 
  1837.     if ( ! inputln ( changefile ) ) 
  1838.     goto lab10 ; 
  1839.     if ( limit < 2 ) 
  1840.     goto lab22 ; 
  1841.     if ( buffer [ 0 ] != 64 ) 
  1842.     goto lab22 ; 
  1843.     if ( ( buffer [ 1 ] >= 88 ) && ( buffer [ 1 ] <= 90 ) ) 
  1844.     buffer [ 1 ] = buffer [ 1 ] + 32 ; 
  1845.     if ( buffer [ 1 ] == 120 ) 
  1846.     goto lab30 ; 
  1847.     if ( ( buffer [ 1 ] == 121 ) || ( buffer [ 1 ] == 122 ) ) 
  1848.     {
  1849.       loc = 2 ; 
  1850.       {
  1851.     putc ('\n',  stdout );
  1852.     Fputs( stdout ,  "! Where is the matching @x?" ) ; 
  1853.     error () ; 
  1854.       } 
  1855.     } 
  1856.     lab22: ; 
  1857.   } 
  1858.   lab30: ; 
  1859.   do {
  1860.       line = line + 1 ; 
  1861.     if ( ! inputln ( changefile ) ) 
  1862.     {
  1863.       {
  1864.     putc ('\n',  stdout );
  1865.     Fputs( stdout ,  "! Change file ended after @x" ) ; 
  1866.     error () ; 
  1867.       } 
  1868.       goto lab10 ; 
  1869.     } 
  1870.   } while ( ! ( limit > 0 ) ) ; 
  1871.   {
  1872.     changelimit = limit ; 
  1873.     if ( limit > 0 ) 
  1874.     {register integer for_end; k = 0 ; for_end = limit - 1 ; if ( k <= 
  1875.     for_end) do 
  1876.       changebuffer [ k ] = buffer [ k ] ; 
  1877.     while ( k++ < for_end ) ; } 
  1878.   } 
  1879.   lab10: ; 
  1880. } 
  1881. void checkchange ( ) 
  1882. {/* 10 */ integer n  ; 
  1883.   integer k  ; 
  1884.   if ( linesdontmatch () ) 
  1885.   goto lab10 ; 
  1886.   n = 0 ; 
  1887.   while ( true ) {
  1888.       
  1889.     changing = ! changing ; 
  1890.     templine = otherline ; 
  1891.     otherline = line ; 
  1892.     line = templine ; 
  1893.     line = line + 1 ; 
  1894.     if ( ! inputln ( changefile ) ) 
  1895.     {
  1896.       {
  1897.     putc ('\n',  stdout );
  1898.     Fputs( stdout ,  "! Change file ended before @y" ) ; 
  1899.     error () ; 
  1900.       } 
  1901.       changelimit = 0 ; 
  1902.       changing = ! changing ; 
  1903.       templine = otherline ; 
  1904.       otherline = line ; 
  1905.       line = templine ; 
  1906.       goto lab10 ; 
  1907.     } 
  1908.     if ( limit > 1 ) 
  1909.     if ( buffer [ 0 ] == 64 ) 
  1910.     {
  1911.       if ( ( buffer [ 1 ] >= 88 ) && ( buffer [ 1 ] <= 90 ) ) 
  1912.       buffer [ 1 ] = buffer [ 1 ] + 32 ; 
  1913.       if ( ( buffer [ 1 ] == 120 ) || ( buffer [ 1 ] == 122 ) ) 
  1914.       {
  1915.     loc = 2 ; 
  1916.     {
  1917.       putc ('\n',  stdout );
  1918.       Fputs( stdout ,  "! Where is the matching @y?" ) ; 
  1919.       error () ; 
  1920.     } 
  1921.       } 
  1922.       else if ( buffer [ 1 ] == 121 ) 
  1923.       {
  1924.     if ( n > 0 ) 
  1925.     {
  1926.       loc = 2 ; 
  1927.       {
  1928.         putc ('\n',  stdout );
  1929.         fprintf( stdout , "%s%ld%s",  "! Hmm... " , (long)n ,             " of the preceding lines failed to match" ) ; 
  1930.         error () ; 
  1931.       } 
  1932.     } 
  1933.     goto lab10 ; 
  1934.       } 
  1935.     } 
  1936.     {
  1937.       changelimit = limit ; 
  1938.       if ( limit > 0 ) 
  1939.       {register integer for_end; k = 0 ; for_end = limit - 1 ; if ( k <= 
  1940.       for_end) do 
  1941.     changebuffer [ k ] = buffer [ k ] ; 
  1942.       while ( k++ < for_end ) ; } 
  1943.     } 
  1944.     changing = ! changing ; 
  1945.     templine = otherline ; 
  1946.     otherline = line ; 
  1947.     line = templine ; 
  1948.     line = line + 1 ; 
  1949.     if ( ! inputln ( webfile ) ) 
  1950.     {
  1951.       {
  1952.     putc ('\n',  stdout );
  1953.     Fputs( stdout ,  "! WEB file ended during a change" ) ; 
  1954.     error () ; 
  1955.       } 
  1956.       inputhasended = true ; 
  1957.       goto lab10 ; 
  1958.     } 
  1959.     if ( linesdontmatch () ) 
  1960.     n = n + 1 ; 
  1961.   } 
  1962.   lab10: ; 
  1963. } 
  1964. void getline ( ) 
  1965. {/* 20 */ lab20: if ( changing ) 
  1966.   {
  1967.     line = line + 1 ; 
  1968.     if ( ! inputln ( changefile ) ) 
  1969.     {
  1970.       {
  1971.     putc ('\n',  stdout );
  1972.     Fputs( stdout ,  "! Change file ended without @z" ) ; 
  1973.     error () ; 
  1974.       } 
  1975.       buffer [ 0 ] = 64 ; 
  1976.       buffer [ 1 ] = 122 ; 
  1977.       limit = 2 ; 
  1978.     } 
  1979.     if ( limit > 1 ) 
  1980.     if ( buffer [ 0 ] == 64 ) 
  1981.     {
  1982.       if ( ( buffer [ 1 ] >= 88 ) && ( buffer [ 1 ] <= 90 ) ) 
  1983.       buffer [ 1 ] = buffer [ 1 ] + 32 ; 
  1984.       if ( ( buffer [ 1 ] == 120 ) || ( buffer [ 1 ] == 121 ) ) 
  1985.       {
  1986.     loc = 2 ; 
  1987.     {
  1988.       putc ('\n',  stdout );
  1989.       Fputs( stdout ,  "! Where is the matching @z?" ) ; 
  1990.       error () ; 
  1991.     } 
  1992.       } 
  1993.       else if ( buffer [ 1 ] == 122 ) 
  1994.       {
  1995.     primethechangebuffer () ; 
  1996.     changing = ! changing ; 
  1997.     templine = otherline ; 
  1998.     otherline = line ; 
  1999.     line = templine ; 
  2000.       } 
  2001.     } 
  2002.   } 
  2003.   if ( ! changing ) 
  2004.   {
  2005.     {
  2006.       line = line + 1 ; 
  2007.       if ( ! inputln ( webfile ) ) 
  2008.       inputhasended = true ; 
  2009.       else if ( limit == changelimit ) 
  2010.       if ( buffer [ 0 ] == changebuffer [ 0 ] ) 
  2011.       if ( changelimit > 0 ) 
  2012.       checkchange () ; 
  2013.     } 
  2014.     if ( changing ) 
  2015.     goto lab20 ; 
  2016.   } 
  2017.   loc = 0 ; 
  2018.   buffer [ limit ] = 32 ; 
  2019. } 
  2020. eightbits zcontrolcode ( c ) 
  2021. ASCIIcode c ; 
  2022. {register eightbits Result; switch ( c ) 
  2023.   {case 64 : 
  2024.     Result = 64 ; 
  2025.     break ; 
  2026.   case 39 : 
  2027.     Result = 12 ; 
  2028.     break ; 
  2029.   case 34 : 
  2030.     Result = 13 ; 
  2031.     break ; 
  2032.   case 36 : 
  2033.     Result = 125 ; 
  2034.     break ; 
  2035.   case 32 : 
  2036.   case 9 : 
  2037.     Result = 136 ; 
  2038.     break ; 
  2039.   case 42 : 
  2040.     {
  2041.       fprintf( stdout , "%c%ld",  '*' , (long)modulecount + 1 ) ; 
  2042.       flush ( stdout ) ; 
  2043.       Result = 136 ; 
  2044.     } 
  2045.     break ; 
  2046.   case 68 : 
  2047.   case 100 : 
  2048.     Result = 133 ; 
  2049.     break ; 
  2050.   case 70 : 
  2051.   case 102 : 
  2052.     Result = 132 ; 
  2053.     break ; 
  2054.   case 123 : 
  2055.     Result = 9 ; 
  2056.     break ; 
  2057.   case 125 : 
  2058.     Result = 10 ; 
  2059.     break ; 
  2060.   case 80 : 
  2061.   case 112 : 
  2062.     Result = 134 ; 
  2063.     break ; 
  2064.   case 84 : 
  2065.   case 116 : 
  2066.   case 94 : 
  2067.   case 46 : 
  2068.   case 58 : 
  2069.     Result = 131 ; 
  2070.     break ; 
  2071.   case 38 : 
  2072.     Result = 127 ; 
  2073.     break ; 
  2074.   case 60 : 
  2075.     Result = 135 ; 
  2076.     break ; 
  2077.   case 61 : 
  2078.     Result = 2 ; 
  2079.     break ; 
  2080.   case 92 : 
  2081.     Result = 3 ; 
  2082.     break ; 
  2083.     default: 
  2084.     Result = 0 ; 
  2085.     break ; 
  2086.   } 
  2087.   return(Result) ; 
  2088. } 
  2089. eightbits skipahead ( ) 
  2090. {/* 30 */ register eightbits Result; eightbits c  ; 
  2091.   while ( true ) {
  2092.       
  2093.     if ( loc > limit ) 
  2094.     {
  2095.       getline () ; 
  2096.       if ( inputhasended ) 
  2097.       {
  2098.     c = 136 ; 
  2099.     goto lab30 ; 
  2100.       } 
  2101.     } 
  2102.     buffer [ limit + 1 ] = 64 ; 
  2103.     while ( buffer [ loc ] != 64 ) loc = loc + 1 ; 
  2104.     if ( loc <= limit ) 
  2105.     {
  2106.       loc = loc + 2 ; 
  2107.       c = controlcode ( buffer [ loc - 1 ] ) ; 
  2108.       if ( ( c != 0 ) || ( buffer [ loc - 1 ] == 62 ) ) 
  2109.       goto lab30 ; 
  2110.     } 
  2111.   } 
  2112.   lab30: Result = c ; 
  2113.   return(Result) ; 
  2114. } 
  2115. void skipcomment ( ) 
  2116. {/* 10 */ eightbits bal  ; 
  2117.   ASCIIcode c  ; 
  2118.   bal = 0 ; 
  2119.   while ( true ) {
  2120.       
  2121.     if ( loc > limit ) 
  2122.     {
  2123.       getline () ; 
  2124.       if ( inputhasended ) 
  2125.       {
  2126.     {
  2127.       putc ('\n',  stdout );
  2128.       Fputs( stdout ,  "! Input ended in mid-comment" ) ; 
  2129.       error () ; 
  2130.     } 
  2131.     goto lab10 ; 
  2132.       } 
  2133.     } 
  2134.     c = buffer [ loc ] ; 
  2135.     loc = loc + 1 ; 
  2136.     if ( c == 64 ) 
  2137.     {
  2138.       c = buffer [ loc ] ; 
  2139.       if ( ( c != 32 ) && ( c != 9 ) && ( c != 42 ) && ( c != 122 ) && ( c != 
  2140.       90 ) ) 
  2141.       loc = loc + 1 ; 
  2142.       else {
  2143.       
  2144.     {
  2145.       putc ('\n',  stdout );
  2146.       Fputs( stdout ,  "! Section ended in mid-comment" ) ; 
  2147.       error () ; 
  2148.     } 
  2149.     loc = loc - 1 ; 
  2150.     goto lab10 ; 
  2151.       } 
  2152.     } 
  2153.     else if ( ( c == 92 ) && ( buffer [ loc ] != 64 ) ) 
  2154.     loc = loc + 1 ; 
  2155.     else if ( c == 123 ) 
  2156.     bal = bal + 1 ; 
  2157.     else if ( c == 125 ) 
  2158.     {
  2159.       if ( bal == 0 ) 
  2160.       goto lab10 ; 
  2161.       bal = bal - 1 ; 
  2162.     } 
  2163.   } 
  2164.   lab10: ; 
  2165. } 
  2166. eightbits getnext ( ) 
  2167. {/* 20 30 31 */ register eightbits Result; eightbits c  ; 
  2168.   eightbits d  ; 
  2169.   integer j, k  ; 
  2170.   lab20: if ( loc > limit ) 
  2171.   {
  2172.     getline () ; 
  2173.     if ( inputhasended ) 
  2174.     {
  2175.       c = 136 ; 
  2176.       goto lab31 ; 
  2177.     } 
  2178.   } 
  2179.   c = buffer [ loc ] ; 
  2180.   loc = loc + 1 ; 
  2181.   if ( scanninghex ) 
  2182.   if ( ( ( c >= 48 ) && ( c <= 57 ) ) || ( ( c >= 65 ) && ( c <= 70 ) ) ) 
  2183.   goto lab31 ; 
  2184.   else scanninghex = false ; 
  2185.   switch ( c ) 
  2186.   {case 65 : 
  2187.   case 66 : 
  2188.   case 67 : 
  2189.   case 68 : 
  2190.   case 69 : 
  2191.   case 70 : 
  2192.   case 71 : 
  2193.   case 72 : 
  2194.   case 73 : 
  2195.   case 74 : 
  2196.   case 75 : 
  2197.   case 76 : 
  2198.   case 77 : 
  2199.   case 78 : 
  2200.   case 79 : 
  2201.   case 80 : 
  2202.   case 81 : 
  2203.   case 82 : 
  2204.   case 83 : 
  2205.   case 84 : 
  2206.   case 85 : 
  2207.   case 86 : 
  2208.   case 87 : 
  2209.   case 88 : 
  2210.   case 89 : 
  2211.   case 90 : 
  2212.   case 97 : 
  2213.   case 98 : 
  2214.   case 99 : 
  2215.   case 100 : 
  2216.   case 101 : 
  2217.   case 102 : 
  2218.   case 103 : 
  2219.   case 104 : 
  2220.   case 105 : 
  2221.   case 106 : 
  2222.   case 107 : 
  2223.   case 108 : 
  2224.   case 109 : 
  2225.   case 110 : 
  2226.   case 111 : 
  2227.   case 112 : 
  2228.   case 113 : 
  2229.   case 114 : 
  2230.   case 115 : 
  2231.   case 116 : 
  2232.   case 117 : 
  2233.   case 118 : 
  2234.   case 119 : 
  2235.   case 120 : 
  2236.   case 121 : 
  2237.   case 122 : 
  2238.     {
  2239.       if ( ( ( c == 101 ) || ( c == 69 ) ) && ( loc > 1 ) ) 
  2240.       if ( ( buffer [ loc - 2 ] <= 57 ) && ( buffer [ loc - 2 ] >= 48 ) ) 
  2241.       c = 0 ; 
  2242.       if ( c != 0 ) 
  2243.       {
  2244.     loc = loc - 1 ; 
  2245.     idfirst = loc ; 
  2246.     do {
  2247.         loc = loc + 1 ; 
  2248.       d = buffer [ loc ] ; 
  2249.     } while ( ! ( ( ( d < 48 ) || ( ( d > 57 ) && ( d < 65 ) ) || ( ( d > 
  2250.     90 ) && ( d < 97 ) ) || ( d > 122 ) ) && ( d != 95 ) ) ) ; 
  2251.     if ( loc > idfirst + 1 ) 
  2252.     {
  2253.       c = 130 ; 
  2254.       idloc = loc ; 
  2255.     } 
  2256.       } 
  2257.       else c = 69 ; 
  2258.     } 
  2259.     break ; 
  2260.   case 34 : 
  2261.     {
  2262.       doublechars = 0 ; 
  2263.       idfirst = loc - 1 ; 
  2264.       do {
  2265.       d = buffer [ loc ] ; 
  2266.     loc = loc + 1 ; 
  2267.     if ( ( d == 34 ) || ( d == 64 ) ) 
  2268.     if ( buffer [ loc ] == d ) 
  2269.     {
  2270.       loc = loc + 1 ; 
  2271.       d = 0 ; 
  2272.       doublechars = doublechars + 1 ; 
  2273.     } 
  2274.     else {
  2275.         
  2276.       if ( d == 64 ) 
  2277.       {
  2278.         putc ('\n',  stdout );
  2279.         Fputs( stdout ,  "! Double @ sign missing" ) ; 
  2280.         error () ; 
  2281.       } 
  2282.     } 
  2283.     else if ( loc > limit ) 
  2284.     {
  2285.       {
  2286.         putc ('\n',  stdout );
  2287.         Fputs( stdout ,  "! String constant didn't end" ) ; 
  2288.         error () ; 
  2289.       } 
  2290.       d = 34 ; 
  2291.     } 
  2292.       } while ( ! ( d == 34 ) ) ; 
  2293.       idloc = loc - 1 ; 
  2294.       c = 130 ; 
  2295.     } 
  2296.     break ; 
  2297.   case 64 : 
  2298.     {
  2299.       c = controlcode ( buffer [ loc ] ) ; 
  2300.       loc = loc + 1 ; 
  2301.       if ( c == 0 ) 
  2302.       goto lab20 ; 
  2303.       else if ( c == 13 ) 
  2304.       scanninghex = true ; 
  2305.       else if ( c == 135 ) 
  2306.       {
  2307.     k = 0 ; 
  2308.     while ( true ) {
  2309.         
  2310.       if ( loc > limit ) 
  2311.       {
  2312.         getline () ; 
  2313.         if ( inputhasended ) 
  2314.         {
  2315.           {
  2316.         putc ('\n',  stdout );
  2317.         Fputs( stdout ,  "! Input ended in section name" ) ; 
  2318.         error () ; 
  2319.           } 
  2320.           goto lab30 ; 
  2321.         } 
  2322.       } 
  2323.       d = buffer [ loc ] ; 
  2324.       if ( d == 64 ) 
  2325.       {
  2326.         d = buffer [ loc + 1 ] ; 
  2327.         if ( d == 62 ) 
  2328.         {
  2329.           loc = loc + 2 ; 
  2330.           goto lab30 ; 
  2331.         } 
  2332.         if ( ( d == 32 ) || ( d == 9 ) || ( d == 42 ) ) 
  2333.         {
  2334.           {
  2335.         putc ('\n',  stdout );
  2336.         Fputs( stdout ,  "! Section name didn't end" ) ; 
  2337.         error () ; 
  2338.           } 
  2339.           goto lab30 ; 
  2340.         } 
  2341.         k = k + 1 ; 
  2342.         modtext [ k ] = 64 ; 
  2343.         loc = loc + 1 ; 
  2344.       } 
  2345.       loc = loc + 1 ; 
  2346.       if ( k < longestname - 1 ) 
  2347.       k = k + 1 ; 
  2348.       if ( ( d == 32 ) || ( d == 9 ) ) 
  2349.       {
  2350.         d = 32 ; 
  2351.         if ( modtext [ k - 1 ] == 32 ) 
  2352.         k = k - 1 ; 
  2353.       } 
  2354.       modtext [ k ] = d ; 
  2355.     } 
  2356.     lab30: if ( k >= longestname - 2 ) 
  2357.     {
  2358.       {
  2359.         putc ('\n',  stdout );
  2360.         Fputs( stdout ,  "! Section name too long: " ) ; 
  2361.       } 
  2362.       {register integer for_end; j = 1 ; for_end = 25 ; if ( j <= 
  2363.       for_end) do 
  2364.         putc ( xchr [ modtext [ j ] ] ,  stdout );
  2365.       while ( j++ < for_end ) ; } 
  2366.       Fputs( stdout ,  "..." ) ; 
  2367.       if ( history == 0 ) 
  2368.       history = 1 ; 
  2369.     } 
  2370.     if ( ( modtext [ k ] == 32 ) && ( k > 0 ) ) 
  2371.     k = k - 1 ; 
  2372.     if ( k > 3 ) 
  2373.     {
  2374.       if ( ( modtext [ k ] == 46 ) && ( modtext [ k - 1 ] == 46 ) && ( 
  2375.       modtext [ k - 2 ] == 46 ) ) 
  2376.       curmodule = prefixlookup ( k - 3 ) ; 
  2377.       else curmodule = modlookup ( k ) ; 
  2378.     } 
  2379.     else curmodule = modlookup ( k ) ; 
  2380.       } 
  2381.       else if ( c == 131 ) 
  2382.       {
  2383.     do {
  2384.         c = skipahead () ; 
  2385.     } while ( ! ( c != 64 ) ) ; 
  2386.     if ( buffer [ loc - 1 ] != 62 ) 
  2387.     {
  2388.       putc ('\n',  stdout );
  2389.       Fputs( stdout ,  "! Improper @ within control text" ) ; 
  2390.       error () ; 
  2391.     } 
  2392.     goto lab20 ; 
  2393.       } 
  2394.     } 
  2395.     break ; 
  2396.   case 46 : 
  2397.     if ( buffer [ loc ] == 46 ) 
  2398.     {
  2399.       if ( loc <= limit ) 
  2400.       {
  2401.     c = 32 ; 
  2402.     loc = loc + 1 ; 
  2403.       } 
  2404.     } 
  2405.     else if ( buffer [ loc ] == 41 ) 
  2406.     {
  2407.       if ( loc <= limit ) 
  2408.       {
  2409.     c = 93 ; 
  2410.     loc = loc + 1 ; 
  2411.       } 
  2412.     } 
  2413.     break ; 
  2414.   case 58 : 
  2415.     if ( buffer [ loc ] == 61 ) 
  2416.     {
  2417.       if ( loc <= limit ) 
  2418.       {
  2419.     c = 24 ; 
  2420.     loc = loc + 1 ; 
  2421.       } 
  2422.     } 
  2423.     break ; 
  2424.   case 61 : 
  2425.     if ( buffer [ loc ] == 61 ) 
  2426.     {
  2427.       if ( loc <= limit ) 
  2428.       {
  2429.     c = 30 ; 
  2430.     loc = loc + 1 ; 
  2431.       } 
  2432.     } 
  2433.     break ; 
  2434.   case 62 : 
  2435.     if ( buffer [ loc ] == 61 ) 
  2436.     {
  2437.       if ( loc <= limit ) 
  2438.       {
  2439.     c = 29 ; 
  2440.     loc = loc + 1 ; 
  2441.       } 
  2442.     } 
  2443.     break ; 
  2444.   case 60 : 
  2445.     if ( buffer [ loc ] == 61 ) 
  2446.     {
  2447.       if ( loc <= limit ) 
  2448.       {
  2449.     c = 28 ; 
  2450.     loc = loc + 1 ; 
  2451.       } 
  2452.     } 
  2453.     else if ( buffer [ loc ] == 62 ) 
  2454.     {
  2455.       if ( loc <= limit ) 
  2456.       {
  2457.     c = 26 ; 
  2458.     loc = loc + 1 ; 
  2459.       } 
  2460.     } 
  2461.     break ; 
  2462.   case 40 : 
  2463.     if ( buffer [ loc ] == 42 ) 
  2464.     {
  2465.       if ( loc <= limit ) 
  2466.       {
  2467.     c = 9 ; 
  2468.     loc = loc + 1 ; 
  2469.       } 
  2470.     } 
  2471.     else if ( buffer [ loc ] == 46 ) 
  2472.     {
  2473.       if ( loc <= limit ) 
  2474.       {
  2475.     c = 91 ; 
  2476.     loc = loc + 1 ; 
  2477.       } 
  2478.     } 
  2479.     break ; 
  2480.   case 42 : 
  2481.     if ( buffer [ loc ] == 41 ) 
  2482.     {
  2483.       if ( loc <= limit ) 
  2484.       {
  2485.     c = 10 ; 
  2486.     loc = loc + 1 ; 
  2487.       } 
  2488.     } 
  2489.     break ; 
  2490.   case 32 : 
  2491.   case 9 : 
  2492.     goto lab20 ; 
  2493.     break ; 
  2494.   case 123 : 
  2495.     {
  2496.       skipcomment () ; 
  2497.       goto lab20 ; 
  2498.     } 
  2499.     break ; 
  2500.   case 125 : 
  2501.     {
  2502.       {
  2503.     putc ('\n',  stdout );
  2504.     Fputs( stdout ,  "! Extra }" ) ; 
  2505.     error () ; 
  2506.       } 
  2507.       goto lab20 ; 
  2508.     } 
  2509.     break ; 
  2510.     default: 
  2511.     if ( c >= 128 ) 
  2512.     goto lab20 ; 
  2513.     else ; 
  2514.     break ; 
  2515.   } 
  2516.   lab31: Result = c ; 
  2517.   return(Result) ; 
  2518. } 
  2519. void zscannumeric ( p ) 
  2520. namepointer p ; 
  2521. {/* 21 30 */ integer accumulator  ; 
  2522.   schar nextsign  ; 
  2523.   namepointer q  ; 
  2524.   integer val  ; 
  2525.   accumulator = 0 ; 
  2526.   nextsign = 1 ; 
  2527.   while ( true ) {
  2528.       
  2529.     nextcontrol = getnext () ; 
  2530.     lab21: switch ( nextcontrol ) 
  2531.     {case 48 : 
  2532.     case 49 : 
  2533.     case 50 : 
  2534.     case 51 : 
  2535.     case 52 : 
  2536.     case 53 : 
  2537.     case 54 : 
  2538.     case 55 : 
  2539.     case 56 : 
  2540.     case 57 : 
  2541.       {
  2542.     val = 0 ; 
  2543.     do {
  2544.         val = 10 * val + nextcontrol - 48 ; 
  2545.       nextcontrol = getnext () ; 
  2546.     } while ( ! ( ( nextcontrol > 57 ) || ( nextcontrol < 48 ) ) ) ; 
  2547.     {
  2548.       accumulator = accumulator + nextsign * toint ( val ) ; 
  2549.       nextsign = 1 ; 
  2550.     } 
  2551.     goto lab21 ; 
  2552.       } 
  2553.       break ; 
  2554.     case 12 : 
  2555.       {
  2556.     val = 0 ; 
  2557.     nextcontrol = 48 ; 
  2558.     do {
  2559.         val = 8 * val + nextcontrol - 48 ; 
  2560.       nextcontrol = getnext () ; 
  2561.     } while ( ! ( ( nextcontrol > 55 ) || ( nextcontrol < 48 ) ) ) ; 
  2562.     {
  2563.       accumulator = accumulator + nextsign * toint ( val ) ; 
  2564.       nextsign = 1 ; 
  2565.     } 
  2566.     goto lab21 ; 
  2567.       } 
  2568.       break ; 
  2569.     case 13 : 
  2570.       {
  2571.     val = 0 ; 
  2572.     nextcontrol = 48 ; 
  2573.     do {
  2574.         if ( nextcontrol >= 65 ) 
  2575.       nextcontrol = nextcontrol - 7 ; 
  2576.       val = 16 * val + nextcontrol - 48 ; 
  2577.       nextcontrol = getnext () ; 
  2578.     } while ( ! ( ( nextcontrol > 70 ) || ( nextcontrol < 48 ) || ( ( 
  2579.     nextcontrol > 57 ) && ( nextcontrol < 65 ) ) ) ) ; 
  2580.     {
  2581.       accumulator = accumulator + nextsign * toint ( val ) ; 
  2582.       nextsign = 1 ; 
  2583.     } 
  2584.     goto lab21 ; 
  2585.       } 
  2586.       break ; 
  2587.     case 130 : 
  2588.       {
  2589.     q = idlookup ( 0 ) ; 
  2590.     if ( ilk [ q ] != 1 ) 
  2591.     {
  2592.       nextcontrol = 42 ; 
  2593.       goto lab21 ; 
  2594.     } 
  2595.     {
  2596.       accumulator = accumulator + nextsign * toint ( equiv [ q ] - 32768L 
  2597.       ) ; 
  2598.       nextsign = 1 ; 
  2599.     } 
  2600.       } 
  2601.       break ; 
  2602.     case 43 : 
  2603.       ; 
  2604.       break ; 
  2605.     case 45 : 
  2606.       nextsign = - (integer) nextsign ; 
  2607.       break ; 
  2608.     case 132 : 
  2609.     case 133 : 
  2610.     case 135 : 
  2611.     case 134 : 
  2612.     case 136 : 
  2613.       goto lab30 ; 
  2614.       break ; 
  2615.     case 59 : 
  2616.       {
  2617.     putc ('\n',  stdout );
  2618.     Fputs( stdout ,  "! Omit semicolon in numeric definition" ) ; 
  2619.     error () ; 
  2620.       } 
  2621.       break ; 
  2622.       default: 
  2623.       {
  2624.     {
  2625.       putc ('\n',  stdout );
  2626.       Fputs( stdout ,  "! Improper numeric definition will be flushed" ) ; 
  2627.       error () ; 
  2628.     } 
  2629.     do {
  2630.         nextcontrol = skipahead () ; 
  2631.     } while ( ! ( ( nextcontrol >= 132 ) ) ) ; 
  2632.     if ( nextcontrol == 135 ) 
  2633.     {
  2634.       loc = loc - 2 ; 
  2635.       nextcontrol = getnext () ; 
  2636.     } 
  2637.     accumulator = 0 ; 
  2638.     goto lab30 ; 
  2639.       } 
  2640.       break ; 
  2641.     } 
  2642.   } 
  2643.   lab30: ; 
  2644.   if ( abs ( accumulator ) >= 32768L ) 
  2645.   {
  2646.     {
  2647.       putc ('\n',  stdout );
  2648.       fprintf( stdout , "%s%ld",  "! Value too big: " , (long)accumulator ) ; 
  2649.       error () ; 
  2650.     } 
  2651.     accumulator = 0 ; 
  2652.   } 
  2653.   equiv [ p ] = accumulator + 32768L ; 
  2654. } 
  2655. void zscanrepl ( t ) 
  2656. eightbits t ; 
  2657. {/* 22 30 31 21 */ sixteenbits a  ; 
  2658.   ASCIIcode b  ; 
  2659.   eightbits bal  ; 
  2660.   bal = 0 ; 
  2661.   while ( true ) {
  2662.       
  2663.     lab22: a = getnext () ; 
  2664.     switch ( a ) 
  2665.     {case 40 : 
  2666.       bal = bal + 1 ; 
  2667.       break ; 
  2668.     case 41 : 
  2669.       if ( bal == 0 ) 
  2670.       {
  2671.     putc ('\n',  stdout );
  2672.     Fputs( stdout ,  "! Extra )" ) ; 
  2673.     error () ; 
  2674.       } 
  2675.       else bal = bal - 1 ; 
  2676.       break ; 
  2677.     case 39 : 
  2678.       {
  2679.     b = 39 ; 
  2680.     while ( true ) {
  2681.         
  2682.       {
  2683.         if ( tokptr [ z ] == maxtoks ) 
  2684.         {
  2685.           putc ('\n',  stdout );
  2686.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) 
  2687.           ; 
  2688.           error () ; 
  2689.           history = 3 ; 
  2690.           uexit ( 1 ) ; 
  2691.         } 
  2692.         tokmem [ z ][ tokptr [ z ] ] = b ; 
  2693.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  2694.       } 
  2695.       if ( b == 64 ) 
  2696.       if ( buffer [ loc ] == 64 ) 
  2697.       loc = loc + 1 ; 
  2698.       else {
  2699.           
  2700.         putc ('\n',  stdout );
  2701.         Fputs( stdout ,  "! You should double @ signs in strings" ) ; 
  2702.         error () ; 
  2703.       } 
  2704.       if ( loc == limit ) 
  2705.       {
  2706.         {
  2707.           putc ('\n',  stdout );
  2708.           Fputs( stdout ,  "! String didn't end" ) ; 
  2709.           error () ; 
  2710.         } 
  2711.         buffer [ loc ] = 39 ; 
  2712.         buffer [ loc + 1 ] = 0 ; 
  2713.       } 
  2714.       b = buffer [ loc ] ; 
  2715.       loc = loc + 1 ; 
  2716.       if ( b == 39 ) 
  2717.       {
  2718.         if ( buffer [ loc ] != 39 ) 
  2719.         goto lab31 ; 
  2720.         else {
  2721.         
  2722.           loc = loc + 1 ; 
  2723.           {
  2724.         if ( tokptr [ z ] == maxtoks ) 
  2725.         {
  2726.           putc ('\n',  stdout );
  2727.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" ,                   " capacity exceeded" ) ; 
  2728.           error () ; 
  2729.           history = 3 ; 
  2730.           uexit ( 1 ) ; 
  2731.         } 
  2732.         tokmem [ z ][ tokptr [ z ] ] = 39 ; 
  2733.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  2734.           } 
  2735.         } 
  2736.       } 
  2737.     } 
  2738.     lab31: ; 
  2739.       } 
  2740.       break ; 
  2741.     case 35 : 
  2742.       if ( t == 3 ) 
  2743.       a = 0 ; 
  2744.       break ; 
  2745.     case 130 : 
  2746.       {
  2747.     a = idlookup ( 0 ) ; 
  2748.     {
  2749.       if ( tokptr [ z ] == maxtoks ) 
  2750.       {
  2751.         putc ('\n',  stdout );
  2752.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2753.         error () ; 
  2754.         history = 3 ; 
  2755.         uexit ( 1 ) ; 
  2756.       } 
  2757.       tokmem [ z ][ tokptr [ z ] ] = ( a / 256 ) + 128 ; 
  2758.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2759.     } 
  2760.     a = a % 256 ; 
  2761.       } 
  2762.       break ; 
  2763.     case 135 : 
  2764.       if ( t != 135 ) 
  2765.       goto lab30 ; 
  2766.       else {
  2767.       
  2768.     {
  2769.       if ( tokptr [ z ] == maxtoks ) 
  2770.       {
  2771.         putc ('\n',  stdout );
  2772.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2773.         error () ; 
  2774.         history = 3 ; 
  2775.         uexit ( 1 ) ; 
  2776.       } 
  2777.       tokmem [ z ][ tokptr [ z ] ] = ( curmodule / 256 ) + 168 ; 
  2778.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2779.     } 
  2780.     a = curmodule % 256 ; 
  2781.       } 
  2782.       break ; 
  2783.     case 2 : 
  2784.       {
  2785.     {
  2786.       if ( tokptr [ z ] == maxtoks ) 
  2787.       {
  2788.         putc ('\n',  stdout );
  2789.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2790.         error () ; 
  2791.         history = 3 ; 
  2792.         uexit ( 1 ) ; 
  2793.       } 
  2794.       tokmem [ z ][ tokptr [ z ] ] = 2 ; 
  2795.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2796.     } 
  2797.     buffer [ limit + 1 ] = 64 ; 
  2798.     lab21: if ( buffer [ loc ] == 64 ) 
  2799.     {
  2800.       if ( loc < limit ) 
  2801.       if ( buffer [ loc + 1 ] == 64 ) 
  2802.       {
  2803.         {
  2804.           if ( tokptr [ z ] == maxtoks ) 
  2805.           {
  2806.         putc ('\n',  stdout );
  2807.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded"                 ) ; 
  2808.         error () ; 
  2809.         history = 3 ; 
  2810.         uexit ( 1 ) ; 
  2811.           } 
  2812.           tokmem [ z ][ tokptr [ z ] ] = 64 ; 
  2813.           tokptr [ z ] = tokptr [ z ] + 1 ; 
  2814.         } 
  2815.         loc = loc + 2 ; 
  2816.         goto lab21 ; 
  2817.       } 
  2818.     } 
  2819.     else {
  2820.         
  2821.       {
  2822.         if ( tokptr [ z ] == maxtoks ) 
  2823.         {
  2824.           putc ('\n',  stdout );
  2825.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) 
  2826.           ; 
  2827.           error () ; 
  2828.           history = 3 ; 
  2829.           uexit ( 1 ) ; 
  2830.         } 
  2831.         tokmem [ z ][ tokptr [ z ] ] = buffer [ loc ] ; 
  2832.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  2833.       } 
  2834.       loc = loc + 1 ; 
  2835.       goto lab21 ; 
  2836.     } 
  2837.     if ( loc >= limit ) 
  2838.     {
  2839.       putc ('\n',  stdout );
  2840.       Fputs( stdout ,  "! Verbatim string didn't end" ) ; 
  2841.       error () ; 
  2842.     } 
  2843.     else if ( buffer [ loc + 1 ] != 62 ) 
  2844.     {
  2845.       putc ('\n',  stdout );
  2846.       Fputs( stdout ,  "! You should double @ signs in verbatim strings" ) 
  2847.       ; 
  2848.       error () ; 
  2849.     } 
  2850.     loc = loc + 2 ; 
  2851.       } 
  2852.       break ; 
  2853.     case 133 : 
  2854.     case 132 : 
  2855.     case 134 : 
  2856.       if ( t != 135 ) 
  2857.       goto lab30 ; 
  2858.       else {
  2859.       
  2860.     {
  2861.       putc ('\n',  stdout );
  2862.       fprintf( stdout , "%s%c%s",  "! @" , xchr [ buffer [ loc - 1 ] ] ,           " is ignored in Pascal text" ) ; 
  2863.       error () ; 
  2864.     } 
  2865.     goto lab22 ; 
  2866.       } 
  2867.       break ; 
  2868.     case 136 : 
  2869.       goto lab30 ; 
  2870.       break ; 
  2871.       default: 
  2872.       ; 
  2873.       break ; 
  2874.     } 
  2875.     {
  2876.       if ( tokptr [ z ] == maxtoks ) 
  2877.       {
  2878.     putc ('\n',  stdout );
  2879.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2880.     error () ; 
  2881.     history = 3 ; 
  2882.     uexit ( 1 ) ; 
  2883.       } 
  2884.       tokmem [ z ][ tokptr [ z ] ] = a ; 
  2885.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2886.     } 
  2887.   } 
  2888.   lab30: nextcontrol = a ; 
  2889.   if ( bal > 0 ) 
  2890.   {
  2891.     if ( bal == 1 ) 
  2892.     {
  2893.       putc ('\n',  stdout );
  2894.       Fputs( stdout ,  "! Missing )" ) ; 
  2895.       error () ; 
  2896.     } 
  2897.     else {
  2898.     
  2899.       putc ('\n',  stdout );
  2900.       fprintf( stdout , "%s%ld%s",  "! Missing " , (long)bal , " )'s" ) ; 
  2901.       error () ; 
  2902.     } 
  2903.     while ( bal > 0 ) {
  2904.     
  2905.       {
  2906.     if ( tokptr [ z ] == maxtoks ) 
  2907.     {
  2908.       putc ('\n',  stdout );
  2909.       fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2910.       error () ; 
  2911.       history = 3 ; 
  2912.       uexit ( 1 ) ; 
  2913.     } 
  2914.     tokmem [ z ][ tokptr [ z ] ] = 41 ; 
  2915.     tokptr [ z ] = tokptr [ z ] + 1 ; 
  2916.       } 
  2917.       bal = bal - 1 ; 
  2918.     } 
  2919.   } 
  2920.   if ( textptr > maxtexts - 4 ) 
  2921.   {
  2922.     putc ('\n',  stdout );
  2923.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "text" , " capacity exceeded" ) ; 
  2924.     error () ; 
  2925.     history = 3 ; 
  2926.     uexit ( 1 ) ; 
  2927.   } 
  2928.   currepltext = textptr ; 
  2929.   tokstart [ textptr + 4 ] = tokptr [ z ] ; 
  2930.   textptr = textptr + 1 ; 
  2931.   if ( z == 3 ) 
  2932.   z = 0 ; 
  2933.   else z = z + 1 ; 
  2934. } 
  2935. void zdefinemacro ( t ) 
  2936. eightbits t ; 
  2937. {namepointer p  ; 
  2938.   p = idlookup ( t ) ; 
  2939.   scanrepl ( t ) ; 
  2940.   equiv [ p ] = currepltext ; 
  2941.   textlink [ currepltext ] = 0 ; 
  2942. } 
  2943. void scanmodule ( ) 
  2944. {/* 22 30 10 */ namepointer p  ; 
  2945.   modulecount = modulecount + 1 ; 
  2946.   nextcontrol = 0 ; 
  2947.   while ( true ) {
  2948.       
  2949.     lab22: while ( nextcontrol <= 132 ) {
  2950.     
  2951.       nextcontrol = skipahead () ; 
  2952.       if ( nextcontrol == 135 ) 
  2953.       {
  2954.     loc = loc - 2 ; 
  2955.     nextcontrol = getnext () ; 
  2956.       } 
  2957.     } 
  2958.     if ( nextcontrol != 133 ) 
  2959.     goto lab30 ; 
  2960.     nextcontrol = getnext () ; 
  2961.     if ( nextcontrol != 130 ) 
  2962.     {
  2963.       {
  2964.     putc ('\n',  stdout );
  2965.     fprintf( stdout , "%s%s",  "! Definition flushed, must start with " ,         "identifier of length > 1" ) ; 
  2966.     error () ; 
  2967.       } 
  2968.       goto lab22 ; 
  2969.     } 
  2970.     nextcontrol = getnext () ; 
  2971.     if ( nextcontrol == 61 ) 
  2972.     {
  2973.       scannumeric ( idlookup ( 1 ) ) ; 
  2974.       goto lab22 ; 
  2975.     } 
  2976.     else if ( nextcontrol == 30 ) 
  2977.     {
  2978.       definemacro ( 2 ) ; 
  2979.       goto lab22 ; 
  2980.     } 
  2981.     else if ( nextcontrol == 40 ) 
  2982.     {
  2983.       nextcontrol = getnext () ; 
  2984.       if ( nextcontrol == 35 ) 
  2985.       {
  2986.     nextcontrol = getnext () ; 
  2987.     if ( nextcontrol == 41 ) 
  2988.     {
  2989.       nextcontrol = getnext () ; 
  2990.       if ( nextcontrol == 61 ) 
  2991.       {
  2992.         {
  2993.           putc ('\n',  stdout );
  2994.           Fputs( stdout ,  "! Use == for macros" ) ; 
  2995.           error () ; 
  2996.         } 
  2997.         nextcontrol = 30 ; 
  2998.       } 
  2999.       if ( nextcontrol == 30 ) 
  3000.       {
  3001.         definemacro ( 3 ) ; 
  3002.         goto lab22 ; 
  3003.       } 
  3004.     } 
  3005.       } 
  3006.     } 
  3007.     {
  3008.       putc ('\n',  stdout );
  3009.       Fputs( stdout ,  "! Definition flushed since it starts badly" ) ; 
  3010.       error () ; 
  3011.     } 
  3012.   } 
  3013.   lab30: ; 
  3014.   switch ( nextcontrol ) 
  3015.   {case 134 : 
  3016.     p = 0 ; 
  3017.     break ; 
  3018.   case 135 : 
  3019.     {
  3020.       p = curmodule ; 
  3021.       do {
  3022.       nextcontrol = getnext () ; 
  3023.       } while ( ! ( nextcontrol != 43 ) ) ; 
  3024.       if ( ( nextcontrol != 61 ) && ( nextcontrol != 30 ) ) 
  3025.       {
  3026.     {
  3027.       putc ('\n',  stdout );
  3028.       Fputs( stdout ,  "! Pascal text flushed, = sign is missing" ) ; 
  3029.       error () ; 
  3030.     } 
  3031.     do {
  3032.         nextcontrol = skipahead () ; 
  3033.     } while ( ! ( nextcontrol == 136 ) ) ; 
  3034.     goto lab10 ; 
  3035.       } 
  3036.     } 
  3037.     break ; 
  3038.     default: 
  3039.     goto lab10 ; 
  3040.     break ; 
  3041.   } 
  3042.   storetwobytes ( 53248L + modulecount ) ; 
  3043.   scanrepl ( 135 ) ; 
  3044.   if ( p == 0 ) 
  3045.   {
  3046.     textlink [ lastunnamed ] = currepltext ; 
  3047.     lastunnamed = currepltext ; 
  3048.   } 
  3049.   else if ( equiv [ p ] == 0 ) 
  3050.   equiv [ p ] = currepltext ; 
  3051.   else {
  3052.       
  3053.     p = equiv [ p ] ; 
  3054.     while ( textlink [ p ] < maxtexts ) p = textlink [ p ] ; 
  3055.     textlink [ p ] = currepltext ; 
  3056.   } 
  3057.   textlink [ currepltext ] = maxtexts ; 
  3058.   lab10: ; 
  3059. } 
  3060. void main_body() {
  3061.     
  3062.   initialize () ; 
  3063.   openinput () ; 
  3064.   line = 0 ; 
  3065.   otherline = 0 ; 
  3066.   changing = true ; 
  3067.   primethechangebuffer () ; 
  3068.   changing = ! changing ; 
  3069.   templine = otherline ; 
  3070.   otherline = line ; 
  3071.   line = templine ; 
  3072.   limit = 0 ; 
  3073.   loc = 1 ; 
  3074.   buffer [ 0 ] = 32 ; 
  3075.   inputhasended = false ; 
  3076.   Fputs( stdout ,  "This is TANGLE, Version 4.3" ) ; 
  3077.   fprintf( stdout , "%s\n",  versionstring ) ; 
  3078.   phaseone = true ; 
  3079.   modulecount = 0 ; 
  3080.   do {
  3081.       nextcontrol = skipahead () ; 
  3082.   } while ( ! ( nextcontrol == 136 ) ) ; 
  3083.   while ( ! inputhasended ) scanmodule () ; 
  3084.   if ( changelimit != 0 ) 
  3085.   {
  3086.     {register integer for_end; ii = 0 ; for_end = changelimit ; if ( ii <= 
  3087.     for_end) do 
  3088.       buffer [ ii ] = changebuffer [ ii ] ; 
  3089.     while ( ii++ < for_end ) ; } 
  3090.     limit = changelimit ; 
  3091.     changing = true ; 
  3092.     line = otherline ; 
  3093.     loc = changelimit ; 
  3094.     {
  3095.       putc ('\n',  stdout );
  3096.       Fputs( stdout ,  "! Change file entry did not match" ) ; 
  3097.       error () ; 
  3098.     } 
  3099.   } 
  3100.   phaseone = false ; 
  3101.   if ( textlink [ 0 ] == 0 ) 
  3102.   {
  3103.     {
  3104.       putc ('\n',  stdout );
  3105.       Fputs( stdout ,  "! No output was specified." ) ; 
  3106.     } 
  3107.     if ( history == 0 ) 
  3108.     history = 1 ; 
  3109.   } 
  3110.   else {
  3111.       
  3112.     {
  3113.       putc ('\n',  stdout );
  3114.       Fputs( stdout ,  "Writing the output file" ) ; 
  3115.     } 
  3116.     flush ( stdout ) ; 
  3117.     stackptr = 1 ; 
  3118.     bracelevel = 0 ; 
  3119.     curstate .namefield = 0 ; 
  3120.     curstate .replfield = textlink [ 0 ] ; 
  3121.     zo = curstate .replfield % 4 ; 
  3122.     curstate .bytefield = tokstart [ curstate .replfield ] ; 
  3123.     curstate .endfield = tokstart [ curstate .replfield + 4 ] ; 
  3124.     curstate .modfield = 0 ; 
  3125.     outstate = 0 ; 
  3126.     outptr = 0 ; 
  3127.     breakptr = 0 ; 
  3128.     semiptr = 0 ; 
  3129.     outbuf [ 0 ] = 0 ; 
  3130.     line = 1 ; 
  3131.     sendtheoutput () ; 
  3132.     breakptr = outptr ; 
  3133.     semiptr = 0 ; 
  3134.     flushbuffer () ; 
  3135.     if ( bracelevel != 0 ) 
  3136.     {
  3137.       putc ('\n',  stdout );
  3138.       fprintf( stdout , "%s%ld",  "! Program ended at brace level " , (long)bracelevel ) ; 
  3139.       error () ; 
  3140.     } 
  3141.     {
  3142.       putc ('\n',  stdout );
  3143.       Fputs( stdout ,  "Done." ) ; 
  3144.     } 
  3145.   } 
  3146.   lab9999: if ( stringptr > 256 ) 
  3147.   {
  3148.     {
  3149.       putc ('\n',  stdout );
  3150.       fprintf( stdout , "%ld%s",  (long)stringptr - 256 ,       " strings written to string pool file." ) ; 
  3151.     } 
  3152.     putc ( '*' ,  pool );
  3153.     {register integer for_end; ii = 1 ; for_end = 9 ; if ( ii <= for_end) do 
  3154.       {
  3155.     outbuf [ ii ] = poolchecksum % 10 ; 
  3156.     poolchecksum = poolchecksum / 10 ; 
  3157.       } 
  3158.     while ( ii++ < for_end ) ; } 
  3159.     {register integer for_end; ii = 9 ; for_end = 1 ; if ( ii >= for_end) do 
  3160.       putc ( xchr [ 48 + outbuf [ ii ] ] ,  pool );
  3161.     while ( ii-- > for_end ) ; } 
  3162.     putc ('\n',  pool );
  3163.   } 
  3164.   switch ( history ) 
  3165.   {case 0 : 
  3166.     {
  3167.       putc ('\n',  stdout );
  3168.       Fputs( stdout ,  "(No errors were found.)" ) ; 
  3169.     } 
  3170.     break ; 
  3171.   case 1 : 
  3172.     {
  3173.       putc ('\n',  stdout );
  3174.       Fputs( stdout ,  "(Did you see the warning message above?)" ) ; 
  3175.     } 
  3176.     break ; 
  3177.   case 2 : 
  3178.     {
  3179.       putc ('\n',  stdout );
  3180.       Fputs( stdout ,  "(Pardon me, but I think I spotted something wrong.)" ) 
  3181.       ; 
  3182.     } 
  3183.     break ; 
  3184.   case 3 : 
  3185.     {
  3186.       putc ('\n',  stdout );
  3187.       Fputs( stdout ,  "(That was a fatal error, my friend.)" ) ; 
  3188.     } 
  3189.     break ; 
  3190.   } 
  3191.   putc ('\n',  stdout );
  3192.   if ( ( history != 0 ) && ( history != 1 ) ) 
  3193.   uexit ( 1 ) ; 
  3194.   else uexit ( 0 ) ; 
  3195. } 
  3196.