home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / compcomp / yacc / y2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-17  |  49.3 KB  |  1,625 lines
  1. /************************************************************************/
  2. /*                              y2.c                                    */  
  3. /*  YACC source file #2 (of 4).                                         */  
  4. /*  Scanner, parser and symbol table code.                */
  5. /************************************************************************/   
  6.     
  7. /************************************************************************/   
  8. /*                              contents                                */    
  9. /*                                                                      */    
  10. /*  * y2CpyAction       Copy C action to the next ; or closing }        */ 
  11. /*  * y2CpyCode         Copy code between %{ and %} to output.          */ 
  12. /*  * y2CpyUnion        Copy a union declaration to output.             */ 
  13. /*  * y2Define          Define s to be a terminal or nonterminal.       */ 
  14. /*  * y2EnterSymbol     Store id or literal in y2Text[], return address.*/ 
  15. /*  * y2FindName        Identify terminal/nonterminal.                  */ 
  16. /*  * y2GetToken                                                        */ 
  17. /*    y2Initialize      Initialize parser, then call y2yyParse.         */ 
  18. /*  * y2SkipComment     Skip over comments.                             */ 
  19. /*  * y2TypeOf          Determine the type of a symbol.                 */ 
  20. /*  * y2Usage                                                           */ 
  21. /*  * y2WriteDefines    Post declarations: write out the defines        */ 
  22. /*    y2yyParse         Kludged YACC input parser.                      */ 
  23. /*                                                                      */ 
  24. /* * Local to this file.                                                */  
  25. /*                                                                      */ 
  26. /************************************************************************/ 
  27.     
  28.     
  29. /************************************************************************/ 
  30. /*                              history                                 */ 
  31. /*                                                                      */ 
  32. /* 85Nov22 CrT  Below fouled up YYACCEPT/YYERROR.  Fixed.               */ 
  33. /* 85Nov18 CrT    User action chunks are now placed in functions rather    */
  34. /*        than switch cases.  The functions are accessed by an    */
  35. /*              array of function pointers.  This is because many       */ 
  36. /*              compilers have low limits on the size of functions,     */ 
  37. /*              switch statements, and the number of cases in a         */ 
  38. /*              switch statement.  In addition, some compilers implement*/ 
  39. /*              switch statements with a cascade of comparisons rather  */ 
  40. /*              than a jump table.                                      */ 
  41. /* 85Nov17 CrT  I had a } wrong in y2Define.  Fixed.                    */ 
  42. /* 85Nov17 CrT  Changed 'begin:' to 'start:' in y2GetToken, because     */ 
  43. /*              BDS C treats 'begin's as '{'s, with confusing results.  */ 
  44. /*              (This problem reported by Robert A. McIvor in '79.)     */ 
  45. /* 85Nov15 CrT  Global variable names decrypted.                        */ 
  46. /* 85Nov13 CrT  Give plaintiff routine in error messages.               */ 
  47. /* 85Nov12 CrT  Function names decrypted. Still unique in first 6 chars.*/ 
  48. /* 85Nov10 CrT  y2.c reconstructed from 12 subfiles.  Cosmetics.        */ 
  49. /* 83Dec23 SG   Adapted for IBM PC/XT & DeSmet C compiler               */ 
  50. /* 83May15 SG   Fixed up option flag handling for RT-11.                */ 
  51. /* 83Apr12 RBD  Make filename[] size per #define'd                      */ 
  52. /*              FNAMESIZE so VAX filenames won't blow out.              */ 
  53. /*              Conditionalize time handling for banner.                */ 
  54. /*              Make filespec buffer static for safety,                 */ 
  55. /*              since global "infile" is pointed to it.                 */ 
  56. /* 82Mar22 RBD  Added header line, changes for 'new' DECUS library      */ 
  57. /*                                                                      */ 
  58. /* 81Aug27 RBD  Modified for use with DECUS LEX                         */ 
  59. /*              Variable "yylval" resides in yylex(), not in yypars();  */ 
  60. /*              Therefore, is defined "extern" here.                    */ 
  61. /*                                                                      */ 
  62. /*              Also, the command line processing for the Decus version */ 
  63. /*              has been changed.  A new switch has been added to allow */ 
  64. /*              specification of the "table" file name(s), and unused   */ 
  65. /*              switch processing removed.                              */ 
  66. /*                               NOTE                                   */ 
  67. /*              This probably won't run on UNIX any more.               */ 
  68. /*                                                                      */ 
  69. /* 7?????? SCJ  Created.                                                */ 
  70. /*                                                                      */ 
  71. /*                              credits                                 */ 
  72. /*      CrT=CrT                                                         */  
  73. /*      RBD=Bob Denny                                                   */  
  74. /*      SCJ=Steven C Johnson.                                           */  
  75. /*      SG =Scott Guthery                                               */  
  76. /************************************************************************/ 
  77.  
  78.   
  79. #include <stdio.h>
  80. #include "system.h"
  81. #include "dtxtrn.h"
  82.  
  83.  
  84.  
  85.  
  86. /* Token types returned by yacc's input scanner: */
  87. # define IDENTIFIER   257  /* Identifier NOT followed by colo.        */
  88. # define MARK          258  /* %%                    */
  89. # define TERMINAL     259  /* %0 or %term or %token            */
  90. # define LEFT          260  /* %< or %left                */
  91. # define RIGHT          261  /* %> or %right                */
  92. # define BINARY       262  /* %2 or %binary or %nonassoc        */
  93. # define PREC          263  /* %= or %prec                */
  94. # define LCURLY       264  /* %{                    */
  95. # define C_IDENTIFIER 265  /* An IDENTIFIER followed by a colon.    */
  96. # define NUMBER       266  /* A number                    */
  97. # define START          267  /* %start                    */
  98. # define TYPEDEF      268  /* %type                    */
  99. # define TYPENAME     269  /*                        */
  100. # define UNION          270  /* %union                    */
  101. # define ENDFILE    0  /*                        */
  102.                           
  103.  
  104. /* Arguments for y2Define: */
  105. #define TYPEtERMINAL    0
  106. #define TYPEnONTERMINAL 1
  107. #define TYPEpREC    2
  108.  
  109.  
  110.  
  111. /* Communication variables between various I/O routines: */
  112.                                                           
  113. static int   y2InputNumberValue;        /* Value of an input number. */
  114. static char  y2InputTokenText[ NAMEsIZE ];  /* Input token name.     */
  115.                                                           
  116.  
  117.  
  118. /* Storage for names: */
  119.                                                           
  120. static char  y2Text[ MAXy2TEXT ];   /* Contains text of all names.     */
  121. static char *y2TextFree = y2Text;   /* Remaining free space in y2Text[]. */
  122. static int   y2NumberOfDefinedSymbolsWritten = 3;
  123.  
  124.  
  125.  
  126. /* Storage for user-declared types ("<...>" commands): */
  127.  
  128. /* Pointers to names of types, secreted in y2Text: */
  129. static char *  y2TypeName[ MAXtYPES ];
  130.  
  131. static int     y2NumberOfTypesDefined;
  132.  
  133.  
  134.  
  135. /* Symbol tables for tokens and nonterminals: */
  136.                                                           
  137. /* Table giving external name and internal number for each terminal: */
  138. struct toksymb y2Terminal[         MAXtERMINALsTATES ];
  139.  
  140. /* Bit vectors giving associativity and precedence of each terminal: */
  141. int           y2TerminalProperties[ MAXtERMINALsTATES ];
  142. int y2NextTerminal = 0;
  143.  
  144. /* Table giving external name and internal number for nonterminals: */
  145. struct ntsymb y2NonterminalState[ MAXnONTERMINALsTATES ];
  146. int y2LastNonterminal = -1;
  147.  
  148. static int y2RootNonterminal;    /* "%start" symbol.             */
  149.                                                           
  150.  
  151.  
  152. /* Next internal terminal number to assign: */
  153. static int y2NextTerminalNumber = 0;    /* y2Initialize sets it to 0400 */
  154.                                                           
  155.  
  156.  
  157. /* Input and output file descriptors: */
  158.                                                           
  159. FILE * y2InputFD;        /* Yacc input file.            */
  160. FILE * y2ActionFD;        /* File to saving actions in.        */
  161. FILE * y2DefineFD;        /* File for # defines.            */
  162. FILE * y2ytabcFD;        /* y.tab.c file.            */
  163. FILE * y2TempFileFD;        /* Temp. file to pass 2.        */
  164. FILE * y2OutputFD;        /* y.output file.            */
  165.                                                           
  166.  
  167.  
  168. /************************************************************************/
  169. /*                                                                      */
  170. /* Storage for grammar rules. Grammar rules are packed sequentially    */
  171. /* into y2Pool[].   y2Production[i] points to the start of the ith    */
  172. /* grammar rule.  A grammar rule consists of a sequence of positive    */
  173. /* integers terminated by a negative integer.  The positive integers    */
  174. /* are parts of the rule, the negative integer is -i.  Positive     */
  175. /* integers less than FIRSTnONTERMINAL are terminals, others are    */
  176. /* nonterminals -- subtracting FIRSTnONTERMINAL gives the correct    */
  177. /* offset into y2NonterminalState[].   The first entry in the rule is    */
  178. /* the LHS -- the nonterminal being defined -- and the remainder give    */
  179. /* the right hand side.                         */
  180. /*                                                                      */
  181. /* Actions are always fired at the end of a rule.  (Input rules with    */
  182. /* actions in the middle are split into multiple rules.)  When actions    */
  183. /* are encountered, a switch case labeled with the rule number is    */
  184. /* generated, and the RULEhASaCTION bit for that rule set.  Thus, when    */
  185. /* we later generate code reducing this rule, we need only check the    */
  186. /* RULEhASaCTION and, if set, synthesize a call from the rule number.    */
  187. /*                                    */
  188. /************************************************************************/
  189.  
  190. /* Buffer to pack productions into: */
  191. int y2Pool[ MAXy2POOL ];
  192.  
  193. /* Pointer to start of free space in y2Pool: */
  194. int *y2FreePool = y2Pool;
  195.  
  196. /* Count of number of productions in currently in y2Pool: */
  197. int y2ThisProduction= 1;
  198.  
  199. /* Pointers into y2Pool, giving the start of each production in it: */
  200. int *y2Production[ MAXpRODUCTIONS ];
  201.  
  202. /* The production precedence levels.  Same bit    */
  203. /* vector format as y2TerminalProperties:    */
  204. int y2ProductionProperties[ MAXpRODUCTIONS ] ;
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213. /************************************************************************/
  214. /*    y2CpyAction       Copy C action to the next ; or closing }        */
  215. /************************************************************************/
  216. static y2CpyAction( offset )           /* Called only from y2yyParse */
  217. int offset;              /* Number of arguments seen in production */
  218. {
  219.     int braceDepth, c, match, j, s, tok;
  220.        
  221. #ifdef OLD
  222.     /* Create a "case...:" for the impending action: */
  223.     fprintf( y2ActionFD, "\ncase %d:", y2ThisProduction );
  224. #else 
  225.     /* Create a function for the impending action: */
  226.     fprintf( y2ActionFD, "static yyA%03d() {", y2ThisProduction );
  227. #endif 
  228.     /* Pass current line number to output: */
  229.     fprintf(   y2ActionFD,   "\n# line %d\n",    y1LineNumber   );
  230.        
  231.     braceDepth = 0;
  232.        
  233. lup:
  234.     c = y1GetChar( y2InputFD );
  235.  
  236. swtch:
  237.     switch( c ) {
  238.        
  239.     case ';':
  240.     if (braceDepth == 0) {
  241.         putc( c , y2ActionFD );
  242.         goto cpyActEnd;
  243.          } 
  244.      goto lcopy;
  245.        
  246.     case '{':
  247.     braceDepth++;
  248.     goto lcopy;
  249.        
  250.     case '$':
  251.     s   = 1;
  252.     tok = -1;
  253.     c   = y1GetChar( y2InputFD );
  254.  
  255.         if (c == '<') {
  256.  
  257.             /* Type description: */
  258.         y1UngetChar( c, y2InputFD );
  259.         if (y2GetToken() != TYPENAME) {
  260.         y1Error( "y2CpyAction: Bad syntax on $<ident> clause" );
  261.         }
  262.         tok = y2InputNumberValue;
  263.         c    = y1GetChar( y2InputFD );
  264.     }
  265.     if (c == '$') {
  266.         fprintf( y2ActionFD, "yyval");
  267.         if (y2NumberOfTypesDefined) {
  268.  
  269.         /* Put out the proper name: */
  270.         if (tok < 0) {
  271.             tok = y2TypeOf( *y2Production[ y2ThisProduction ] );
  272.         }
  273.                 fprintf( y2ActionFD, ".%s", y2TypeName[tok] );
  274.             } 
  275.         goto lup;
  276.     }
  277.     if (c == '-') {
  278.         s = -s;
  279.         c = y1GetChar( y2InputFD );
  280.     }
  281.     if (isdigit( c )) {
  282.  
  283.         /* Handle a $3 type action argument: */
  284.  
  285.         /* Collect the numerical value in j: */
  286.             j = 0;
  287.         while (isdigit( c )) {
  288.         j = j * 10   +     c - '0';
  289.         c = y1GetChar( y2InputFD );
  290.             } 
  291.         j = j * s    -   offset;
  292.  
  293.         /* Can't refer to part of rule not seen yet: */
  294.             if (j > 0)  y1Error( "y2CpyAction: Illegal use of $%d", j+offset );
  295.  
  296.         /* Compile code for $n variable reference: */
  297.             fprintf( y2ActionFD, "yypvt[-%d]", -j );
  298.  
  299.         /* Special code if we are stacking unions instead of ints: */
  300.             if (y2NumberOfTypesDefined) {
  301.  
  302.         /* Put out the proper name: */
  303.  
  304.         if (j+offset <= 0   &&     tok < 0) {
  305.             y1Error(
  306.             "y2CpyAction: Must specify type of $%d",
  307.             j+offset
  308.             );
  309.         }
  310.         if (tok < 0)   {
  311.             tok = y2TypeOf(
  312.             y2Production[ y2ThisProduction ][ j+offset ]
  313.             );
  314.                 }
  315.                 fprintf( y2ActionFD, ".%s", y2TypeName[tok] );
  316.         }
  317.         goto swtch;
  318.     }
  319.     putc( '$' , y2ActionFD );
  320.     if (s < 0)   putc( '-', y2ActionFD );
  321.     goto swtch;
  322.        
  323.     case '}':
  324.     if (--braceDepth)   goto lcopy;
  325.     putc( c, y2ActionFD );
  326.     goto cpyActEnd;
  327.  
  328.     case '/':
  329.     /* Look for comments: */
  330.     putc( c , y2ActionFD );
  331.     c = y1GetChar( y2InputFD );
  332.     if (c != '*')    goto swtch;
  333.        
  334.     /* It really is a comment: */
  335.        
  336.     putc( c , y2ActionFD );
  337.     c = y1GetChar( y2InputFD );
  338.     while (c != EOF) {
  339.         while (c == '*') {
  340.         putc( c , y2ActionFD );
  341.         if ((c = y1GetChar( y2InputFD ))   ==    '/')   goto lcopy;
  342.             } 
  343.         putc( c , y2ActionFD );
  344.         if (c == '\n')   ++y1LineNumber;
  345.         c = y1GetChar( y2InputFD );
  346.     }
  347.     y1Error( "y2CpyAction: EOF inside comment" );
  348.        
  349.     case '\'':
  350.     /* Character constant: */
  351.     match = '\'';
  352.     goto string;
  353.        
  354.     case '"':
  355.     /* Character string: */
  356.     match = '"';
  357.        
  358. string: 
  359.        
  360.     putc( c, y2ActionFD );
  361.     while (c = y1GetChar( y2InputFD )) {
  362.         if (c == '\\') {
  363.         putc( c , y2ActionFD );
  364.         c = y1GetChar(y2InputFD);
  365.         if (c == '\n')     ++y1LineNumber;
  366.         } else if( c==match ) {
  367.         goto lcopy;
  368.         } else if( c=='\n' ) {
  369.         y1Error( "y2CpyAction: Newline in string or char constant" );
  370.         }
  371.         putc( c , y2ActionFD );
  372.     }
  373.     y1Error( "y2CpyAction: EOF in string or character constant" );
  374.        
  375.     case EOF:
  376.     /* EOF: */
  377.     y1Error( "y2CpyAction: Action does not terminate" );
  378.        
  379.     case '\n':
  380.     ++y1LineNumber;
  381.     goto lcopy;
  382.     }
  383.        
  384. lcopy: 
  385.     putc( c, y2ActionFD );
  386.     goto lup;
  387.  
  388.  
  389. cpyActEnd:
  390. #ifdef OLD
  391.     /* Wrap up this "case" in the action switch statement: */
  392.     fprintf( y2ActionFD, " break;" ); 
  393. #else
  394.     /* Wrap up this action fn: */
  395.     fprintf( y2ActionFD, "\n    return -1;\n}\n\n" );
  396. #endif
  397. }
  398.  
  399.  
  400. /************************************************************************/
  401. /*    y2CpyCode         Copy code between \{ and \} to output.          */ 
  402. /************************************************************************/ 
  403. static y2CpyCode() {
  404.  
  405.     int c; 
  406.  
  407.     c = y1GetChar( y2InputFD );
  408.  
  409.     if (c == '\n') { 
  410.     c = y1GetChar( y2InputFD );
  411.     y1LineNumber++;
  412.     } 
  413.  
  414.     /* Pass line number to output file: */
  415.     fprintf( y2ytabcFD, "\n# line %d\n", y1LineNumber );
  416.  
  417.     /* Copy the code over: */
  418.     while (c != EOF) {
  419.         if (c == '\\') { 
  420.         if ((c = y1GetChar(y2InputFD))   ==   '}')     return;
  421.         else                      putc('\\', y2ytabcFD );
  422.         } 
  423.         if (c == '%') { 
  424.         if ((c = y1GetChar(y2InputFD))   ==   '}')     return;
  425.         else                      putc('%', y2ytabcFD );
  426.         } 
  427.     putc( c , y2ytabcFD );
  428.     if (c == '\n')     ++y1LineNumber;
  429.     c = y1GetChar(y2InputFD);
  430.     } 
  431.     y1Error( "y2CpyCode: EOF before %%}" );
  432. }
  433.   
  434.  
  435. /************************************************************************/
  436. /*    y2CpyUnion        Copy a union declaration to output.             */
  437. /************************************************************************/
  438. static y2CpyUnion() {           /* Called only from y2yyParse */
  439.  
  440.     /**********************************************/
  441.     /* Copy the union declaration to the output.  */
  442.     /* Copy also to the .h file if one requested. */
  443.     /**********************************************/
  444.  
  445.     int level, c;
  446.  
  447.     /* Pass input line number to output for debugging purposes: */
  448.     fprintf( y2ytabcFD, "\n# line %d\n", y1LineNumber );
  449.  
  450.     fprintf( y2ytabcFD, "\n#define UNION 1\n");
  451.     fprintf( y2ytabcFD, "typedef union " );
  452.     if (y2DefineFD)   fprintf( y2DefineFD, "\ntypedef union " );
  453.        
  454.     level = 0;
  455.     loop {
  456.     if ((c = y1GetChar( y2InputFD ))   ==    EOF) {
  457.         y1Error( "y2CpyUnion: EOF encountered while processing %%union" );
  458.     }
  459.     putc( c, y2ytabcFD );
  460.     if (y2DefineFD)   putc( c, y2DefineFD );
  461.        
  462.     switch (c) {
  463.     case '\n':    ++y1LineNumber;             break;
  464.     case '{':    ++level;                break;
  465.     case '}':
  466.         if (!--level) {
  467.  
  468.         /* We are finished copying: */
  469.         fprintf( y2ytabcFD, " YYSTYPE;\n" );
  470.         if (y2DefineFD) {
  471.             fprintf(
  472.             y2DefineFD,
  473.             " YYSTYPE;\nextern YYSTYPE yylval;\n"
  474.             );
  475.         }
  476.         return;
  477.         }
  478.     }
  479.     }
  480. }
  481.  
  482.  
  483. /************************************************************************/
  484. /*    y2Define          Define s to be a terminal or nonterminal.       */ 
  485. /************************************************************************/ 
  486. y2Define( t, s )    /* Called by y2FindName and y2Initialize */
  487. int             t; 
  488. register char  *s; 
  489. { 
  490.     /*****************************************************/ 
  491.     /* Define s to be a    terminal if t=TYPEtERMINAL     */
  492.     /*           or a nonterminal if t=TYPEnONTERMINAL */
  493.     /*           or a (???--CrT)     t=TYPEpREC     */
  494.     /*****************************************************/ 
  495.  
  496.     register val; 
  497.            
  498.     if (t != TYPEtERMINAL) {
  499.     if (++y2LastNonterminal >= MAXnONTERMINALsTATES) {
  500.         y1Error(
  501.         "y2Define  Too many nonterminals, limit %d",
  502.         MAXnONTERMINALsTATES
  503.         );
  504.         } 
  505.     y2NonterminalState[ y2LastNonterminal ].name = y2EnterSymbol(s);
  506.  
  507.     return( FIRSTnONTERMINAL + y2LastNonterminal );
  508.     }
  509.  
  510.     /* Must be a terminal */
  511.     if (++y2NextTerminal >= MAXtERMINALsTATES)     {
  512.     y1Error( "y2Define: Too many terminals, limit %d",MAXtERMINALsTATES);
  513.     }
  514.     y2Terminal[ y2NextTerminal ].name  = y2EnterSymbol(s);
  515.            
  516.     /* Establish value for token: */ 
  517.            
  518.     if (s[0] == ' '   &&   s[2] == '\0') { 
  519.   
  520.         /* Single character literal: */ 
  521.         val = s[1]; 
  522.   
  523.     } else if (s[0] != ' '   ||   s[1] != '\\') {
  524.  
  525.         val = y2NextTerminalNumber++;
  526.  
  527.     } else {
  528.  
  529.         /* Escape sequence: */ 
  530.         if (s[3] == '\0' ) { 
  531.   
  532.             /* Single character escape sequence: */ 
  533.             switch ( s[2] ) { 
  534.                 /* Character which is escaped: */ 
  535.             case  'n':      val = '\n';             break; 
  536.             case  'r':      val = '\r';             break; 
  537.             case  'b':      val = '\b';             break; 
  538.             case  't':      val = '\t';             break; 
  539.             case  'f':      val = '\f';             break; 
  540.             case '\'':      val = '\'';             break; 
  541.             case  '"':      val =  '"';             break; 
  542.             case '\\':      val = '\\';             break; 
  543.             default: 
  544.         y1Error( "y2Define: Invalid escape" );
  545.             }  
  546.   
  547.         } else if (s[2] <= '7'   &&   s[2] >= '0') { 
  548.   
  549.             /* \nnn sequence: */ 
  550.             if ( 
  551.                 s[3] < '0' 
  552.                 || 
  553.                 s[3] > '7' 
  554.                 || 
  555.                 s[4] < '0' 
  556.                 || 
  557.                 s[4] > '7' 
  558.                 || 
  559.                 s[5] != '\0' 
  560.             ) { 
  561.         y1Error( "y2Define Illegal \\nnn construction" );
  562.             } 
  563.   
  564.             /****************************************************************/ 
  565.         /* CrT: Naive code to translate \nnn to octal char is:        */
  566.             /* val = 64 * (s[2]-'0')   +   8 * (s[3]-'0')   +   (s[4]-'0'); */ 
  567.             /* Factoring the '0's out for speed (?!?!!??) gives SCJ's:      */ 
  568.             /****************************************************************/ 
  569.         val = 64 * s[2]   +   8 * s[3]   +     s[4]    -   73 * '0';
  570.         if (val == 0)   y1Error( "y2Define: '\\000' is illegal" );
  571.         } 
  572.     }
  573.     y2Terminal[ y2NextTerminal ].value        = val;
  574.     y2TerminalProperties[ y2NextTerminal ]  = 0;
  575.  
  576.     return   y2NextTerminal;
  577. } 
  578.   
  579.  
  580. /************************************************************************/
  581. /*    y2EnterSymbol     Store id or literal in y2Text[], return address.*/
  582. /************************************************************************/
  583. static char *y2EnterSymbol( s )    /* Called by y2Define and y2GetToken */
  584. register char *s;
  585. {
  586.     char *temp;
  587.           
  588.     temp = y2TextFree;
  589.     do {
  590.     if (y2TextFree >= &y2Text[ MAXy2TEXT ]) {
  591.  
  592.             y1Error( "y2EnterSymbol: Too many chars in id's and literals" );
  593.  
  594.         } else {
  595.  
  596.             *y2TextFree++ = *s;
  597.  
  598.         }
  599.     } while (*s++);
  600.  
  601.     return  temp;
  602. }
  603.  
  604.  
  605. /************************************************************************/
  606. /*      y2FindName                                                      */ 
  607. /************************************************************************/ 
  608. static y2FindName( t, s )        /* Called only from y2yyParse    */
  609. int           t;    /* TYPEtERMINAL, TYPEnONTERMINAL or TYPEpREC.    */
  610. register char *s; 
  611. { 
  612.     int i; 
  613.            
  614.     /* Handle literals: */
  615.     if (s[0] == ' ')   t = TYPEtERMINAL;
  616.   
  617.     /* May be a terminal: */
  618.     FORaLLtERMINALS(i) {
  619.     if (!strcmp( s, y2Terminal[i].name ))    return i;
  620.     } 
  621.  
  622.     /* May be a nonterminal: */
  623.     FORaLLnONTERMINALS(i) {
  624.     if (!strcmp( s, y2NonterminalState[i].name )) {
  625.         return i+FIRSTnONTERMINAL;
  626.     }
  627.     } 
  628.  
  629.     /* Identifiers in "%prec id" statements should be predeclared: */
  630.     if (t == TYPEpREC) {
  631.     y1Error( "y2FindName: %s should have been defined earlier", s );
  632.     }
  633.   
  634.     /* Create an entry for undefined name: */
  635.     return   y2Define( t, s );
  636. } 
  637.   
  638.  
  639. /************************************************************************/
  640. /*    y2GetToken                            */
  641. /************************************************************************/
  642. static y2GetToken() {        /* Called from y2yyParse, y2CpyAction    */
  643.  
  644.     static int  peekline;
  645.  
  646.     register    len;
  647.     register    base;
  648.     register    c;
  649.  
  650.     int         match;
  651.     int     percentCommand;
  652.     int     i;
  653.  
  654. start:
  655.     percentCommand  = FALSE;
  656.     y1LineNumber   += peekline;
  657.     peekline        = 0;
  658.     c            = y1GetChar( y2InputFD );
  659.  
  660.     /* Skip any leading whitespace: */
  661.     while (
  662.     c == ' '
  663.     ||
  664.     c == '\n'
  665.     ||
  666.     c == '\t'
  667.     ||
  668.     c == '\f'
  669.     ||
  670.     c == '\r'
  671.     ) {
  672.     if (c == '\n')     ++y1LineNumber;
  673.     c = y1GetChar( y2InputFD );
  674.     }
  675.  
  676.     /* Skip comments: */
  677.     if (c == '/') {
  678.     /* Skip comment: */
  679.     y1LineNumber += y2SkipComment();
  680.     goto start;
  681.     }
  682.           
  683.     /* We have nonwhitespace noncomment: decide what kind of token: */
  684.     switch (c) {
  685.  
  686.     case EOF:
  687.     /* EOF: */
  688.     return     ENDFILE;
  689.  
  690.     case '{':
  691.     /* Action: */
  692.     y1UngetChar( c, y2InputFD );
  693.     return( '=' );
  694.  
  695.      case '<':
  696.     /* Get, and look up, a type name (union member name): */
  697.     len = 0;
  698.     while (
  699.         (c = y1GetChar( y2InputFD ))   !=    '>'
  700.         &&
  701.         c >= 0
  702.         &&
  703.         c != '\n'
  704.     ) {
  705.         y2InputTokenText[ i ] = c;
  706.  
  707.         /* Truncate too-long type names: */
  708.             if (++len >= NAMEsIZE)   --len;
  709.     }
  710.  
  711.     /* Check for '>' missing: */
  712.         if (c != '>')   y1Error( "y2GetToken: Unterminated < ... > clause" );
  713.  
  714.     /* Tie off name: */
  715.         y2InputTokenText[ len ] = '\0';
  716.  
  717.     /* If typename already entered, don't enter it again: */
  718.         for (i = 1;   i <= y2NumberOfTypesDefined;   ++i) {
  719.         if (!strcmp( y2TypeName[i], y2InputTokenText )) {
  720.         y2InputNumberValue = i;
  721.         return( TYPENAME );
  722.             } 
  723.     }
  724.  
  725.     /* Enter typename: */
  726.     y2TypeName[ y2InputNumberValue = ++y2NumberOfTypesDefined ]   = (
  727.         y2EnterSymbol( y2InputTokenText )
  728.     );
  729.  
  730.         return   TYPENAME;
  731.  
  732.     case '"':
  733.     case '\'':
  734.     match            = c;
  735.     y2InputTokenText[0] = ' ';
  736.     len            = 1;
  737.     loop {
  738.  
  739.         c = y1GetChar( y2InputFD );
  740.  
  741.             if (c == '\n'   ||   c == EOF) {
  742.         y1Error( "y2GetToken: Illegal or missing ' or \"" );
  743.         }
  744.         if (c == '\\') {
  745.  
  746.         c = y1GetChar( y2InputFD );
  747.         y2InputTokenText[i] = '\\';
  748.         if( ++len >= NAMEsIZE ) --len;
  749.  
  750.         } else if( c == match ) {
  751.  
  752.                 break;
  753.  
  754.             }
  755.         y2InputTokenText[len] = c;
  756.         if (++len >= NAMEsIZE )   --len;
  757.     }
  758.     break;
  759.           
  760.     case '%':
  761.     case '\\':
  762.           
  763.     switch (c = y1GetChar( y2InputFD ))  {
  764.  
  765.         case '%':
  766.     case '\\':    return     MARK     ;
  767.     case '0':    return     TERMINAL;
  768.     case '<':    return     LEFT     ;
  769.     case '2':    return     BINARY  ;
  770.     case '>':    return     RIGHT     ;
  771.     case '=':    return     PREC     ;
  772.     case '{':    return     LCURLY  ;
  773.     default:
  774.         percentCommand = TRUE;
  775.     }
  776.           
  777.     default:
  778.           
  779.     if (isdigit( c )) {
  780.  
  781.             /* Number: */
  782.         y2InputNumberValue    = c - '0';
  783.         base        =   (c == '0')     ?   8     :   10;
  784.  
  785.         for (
  786.         c = y1GetChar( y2InputFD );
  787.         isdigit( c );
  788.         c = y1GetChar( y2InputFD )
  789.         ) {
  790.         y2InputNumberValue = y2InputNumberValue * base     +   (c - '0');
  791.             } 
  792.         y1UngetChar( c, y2InputFD );
  793.         return   NUMBER;
  794.  
  795.         } else if (
  796.  
  797.             !islower( c )
  798.         &&
  799.         !isupper( c )
  800.         &&
  801.         c != '_'
  802.         &&
  803.         c != '.'
  804.         &&
  805.         c != '$'
  806.  
  807.         ) {
  808.  
  809.             return   c;
  810.  
  811.         } else {
  812.  
  813.             len = 0;
  814.  
  815.             while (
  816.         islower( c )
  817.         ||
  818.         isupper( c )
  819.         ||
  820.         isdigit( c )
  821.         ||
  822.         c == '_'
  823.         ||
  824.         c == '.'
  825.         ||
  826.         c == '$'
  827.         ) {
  828.         if (percentCommand && isupper(c)) {
  829.             c  +=  'a' - 'A';
  830.         }
  831.                 y2InputTokenText[ len ] = c;
  832.         if (++len >= NAMEsIZE)     --len;
  833.         c = y1GetChar( y2InputFD );
  834.             } 
  835.     }
  836.  
  837.     y1UngetChar( c, y2InputFD );
  838.     }
  839.           
  840.     y2InputTokenText[ len ] = '\0';
  841.           
  842.     if (percentCommand) {
  843.     /* Find a reserved word: */
  844.     if (!strcmp(y2InputTokenText,"term"    ))   return( TERMINAL );
  845.     if (!strcmp(y2InputTokenText,"token"   ))   return( TERMINAL );
  846.     if (!strcmp(y2InputTokenText,"left"    ))   return( LEFT     );
  847.     if (!strcmp(y2InputTokenText,"nonassoc"))   return( BINARY   );
  848.     if (!strcmp(y2InputTokenText,"binary"  ))   return( BINARY   );
  849.     if (!strcmp(y2InputTokenText,"right"   ))   return( RIGHT    );
  850.     if (!strcmp(y2InputTokenText,"prec"    ))   return( PREC     );
  851.     if (!strcmp(y2InputTokenText,"start"   ))   return( START    );
  852.     if (!strcmp(y2InputTokenText,"type"    ))   return( TYPEDEF  );
  853.     if (!strcmp(y2InputTokenText,"union"   ))   return( UNION    );
  854.  
  855.     y1Error(
  856.         "y2GetToken: Invalid escape, or illegal reserved word: %s",
  857.         y2InputTokenText
  858.     );
  859.     }
  860.           
  861.     /* Look ahead to distinguish IDENTIFIER from C_IDENTIFIER: */
  862.           
  863.     c = y1GetChar( y2InputFD );
  864.     while (
  865.     c == ' '
  866.     ||
  867.     c == '\t'
  868.     ||
  869.     c == '\n'
  870.     ||
  871.     c == '\f'
  872.     ||
  873.     c == '/'
  874.     ) {
  875.     if( c == '\n' ) {
  876.         ++peekline;
  877.     } else if( c == '/' ) {
  878.         /* Look for comments: */
  879.         peekline += y2SkipComment();
  880.     }
  881.     c = y1GetChar( y2InputFD );
  882.     }
  883.  
  884.     if (c == ':')   return C_IDENTIFIER;
  885.  
  886.     y1UngetChar( c, y2InputFD );
  887.  
  888.     return   IDENTIFIER;
  889. }
  890.  
  891.  
  892. /************************************************************************/
  893. /*    y2Initialize                            */
  894. /************************************************************************/
  895. y2Initialize( argc, argv )    /* Called once from main at startup    */
  896. int   argc; 
  897. char *argv[];  
  898. { 
  899.     char filename[    FNAMESIZE ];
  900.     char inputFilename[ FNAMESIZE ];
  901.     char *cp;
  902.     int  i;
  903.     int  makeHFile;
  904.     int  makeIFile;
  905.  
  906.     makeHFile    = FALSE;
  907.     makeIFile    = FALSE;
  908.  
  909.     y2OutputFD    = NULL;
  910.     y2DefineFD    = NULL;
  911.  
  912.     /* Handle all commandline switches: */
  913.     for (i = 1;   --argc   &&   argv[i][0] == '-';   i++) {
  914.  
  915.         while (*++(argv[i])) { 
  916.             switch( toupper( *argv[i] )) { 
  917.         case 'I':            makeIFile++;    continue;
  918.         case 'H':            makeHFile++;    continue;
  919.             default: 
  920.         fprintf(stderr, "y2Initialize: Bad option: %c\n", *argv[i]);
  921.                 y2Usage(); 
  922.             }  
  923.         } 
  924.     }
  925.            
  926.     /* Catch no filename given: */
  927.     if (!argc)     y2Usage();
  928.   
  929.     /************************************************************************/ 
  930.     /* Now open the input file with a default extension of ".Y",            */ 
  931.     /* then replace the period in argv[1] with a null, so argv[1]           */ 
  932.     /* can be used to form the table, defs and info filenames.              */ 
  933.     /************************************************************************/ 
  934.            
  935.     /* Find the input filename: */
  936.     cp = argv[i]; 
  937.   
  938.     /* Scan past '.' or to null: */ 
  939.     while (*cp++ != '.'   &&   *cp);
  940.   
  941.     /* Make our own copy: */
  942.     strcpy( filename, argv[i] );
  943.  
  944.     /* Make sure "filename" copy has ".Y" extention    */
  945.     /* and       , argv[] copy has   no extention:    */
  946.     if (!*cp)    strcat( filename, ".Y"    );   /* Add default ".y" */
  947.     else     *(argv[i]-1) = '\0';        /* Null the period: */
  948.  
  949.     /* Open the xxx.y input file: */
  950.     strcpy( inputFilename, filename );
  951.     if ((y2InputFD = fopen( filename, "r" ))   ==   NULL) {
  952.     y1Error( "y2Initialize: Cannot open input file \"%s\"", filename );
  953.     } 
  954.   
  955.     /* If -h option specified, create a xxx.h file to #define the tokens: */
  956.     if (makeHFile) {
  957.     strcpy( filename, argv[i] );
  958.     strcat( filename, ".H"      );
  959.   
  960.     if ((y2DefineFD = fopen( filename, "w" ))   ==     NULL)     {
  961.         y1Error( "y2Initialize: Cannot open defs file\"%s\"", filename);
  962.     }
  963.     } 
  964.            
  965.     /* If -i option specified, create a xxx.i file to hold the    */
  966.     /* human-readable description of the parser:        */
  967.     if (makeIFile) {
  968.     strcpy( filename, argv[i] );
  969.     strcat( filename, ".I"      );
  970.   
  971.     if ((y2OutputFD = fopen( filename, "w" ))   ==     NULL)     {
  972.         y1Error( "y2Initialize: Cannot open info file\"%s\"", filename);
  973.     }
  974.     } 
  975.   
  976.     /* Create the xxx.c file containing the parser proper: */
  977.     strcpy( filename, argv[i] );
  978.     strcat( filename, ".C"    );
  979.   
  980.     if ((y2ytabcFD = fopen(filename, "w"))   ==   NULL)   {
  981.     y1Error( "y2Initialize: Cannot open table file\"%s\"", filename);
  982.     }
  983.   
  984.     /* Open a temporary(?) file for gotos: */
  985.     if ((y2TempFileFD = fopen( TEMPNAME, "w" ))   ==   NULL)   {
  986.     y1Error( "y2Initialize: Cannot open temp file"     );
  987.     }
  988.   
  989.     /* Open a file to copy the user-supplied rule-action code into. */
  990.     /* (We add calling machinery as we go along.)            */
  991.     if ((y2ActionFD = fopen( ACTNAME, "w" ))   ==   NULL) {
  992.     y1Error( "y2Initialize: Cannot open action file" );
  993.     }
  994.   
  995.     /* Put out a header line at the beginning of the 'table' file: */
  996.     /* CrT: What is "CSD"? Capricious Software Demolition :-) ?    */
  997.     fprintf(
  998.     y2ytabcFD,
  999.     "\n/* Created by CSD_YACC (IBM PC) from \"%s\" */\n",
  1000.     inputFilename
  1001.     );
  1002.   
  1003.     /* Complete the initialization: */
  1004.   
  1005.     y2TextFree     = y2Text;
  1006.   
  1007.     /* End token is 0: */
  1008.     y2Define( 0,"$end" ); 
  1009.   
  1010.     /* Other noncharacter terminal tokens start at 257: */
  1011.     y2NextTerminalNumber  = 0400;
  1012.   
  1013.     /* Define remaining special tokens: */
  1014.     y2Define( 0, "error"   ); 
  1015.     y2Define( 1, "$accept" ); 
  1016.   
  1017.     /* y2Pool is empty: */
  1018.     y2FreePool = y2Pool;
  1019. }
  1020.           
  1021.  
  1022. /************************************************************************/ 
  1023. /*      y2SkipComment   Skip over comments.                             */ 
  1024. /************************************************************************/  
  1025. static y2SkipComment() {    /* Called only from y2GetToken        */
  1026.     
  1027.     register c;
  1028.     register linesSkipped;
  1029.  
  1030.     linesSkipped =0;
  1031.     
  1032.     /* y2SkipComment is called after reading a '/': */ 
  1033.             
  1034.     if (y1GetChar( y2InputFD )     !=   '*')  {
  1035.     y1Error( "y2SkipComment: Illegal comment" );
  1036.     }
  1037.     
  1038.     for (c = y1GetChar( y2InputFD );   c != EOF;   c = y1GetChar( y2InputFD )){
  1039.     
  1040.         while (c == '*') {  
  1041.     
  1042.         if ((c = y1GetChar( y2InputFD ))   ==   '/')   return linesSkipped;
  1043.         }  
  1044.     if (c == '\n')     ++linesSkipped;
  1045.     }
  1046.  
  1047.     y1Error( "y2SkipComment: EOF inside comment" );
  1048.  
  1049.     /* NOTREACHED */  
  1050. } 
  1051.   
  1052.  
  1053. /************************************************************************/
  1054. /*      y2TypeOf        Determine the type of a symbol.                 */ 
  1055. /************************************************************************/ 
  1056. static y2TypeOf( t )           /* Called only by y2CpyAction        */
  1057. int t; 
  1058. { 
  1059.     register v; 
  1060.   
  1061.     if (t >= FIRSTnONTERMINAL)    {
  1062.     v = y2NonterminalState[ t - FIRSTnONTERMINAL ].tvalue;
  1063.     } else {
  1064.     v = TYPE( y2TerminalProperties[ t ] );
  1065.     }
  1066.   
  1067.     if (v <= 0) { 
  1068.         y1Error( 
  1069.         "y2TypeOf: Must specify type for %s",
  1070.         (
  1071.         (t >= FIRSTnONTERMINAL)
  1072.         ?
  1073.         y2NonterminalState[ t-FIRSTnONTERMINAL ].name
  1074.         :
  1075.         y2Terminal[ t ].name
  1076.         )
  1077.         ); 
  1078.     } 
  1079.     return   v; 
  1080. } 
  1081.   
  1082.   
  1083. /************************************************************************/
  1084. /*    y2Usage                             */
  1085. /************************************************************************/ 
  1086. static y2Usage() {        /* Called only by y2Initialize        */
  1087.    
  1088.     fprintf( stderr, "\nCDS_YACC:\n"                  );
  1089.     fprintf( stderr, "   yacc -hi infile\n\n"                     ); 
  1090.     fprintf( stderr, "Switches:\n"                                ); 
  1091.     fprintf( stderr, "   -h   Create definitions header file\n"   ); 
  1092.     fprintf( stderr, "   -i   Create parser description file\n\n" ); 
  1093.     fprintf( stderr, "Default input file extension is \".Y\"\n"   ); 
  1094.     fprintf( stderr, "Defs file same name, \".H\" extension.\n"   ); 
  1095.     fprintf( stderr, "Info file same name, \".I\" extension.\n"   ); 
  1096.    
  1097.     exit(EX_ERR);  
  1098. }  
  1099.    
  1100.  
  1101. /************************************************************************/
  1102. /*    y2WriteDefines    Post declarations: write out the defines        */ 
  1103. /************************************************************************/ 
  1104. static y2WriteDefines() {    /* Called only by y2yyParse        */
  1105.   
  1106.     /********************************************************************/
  1107.     /* Write out the defines.  We do this at the end of the declaration */
  1108.     /* section.  If a %{ ... %} section is encountered we write all    */
  1109.     /* pending declarations out to give the C code access to them.    */
  1110.     /* Thus, we may not be writing ALL existing declarations this call: */
  1111.     /********************************************************************/
  1112.  
  1113.     register int  i, c; 
  1114.     register char *cp; 
  1115.            
  1116.     /* For all declarations not yet written out: */
  1117.     for (i = y2NumberOfDefinedSymbolsWritten;   i <= y2NextTerminal;   ++i) {
  1118.   
  1119.     cp = y2Terminal[i].name;
  1120.     if (*cp == ' ')   ++cp;  /* Literals. */
  1121.            
  1122.     /* Ignore defined strings with special characters in them: */
  1123.         for (   ;   c = *cp;   ++cp) {
  1124.         if (!islower(c)  &&  !isupper(c)  &&  !isdigit(c)  &&  c != '_') {
  1125.                 goto nodef; 
  1126.             } 
  1127.         } 
  1128.            
  1129.     /* Write out the #define: */
  1130.         fprintf(
  1131.         y2ytabcFD,
  1132.         "# define %s %d\n",
  1133.         y2Terminal[i].name,
  1134.         y2Terminal[i].value
  1135.     );
  1136.  
  1137.  
  1138.     /* If a .h file was requested, write to it also: */
  1139.         if (y2DefineFD != NULL) {
  1140.             fprintf( 
  1141.         y2DefineFD,
  1142.                 "# define %s %d\n", 
  1143.         y2Terminal[i].name,
  1144.         y2Terminal[i].value
  1145.             ); 
  1146.         } 
  1147. nodef:  ; 
  1148.     } 
  1149.     y2NumberOfDefinedSymbolsWritten = y2NextTerminal+1;
  1150. } 
  1151.   
  1152.  
  1153. /************************************************************************/
  1154. /*    y2yyParse    Kludged YACC input parser.            */
  1155. /************************************************************************/
  1156. y2yyParse() {         /* Called only from main. */
  1157.  
  1158.     int  token;
  1159.     int  j;
  1160.     int  c;
  1161.     int *p;
  1162.     char actionName[8];
  1163.     int  typeOfEmpty;
  1164.  
  1165.     int  associativity = 0;
  1166.     int  type           = 0;
  1167.     int  precedence    = 0;
  1168.  
  1169.     /* "Sorry -- no yacc parser here..... we must bootstrap somehow..."  */
  1170.  
  1171.     /* Handle the declaration section ended by a %% MARKer: */
  1172.     for (token = y2GetToken();     token != MARK   &&   token != ENDFILE;   ) {
  1173.   
  1174.     switch (token) {
  1175.   
  1176.         case LCURLY: 
  1177.         /* Copy some literal C code across. Give it definitions to date: */
  1178.             y2WriteDefines(); 
  1179.             y2CpyCode(); 
  1180.         token = y2GetToken();
  1181.             continue;  
  1182.             
  1183.         case UNION: 
  1184.             /* Copy the union declaration to the output: */  
  1185.             y2CpyUnion(); 
  1186.         token = y2GetToken();
  1187.             continue;  
  1188.             
  1189.         case ';': 
  1190.         token = y2GetToken();
  1191.             break; 
  1192.            
  1193.         case START: 
  1194.         /* Handle a %start declaration: */
  1195.             if ((token = y2GetToken())   !=   IDENTIFIER) {
  1196.         y1Error( "y2yyParse: Bad %%start construction" );
  1197.             }  
  1198.         y2RootNonterminal    = (
  1199.         y2FindName( TYPEnONTERMINAL, y2InputTokenText )
  1200.         );
  1201.             token       = y2GetToken();
  1202.             continue; 
  1203.            
  1204.         case TYPEDEF: 
  1205.         /* Handle a %token declaration: */
  1206.             if ((token = y2GetToken())   !=   TYPENAME) {
  1207.         y1Error( "y2yyParse: Bad syntax in %%type" );
  1208.             } 
  1209.         type  = y2InputNumberValue;
  1210.   
  1211.         /* Handle IDENTIFIER string following the %token: */
  1212.             loop {
  1213.   
  1214.         switch (token = y2GetToken()) {
  1215.   
  1216.         case ',':                 continue;
  1217.         case ';':    token = y2GetToken();        break;
  1218.    
  1219.                 case IDENTIFIER: 
  1220.   
  1221.             /* Look up token, creating new entry if necessary: */
  1222.                     token = y2FindName( TYPEnONTERMINAL, y2InputTokenText );
  1223.  
  1224.             /* Handle terminals and nonterminals separately: */
  1225.                     if (token < FIRSTnONTERMINAL) {
  1226.   
  1227.                         /* Terminal: */
  1228.  
  1229.                         /* See what it is declared as: */
  1230.                         j = TYPE( y2TerminalProperties[ token ] );
  1231.   
  1232.             /* OK if no type yet or same type: */
  1233.                         if (j == 0   ||   j == type) {
  1234.  
  1235.                 SETtYPEtO( y2TerminalProperties[token], type );
  1236.  
  1237.                         } else { 
  1238.                             y1Error( 
  1239.                 "y2yyParse: Type redeclaration of token %s",
  1240.                  y2Terminal[token].name
  1241.                             ); 
  1242.                         } 
  1243.   
  1244.                     } else { 
  1245.   
  1246.             /* Nonterminal: */
  1247.  
  1248.             /* See what it is was previously declared as: */
  1249.                         j   = y2NonterminalState[
  1250.                 token - FIRSTnONTERMINAL
  1251.             ].tvalue;
  1252.   
  1253.             /* No type or matching type ok: */
  1254.                         if (j == 0   ||   j == type) {
  1255.  
  1256.                 y2NonterminalState[
  1257.                 token - FIRSTnONTERMINAL
  1258.                 ].tvalue = type;
  1259.  
  1260.                         } else { 
  1261.                 y1Error(
  1262.                 "y2yyParse: Redeclaration of nonterminal %s",
  1263.                 y2NonterminalState[
  1264.                     token - FIRSTnONTERMINAL
  1265.                 ].name
  1266.                             ); 
  1267.             }
  1268.                     } 
  1269.                     continue; 
  1270.   
  1271.                 default: 
  1272.                     break; 
  1273.                 } 
  1274.                 break; 
  1275.             }  
  1276.             continue; 
  1277.            
  1278.         case LEFT: 
  1279.         case BINARY: 
  1280.     case RIGHT:          ++precedence;    /* Fall into TERMINAL: */
  1281.  
  1282.     case TERMINAL:
  1283.         /* Nonzero means new precedence and associativity: */
  1284.         associativity = token - TERMINAL;
  1285.         type  = 0;
  1286.   
  1287.             /* Get identifiers so defined: */ 
  1288.            
  1289.         token = y2GetToken();
  1290.  
  1291.         if (token == TYPENAME) {
  1292.   
  1293.                 /* There is a type defined: */ 
  1294.         type    = y2InputNumberValue;
  1295.         token    = y2GetToken();
  1296.             }  
  1297.  
  1298.             loop {
  1299.   
  1300.         switch (token) {
  1301.  
  1302.                 case ',':       token = y2GetToken();        continue;
  1303.         case ';':                    break;
  1304.  
  1305.                 case IDENTIFIER: 
  1306.             j = y2FindName( TYPEtERMINAL, y2InputTokenText );
  1307.  
  1308.             if (associativity) {
  1309.  
  1310.             if (ASSOCIATIVITY( y2TerminalProperties[j] )) {
  1311.                             y1Error( 
  1312.                 "y2yyParse: Redeclaration of precedence of %s",
  1313.                 y2InputTokenText
  1314.                             ); 
  1315.                         } 
  1316.             SETaSSOCIATIVITYtO(   y2TerminalProperties[j], associativity);
  1317.             SETpRECEDENCElEVELtO( y2TerminalProperties[j], precedence);
  1318.                     } 
  1319.   
  1320.             if (type) {
  1321.             if (TYPE( y2TerminalProperties[j] )) {
  1322.                             y1Error( 
  1323.                 "y2yyParse: Redeclaration of type of %s",
  1324.                 y2InputTokenText
  1325.                             ); 
  1326.                         } 
  1327.             SETtYPEtO( y2TerminalProperties[j], type );
  1328.                     } 
  1329.   
  1330.             if ((token = y2GetToken())     ==   NUMBER) {
  1331.             y2Terminal[j].value = y2InputNumberValue;
  1332.             if (j < y2NumberOfDefinedSymbolsWritten   &&   j > 2) {
  1333.                             y1Error( 
  1334.                 "y2yyParse: Must define type # of %s earlier",
  1335.                 y2Terminal[j].name
  1336.                             ); 
  1337.                         } 
  1338.             token = y2GetToken();
  1339.                     } 
  1340.                     continue; 
  1341.                 } 
  1342.                 break; 
  1343.             }  
  1344.             continue; 
  1345.            
  1346.         default: 
  1347.         printf(  "y2yyParse: Unrecognized character: %o\n", token);
  1348.         y1Error( "y2yyParse: Syntax error" );
  1349.         } 
  1350.     } 
  1351.            
  1352.  
  1353.  
  1354.     /******************************/
  1355.     /* End of declaration section */
  1356.     /******************************/
  1357.  
  1358.     if (token == ENDFILE)  y1Error( "y2yyParse: Unexpected EOF before %%" );
  1359.   
  1360.     /* Token is MARK (%%), wrap up declaration section stuff: */
  1361.            
  1362.     y2WriteDefines(); 
  1363.            
  1364.     fprintf( y2ytabcFD,"#define yyclearin yychar = -1\n" );
  1365.     fprintf( y2ytabcFD,"#define yyerrok yyerrflag = 0\n" );
  1366. #ifdef XYZZY 
  1367.     fprintf( y2ytabcFD,"extern int yychar;\nextern short yyerrflag;\n" );
  1368. #endif 
  1369.     fprintf(
  1370.     y2ytabcFD,
  1371.     "#ifndef YYMAXDEPTH\n#define YYMAXDEPTH 150\n#endif\n"
  1372.     );
  1373.     if (!y2NumberOfTypesDefined) {
  1374.     fprintf(
  1375.         y2ytabcFD,
  1376.         "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n"
  1377.     );
  1378.     } 
  1379.   
  1380. #ifdef unix  
  1381.     fprintf( y2ytabcFD,  "YYSTYPE yylval, yyval;\n" );
  1382. #else      
  1383.     fprintf( y2ytabcFD, "extern YYSTYPE yylval;  /*CSD & DECUS LEX */\n");
  1384.     fprintf( y2ytabcFD, "YYSTYPE yyval;          /*CSD & DECUS LEX */\n");
  1385. #endif     
  1386.   
  1387.     /* Set up to start parsing the rules ("productions"): */
  1388.     y2Production[ 0 ]     = y2FreePool;
  1389.   
  1390.     /* If no %start declaration is made, the first nonterminal is used: */
  1391.   
  1392.     *y2FreePool++ = FIRSTnONTERMINAL;
  1393.     *y2FreePool++ = y2RootNonterminal;
  1394.     *y2FreePool++ = 1;
  1395.     *y2FreePool++ = 0;
  1396.   
  1397.     y2Production[1]    = y2FreePool;
  1398.   
  1399.     /* Copy any %{...%} code between the %% and the first rule: */
  1400.     while ((token = y2GetToken())   ==     LCURLY)   y2CpyCode();
  1401.   
  1402.     if (token != C_IDENTIFIER) {
  1403.     y1Error( "y2yyParse: Bad syntax on first rule" );
  1404.     }
  1405.     if (!y2RootNonterminal) {
  1406.     y2Production[0][1] = y2FindName(TYPEnONTERMINAL,y2InputTokenText);
  1407.     }
  1408.            
  1409.     /* Now read all rules in the grammar: */
  1410.     while (token != MARK   &&    token != ENDFILE) {
  1411.   
  1412.         /* Process a rule: */ 
  1413.            
  1414.     if     (token == '|'         ) {
  1415.   
  1416.         /* Copy over LHS of previous production: */
  1417.         *y2FreePool++ = *y2Production[ y2ThisProduction-1 ];
  1418.   
  1419.     } else if (token == C_IDENTIFIER) {
  1420.   
  1421.         /* Copy internal ID# for LHS nonterminal to first slot in rule: */
  1422.             *y2FreePool   = y2FindName( TYPEnONTERMINAL, y2InputTokenText );
  1423.         if (*y2FreePool < FIRSTnONTERMINAL)  {
  1424.            y1Error( "y2yyParse: Terminal illegal on LHS of grammar rule" );
  1425.         }
  1426.         ++y2FreePool;
  1427.   
  1428.         } else { 
  1429.   
  1430.         y1Error( "y2yyParse: Illegal rule: missing semicolon or | ?" );
  1431.   
  1432.         } 
  1433.            
  1434.         /* Read rule body: */ 
  1435.     token = y2GetToken();
  1436.   
  1437. more_rule:  
  1438.     while (token == IDENTIFIER) {
  1439.   
  1440.         *y2FreePool = y2FindName( TYPEnONTERMINAL, y2InputTokenText );
  1441.   
  1442.         /* Grammar rules inherit the associativity and  */
  1443.         /* precedence of any embedded terminals:        */
  1444.             if (*y2FreePool < FIRSTnONTERMINAL) {
  1445.         y2ProductionProperties[ y2ThisProduction ]  = (
  1446.             y2TerminalProperties[ *y2FreePool ]
  1447.         );
  1448.             }
  1449.   
  1450.         ++y2FreePool;
  1451.         token = y2GetToken();
  1452.         } 
  1453.   
  1454.     /* Handle "%prec" commands: */
  1455.         if (token == PREC) {
  1456.         if (y2GetToken() != IDENTIFIER)   {
  1457.         y1Error( "y2yyParse: Illegal %%prec syntax" );
  1458.         }
  1459.  
  1460.         /* Look up terminal specified in %prec: */
  1461.             j   = y2FindName( TYPEpREC, y2InputTokenText );
  1462.  
  1463.         /* Make sure it is not a nonterminal: */
  1464.             if (j >= FIRSTnONTERMINAL) {
  1465.                 y1Error( 
  1466.             "y2yyParse: Nonterminal %s illegal after %%prec",
  1467.             y2NonterminalState[ j-FIRSTnONTERMINAL ].name
  1468.                 ); 
  1469.             } 
  1470.  
  1471.         /* Let current rule inherit specified precedence: */
  1472.         y2ProductionProperties[ y2ThisProduction ] = (
  1473.         y2TerminalProperties[ j ]
  1474.         );
  1475.             token = y2GetToken();
  1476.         } 
  1477.   
  1478.     /* Handle actions: */
  1479.         if (token == '=') {
  1480.             int RHSItems;
  1481.  
  1482.         /* Remember that this rule has an action: */
  1483.             y2ProductionProperties[ y2ThisProduction ]   |= RULEhASaCTION;
  1484.  
  1485.         /* Figure number of items seen so far on right-hand side */
  1486.         /* of grammar rule (for check $n args in actions):         */
  1487.         RHSItems  =  y2FreePool  -    y2Production[ y2ThisProduction ]  -1;
  1488.  
  1489.         /* Copy action code to output, handling $ variables: */
  1490.             y2CpyAction( RHSItems );
  1491.  
  1492.         /* Check for more rule after the action: */
  1493.             if ((token = y2GetToken())   ==   IDENTIFIER) {
  1494.   
  1495.         /* Action within rule. Split it into two rules: */
  1496.         sprintf( actionName, "$$%d", y2ThisProduction );
  1497.   
  1498.         /* Create a nonterminal: */
  1499.         j = y2FindName(TYPEnONTERMINAL,actionName);
  1500.   
  1501.   
  1502.                 /*******************************************************/ 
  1503.         /* The current rule will become rule number           */
  1504.         /* y2ThisProduction+1.    Move the contents down, and    */
  1505.         /* make room for the null:                   */
  1506.                 /*******************************************************/ 
  1507.   
  1508.         for (
  1509.             p  = y2FreePool;
  1510.             p >= y2Production[ y2ThisProduction ];
  1511.             p--
  1512.         ) {
  1513.             p[2] = *p;
  1514.         }
  1515.                 y2FreePool += 2;
  1516.   
  1517.                 /* Enter null production for action: */ 
  1518.         p    = y2Production[ y2ThisProduction ];
  1519.                 *p++    = j; 
  1520.         *p++    = -y2ThisProduction;
  1521.            
  1522.                 /* Update the production information: */ 
  1523.  
  1524.         /* Current rule does NOT have an action after all: */
  1525.         y2ProductionProperties[ y2ThisProduction+1 ] = (
  1526.             y2ProductionProperties[ y2ThisProduction ] & ~RULEhASaCTION
  1527.         );
  1528.  
  1529.         /* But added null production DOES have an action: */
  1530.         y2ProductionProperties[ y2ThisProduction   ] =    RULEhASaCTION;
  1531.            
  1532.         /* Check for too productions: */
  1533.         if (++y2ThisProduction >= MAXpRODUCTIONS)   {
  1534.             y1Error( "y2yyParse: More than %d rules", MAXpRODUCTIONS );
  1535.         }
  1536.         y2Production[ y2ThisProduction ]    = p;
  1537.            
  1538.                 /* Make the action appear in the original rule: */ 
  1539.         *y2FreePool++ = j;
  1540.   
  1541.                 /* Get some more of the rule: */ 
  1542.                 goto more_rule; 
  1543.             }  
  1544.         } 
  1545.            
  1546.     /* Handle end of rule: */
  1547.         while (token == ';')    token = y2GetToken();
  1548.            
  1549.     *y2FreePool++ = -y2ThisProduction;
  1550.            
  1551.         /* Check that default action is reasonable: */ 
  1552.            
  1553.         if ( 
  1554.         y2NumberOfTypesDefined
  1555.             && 
  1556.         !(y2ProductionProperties[ y2ThisProduction ] & RULEhASaCTION)
  1557.             && 
  1558.         y2NonterminalState[ * /* DeSmet C bug pins the '*' to this line */
  1559.         y2Production[ y2ThisProduction ]
  1560.         -
  1561.         FIRSTnONTERMINAL
  1562.         ].tvalue
  1563.     ) {
  1564.             /* No explicit action, LHS has value: */ 
  1565.         typeOfEmpty = y2Production[ y2ThisProduction ][ 1 ];
  1566.   
  1567.         if (typeOfEmpty < 0) {
  1568.   
  1569.         y1Error("y2yyParse: Must return value, since LHS has a type");
  1570.  
  1571.         } else if (typeOfEmpty >= FIRSTnONTERMINAL ) {
  1572.   
  1573.          typeOfEmpty = (
  1574.              y2NonterminalState[ typeOfEmpty-FIRSTnONTERMINAL ].tvalue
  1575.          );
  1576.             } else { 
  1577.   
  1578.          typeOfEmpty = TYPE( y2TerminalProperties[typeOfEmpty] );
  1579.             } 
  1580.   
  1581.         if (
  1582.         typeOfEmpty
  1583.         !=
  1584.         y2NonterminalState[ * /* DeSmet C bug keeps '*' from moving */
  1585.             y2Production[ y2ThisProduction ]
  1586.             -
  1587.             FIRSTnONTERMINAL
  1588.         ].tvalue
  1589.         ) {
  1590.         y1Error("y2yyParse: Default action has potential type clash");
  1591.         }
  1592.         } 
  1593.  
  1594.     /* Check for too many productions: */
  1595.     if (++y2ThisProduction >= MAXpRODUCTIONS)  {
  1596.          y1Error( "y2yyParse: more than %d rules", MAXpRODUCTIONS );
  1597.     }
  1598.   
  1599.     y2Production[ y2ThisProduction ]       = y2FreePool;
  1600.     y2ProductionProperties[ y2ThisProduction ] =   0;
  1601.     } 
  1602.   
  1603.  
  1604.     /*********************/
  1605.     /* End of all rules: */
  1606.     /*********************/
  1607.  
  1608.     /* Properly terminate the last line: */ 
  1609.     fprintf(y2ActionFD, "/* End of actions. */");
  1610.     fclose( y2ActionFD );
  1611.     fprintf( y2ytabcFD, "# define YYERRCODE %d\n", y2Terminal[2].value );
  1612.   
  1613.     /* Copy anything remaining to the output code file: */
  1614.     if (token == MARK) {
  1615.     fprintf( y2ytabcFD, "\n#line %d\n", y1LineNumber );
  1616.   
  1617.     while ((c = y1GetChar( y2InputFD ))   !=   EOF)   putc( c, y2ytabcFD );
  1618.     } 
  1619.     fclose( y2InputFD );
  1620.  
  1621.     /* All finished with input! Now return and start analysing grammar: */
  1622. }
  1623.            
  1624.  
  1625.