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