# line 2 "gram.y" #include #include "lburg.h" static char rcsid[] = "$Id: gram.y,v 2.1 1994/11/30 21:53:18 drh Exp $"; /*lint -e616 -e527 -e652 -esym(552,yynerrs) -esym(563,yynewstate,yyerrlab) */ # line 7 "gram.y" typedef union { int n; char *string; Tree tree; } YYSTYPE; # define TERM 257 # define START 258 # define PPERCENT 259 # define ID 260 # define TEMPLATE 261 # define CODE 262 # define INT 263 #define yyclearin yychar = -1 #define yyerrok yyerrflag = 0 extern int yychar; extern int yyerrflag; #ifndef YYMAXDEPTH #define YYMAXDEPTH 150 #endif YYSTYPE yylval, yyval; typedef int yytabelem; # define YYERRCODE 256 # line 58 "gram.y" #include #include #include #include #include int errcnt = 0; FILE *infp = NULL; FILE *outfp = NULL; static char buf[BUFSIZ], *bp = buf; static int yylineno = 0; static int ppercent = 0; static int code = 0; static int get(void) { if (*bp == 0) { if (fgets(buf, sizeof buf, infp) == NULL) return EOF; bp = buf; yylineno++; while (buf[0] == '%' && buf[1] == '{' && buf[2] == '\n') { for (;;) { if (fgets(buf, sizeof buf, infp) == NULL) { yywarn("unterminated %{...%}\n"); return EOF; } yylineno++; if (strcmp(buf, "%}\n") == 0) break; fputs(buf, outfp); } if (fgets(buf, sizeof buf, infp) == NULL) return EOF; yylineno++; } } return *bp++; } void yyerror(char *fmt, ...) { va_list ap; va_start(ap, fmt); if (yylineno > 0) fprintf(stderr, "line %d: ", yylineno); vfprintf(stderr, fmt, ap); if (fmt[strlen(fmt)-1] != '\n') fprintf(stderr, "\n"); errcnt++; } int yylex(void) { int c; if (code) { char *p; bp += strspn(bp, " \t\f"); p = strchr(bp, '\n'); while (p > bp && isspace(p[-1])) p--; yylval.string = alloc(p - bp + 1); strncpy(yylval.string, bp, p - bp); yylval.string[p - bp] = 0; bp = p; code--; return CODE; } while ((c = get()) != EOF) { switch (c) { case ' ': case '\f': case '\t': continue; case '\n': case '(': case ')': case ',': case ':': case '=': return c; } if (c == '%' && *bp == '%') { bp++; return ppercent++ ? 0 : PPERCENT; } else if (c == '%' && strncmp(bp, "term", 4) == 0 && isspace(bp[4])) { bp += 4; return TERM; } else if (c == '%' && strncmp(bp, "start", 5) == 0 && isspace(bp[5])) { bp += 5; return START; } else if (c == '"') { char *p = strchr(bp, '"'); if (p == NULL) { yyerror("missing \" in assembler template\n"); p = strchr(bp, '\n'); } assert(p); yylval.string = alloc(p - bp + 1); strncpy(yylval.string, bp, p - bp); yylval.string[p - bp] = 0; bp = *p == '"' ? p + 1 : p; code++; return TEMPLATE; } else if (isdigit(c)) { int n = 0; do { int d = c - '0'; if (n > (INT_MAX - d)/10) yyerror("integer greater than %d\n", INT_MAX); else n = 10*n + d; c = get(); } while (isdigit(c)); bp--; yylval.n = n; return INT; } else if (isalpha(c)) { char *p = bp - 1; while (isalpha(c) || isdigit(c) || c == '_') c = get(); bp--; yylval.string = alloc(bp - p + 1); strncpy(yylval.string, p, bp - p); yylval.string[bp - p] = 0; return ID; } else if (isprint(c)) yyerror("illegal character `%c'\n", c); else yyerror("illegal character `\0%o'\n", c); } return 0; } void yywarn(char *fmt, ...) { va_list ap; va_start(ap, fmt); if (yylineno > 0) fprintf(stderr, "line %d: ", yylineno); fprintf(stderr, "warning: "); vfprintf(stderr, fmt, ap); } static yytabelem yyexca[] ={ -1, 1, 0, -1, -2, 0, -1, 2, 0, 2, -2, 0, -1, 9, 0, 1, -2, 0, }; # define YYNPROD 20 # define YYLAST 256 static yytabelem yyact[]={ 25, 7, 29, 26, 17, 15, 24, 12, 22, 20, 32, 35, 27, 33, 23, 31, 21, 19, 13, 11, 10, 4, 9, 2, 1, 28, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 6, 3, 16, 0, 0, 18, 12 }; static yytabelem yypact[]={ -1000, -1000, -9, -1000, -1000, -1000, -253, -1000, 8, -5, -6, 7, -1000, -1000, -49, -1000, 6, -1000, -53, -1000, -254, -1000, -263, -258, -28, -1000, -260, -254, 5, -1000, -31, -1000, -1000, -254, -30, -1000 }; static yytabelem yypgo[]={ 0, 19, 25, 14, 24, 23, 22, 21, 20 }; static yytabelem yyr1[]={ 0, 4, 4, 5, 5, 7, 7, 7, 7, 8, 8, 6, 6, 6, 6, 1, 3, 3, 3, 2 }; static yytabelem yyr2[]={ 0, 7, 3, 0, 4, 6, 7, 2, 5, 0, 9, 0, 15, 4, 7, 3, 3, 9, 13, 3 }; static yytabelem yychk[]={ -1000, -4, -5, 259, -7, 257, 258, 10, 256, -6, -8, -1, 260, 10, -1, 10, 256, 10, 260, 10, 58, 10, 61, -3, 260, 263, 261, 40, -2, 262, -3, 10, 41, 44, -3, 41 }; static yytabelem yydef[]={ 3, -2, -2, 11, 4, 9, 0, 7, 0, -2, 0, 0, 15, 8, 0, 13, 0, 5, 0, 6, 0, 14, 0, 0, 16, 10, 0, 0, 0, 19, 0, 12, 17, 0, 0, 18 }; typedef struct { char *t_name; int t_val; } yytoktype; #ifndef YYDEBUG # define YYDEBUG 0 /* don't allow debugging */ #endif #if YYDEBUG yytoktype yytoks[] = { "TERM", 257, "START", 258, "PPERCENT", 259, "ID", 260, "TEMPLATE", 261, "CODE", 262, "INT", 263, "-unknown-", -1 /* ends search */ }; char * yyreds[] = { "-no such reduction-", "spec : decls PPERCENT rules", "spec : decls", "decls : /* empty */", "decls : decls decl", "decl : TERM blist '\n'", "decl : START nonterm '\n'", "decl : '\n'", "decl : error '\n'", "blist : /* empty */", "blist : blist ID '=' INT", "rules : /* empty */", "rules : rules nonterm ':' tree TEMPLATE cost '\n'", "rules : rules '\n'", "rules : rules error '\n'", "nonterm : ID", "tree : ID", "tree : ID '(' tree ')'", "tree : ID '(' tree ',' tree ')'", "cost : CODE", }; #endif /* YYDEBUG */ /* * (c) Copyright 1990, OPEN SOFTWARE FOUNDATION, INC. * ALL RIGHTS RESERVED */ /* * OSF/1 Release 1.0 */ /* @(#)yaccpar 1.3 com/cmd/lang/yacc,3.1, 9/7/89 18:46:37 */ /* ** Skeleton parser driver for yacc output */ /* ** yacc user known macros and defines */ #ifdef YYSPLIT # define YYERROR return(-2) #else # define YYERROR goto yyerrlab #endif #define YYACCEPT return(0) #define YYABORT return(1) #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ yyerror( "syntax error - cannot backup" );\ goto yyerrlab;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #define YYRECOVERING() (!!yyerrflag) #ifndef YYDEBUG # define YYDEBUG 1 /* make debugging available */ #endif /* ** user known globals */ int yydebug; /* set to 1 to get debugging */ /* ** driver internal defines */ #define YYFLAG (-1000) #ifdef YYSPLIT # define YYSCODE { \ extern int (*yyf[])(); \ register int yyret; \ if (yyf[yytmp]) \ if ((yyret=(*yyf[yytmp])()) == -2) \ goto yyerrlab; \ else if (yyret>=0) return(yyret); \ } #endif /* ** global variables used by the parser */ YYSTYPE yyv[ YYMAXDEPTH ]; /* value stack */ int yys[ YYMAXDEPTH ]; /* state stack */ YYSTYPE *yypv; /* top of value stack */ YYSTYPE *yypvt; /* top of value stack for $vars */ int *yyps; /* top of state stack */ int yystate; /* current state */ int yytmp; /* extra var (lasts between blocks) */ int yynerrs; /* number of errors */ int yyerrflag; /* error recovery flag */ int yychar; /* current input token number */ /* ** yyparse - return 0 if worked, 1 if syntax error not recovered from */ int yyparse() { /* ** Initialize externals - yyparse may be called more than once */ yypv = &yyv[-1]; yyps = &yys[-1]; yystate = 0; yytmp = 0; yynerrs = 0; yyerrflag = 0; yychar = -1; goto yystack; { register YYSTYPE *yy_pv; /* top of value stack */ register int *yy_ps; /* top of state stack */ register int yy_state; /* current state */ register int yy_n; /* internal state number info */ /* ** get globals into registers. ** branch to here only if YYBACKUP was called. */ yynewstate: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; goto yy_newstate; /* ** get globals into registers. ** either we just started, or we just finished a reduction */ yystack: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; /* ** top of for (;;) loop while no reductions done */ yy_stack: /* ** put a state and value onto the stacks */ #if YYDEBUG /* ** if debugging, look up token value in list of value vs. ** name pairs. 0 and negative (-1) are special values. ** Note: linear search is used since time is not a real ** consideration while debugging. */ if ( yydebug ) { register int yy_i; printf( "State %d, token ", yy_state ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ++yy_ps >= &yys[ YYMAXDEPTH ] ) /* room on stack? */ { yyerror( "yacc stack overflow" ); YYABORT; } *yy_ps = yy_state; *++yy_pv = yyval; /* ** we have a new state - find out what to do */ yy_newstate: if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) goto yydefault; /* simple state */ #if YYDEBUG /* ** if debugging, need to mark whether new token grabbed */ yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) goto yydefault; if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ { yychar = -1; yyval = yylval; yy_state = yy_n; if ( yyerrflag > 0 ) yyerrflag--; goto yy_stack; } yydefault: if ( ( yy_n = yydef[ yy_state ] ) == -2 ) { #if YYDEBUG yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ /* ** look through exception table */ { register int *yyxi = yyexca; while ( ( *yyxi != -1 ) || ( yyxi[1] != yy_state ) ) { yyxi += 2; } while ( ( *(yyxi += 2) >= 0 ) && ( *yyxi != yychar ) ) ; if ( ( yy_n = yyxi[1] ) < 0 ) YYACCEPT; } } /* ** check for syntax error */ if ( yy_n == 0 ) /* have an error */ { /* no worry about speed here! */ switch ( yyerrflag ) { case 0: /* new error */ yyerror( "syntax error" ); goto skip_init; yyerrlab: /* ** get globals into registers. ** we have a user generated syntax type error */ yy_pv = yypv; yy_ps = yyps; yy_state = yystate; yynerrs++; skip_init: case 1: case 2: /* incompletely recovered error */ /* try again... */ yyerrflag = 3; /* ** find state where "error" is a legal ** shift action */ while ( yy_ps >= yys ) { yy_n = yypact[ *yy_ps ] + YYERRCODE; if ( yy_n >= 0 && yy_n < YYLAST && yychk[yyact[yy_n]] == YYERRCODE) { /* ** simulate shift of "error" */ yy_state = yyact[ yy_n ]; goto yy_stack; } /* ** current state has no shift on ** "error", pop stack */ #if YYDEBUG # define _POP_ "Error recovery pops state %d, uncovers state %d\n" if ( yydebug ) printf( _POP_, *yy_ps, yy_ps[-1] ); # undef _POP_ #endif yy_ps--; yy_pv--; } /* ** there is no state on stack with "error" as ** a valid shift. give up. */ YYABORT; case 3: /* no shift yet; eat a token */ #if YYDEBUG /* ** if debugging, look up token in list of ** pairs. 0 and negative shouldn't occur, ** but since timing doesn't matter when ** debugging, it doesn't hurt to leave the ** tests here. */ if ( yydebug ) { register int yy_i; printf( "Error recovery discards " ); if ( yychar == 0 ) printf( "token end-of-file\n" ); else if ( yychar < 0 ) printf( "token -none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "token %s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( yychar == 0 ) /* reached EOF. quit */ YYABORT; yychar = -1; goto yy_newstate; } }/* end if ( yy_n == 0 ) */ /* ** reduction by production yy_n ** put stack tops, etc. so things right after switch */ #if YYDEBUG /* ** if debugging, print the string that is the user's ** specification of the reduction which is just about ** to be done. */ if ( yydebug ) printf( "Reduce by (%d) \"%s\"\n", yy_n, yyreds[ yy_n ] ); #endif yytmp = yy_n; /* value to switch over */ yypvt = yy_pv; /* $vars top of value stack */ /* ** Look in goto table for next state ** Sorry about using yy_state here as temporary ** register variable, but why not, if it works... ** If yyr2[ yy_n ] doesn't have the low order bit ** set, then there is no action to be done for ** this reduction. So, no saving & unsaving of ** registers done. The only difference between the ** code just after the if and the body of the if is ** the goto yy_stack in the body. This way the test ** can be made before the choice of what to do is needed. */ { /* length of production doubled with extra bit */ register int yy_len = yyr2[ yy_n ]; if ( !( yy_len & 01 ) ) { yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } goto yy_stack; } yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } } /* save until reenter driver code */ yystate = yy_state; yyps = yy_ps; yypv = yy_pv; } /* ** code supplied by user is placed in this switch */ switch(yytmp){ case 1: # line 21 "gram.y" { yylineno = 0; } /*NOTREACHED*/ break; case 2: # line 22 "gram.y" { yylineno = 0; } /*NOTREACHED*/ break; case 6: # line 30 "gram.y" { if (nonterm(yypvt[-1].string)->number != 1) yyerror("redeclaration of the start symbol\n"); } /*NOTREACHED*/ break; case 8: # line 35 "gram.y" { yyerrok; } /*NOTREACHED*/ break; case 10: # line 39 "gram.y" { term(yypvt[-2].string, yypvt[-0].n); } /*NOTREACHED*/ break; case 12: # line 43 "gram.y" { rule(yypvt[-5].string, yypvt[-3].tree, yypvt[-2].string, yypvt[-1].string); } /*NOTREACHED*/ break; case 14: # line 45 "gram.y" { yyerrok; } /*NOTREACHED*/ break; case 15: # line 48 "gram.y" { nonterm(yyval.string = yypvt[-0].string); } /*NOTREACHED*/ break; case 16: # line 51 "gram.y" { yyval.tree = tree(yypvt[-0].string, 0, 0); } /*NOTREACHED*/ break; case 17: # line 52 "gram.y" { yyval.tree = tree(yypvt[-3].string, yypvt[-1].tree, 0); } /*NOTREACHED*/ break; case 18: # line 53 "gram.y" { yyval.tree = tree(yypvt[-5].string, yypvt[-3].tree, yypvt[-1].tree); } /*NOTREACHED*/ break; case 19: # line 56 "gram.y" { if (*yypvt[-0].string == 0) yyval.string = "0"; } /*NOTREACHED*/ break; } goto yystack; /* reset registers in driver code */ }