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