![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to yaccpar CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / yacc|
Return to yaccpar CVS log | Up to [Research Unix] / researchv10no / cmd / yacc |
1.1 root 1: # ifdef YYDEBUG
2: # include "y.debug"
3: # endif
4:
5: # define YYFLAG -1000
6: # define YYERROR goto yyerrlab
7: # define YYACCEPT return(0)
8: # define YYABORT return(1)
9:
10: /* parser for yacc output */
11:
12: #ifdef YYDEBUG
13: int yydebug = 0; /* 1 for debugging */
14: #endif
15: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
16: int yychar = -1; /* current input token number */
17: int yynerrs = 0; /* number of errors */
18: short yyerrflag = 0; /* error recovery flag */
19:
20: yyparse()
21: { short yys[YYMAXDEPTH];
22: int yyj, yym;
23: register YYSTYPE *yypvt;
24: register int yystate, yyn;
25: register short *yyps;
26: register YYSTYPE *yypv;
27: register short *yyxi;
28:
29: yystate = 0;
30: yychar = -1;
31: yynerrs = 0;
32: yyerrflag = 0;
33: yyps= &yys[-1];
34: yypv= &yyv[-1];
35:
36: yystack: /* put a state and value onto the stack */
37: #ifdef YYDEBUG
38: if(yydebug >= 3)
39: if(yychar < 0 || yytoknames[yychar] == 0)
40: printf("char %d in %s", yychar, yystates[yystate]);
41: else
42: printf("%s in %s", yytoknames[yychar], yystates[yystate]);
43: #endif
44: if( ++yyps >= &yys[YYMAXDEPTH] ) {
45: yyerror( "yacc stack overflow" );
46: return(1);
47: }
48: *yyps = yystate;
49: ++yypv;
50: *yypv = yyval;
51: yynewstate:
52: yyn = yypact[yystate];
53: if(yyn <= YYFLAG) goto yydefault; /* simple state */
54: if(yychar<0) {
55: yychar = yylex();
56: #ifdef YYDEBUG
57: if(yydebug >= 2) {
58: if(yychar <= 0)
59: printf("lex EOF\n");
60: else if(yytoknames[yychar])
61: printf("lex %s\n", yytoknames[yychar]);
62: else
63: printf("lex (%c)\n", yychar);
64: }
65: #endif
66: if(yychar < 0)
67: yychar = 0;
68: }
69: if((yyn += yychar) < 0 || yyn >= YYLAST)
70: goto yydefault;
71: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
72: yychar = -1;
73: yyval = yylval;
74: yystate = yyn;
75: if( yyerrflag > 0 ) --yyerrflag;
76: goto yystack;
77: }
78: yydefault:
79: /* default state action */
80: if( (yyn=yydef[yystate]) == -2 ) {
81: if(yychar < 0) {
82: yychar = yylex();
83: #ifdef YYDEBUG
84: if(yydebug >= 2)
85: if(yychar < 0)
86: printf("lex EOF\n");
87: else
88: printf("lex %s\n", yytoknames[yychar]);
89: #endif
90: if(yychar < 0)
91: yychar = 0;
92: }
93: /* look through exception table */
94: for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate);
95: yyxi += 2 ) ; /* VOID */
96: while( *(yyxi+=2) >= 0 ){
97: if( *yyxi == yychar ) break;
98: }
99: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
100: }
101: if( yyn == 0 ){ /* error */
102: /* error ... attempt to resume parsing */
103: switch( yyerrflag ){
104: case 0: /* brand new error */
105: #ifdef YYDEBUG
106: yyerror("syntax error\n%s", yystates[yystate]);
107: if(yytoknames[yychar])
108: yyerror("saw %s\n", yytoknames[yychar]);
109: else if(yychar >= ' ' && yychar < '\177')
110: yyerror("saw `%c'\n", yychar);
111: else if(yychar == 0)
112: yyerror("saw EOF\n");
113: else
114: yyerror("saw char 0%o\n", yychar);
115: #else
116: yyerror( "syntax error" );
117: #endif
118: yyerrlab:
119: ++yynerrs;
120: case 1:
121: case 2: /* incompletely recovered error ... try again */
122: yyerrflag = 3;
123: /* find a state where "error" is a legal shift action */
124: while ( yyps >= yys ) {
125: yyn = yypact[*yyps] + YYERRCODE;
126: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
127: yystate = yyact[yyn]; /* simulate a shift of "error" */
128: goto yystack;
129: }
130: yyn = yypact[*yyps];
131: /* the current yyps has no shift onn "error", pop stack */
132: #ifdef YYDEBUG
133: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
134: #endif
135: --yyps;
136: --yypv;
137: }
138: /* there is no state on the stack with an error shift ... abort */
139: yyabort:
140: return(1);
141: case 3: /* no shift yet; clobber input char */
142: #ifdef YYDEBUG
143: if( yydebug ) {
144: printf("error recovery discards ");
145: if(yytoknames[yychar])
146: printf("%s\n", yytoknames[yychar]);
147: else if(yychar >= ' ' && yychar < '\177')
148: printf("`%c'\n", yychar);
149: else if(yychar == 0)
150: printf("EOF\n");
151: else
152: printf("char 0%o\n", yychar);
153: }
154: #endif
155: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
156: yychar = -1;
157: goto yynewstate; /* try again in the same state */
158: }
159: }
160: /* reduction by production yyn */
161: #ifdef YYDEBUG
162: if(yydebug) { char *s;
163: printf("reduce %d in:\n\t", yyn);
164: for(s = yystates[yystate]; *s; s++) {
165: putchar(*s);
166: if(*s == '\n' && *(s+1))
167: putchar('\t');
168: }
169: }
170: #endif
171: yyps -= yyr2[yyn];
172: yypvt = yypv;
173: yypv -= yyr2[yyn];
174: yyval = yypv[1];
175: yym=yyn;
176: /* consult goto table to find next state */
177: yyn = yyr1[yyn];
178: yyj = yypgo[yyn] + *yyps + 1;
179: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
180: switch(yym){
181: $A
182: }
183: goto yystack; /* stack new state and value */
184: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.