Mercurial > vba-clojure

comparison src/sdl/expr.cpp @ 1:f9f4f1b99eed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
importing src directory
author Robert McIntyre <rlm@mit.edu>
date Sat, 03 Mar 2012 10:31:27 -0600
parents
children
comparison
equal deleted inserted replaced
0:8ced16adf2e1 1:f9f4f1b99eed
1
2 /* A Bison parser, made from expr.y
3 by GNU Bison version 1.28 */
4
5 #define YYBISON 1 /* Identify Bison output. */
6
7 #define TOKEN_IDENTIFIER 257
8 #define TOKEN_DOT 258
9 #define TOKEN_STAR 259
10 #define TOKEN_ARROW 260
11 #define TOKEN_ADDR 261
12 #define TOKEN_SIZEOF 262
13 #define TOKEN_NUMBER 263
14
15 #line 1 "expr.y"
16
17 namespace std {
18 #include <stdio.h>
19 #include <memory.h>
20 #include <stdlib.h>
21 #include <string.h>
22 }
23
24 using namespace std;
25
26 #include "../common/System.h"
27 #include "../gba/elf.h"
28 #include "exprNode.h"
29
30 extern int yyerror(char *);
31 extern int yylex();
32 extern char *yytext;
33
34
35 //#define YYERROR_VERBOSE 1
36 //#define YYDEBUG 1
37
38 Node *result = NULL;
39 #ifndef YYSTYPE
40 #define YYSTYPE int
41 #endif
42 #include <stdio.h>
43
44 #ifndef __cplusplus
45 #ifndef __STDC__
46 #define const
47 #endif
48 #endif
49
50
51
52 #define YYFINAL 26
53 #define YYFLAG -32768
54 #define YYNTBASE 14
55
56 #define YYTRANSLATE(x) ((unsigned)(x) <= 263 ? yytranslate[x] : 19)
57
58 static const char yytranslate[] = { 0,
59 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
60 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
61 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
62 2, 2, 2, 2, 2, 2, 2, 2, 2, 11,
63 12, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68 10, 2, 13, 2, 2, 2, 2, 2, 2, 2,
69 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
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, 2, 2, 2, 2, 2, 2, 2, 2,
74 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
75 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
76 2, 2, 2, 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, 2, 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, 2, 2, 2, 2, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
85 7, 8, 9
86 };
87
88 #if YYDEBUG != 0
89 static const short yyprhs[] = { 0,
90 0, 2, 4, 8, 12, 16, 21, 23, 26, 29,
91 34, 36
92 };
93
94 static const short yyrhs[] = { 15,
95 0, 16, 0, 11, 15, 12, 0, 15, 4, 18,
96 0, 15, 6, 18, 0, 15, 10, 17, 13, 0,
97 18, 0, 5, 15, 0, 7, 15, 0, 8, 11,
98 15, 12, 0, 9, 0, 3, 0
99 };
100
101 #endif
102
103 #if YYDEBUG != 0
104 static const short yyrline[] = { 0,
105 32, 35, 36, 37, 38, 39, 42, 43, 44, 45,
106 49, 53
107 };
108 #endif
109
110
111 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
112
113 static const char * const yytname[] = { "$","error","$undefined.","TOKEN_IDENTIFIER",
114 "TOKEN_DOT","TOKEN_STAR","TOKEN_ARROW","TOKEN_ADDR","TOKEN_SIZEOF","TOKEN_NUMBER",
115 "'['","'('","')'","']'","final","expression","simple_expression","number","ident", NULL
116 };
117 #endif
118
119 static const short yyr1[] = { 0,
120 14, 15, 15, 15, 15, 15, 16, 16, 16, 16,
121 17, 18
122 };
123
124 static const short yyr2[] = { 0,
125 1, 1, 3, 3, 3, 4, 1, 2, 2, 4,
126 1, 1
127 };
128
129 static const short yydefact[] = { 0,
130 12, 0, 0, 0, 0, 1, 2, 7, 8, 9,
131 0, 0, 0, 0, 0, 0, 3, 4, 5, 11,
132 0, 10, 6, 0, 0, 0
133 };
134
135 static const short yydefgoto[] = { 24,
136 6, 7, 21, 8
137 };
138
139 static const short yypact[] = { -1,
140 -32768, -1, -1, -6, -1, 17,-32768,-32768, 17, 17,
141 -1, 7, 5, 5, 13, 8,-32768,-32768,-32768,-32768,
142 11,-32768,-32768, 25, 26,-32768
143 };
144
145 static const short yypgoto[] = {-32768,
146 -2,-32768,-32768, 2
147 };
148
149
150 #define YYLAST 27
151
152
153 static const short yytable[] = { 9,
154 10, 1, 12, 2, 11, 3, 4, 1, 16, 5,
155 13, 13, 14, 14, 18, 19, 15, 15, 17, 22,
156 13, 20, 14, 23, 25, 26, 15
157 };
158
159 static const short yycheck[] = { 2,
160 3, 3, 5, 5, 11, 7, 8, 3, 11, 11,
161 4, 4, 6, 6, 13, 14, 10, 10, 12, 12,
162 4, 9, 6, 13, 0, 0, 10
163 };
164 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
165 #line 3 "/usr/lib/bison.simple"
166 /* This file comes from bison-1.28. */
167
168 /* Skeleton output parser for bison,
169 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
170
171 This program is free software; you can redistribute it and/or modify
172 it under the terms of the GNU General Public License as published by
173 the Free Software Foundation; either version 2, or (at your option)
174 any later version.
175
176 This program is distributed in the hope that it will be useful,
177 but WITHOUT ANY WARRANTY; without even the implied warranty of
178 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
179 GNU General Public License for more details.
180
181 You should have received a copy of the GNU General Public License
182 along with this program; if not, write to the Free Software
183 Foundation, Inc., 59 Temple Place - Suite 330,
184 Boston, MA 02111-1307, USA. */
185
186 /* As a special exception, when this file is copied by Bison into a
187 Bison output file, you may use that output file without restriction.
188 This special exception was added by the Free Software Foundation
189 in version 1.24 of Bison. */
190
191 /* This is the parser code that is written into each bison parser
192 when the %semantic_parser declaration is not specified in the grammar.
193 It was written by Richard Stallman by simplifying the hairy parser
194 used when %semantic_parser is specified. */
195
196 #ifndef YYSTACK_USE_ALLOCA
197 #ifdef alloca
198 #define YYSTACK_USE_ALLOCA
199 #else /* alloca not defined */
200 #ifdef __GNUC__
201 #define YYSTACK_USE_ALLOCA
202 #define alloca __builtin_alloca
203 #else /* not GNU C. */
204 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
205 #define YYSTACK_USE_ALLOCA
206 #include <alloca.h>
207 #else /* not sparc */
208 /* We think this test detects Watcom and Microsoft C. */
209 /* This used to test MSDOS, but that is a bad idea
210 since that symbol is in the user namespace. */
211 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
212 #if 0 /* No need for malloc.h, which pollutes the namespace;
213 instead, just don't use alloca. */
214 #include <malloc.h>
215 #endif
216 #else /* not MSDOS, or __TURBOC__ */
217 #if defined(_AIX)
218 /* I don't know what this was needed for, but it pollutes the namespace.
219 So I turned it off. rms, 2 May 1997. */
220 /* #include <malloc.h> */
221 #pragma alloca
222 #define YYSTACK_USE_ALLOCA
223 #else /* not MSDOS, or __TURBOC__, or _AIX */
224 #if 0
225 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
226 and on HPUX 10. Eventually we can turn this on. */
227 #define YYSTACK_USE_ALLOCA
228 #define alloca __builtin_alloca
229 #endif /* __hpux */
230 #endif
231 #endif /* not _AIX */
232 #endif /* not MSDOS, or __TURBOC__ */
233 #endif /* not sparc */
234 #endif /* not GNU C */
235 #endif /* alloca not defined */
236 #endif /* YYSTACK_USE_ALLOCA not defined */
237
238 #ifdef YYSTACK_USE_ALLOCA
239 #define YYSTACK_ALLOC alloca
240 #else
241 #define YYSTACK_ALLOC malloc
242 #endif
243
244 /* Note: there must be only one dollar sign in this file.
245 It is replaced by the list of actions, each action
246 as one case of the switch. */
247
248 #define yyerrok (yyerrstatus = 0)
249 #define yyclearin (yychar = YYEMPTY)
250 #define YYEMPTY -2
251 #define YYEOF 0
252 #define YYACCEPT goto yyacceptlab
253 #define YYABORT goto yyabortlab
254 #define YYERROR goto yyerrlab1
255 /* Like YYERROR except do call yyerror.
256 This remains here temporarily to ease the
257 transition to the new meaning of YYERROR, for GCC.
258 Once GCC version 2 has supplanted version 1, this can go. */
259 #define YYFAIL goto yyerrlab
260 #define YYRECOVERING() (!!yyerrstatus)
261 #define YYBACKUP(token, value) \
262 do \
263 if (yychar == YYEMPTY && yylen == 1) \
264 { yychar = (token), yylval = (value); \
265 yychar1 = YYTRANSLATE (yychar); \
266 YYPOPSTACK; \
267 goto yybackup; \
268 } \
269 else \
270 { yyerror ("syntax error: cannot back up"); YYERROR; } \
271 while (0)
272
273 #define YYTERROR 1
274 #define YYERRCODE 256
275
276 #ifndef YYPURE
277 #define YYLEX yylex()
278 #endif
279
280 #ifdef YYPURE
281 #ifdef YYLSP_NEEDED
282 #ifdef YYLEX_PARAM
283 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
284 #else
285 #define YYLEX yylex(&yylval, &yylloc)
286 #endif
287 #else /* not YYLSP_NEEDED */
288 #ifdef YYLEX_PARAM
289 #define YYLEX yylex(&yylval, YYLEX_PARAM)
290 #else
291 #define YYLEX yylex(&yylval)
292 #endif
293 #endif /* not YYLSP_NEEDED */
294 #endif
295
296 /* If nonreentrant, generate the variables here */
297
298 #ifndef YYPURE
299
300 int yychar; /* the lookahead symbol */
301 YYSTYPE yylval; /* the semantic value of the */
302 /* lookahead symbol */
303
304 #ifdef YYLSP_NEEDED
305 YYLTYPE yylloc; /* location data for the lookahead */
306 /* symbol */
307 #endif
308
309 int yynerrs; /* number of parse errors so far */
310 #endif /* not YYPURE */
311
312 #if YYDEBUG != 0
313 int yydebug; /* nonzero means print parse trace */
314 /* Since this is uninitialized, it does not stop multiple parsers
315 from coexisting. */
316 #endif
317
318 /* YYINITDEPTH indicates the initial size of the parser's stacks */
319
320 #ifndef YYINITDEPTH
321 #define YYINITDEPTH 200
322 #endif
323
324 /* YYMAXDEPTH is the maximum size the stacks can grow to
325 (effective only if the built-in stack extension method is used). */
326
327 #if YYMAXDEPTH == 0
328 #undef YYMAXDEPTH
329 #endif
330
331 #ifndef YYMAXDEPTH
332 #define YYMAXDEPTH 10000
333 #endif
334
335 /* Define __yy_memcpy. Note that the size argument
336 should be passed with type unsigned int, because that is what the non-GCC
337 definitions require. With GCC, __builtin_memcpy takes an arg
338 of type size_t, but it can handle unsigned int. */
339
340 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
341 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
342 #else /* not GNU C or C++ */
343 #ifndef __cplusplus
344
345 /* This is the most reliable way to avoid incompatibilities
346 in available built-in functions on various systems. */
347 static void
348 __yy_memcpy (to, from, count)
349 char *to;
350 char *from;
351 unsigned int count;
352 {
353 register char *f = from;
354 register char *t = to;
355 register int i = count;
356
357 while (i-- > 0)
358 *t++ = *f++;
359 }
360
361 #else /* __cplusplus */
362
363 /* This is the most reliable way to avoid incompatibilities
364 in available built-in functions on various systems. */
365 static void
366 __yy_memcpy (char *to, char *from, unsigned int count)
367 {
368 register char *t = to;
369 register char *f = from;
370 register int i = count;
371
372 while (i-- > 0)
373 *t++ = *f++;
374 }
375
376 #endif
377 #endif
378
379 #line 217 "/usr/lib/bison.simple"
380
381 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
382 into yyparse. The argument should have type void *.
383 It should actually point to an object.
384 Grammar actions can access the variable by casting it
385 to the proper pointer type. */
386
387 #ifdef YYPARSE_PARAM
388 #ifdef __cplusplus
389 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
390 #define YYPARSE_PARAM_DECL
391 #else /* not __cplusplus */
392 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
393 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
394 #endif /* not __cplusplus */
395 #else /* not YYPARSE_PARAM */
396 #define YYPARSE_PARAM_ARG
397 #define YYPARSE_PARAM_DECL
398 #endif /* not YYPARSE_PARAM */
399
400 /* Prevent warning if -Wstrict-prototypes. */
401 #ifdef __GNUC__
402 #ifdef YYPARSE_PARAM
403 int yyparse (void *);
404 #else
405 int yyparse (void);
406 #endif
407 #endif
408
409 int
410 yyparse(YYPARSE_PARAM_ARG)
411 YYPARSE_PARAM_DECL
412 {
413 register int yystate;
414 register int yyn;
415 register short *yyssp;
416 register YYSTYPE *yyvsp;
417 int yyerrstatus; /* number of tokens to shift before error messages enabled */
418 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
419
420 short yyssa[YYINITDEPTH]; /* the state stack */
421 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
422
423 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
424 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
425
426 #ifdef YYLSP_NEEDED
427 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
428 YYLTYPE *yyls = yylsa;
429 YYLTYPE *yylsp;
430
431 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
432 #else
433 #define YYPOPSTACK (yyvsp--, yyssp--)
434 #endif
435
436 int yystacksize = YYINITDEPTH;
437 int yyfree_stacks = 0;
438
439 #ifdef YYPURE
440 int yychar;
441 YYSTYPE yylval;
442 int yynerrs;
443 #ifdef YYLSP_NEEDED
444 YYLTYPE yylloc;
445 #endif
446 #endif
447
448 YYSTYPE yyval; /* the variable used to return */
449 /* semantic values from the action */
450 /* routines */
451
452 int yylen;
453
454 #if YYDEBUG != 0
455 if (yydebug)
456 fprintf(stderr, "Starting parse\n");
457 #endif
458
459 yystate = 0;
460 yyerrstatus = 0;
461 yynerrs = 0;
462 yychar = YYEMPTY; /* Cause a token to be read. */
463
464 /* Initialize stack pointers.
465 Waste one element of value and location stack
466 so that they stay on the same level as the state stack.
467 The wasted elements are never initialized. */
468
469 yyssp = yyss - 1;
470 yyvsp = yyvs;
471 #ifdef YYLSP_NEEDED
472 yylsp = yyls;
473 #endif
474
475 /* Push a new state, which is found in yystate . */
476 /* In all cases, when you get here, the value and location stacks
477 have just been pushed. so pushing a state here evens the stacks. */
478 yynewstate:
479
480 *++yyssp = yystate;
481
482 if (yyssp >= yyss + yystacksize - 1)
483 {
484 /* Give user a chance to reallocate the stack */
485 /* Use copies of these so that the &'s don't force the real ones into memory. */
486 YYSTYPE *yyvs1 = yyvs;
487 short *yyss1 = yyss;
488 #ifdef YYLSP_NEEDED
489 YYLTYPE *yyls1 = yyls;
490 #endif
491
492 /* Get the current used size of the three stacks, in elements. */
493 int size = yyssp - yyss + 1;
494
495 #ifdef yyoverflow
496 /* Each stack pointer address is followed by the size of
497 the data in use in that stack, in bytes. */
498 #ifdef YYLSP_NEEDED
499 /* This used to be a conditional around just the two extra args,
500 but that might be undefined if yyoverflow is a macro. */
501 yyoverflow("parser stack overflow",
502 &yyss1, size * sizeof (*yyssp),
503 &yyvs1, size * sizeof (*yyvsp),
504 &yyls1, size * sizeof (*yylsp),
505 &yystacksize);
506 #else
507 yyoverflow("parser stack overflow",
508 &yyss1, size * sizeof (*yyssp),
509 &yyvs1, size * sizeof (*yyvsp),
510 &yystacksize);
511 #endif
512
513 yyss = yyss1; yyvs = yyvs1;
514 #ifdef YYLSP_NEEDED
515 yyls = yyls1;
516 #endif
517 #else /* no yyoverflow */
518 /* Extend the stack our own way. */
519 if (yystacksize >= YYMAXDEPTH)
520 {
521 yyerror("parser stack overflow");
522 if (yyfree_stacks)
523 {
524 free (yyss);
525 free (yyvs);
526 #ifdef YYLSP_NEEDED
527 free (yyls);
528 #endif
529 }
530 return 2;
531 }
532 yystacksize *= 2;
533 if (yystacksize > YYMAXDEPTH)
534 yystacksize = YYMAXDEPTH;
535 #ifndef YYSTACK_USE_ALLOCA
536 yyfree_stacks = 1;
537 #endif
538 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
539 __yy_memcpy ((char *)yyss, (char *)yyss1,
540 size * (unsigned int) sizeof (*yyssp));
541 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
542 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
543 size * (unsigned int) sizeof (*yyvsp));
544 #ifdef YYLSP_NEEDED
545 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
546 __yy_memcpy ((char *)yyls, (char *)yyls1,
547 size * (unsigned int) sizeof (*yylsp));
548 #endif
549 #endif /* no yyoverflow */
550
551 yyssp = yyss + size - 1;
552 yyvsp = yyvs + size - 1;
553 #ifdef YYLSP_NEEDED
554 yylsp = yyls + size - 1;
555 #endif
556
557 #if YYDEBUG != 0
558 if (yydebug)
559 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
560 #endif
561
562 if (yyssp >= yyss + yystacksize - 1)
563 YYABORT;
564 }
565
566 #if YYDEBUG != 0
567 if (yydebug)
568 fprintf(stderr, "Entering state %d\n", yystate);
569 #endif
570
571 goto yybackup;
572 yybackup:
573
574 /* Do appropriate processing given the current state. */
575 /* Read a lookahead token if we need one and don't already have one. */
576 /* yyresume: */
577
578 /* First try to decide what to do without reference to lookahead token. */
579
580 yyn = yypact[yystate];
581 if (yyn == YYFLAG)
582 goto yydefault;
583
584 /* Not known => get a lookahead token if don't already have one. */
585
586 /* yychar is either YYEMPTY or YYEOF
587 or a valid token in external form. */
588
589 if (yychar == YYEMPTY)
590 {
591 #if YYDEBUG != 0
592 if (yydebug)
593 fprintf(stderr, "Reading a token: ");
594 #endif
595 yychar = YYLEX;
596 }
597
598 /* Convert token to internal form (in yychar1) for indexing tables with */
599
600 if (yychar <= 0) /* This means end of input. */
601 {
602 yychar1 = 0;
603 yychar = YYEOF; /* Don't call YYLEX any more */
604
605 #if YYDEBUG != 0
606 if (yydebug)
607 fprintf(stderr, "Now at end of input.\n");
608 #endif
609 }
610 else
611 {
612 yychar1 = YYTRANSLATE(yychar);
613
614 #if YYDEBUG != 0
615 if (yydebug)
616 {
617 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
618 /* Give the individual parser a way to print the precise meaning
619 of a token, for further debugging info. */
620 #ifdef YYPRINT
621 YYPRINT (stderr, yychar, yylval);
622 #endif
623 fprintf (stderr, ")\n");
624 }
625 #endif
626 }
627
628 yyn += yychar1;
629 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
630 goto yydefault;
631
632 yyn = yytable[yyn];
633
634 /* yyn is what to do for this token type in this state.
635 Negative => reduce, -yyn is rule number.
636 Positive => shift, yyn is new state.
637 New state is final state => don't bother to shift,
638 just return success.
639 0, or most negative number => error. */
640
641 if (yyn < 0)
642 {
643 if (yyn == YYFLAG)
644 goto yyerrlab;
645 yyn = -yyn;
646 goto yyreduce;
647 }
648 else if (yyn == 0)
649 goto yyerrlab;
650
651 if (yyn == YYFINAL)
652 YYACCEPT;
653
654 /* Shift the lookahead token. */
655
656 #if YYDEBUG != 0
657 if (yydebug)
658 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
659 #endif
660
661 /* Discard the token being shifted unless it is eof. */
662 if (yychar != YYEOF)
663 yychar = YYEMPTY;
664
665 *++yyvsp = yylval;
666 #ifdef YYLSP_NEEDED
667 *++yylsp = yylloc;
668 #endif
669
670 /* count tokens shifted since error; after three, turn off error status. */
671 if (yyerrstatus) yyerrstatus--;
672
673 yystate = yyn;
674 goto yynewstate;
675
676 /* Do the default action for the current state. */
677 yydefault:
678
679 yyn = yydefact[yystate];
680 if (yyn == 0)
681 goto yyerrlab;
682
683 /* Do a reduction. yyn is the number of a rule to reduce with. */
684 yyreduce:
685 yylen = yyr2[yyn];
686 if (yylen > 0)
687 yyval = yyvsp[1-yylen]; /* implement default value of the action */
688
689 #if YYDEBUG != 0
690 if (yydebug)
691 {
692 int i;
693
694 fprintf (stderr, "Reducing via rule %d (line %d), ",
695 yyn, yyrline[yyn]);
696
697 /* Print the symbols being reduced, and their result. */
698 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
699 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
700 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
701 }
702 #endif
703
704
705 switch (yyn) {
706
707 case 1:
708 #line 32 "expr.y"
709 { result = yyvsp[0]; ;
710 break;}
711 case 2:
712 #line 36 "expr.y"
713 { yyval = yyvsp[0]; ;
714 break;}
715 case 3:
716 #line 37 "expr.y"
717 { yyval = yyvsp[-1]; ;
718 break;}
719 case 4:
720 #line 38 "expr.y"
721 { yyval = exprNodeDot(yyvsp[-2], yyvsp[0]); ;
722 break;}
723 case 5:
724 #line 39 "expr.y"
725 { yyval = exprNodeArrow(yyvsp[-2], yyvsp[0]); ;
726 break;}
727 case 6:
728 #line 40 "expr.y"
729 { yyval = exprNodeArray(yyvsp[-3], yyvsp[-1]); ;
730 break;}
731 case 7:
732 #line 43 "expr.y"
733 { yyval = yyvsp[0]; ;
734 break;}
735 case 8:
736 #line 44 "expr.y"
737 { yyval = exprNodeStar(yyvsp[0]); ;
738 break;}
739 case 9:
740 #line 45 "expr.y"
741 { yyval = exprNodeAddr(yyvsp[0]); ;
742 break;}
743 case 10:
744 #line 46 "expr.y"
745 { yyval = exprNodeSizeof(yyvsp[-1]); ;
746 break;}
747 case 11:
748 #line 50 "expr.y"
749 { yyval = exprNodeNumber(); ;
750 break;}
751 case 12:
752 #line 54 "expr.y"
753 {yyval = exprNodeIdentifier(); ;
754 break;}
755 }
756 /* the action file gets copied in in place of this dollarsign */
757 #line 543 "/usr/lib/bison.simple"
758
759 yyvsp -= yylen;
760 yyssp -= yylen;
761 #ifdef YYLSP_NEEDED
762 yylsp -= yylen;
763 #endif
764
765 #if YYDEBUG != 0
766 if (yydebug)
767 {
768 short *ssp1 = yyss - 1;
769 fprintf (stderr, "state stack now");
770 while (ssp1 != yyssp)
771 fprintf (stderr, " %d", *++ssp1);
772 fprintf (stderr, "\n");
773 }
774 #endif
775
776 *++yyvsp = yyval;
777
778 #ifdef YYLSP_NEEDED
779 yylsp++;
780 if (yylen == 0)
781 {
782 yylsp->first_line = yylloc.first_line;
783 yylsp->first_column = yylloc.first_column;
784 yylsp->last_line = (yylsp-1)->last_line;
785 yylsp->last_column = (yylsp-1)->last_column;
786 yylsp->text = 0;
787 }
788 else
789 {
790 yylsp->last_line = (yylsp+yylen-1)->last_line;
791 yylsp->last_column = (yylsp+yylen-1)->last_column;
792 }
793 #endif
794
795 /* Now "shift" the result of the reduction.
796 Determine what state that goes to,
797 based on the state we popped back to
798 and the rule number reduced by. */
799
800 yyn = yyr1[yyn];
801
802 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
803 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
804 yystate = yytable[yystate];
805 else
806 yystate = yydefgoto[yyn - YYNTBASE];
807
808 goto yynewstate;
809
810 yyerrlab: /* here on detecting error */
811
812 if (! yyerrstatus)
813 /* If not already recovering from an error, report this error. */
814 {
815 ++yynerrs;
816
817 #ifdef YYERROR_VERBOSE
818 yyn = yypact[yystate];
819
820 if (yyn > YYFLAG && yyn < YYLAST)
821 {
822 int size = 0;
823 char *msg;
824 int x, count;
825
826 count = 0;
827 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
828 for (x = (yyn < 0 ? -yyn : 0);
829 x < (sizeof(yytname) / sizeof(char *)); x++)
830 if (yycheck[x + yyn] == x)
831 size += strlen(yytname[x]) + 15, count++;
832 msg = (char *) malloc(size + 15);
833 if (msg != 0)
834 {
835 strcpy(msg, "parse error");
836
837 if (count < 5)
838 {
839 count = 0;
840 for (x = (yyn < 0 ? -yyn : 0);
841 x < (sizeof(yytname) / sizeof(char *)); x++)
842 if (yycheck[x + yyn] == x)
843 {
844 strcat(msg, count == 0 ? ", expecting `" : " or `");
845 strcat(msg, yytname[x]);
846 strcat(msg, "'");
847 count++;
848 }
849 }
850 yyerror(msg);
851 free(msg);
852 }
853 else
854 yyerror ("parse error; also virtual memory exceeded");
855 }
856 else
857 #endif /* YYERROR_VERBOSE */
858 yyerror("parse error");
859 }
860
861 goto yyerrlab1;
862 yyerrlab1: /* here on error raised explicitly by an action */
863
864 if (yyerrstatus == 3)
865 {
866 /* if just tried and failed to reuse lookahead token after an error, discard it. */
867
868 /* return failure if at end of input */
869 if (yychar == YYEOF)
870 YYABORT;
871
872 #if YYDEBUG != 0
873 if (yydebug)
874 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
875 #endif
876
877 yychar = YYEMPTY;
878 }
879
880 /* Else will try to reuse lookahead token
881 after shifting the error token. */
882
883 yyerrstatus = 3; /* Each real token shifted decrements this */
884
885 goto yyerrhandle;
886
887 yyerrdefault: /* current state does not do anything special for the error token. */
888
889 #if 0
890 /* This is wrong; only states that explicitly want error tokens
891 should shift them. */
892 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
893 if (yyn) goto yydefault;
894 #endif
895
896 yyerrpop: /* pop the current state because it cannot handle the error token */
897
898 if (yyssp == yyss) YYABORT;
899 yyvsp--;
900 yystate = *--yyssp;
901 #ifdef YYLSP_NEEDED
902 yylsp--;
903 #endif
904
905 #if YYDEBUG != 0
906 if (yydebug)
907 {
908 short *ssp1 = yyss - 1;
909 fprintf (stderr, "Error: state stack now");
910 while (ssp1 != yyssp)
911 fprintf (stderr, " %d", *++ssp1);
912 fprintf (stderr, "\n");
913 }
914 #endif
915
916 yyerrhandle:
917
918 yyn = yypact[yystate];
919 if (yyn == YYFLAG)
920 goto yyerrdefault;
921
922 yyn += YYTERROR;
923 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
924 goto yyerrdefault;
925
926 yyn = yytable[yyn];
927 if (yyn < 0)
928 {
929 if (yyn == YYFLAG)
930 goto yyerrpop;
931 yyn = -yyn;
932 goto yyreduce;
933 }
934 else if (yyn == 0)
935 goto yyerrpop;
936
937 if (yyn == YYFINAL)
938 YYACCEPT;
939
940 #if YYDEBUG != 0
941 if (yydebug)
942 fprintf(stderr, "Shifting error token, ");
943 #endif
944
945 *++yyvsp = yylval;
946 #ifdef YYLSP_NEEDED
947 *++yylsp = yylloc;
948 #endif
949
950 yystate = yyn;
951 goto yynewstate;
952
953 yyacceptlab:
954 /* YYACCEPT comes here. */
955 if (yyfree_stacks)
956 {
957 free (yyss);
958 free (yyvs);
959 #ifdef YYLSP_NEEDED
960 free (yyls);
961 #endif
962 }
963 return 0;
964
965 yyabortlab:
966 /* YYABORT comes here. */
967 if (yyfree_stacks)
968 {
969 free (yyss);
970 free (yyvs);
971 #ifdef YYLSP_NEEDED
972 free (yyls);
973 #endif
974 }
975 return 1;
976 }
977 #line 57 "expr.y"
978
979
980 int yyerror(char *s)
981 {
982 return 0;
983 }
984
985 #ifndef SDL
986 extern FILE *yyin;
987 int main(int argc, char **argv)
988 {
989 // yydebug = 1;
990 ++argv, --argc;
991 if(argc > 0)
992 yyin = fopen(argv[0], "r");
993 else
994 yyin = stdin;
995 if(!yyparse())
996 result->print();
997 }
998 #endif