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