![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cexp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 1.x] / gcc|
Return to cexp.c CVS log | Up to [GCC 1.x] / gcc |
1.1 root 1:
2: /* A Bison parser, made from cexp.y */
3:
4: #define INT 258
5: #define CHAR 259
6: #define NAME 260
7: #define ERROR 261
8: #define OR 262
9: #define AND 263
10: #define EQUAL 264
11: #define NOTEQUAL 265
12: #define LEQ 266
13: #define GEQ 267
14: #define LSH 268
15: #define RSH 269
16: #define UNARY 270
17:
18: #line 109 "cexp.y"
19:
20: #include <setjmp.h>
21: /* #define YYDEBUG 1 */
22:
23: static int yylex ();
24: static yyerror ();
25: int expression_value;
26:
27: static jmp_buf parse_return_error;
28:
29: /* some external tables of character types */
30: extern unsigned char is_idstart[], is_idchar[];
31:
32:
33: #line 124 "cexp.y"
34: typedef union {
35: long lval;
36: int voidval;
37: char *sval;
38: } YYSTYPE;
39:
40: #ifndef YYLTYPE
41: typedef
42: struct yyltype
43: {
44: int timestamp;
45: int first_line;
46: int first_column;
47: int last_line;
48: int last_column;
49: char *text;
50: }
51: yyltype;
52:
53: #define YYLTYPE yyltype
54: #endif
55:
56: #define YYACCEPT return(0)
57: #define YYABORT return(1)
58: #define YYERROR return(1)
59: #include <stdio.h>
60:
61:
62:
63: #define YYFINAL 59
64: #define YYFLAG -32768
65: #define YYNTBASE 33
66:
67: #define YYTRANSLATE(x) (yytranslate[x])
68:
69: static char yytranslate[] = { 0,
70: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
72: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
73: 2, 2, 29, 2, 2, 2, 27, 14, 2, 31,
74: 32, 25, 23, 9, 24, 2, 26, 2, 2, 2,
75: 2, 2, 2, 2, 2, 2, 2, 8, 2, 17,
76: 2, 18, 7, 2, 2, 2, 2, 2, 2, 2,
77: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
78: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
79: 2, 2, 2, 13, 2, 2, 2, 2, 2, 2,
80: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
81: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
82: 2, 2, 2, 12, 2, 30, 2, 2, 2, 2,
83: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
90: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
91: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
92: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95: 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
96: 6, 10, 11, 15, 16, 19, 20, 21, 22, 28
97: };
98:
99: static short yyrline[] = { 0,
100: 153, 158, 159, 164, 166, 168, 170, 175, 177, 179,
101: 181, 183, 185, 187, 189, 191, 193, 195, 197, 199,
102: 201, 203, 205, 207, 209, 211, 213, 215, 217
103: };
104:
105: static char * yytname[] = { 0,
106: "error","$illegal.","INT","CHAR","NAME","ERROR","'?'","':'","','","OR",
107: "AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'","'>'","LEQ","GEQ",
108: "LSH","RSH","'+'","'-'","'*'","'/'","'%'","UNARY","'!'","'~'",
109: "'('","')'","start"
110: };
111:
112: static short yyr1[] = { 0,
113: 33, 34, 34, 35, 35, 35, 35, 35, 35, 35,
114: 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
115: 35, 35, 35, 35, 35, 35, 35, 35, 35
116: };
117:
118: static short yyr2[] = { 0,
119: 1, 1, 3, 2, 2, 2, 3, 3, 3, 3,
120: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121: 3, 3, 3, 3, 3, 5, 1, 1, 1
122: };
123:
124: static short yydefact[] = { 0,
125: 27, 28, 29, 0, 0, 0, 0, 1, 2, 4,
126: 5, 6, 0, 0, 0, 0, 0, 0, 0, 0,
127: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
128: 0, 0, 0, 7, 3, 0, 25, 24, 23, 22,
129: 21, 15, 16, 19, 20, 17, 18, 13, 14, 11,
130: 12, 8, 9, 10, 0, 26, 0, 0, 0
131: };
132:
133: static short yydefgoto[] = { 57,
134: 8, 9
135: };
136:
137: static short yypact[] = { 28,
138: -32768,-32768,-32768, 28, 28, 28, 28, -3, 74,-32768,
139: -32768,-32768, -2, 28, 28, 28, 28, 28, 28, 28,
140: 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
141: 28, 28, 28,-32768, 74, 53, 23, 90, 105, 119,
142: 132, 143, 143, 150, 150, 150, 150, 155, 155, -22,
143: -22,-32768,-32768,-32768, 28, 74, 8, 9,-32768
144: };
145:
146: static short yypgoto[] = {-32768,
147: 46, -4
148: };
149:
150:
151: #define YYLAST 182
152:
153:
154: static short yytable[] = { 10,
155: 11, 12, 31, 32, 33, 14, 14, 58, 59, 35,
156: 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
157: 46, 47, 48, 49, 50, 51, 52, 53, 54, 34,
158: 1, 2, 3, 17, 18, 19, 20, 21, 22, 23,
159: 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
160: 56, 4, 13, 0, 0, 0, 5, 6, 7, 15,
161: 55, 0, 16, 17, 18, 19, 20, 21, 22, 23,
162: 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
163: 15, 0, 0, 16, 17, 18, 19, 20, 21, 22,
164: 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
165: 33, 18, 19, 20, 21, 22, 23, 24, 25, 26,
166: 27, 28, 29, 30, 31, 32, 33, 19, 20, 21,
167: 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
168: 32, 33, 20, 21, 22, 23, 24, 25, 26, 27,
169: 28, 29, 30, 31, 32, 33, 21, 22, 23, 24,
170: 25, 26, 27, 28, 29, 30, 31, 32, 33, 23,
171: 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
172: 27, 28, 29, 30, 31, 32, 33, 29, 30, 31,
173: 32, 33
174: };
175:
176: static short yycheck[] = { 4,
177: 5, 6, 25, 26, 27, 9, 9, 0, 0, 14,
178: 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
179: 25, 26, 27, 28, 29, 30, 31, 32, 33, 32,
180: 3, 4, 5, 11, 12, 13, 14, 15, 16, 17,
181: 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
182: 55, 24, 7, -1, -1, -1, 29, 30, 31, 7,
183: 8, -1, 10, 11, 12, 13, 14, 15, 16, 17,
184: 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
185: 7, -1, -1, 10, 11, 12, 13, 14, 15, 16,
186: 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
187: 27, 12, 13, 14, 15, 16, 17, 18, 19, 20,
188: 21, 22, 23, 24, 25, 26, 27, 13, 14, 15,
189: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
190: 26, 27, 14, 15, 16, 17, 18, 19, 20, 21,
191: 22, 23, 24, 25, 26, 27, 15, 16, 17, 18,
192: 19, 20, 21, 22, 23, 24, 25, 26, 27, 17,
193: 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
194: 21, 22, 23, 24, 25, 26, 27, 23, 24, 25,
195: 26, 27
196: };
197: #define YYPURE 1
198:
199: #line 2 "bison.simple"
200:
201: /* Skeleton output parser for bison,
202: copyright (C) 1984 Bob Corbett and Richard Stallman
203:
204: Permission is granted to anyone to make or distribute verbatim copies of this program
205: provided that the copyright notice and this permission notice are preserved;
206: and provided that the recipient is not asked to waive or limit his right to
207: redistribute copies as permitted by this permission notice;
208: and provided that anyone possessing an executable copy
209: is granted access to copy the source code, in machine-readable form,
210: in some reasonable manner.
211:
212: Permission is granted to distribute derived works or enhanced versions of
213: this program under the above conditions with the additional condition
214: that the entire derivative or enhanced work
215: must be covered by a permission notice identical to this one.
216:
217: Anything distributed as part of a package containing portions derived
218: from this program, which cannot in current practice perform its function usefully
219: in the absense of what was derived directly from this program,
220: is to be considered as forming, together with the latter,
221: a single work derived from this program,
222: which must be entirely covered by a permission notice identical to this one
223: in order for distribution of the package to be permitted.
224:
225: In other words, you are welcome to use, share and improve this program.
226: You are forbidden to forbid anyone else to use, share and improve
227: what you give them. Help stamp out software-hoarding! */
228:
229: /* This is the parser code that is written into each bison parser
230: when the %semantic_parser declaration is not specified in the grammar.
231: It was written by Richard Stallman by simplifying the hairy parser
232: used when %semantic_parser is specified. */
233:
234: /* Note: there must be only one dollar sign in this file.
235: It is replaced by the list of actions, each action
236: as one case of the switch. */
237:
238: #define yyerrok (yyerrstatus = 0)
239: #define yyclearin (yychar = YYEMPTY)
240: #define YYEMPTY -2
241: #define YYEOF 0
242: #define YYFAIL goto yyerrlab;
243:
244: #define YYTERROR 1
245:
246: #ifndef YYIMPURE
247: #define YYLEX yylex()
248: #endif
249:
250: #ifndef YYPURE
251: #define YYLEX yylex(&yylval, &yylloc)
252: #endif
253:
254: /* If nonreentrant, generate the variables here */
255:
256: #ifndef YYIMPURE
257:
258: int yychar; /* the lookahead symbol */
259: YYSTYPE yylval; /* the semantic value of the */
260: /* lookahead symbol */
261:
262: YYLTYPE yylloc; /* location data for the lookahead */
263: /* symbol */
264:
265: int yydebug = 0; /* nonzero means print parse trace */
266:
267: #endif /* YYIMPURE */
268:
269:
270: /* YYMAXDEPTH indicates the initial size of the parser's stacks */
271:
272: #ifndef YYMAXDEPTH
273: #define YYMAXDEPTH 200
274: #endif
275:
276: /* YYMAXLIMIT is the maximum size the stacks can grow to
277: (effective only if the built-in stack extension method is used). */
278:
279: #ifndef YYMAXLIMIT
280: #define YYMAXLIMIT 10000
281: #endif
282:
283:
284: #line 87 "bison.simple"
285: int
286: yyparse()
287: {
288: register int yystate;
289: register int yyn;
290: register short *yyssp;
291: register YYSTYPE *yyvsp;
292: YYLTYPE *yylsp;
293: int yyerrstatus; /* number of tokens to shift before error messages enabled */
294: int yychar1; /* lookahead token as an internal (translated) token number */
295:
296: short yyssa[YYMAXDEPTH]; /* the state stack */
297: YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */
298: YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */
299:
300: short *yyss = yyssa; /* refer to the stacks thru separate pointers */
301: YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
302: YYLTYPE *yyls = yylsa;
303:
304: int yymaxdepth = YYMAXDEPTH;
305:
306: #ifndef YYPURE
307:
308: int yychar;
309: YYSTYPE yylval;
310: YYLTYPE yylloc;
311:
312: extern int yydebug;
313:
314: #endif
315:
316:
317: YYSTYPE yyval; /* the variable used to return */
318: /* semantic values from the action */
319: /* routines */
320:
321: int yylen;
322:
323: if (yydebug)
324: fprintf(stderr, "Starting parse\n");
325:
326: yystate = 0;
327: yyerrstatus = 0;
328: yychar = YYEMPTY; /* Cause a token to be read. */
329:
330: /* Initialize stack pointers.
331: Waste one element of value and location stack
332: so that they stay on the same level as the state stack. */
333:
334: yyssp = yyss - 1;
335: yyvsp = yyvs;
336: yylsp = yyls;
337:
338: /* Push a new state, which is found in yystate . */
339: /* In all cases, when you get here, the value and location stacks
340: have just been pushed. so pushing a state here evens the stacks. */
341: yynewstate:
342:
343: *++yyssp = yystate;
344:
345: if (yyssp >= yyss + yymaxdepth - 1)
346: {
347: /* Give user a chance to reallocate the stack */
348: /* Use copies of these so that the &'s don't force the real ones into memory. */
349: YYSTYPE *yyvs1 = yyvs;
350: YYLTYPE *yyls1 = yyls;
351: short *yyss1 = yyss;
352:
353: /* Get the current used size of the three stacks, in elements. */
354: int size = yyssp - yyss + 1;
355:
356: #ifdef yyoverflow
357: /* Each stack pointer address is followed by the size of
358: the data in use in that stack, in bytes. */
359: yyoverflow("parser stack overflow",
360: &yyss1, size * sizeof (*yyssp),
361: &yyvs1, size * sizeof (*yyvsp),
362: &yyls1, size * sizeof (*yylsp),
363: &yymaxdepth);
364:
365: yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
366: #else /* no yyoverflow */
367: /* Extend the stack our own way. */
368: if (yymaxdepth >= YYMAXLIMIT)
369: yyerror("parser stack overflow");
370: yymaxdepth *= 2;
371: if (yymaxdepth > YYMAXLIMIT)
372: yymaxdepth = YYMAXLIMIT;
373: yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
374: bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
375: yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
376: bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
377: yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
378: bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
379: #endif /* no yyoverflow */
380:
381: yyssp = yyss + size - 1;
382: yylsp = yyls + size - 1;
383: yyvsp = yyvs + size - 1;
384:
385: if (yydebug)
386: fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
387:
388: if (yyssp >= yyss + yymaxdepth - 1)
389: YYERROR;
390: }
391:
392: if (yydebug)
393: fprintf(stderr, "Entering state %d\n", yystate);
394:
395: /* Do appropriate processing given the current state. */
396: /* Read a lookahead token if we need one and don't already have one. */
397: yyresume:
398:
399: /* First try to decide what to do without reference to lookahead token. */
400:
401: yyn = yypact[yystate];
402: if (yyn == YYFLAG)
403: goto yydefault;
404:
405: /* Not known => get a lookahead token if don't already have one. */
406:
407: /* yychar is either YYEMPTY or YYEOF
408: or a valid token in external form. */
409:
410: if (yychar == YYEMPTY)
411: {
412: yychar = YYLEX;
413: }
414:
415: /* Convert token to internal form (in yychar1) for indexing tables with */
416:
417: if (yychar <= 0) /* This means end of input. */
418: {
419: yychar1 = 0;
420: yychar = YYEOF; /* Don't call YYLEX any more */
421:
422: if (yydebug)
423: fprintf(stderr, "Now at end of input.\n");
424: }
425: else
426: {
427: yychar1 = YYTRANSLATE(yychar);
428:
429: if (yydebug)
430: fprintf(stderr, "Parsing next token; it is %d (%s)\n", yychar, yytname[yychar1]);
431: }
432:
433: yyn += yychar1;
434: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
435: goto yydefault;
436:
437: yyn = yytable[yyn];
438:
439: /* yyn is what to do for this token type in this state.
440: Negative => reduce, -yyn is rule number.
441: Positive => shift, yyn is new state.
442: New state is final state => don't bother to shift,
443: just return success.
444: 0, or most negative number => error. */
445:
446: if (yyn < 0)
447: {
448: if (yyn == YYFLAG)
449: goto yyerrlab;
450: yyn = -yyn;
451: goto yyreduce;
452: }
453: else if (yyn == 0)
454: goto yyerrlab;
455:
456: if (yyn == YYFINAL)
457: YYACCEPT;
458:
459: /* Shift the lookahead token. */
460:
461: if (yydebug)
462: fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
463:
464: /* Discard the token being shifted unless it is eof. */
465: if (yychar != YYEOF)
466: yychar = YYEMPTY;
467:
468: *++yyvsp = yylval;
469: *++yylsp = yylloc;
470:
471: /* count tokens shifted since error; after three, turn off error status. */
472: if (yyerrstatus) yyerrstatus--;
473:
474: yystate = yyn;
475: goto yynewstate;
476:
477: /* Do the default action for the current state. */
478: yydefault:
479:
480: yyn = yydefact[yystate];
481: if (yyn == 0)
482: goto yyerrlab;
483:
484: /* Do a reduction. yyn is the number of a rule to reduce with. */
485: yyreduce:
486: yylen = yyr2[yyn];
487: yyval = yyvsp[1-yylen]; /* implement default value of the action */
488:
489: if (yydebug)
490: {
491: if (yylen == 1)
492: fprintf (stderr, "Reducing 1 value via line %d, ",
493: yyrline[yyn]);
494: else
495: fprintf (stderr, "Reducing %d values via line %d, ",
496: yylen, yyrline[yyn]);
497: }
498:
499:
500: switch (yyn) {
501:
502: case 1:
503: #line 154 "cexp.y"
504: { expression_value = yyvsp[0].lval; ;
505: break;}
506: case 3:
507: #line 160 "cexp.y"
508: { yyval.lval = yyvsp[0].lval; ;
509: break;}
510: case 4:
511: #line 165 "cexp.y"
512: { yyval.lval = - yyvsp[0].lval; ;
513: break;}
514: case 5:
515: #line 167 "cexp.y"
516: { yyval.lval = ! yyvsp[0].lval; ;
517: break;}
518: case 6:
519: #line 169 "cexp.y"
520: { yyval.lval = ~ yyvsp[0].lval; ;
521: break;}
522: case 7:
523: #line 171 "cexp.y"
524: { yyval.lval = yyvsp[-1].lval; ;
525: break;}
526: case 8:
527: #line 176 "cexp.y"
528: { yyval.lval = yyvsp[-2].lval * yyvsp[0].lval; ;
529: break;}
530: case 9:
531: #line 178 "cexp.y"
532: { yyval.lval = yyvsp[-2].lval / yyvsp[0].lval; ;
533: break;}
534: case 10:
535: #line 180 "cexp.y"
536: { yyval.lval = yyvsp[-2].lval % yyvsp[0].lval; ;
537: break;}
538: case 11:
539: #line 182 "cexp.y"
540: { yyval.lval = yyvsp[-2].lval + yyvsp[0].lval; ;
541: break;}
542: case 12:
543: #line 184 "cexp.y"
544: { yyval.lval = yyvsp[-2].lval - yyvsp[0].lval; ;
545: break;}
546: case 13:
547: #line 186 "cexp.y"
548: { yyval.lval = yyvsp[-2].lval << yyvsp[0].lval; ;
549: break;}
550: case 14:
551: #line 188 "cexp.y"
552: { yyval.lval = yyvsp[-2].lval >> yyvsp[0].lval; ;
553: break;}
554: case 15:
555: #line 190 "cexp.y"
556: { yyval.lval = (yyvsp[-2].lval == yyvsp[0].lval); ;
557: break;}
558: case 16:
559: #line 192 "cexp.y"
560: { yyval.lval = (yyvsp[-2].lval != yyvsp[0].lval); ;
561: break;}
562: case 17:
563: #line 194 "cexp.y"
564: { yyval.lval = (yyvsp[-2].lval <= yyvsp[0].lval); ;
565: break;}
566: case 18:
567: #line 196 "cexp.y"
568: { yyval.lval = (yyvsp[-2].lval >= yyvsp[0].lval); ;
569: break;}
570: case 19:
571: #line 198 "cexp.y"
572: { yyval.lval = (yyvsp[-2].lval < yyvsp[0].lval); ;
573: break;}
574: case 20:
575: #line 200 "cexp.y"
576: { yyval.lval = (yyvsp[-2].lval > yyvsp[0].lval); ;
577: break;}
578: case 21:
579: #line 202 "cexp.y"
580: { yyval.lval = (yyvsp[-2].lval & yyvsp[0].lval); ;
581: break;}
582: case 22:
583: #line 204 "cexp.y"
584: { yyval.lval = (yyvsp[-2].lval ^ yyvsp[0].lval); ;
585: break;}
586: case 23:
587: #line 206 "cexp.y"
588: { yyval.lval = (yyvsp[-2].lval | yyvsp[0].lval); ;
589: break;}
590: case 24:
591: #line 208 "cexp.y"
592: { yyval.lval = (yyvsp[-2].lval && yyvsp[0].lval); ;
593: break;}
594: case 25:
595: #line 210 "cexp.y"
596: { yyval.lval = (yyvsp[-2].lval || yyvsp[0].lval); ;
597: break;}
598: case 26:
599: #line 212 "cexp.y"
600: { yyval.lval = yyvsp[-4].lval ? yyvsp[-2].lval : yyvsp[0].lval; ;
601: break;}
602: case 27:
603: #line 214 "cexp.y"
604: { yyval.lval = yylval.lval; ;
605: break;}
606: case 28:
607: #line 216 "cexp.y"
608: { yyval.lval = yylval.lval; ;
609: break;}
610: case 29:
611: #line 218 "cexp.y"
612: { yyval.lval = 0; ;
613: break;}
614: }
615: /* the action file gets copied in in place of this dollarsign */
616: #line 303 "bison.simple"
617:
618: yyvsp -= yylen;
619: yylsp -= yylen;
620: yyssp -= yylen;
621:
622: if (yydebug)
623: {
624: short *ssp1 = yyss - 1;
625: fprintf (stderr, "state stack now", yyssp-yyss);
626: while (ssp1 != yyssp)
627: fprintf (stderr, " %d", *++ssp1);
628: fprintf (stderr, "\n");
629: }
630:
631: *++yyvsp = yyval;
632:
633: yylsp++;
634: if (yylen == 0)
635: {
636: yylsp->first_line = yylloc.first_line;
637: yylsp->first_column = yylloc.first_column;
638: yylsp->last_line = (yylsp-1)->last_line;
639: yylsp->last_column = (yylsp-1)->last_column;
640: yylsp->text = 0;
641: }
642: else
643: {
644: yylsp->last_line = (yylsp+yylen-1)->last_line;
645: yylsp->last_column = (yylsp+yylen-1)->last_column;
646: }
647:
648: /* Now "shift" the result of the reduction.
649: Determine what state that goes to,
650: based on the state we popped back to
651: and the rule number reduced by. */
652:
653: yyn = yyr1[yyn];
654:
655: yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
656: if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
657: yystate = yytable[yystate];
658: else
659: yystate = yydefgoto[yyn - YYNTBASE];
660:
661: goto yynewstate;
662:
663: yyerrlab: /* here on detecting error */
664:
665: if (! yyerrstatus)
666: /* If not already recovering from an error, report this error. */
667: {
668: yyerror("parse error");
669: }
670:
671: if (yyerrstatus == 3)
672: {
673: /* if just tried and failed to reuse lookahead token after an error, discard it. */
674:
675: /* return failure if at end of input */
676: if (yychar == YYEOF)
677: YYERROR;
678:
679: if (yydebug)
680: fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
681:
682: yychar = YYEMPTY;
683: }
684:
685: /* Else will try to reuse lookahead token
686: after shifting the error token. */
687:
688: yyerrstatus = 3; /* Each real token shifted decrements this */
689:
690: goto yyerrhandle;
691:
692: yyerrdefault: /* current state does not do anything special for the error token. */
693:
694: #if 0
695: /* This is wrong; only states that explicitly want error tokens
696: should shift them. */
697: yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
698: if (yyn) goto yydefault;
699: #endif
700:
701: yyerrpop: /* pop the current state because it cannot handle the error token */
702:
703: if (yyssp == yyss) YYERROR;
704: yyvsp--;
705: yylsp--;
706: yystate = *--yyssp;
707:
708: if (yydebug)
709: {
710: short *ssp1 = yyss - 1;
711: fprintf (stderr, "Error: state stack now", yyssp-yyss);
712: while (ssp1 != yyssp)
713: fprintf (stderr, " %d", *++ssp1);
714: fprintf (stderr, "\n");
715: }
716:
717: yyerrhandle:
718:
719: yyn = yypact[yystate];
720: if (yyn == YYFLAG)
721: goto yyerrdefault;
722:
723: yyn += YYTERROR;
724: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
725: goto yyerrdefault;
726:
727: yyn = yytable[yyn];
728: if (yyn < 0)
729: {
730: if (yyn == YYFLAG)
731: goto yyerrpop;
732: yyn = -yyn;
733: goto yyreduce;
734: }
735: else if (yyn == 0)
736: goto yyerrpop;
737:
738: if (yyn == YYFINAL)
739: YYACCEPT;
740:
741: if (yydebug)
742: fprintf(stderr, "Shifting error token, ");
743:
744: *++yyvsp = yylval;
745: *++yylsp = yylloc;
746:
747: yystate = yyn;
748: goto yynewstate;
749: }
750: #line 220 "cexp.y"
751:
752:
753: /* During parsing of a C expression, the pointer to the next character
754: is in this variable. */
755:
756: static char *lexptr;
757:
758: /* Take care of parsing a number (anything that starts with a digit).
759: Set yylval and return the token type; update lexptr.
760: LEN is the number of characters in it. */
761:
762: /* maybe needs to actually deal with floating point numbers */
763:
764: static int
765: parse_number (olen)
766: int olen;
767: {
768: register char *p = lexptr;
769: register long n = 0;
770: register int c;
771: register int base = 10;
772: register len = olen;
773: char *err_copy;
774:
775: extern double atof ();
776:
777: for (c = 0; c < len; c++)
778: if (p[c] == '.') {
779: /* It's a float since it contains a point. */
780: yyerror ("floating point numbers not allowed in #if expressions");
781: return ERROR;
782:
783: /* ****************
784: yylval.dval = atof (p);
785: lexptr += len;
786: return FLOAT;
787: **************** */
788: }
789:
790: if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
791: p += 2;
792: base = 16;
793: len -= 2;
794: }
795: else if (*p == '0')
796: base = 8;
797:
798: while (len-- > 0) {
799: c = *p++;
800: n *= base;
801: if (c >= '0' && c <= '9')
802: n += c - '0';
803: else {
804: if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
805: if (base == 16 && c >= 'a' && c <= 'f')
806: n += c - 'a' + 10;
807: else if (len == 0 && c == 'l')
808: ;
809: else {
810: yyerror ("Invalid number in #if expression");
811: return ERROR;
812: }
813: }
814: }
815:
816: lexptr = p;
817: yylval.lval = n;
818: return INT;
819: }
820:
821: struct token {
822: char *operator;
823: int token;
824: };
825:
826: #define NULL 0
827:
828: static struct token tokentab2[] = {
829: {"&&", AND},
830: {"||", OR},
831: {"<<", LSH},
832: {">>", RSH},
833: {"==", EQUAL},
834: {"!=", NOTEQUAL},
835: {"<=", LEQ},
836: {">=", GEQ},
837: {NULL, ERROR}
838: };
839:
840: /* Read one token, getting characters through lexptr. */
841:
842: static int
843: yylex ()
844: {
845: register int c;
846: register int namelen;
847: register char *tokstart;
848: register struct token *toktab;
849:
850: retry:
851:
852: tokstart = lexptr;
853: c = *tokstart;
854: /* See if it is a special token of length 2. */
855: for (toktab = tokentab2; toktab->operator != NULL; toktab++)
856: if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
857: lexptr += 2;
858: return toktab->token;
859: }
860:
861: switch (c) {
862: case 0:
863: return 0;
864:
865: case ' ':
866: case '\t':
867: case '\n':
868: lexptr++;
869: goto retry;
870:
871: case '\'':
872: lexptr++;
873: c = *lexptr++;
874: if (c == '\\')
875: c = parse_escape (&lexptr);
876: yylval.lval = c;
877: c = *lexptr++;
878: if (c != '\'') {
879: yyerror ("Invalid character constant in #if");
880: return ERROR;
881: }
882:
883: return CHAR;
884:
885: /* some of these chars are invalid in constant expressions;
886: maybe do something about them later */
887: case '/':
888: case '+':
889: case '-':
890: case '*':
891: case '%':
892: case '|':
893: case '&':
894: case '^':
895: case '~':
896: case '!':
897: case '@':
898: case '<':
899: case '>':
900: case '(':
901: case ')':
902: case '[':
903: case ']':
904: case '.':
905: case '?':
906: case ':':
907: case '=':
908: case '{':
909: case '}':
910: case ',':
911: lexptr++;
912: return c;
913:
914: case '"':
915: yyerror ("double quoted strings not allowed in #if expressions");
916: return ERROR;
917: }
918: if (c >= '0' && c <= '9') {
919: /* It's a number */
920: for (namelen = 0;
921: c = tokstart[namelen], is_idchar[c] || c == '.';
922: namelen++)
923: ;
924: return parse_number (namelen);
925: }
926:
927: if (!is_idstart[c]) {
928: yyerror ("Invalid token in expression");
929: return ERROR;
930: }
931:
932: /* It is a name. See how long it is. */
933:
934: for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
935: ;
936:
937: lexptr += namelen;
938: return NAME;
939: }
940:
941:
942: /* Parse a C escape sequence. STRING_PTR points to a variable
943: containing a pointer to the string to parse. That pointer
944: is updated past the characters we use. The value of the
945: escape sequence is returned.
946:
947: A negative value means the sequence \ newline was seen,
948: which is supposed to be equivalent to nothing at all.
949:
950: If \ is followed by a null character, we return a negative
951: value and leave the string pointer pointing at the null character.
952:
953: If \ is followed by 000, we return 0 and leave the string pointer
954: after the zeros. A value of 0 does not mean end of string. */
955:
956: static int
957: parse_escape (string_ptr)
958: char **string_ptr;
959: {
960: register int c = *(*string_ptr)++;
961: switch (c)
962: {
963: case 'a':
964: return '\a';
965: case 'b':
966: return '\b';
967: case 'e':
968: return 033;
969: case 'f':
970: return '\f';
971: case 'n':
972: return '\n';
973: case 'r':
974: return '\r';
975: case 't':
976: return '\t';
977: case 'v':
978: return '\v';
979: case '\n':
980: return -2;
981: case 0:
982: (*string_ptr)--;
983: return 0;
984: case '^':
985: c = *(*string_ptr)++;
986: if (c == '\\')
987: c = parse_escape (string_ptr);
988: if (c == '?')
989: return 0177;
990: return (c & 0200) | (c & 037);
991:
992: case '0':
993: case '1':
994: case '2':
995: case '3':
996: case '4':
997: case '5':
998: case '6':
999: case '7':
1000: {
1001: register int i = c - '0';
1002: register int count = 0;
1003: while (++count < 3)
1004: {
1005: if ((c = *(*string_ptr)++) >= '0' && c <= '7')
1006: {
1007: i *= 8;
1008: i += c - '0';
1009: }
1010: else
1011: {
1012: (*string_ptr)--;
1013: break;
1014: }
1015: }
1016: return i;
1017: }
1018: default:
1019: return c;
1020: }
1021: }
1022:
1023: static
1024: yyerror (s)
1025: char *s;
1026: {
1027: error (s);
1028: longjmp (parse_return_error, 1);
1029: }
1030:
1031: /* This page contains the entry point to this file. */
1032:
1033: /* Parse STRING as an expression, and complain if this fails
1034: to use up all of the contents of STRING. */
1035: /* We do not support C comments. They should be removed before
1036: this function is called. */
1037:
1038: int
1039: parse_c_expression (string)
1040: char *string;
1041: {
1042: lexptr = string;
1043:
1044: if (lexptr == 0 || *lexptr == 0) {
1045: error ("empty #if expression");
1046: return 0; /* don't include the #if group */
1047: }
1048:
1049: /* if there is some sort of scanning error, just return 0 and assume
1050: the parsing routine has printed an error message somewhere.
1051: there is surely a better thing to do than this. */
1052: if (setjmp(parse_return_error))
1053: return 0;
1054:
1055: if (yyparse ())
1056: return 0; /* actually this is never reached
1057: the way things stand. */
1058: if (*lexptr)
1059: error ("Junk after end of expression.");
1060:
1061: return expression_value; /* set by yyparse() */
1062: }
1063:
1064: #ifdef TEST_EXP_READER
1065: /* main program, for testing purposes. */
1066: main()
1067: {
1068: int n;
1069: char buf[1024];
1070: extern int yydebug;
1071: /*
1072: yydebug = 1;
1073: */
1074: initialize_random_junk ();
1075:
1076: for (;;) {
1077: printf("enter expression: ");
1078: n = 0;
1079: while ((buf[n] = getchar()) != '\n')
1080: n++;
1081: buf[n] = '\0';
1082: printf("parser returned %d\n", parse_c_expression(buf));
1083: }
1084: }
1085:
1086: /* table to tell if char can be part of a C identifier. */
1087: char is_idchar[256];
1088: /* table to tell if char can be first char of a c identifier. */
1089: char is_idstart[256];
1090: /* table to tell if c is horizontal space. isspace() thinks that
1091: newline is space; this is not a good idea for this program. */
1092: char is_hor_space[256];
1093:
1094: /*
1095: * initialize random junk in the hash table and maybe other places
1096: */
1097: initialize_random_junk()
1098: {
1099: register int i;
1100:
1101: /*
1102: * Set up is_idchar and is_idstart tables. These should be
1103: * faster than saying (is_alpha(c) || c == '_'), etc.
1104: * Must do set up these things before calling any routines tthat
1105: * refer to them.
1106: */
1107: for (i = 'a'; i <= 'z'; i++) {
1108: ++is_idchar[i - 'a' + 'A'];
1109: ++is_idchar[i];
1110: ++is_idstart[i - 'a' + 'A'];
1111: ++is_idstart[i];
1112: }
1113: for (i = '0'; i <= '9'; i++)
1114: ++is_idchar[i];
1115: ++is_idchar['_'];
1116: ++is_idstart['_'];
1117: #ifdef DOLLARS_IN_IDENTIFIERS
1118: ++is_idchar['$'];
1119: ++is_idstart['$'];
1120: #endif
1121:
1122: /* horizontal space table */
1123: ++is_hor_space[' '];
1124: ++is_hor_space['\t'];
1125: }
1126:
1127: error (msg)
1128: {
1129: printf("error: %s\n", msg);
1130: }
1131: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.