![[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 [Apple XNU] / GNUtools / cc|
Return to bi-parser.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1:
2: /* A Bison parser, made from bi-parser.y */
3:
4: #define DEFOP 258
5: #define STRING 259
6:
7: #line 21 "bi-parser.y"
8:
9:
10: #include <stdio.h>
11: #include "hconfig.h"
12: #include "bi-defs.h"
13:
14: extern char yytext[];
15: extern int yyleng;
16:
17:
18: /* Chain of all defs built by the parser. */
19: struct def *defs;
20: int ndefs;
21:
22: static struct node *makenode ();
23: static struct variation *makevar ();
24: static struct def *makedef ();
25:
26: void yyerror ();
27:
28:
29: #line 43 "bi-parser.y"
30: typedef union
31: {
32: char *string;
33: struct def *def;
34: struct variation *variation;
35: struct node *node;
36: } YYSTYPE;
37:
38: #ifndef YYLTYPE
39: typedef
40: struct yyltype
41: {
42: int timestamp;
43: int first_line;
44: int first_column;
45: int last_line;
46: int last_column;
47: char *text;
48: }
49: yyltype;
50:
51: #define YYLTYPE yyltype
52: #endif
53:
54: #include <stdio.h>
55:
56: #ifndef __STDC__
57: #define const
58: #endif
59:
60:
61:
62: #define YYFINAL 39
63: #define YYFLAG -32768
64: #define YYNTBASE 8
65:
66: #define YYTRANSLATE(x) ((unsigned)(x) <= 259 ? yytranslate[x] : 17)
67:
68: static const char yytranslate[] = { 0,
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, 5,
73: 7, 2, 2, 6, 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, 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, 1, 2, 3, 4
95: };
96:
97: static const short yyrline[] = { 0,
98: 59, 64, 66, 70, 75, 77, 81, 84, 86, 88,
99: 92, 94, 97, 100, 104, 107, 111
100: };
101:
102: static const char * const yytname[] = { 0,
103: "error","$illegal.","DEFOP","STRING","'('","','","')'","top"
104: };
105:
106: static const short yyr1[] = { 0,
107: 8, 9, 9, 10, 11, 11, 12, 12, 12, 12,
108: 13, 13, 14, 14, 15, 15, 16
109: };
110:
111: static const short yyr2[] = { 0,
112: 1, 1, 2, 10, 1, 3, 3, 5, 7, 9,
113: 0, 1, 3, 0, 1, 3, 1
114: };
115:
116: static const short yydefact[] = { 0,
117: 0, 1, 2, 0, 3, 0, 11, 12, 0, 0,
118: 0, 11, 0, 5, 0, 0, 0, 14, 7, 6,
119: 4, 0, 0, 17, 0, 15, 14, 8, 13, 0,
120: 0, 16, 14, 9, 0, 10, 0, 0, 0
121: };
122:
123: static const short yydefgoto[] = { 37,
124: 2, 3, 13, 14, 9, 23, 25, 26
125: };
126:
127: static const short yypact[] = { 2,
128: 6, 2,-32768, 8,-32768, 7, 10,-32768, 9, 11,
129: 12, 10, -5,-32768, -3, 12, 13, 14,-32768,-32768,
130: -32768, 17, 1,-32768, 15, 18, 14,-32768,-32768, 17,
131: 3,-32768, 14,-32768, 16,-32768, 25, 26,-32768
132: };
133:
134: static const short yypgoto[] = {-32768,
135: -32768, 27,-32768, 19, 20, -27, -12,-32768
136: };
137:
138:
139: #define YYLAST 35
140:
141:
142: static const short yytable[] = { 31,
143: 16, 17, 18, 19, 1, 35, 27, 28, 33, 34,
144: 4, 6, 7, 8, 10, 11, 12, 32, 22, 21,
145: 24, 29, 36, 30, 38, 39, 0, 0, 5, 0,
146: 0, 15, 0, 0, 20
147: };
148:
149: static const short yycheck[] = { 27,
150: 6, 7, 6, 7, 3, 33, 6, 7, 6, 7,
151: 5, 4, 6, 4, 6, 5, 5, 30, 5, 7,
152: 4, 7, 7, 6, 0, 0, -1, -1, 2, -1,
153: -1, 12, -1, -1, 16
154: };
155: #define YYPURE 1
156:
157: /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
158: #line 3 "bison.simple"
159:
160: /* Skeleton output parser for bison,
161: Copyright (C) 1984 Bob Corbett and Richard Stallman
162:
163: This program is free software; you can redistribute it and/or modify
164: it under the terms of the GNU General Public License as published by
165: the Free Software Foundation; either version 1, or (at your option)
166: any later version.
167:
168: This program is distributed in the hope that it will be useful,
169: but WITHOUT ANY WARRANTY; without even the implied warranty of
170: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
171: GNU General Public License for more details.
172:
173: You should have received a copy of the GNU General Public License
174: along with this program; if not, write to the Free Software
175: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
176:
177:
178: #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
179: #include <alloca.h>
180: #endif
181:
182: /* This is the parser code that is written into each bison parser
183: when the %semantic_parser declaration is not specified in the grammar.
184: It was written by Richard Stallman by simplifying the hairy parser
185: used when %semantic_parser is specified. */
186:
187: /* Note: there must be only one dollar sign in this file.
188: It is replaced by the list of actions, each action
189: as one case of the switch. */
190:
191: #define yyerrok (yyerrstatus = 0)
192: #define yyclearin (yychar = YYEMPTY)
193: #define YYEMPTY -2
194: #define YYEOF 0
195: #define YYFAIL goto yyerrlab;
196: #define YYACCEPT return(0)
197: #define YYABORT return(1)
198: #define YYERROR goto yyerrlab
199:
200: #define YYTERROR 1
201: #define YYERRCODE 256
202:
203: #ifndef YYIMPURE
204: #define YYLEX yylex()
205: #endif
206:
207: #ifndef YYPURE
208: #define YYLEX yylex(&yylval, &yylloc)
209: #endif
210:
211: /* If nonreentrant, generate the variables here */
212:
213: #ifndef YYIMPURE
214:
215: int yychar; /* the lookahead symbol */
216: YYSTYPE yylval; /* the semantic value of the */
217: /* lookahead symbol */
218:
219: YYLTYPE yylloc; /* location data for the lookahead */
220: /* symbol */
221:
222: int yynerrs; /* number of parse errors so far */
223: #endif /* YYIMPURE */
224:
225: #if YYDEBUG != 0
226: int yydebug; /* nonzero means print parse trace */
227: /* Since this is uninitialized, it does not stop multiple parsers
228: from coexisting. */
229: #endif
230:
231: /* YYMAXDEPTH indicates the initial size of the parser's stacks */
232:
233: #ifndef YYMAXDEPTH
234: #define YYMAXDEPTH 200
235: #endif
236:
237: /* YYMAXLIMIT is the maximum size the stacks can grow to
238: (effective only if the built-in stack extension method is used). */
239:
240: #ifndef YYMAXLIMIT
241: #define YYMAXLIMIT 10000
242: #endif
243:
244:
245: #line 90 "bison.simple"
246: int
247: yyparse()
248: {
249: register int yystate;
250: register int yyn;
251: register short *yyssp;
252: register YYSTYPE *yyvsp;
253: YYLTYPE *yylsp;
254: int yyerrstatus; /* number of tokens to shift before error messages enabled */
255: int yychar1; /* lookahead token as an internal (translated) token number */
256:
257: short yyssa[YYMAXDEPTH]; /* the state stack */
258: YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */
259: YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */
260:
261: short *yyss = yyssa; /* refer to the stacks thru separate pointers */
262: YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
263: YYLTYPE *yyls = yylsa;
264:
265: int yymaxdepth = YYMAXDEPTH;
266:
267: #ifndef YYPURE
268: int yychar;
269: YYSTYPE yylval;
270: YYLTYPE yylloc;
271: int yynerrs;
272: #endif
273:
274: YYSTYPE yyval; /* the variable used to return */
275: /* semantic values from the action */
276: /* routines */
277:
278: int yylen;
279:
280: #if YYDEBUG != 0
281: if (yydebug)
282: fprintf(stderr, "Starting parse\n");
283: #endif
284:
285: yystate = 0;
286: yyerrstatus = 0;
287: yynerrs = 0;
288: yychar = YYEMPTY; /* Cause a token to be read. */
289:
290: /* Initialize stack pointers.
291: Waste one element of value and location stack
292: so that they stay on the same level as the state stack. */
293:
294: yyssp = yyss - 1;
295: yyvsp = yyvs;
296: yylsp = yyls;
297:
298: /* Push a new state, which is found in yystate . */
299: /* In all cases, when you get here, the value and location stacks
300: have just been pushed. so pushing a state here evens the stacks. */
301: yynewstate:
302:
303: *++yyssp = yystate;
304:
305: if (yyssp >= yyss + yymaxdepth - 1)
306: {
307: /* Give user a chance to reallocate the stack */
308: /* Use copies of these so that the &'s don't force the real ones into memory. */
309: YYSTYPE *yyvs1 = yyvs;
310: YYLTYPE *yyls1 = yyls;
311: short *yyss1 = yyss;
312:
313: /* Get the current used size of the three stacks, in elements. */
314: int size = yyssp - yyss + 1;
315:
316: #ifdef yyoverflow
317: /* Each stack pointer address is followed by the size of
318: the data in use in that stack, in bytes. */
319: yyoverflow("parser stack overflow",
320: &yyss1, size * sizeof (*yyssp),
321: &yyvs1, size * sizeof (*yyvsp),
322: &yyls1, size * sizeof (*yylsp),
323: &yymaxdepth);
324:
325: yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
326: #else /* no yyoverflow */
327: /* Extend the stack our own way. */
328: if (yymaxdepth >= YYMAXLIMIT)
329: yyerror("parser stack overflow");
330: yymaxdepth *= 2;
331: if (yymaxdepth > YYMAXLIMIT)
332: yymaxdepth = YYMAXLIMIT;
333: yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
334: bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
335: yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
336: bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
337: #ifdef YYLSP_NEEDED
338: yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
339: bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
340: #endif
341: #endif /* no yyoverflow */
342:
343: yyssp = yyss + size - 1;
344: yyvsp = yyvs + size - 1;
345: #ifdef YYLSP_NEEDED
346: yylsp = yyls + size - 1;
347: #endif
348:
349: #if YYDEBUG != 0
350: if (yydebug)
351: fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
352: #endif
353:
354: if (yyssp >= yyss + yymaxdepth - 1)
355: YYABORT;
356: }
357:
358: #if YYDEBUG != 0
359: if (yydebug)
360: fprintf(stderr, "Entering state %d\n", yystate);
361: #endif
362:
363: /* Do appropriate processing given the current state. */
364: /* Read a lookahead token if we need one and don't already have one. */
365: yyresume:
366:
367: /* First try to decide what to do without reference to lookahead token. */
368:
369: yyn = yypact[yystate];
370: if (yyn == YYFLAG)
371: goto yydefault;
372:
373: /* Not known => get a lookahead token if don't already have one. */
374:
375: /* yychar is either YYEMPTY or YYEOF
376: or a valid token in external form. */
377:
378: if (yychar == YYEMPTY)
379: {
380: #if YYDEBUG != 0
381: if (yydebug)
382: fprintf(stderr, "Reading a token: ");
383: #endif
384: yychar = YYLEX;
385: }
386:
387: /* Convert token to internal form (in yychar1) for indexing tables with */
388:
389: if (yychar <= 0) /* This means end of input. */
390: {
391: yychar1 = 0;
392: yychar = YYEOF; /* Don't call YYLEX any more */
393:
394: #if YYDEBUG != 0
395: if (yydebug)
396: fprintf(stderr, "Now at end of input.\n");
397: #endif
398: }
399: else
400: {
401: yychar1 = YYTRANSLATE(yychar);
402:
403: #if YYDEBUG != 0
404: if (yydebug)
405: fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
406: #endif
407: }
408:
409: yyn += yychar1;
410: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
411: goto yydefault;
412:
413: yyn = yytable[yyn];
414:
415: /* yyn is what to do for this token type in this state.
416: Negative => reduce, -yyn is rule number.
417: Positive => shift, yyn is new state.
418: New state is final state => don't bother to shift,
419: just return success.
420: 0, or most negative number => error. */
421:
422: if (yyn < 0)
423: {
424: if (yyn == YYFLAG)
425: goto yyerrlab;
426: yyn = -yyn;
427: goto yyreduce;
428: }
429: else if (yyn == 0)
430: goto yyerrlab;
431:
432: if (yyn == YYFINAL)
433: YYACCEPT;
434:
435: /* Shift the lookahead token. */
436:
437: #if YYDEBUG != 0
438: if (yydebug)
439: fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
440: #endif
441:
442: /* Discard the token being shifted unless it is eof. */
443: if (yychar != YYEOF)
444: yychar = YYEMPTY;
445:
446: *++yyvsp = yylval;
447: #ifdef YYLSP_NEEDED
448: *++yylsp = yylloc;
449: #endif
450:
451: /* count tokens shifted since error; after three, turn off error status. */
452: if (yyerrstatus) yyerrstatus--;
453:
454: yystate = yyn;
455: goto yynewstate;
456:
457: /* Do the default action for the current state. */
458: yydefault:
459:
460: yyn = yydefact[yystate];
461: if (yyn == 0)
462: goto yyerrlab;
463:
464: /* Do a reduction. yyn is the number of a rule to reduce with. */
465: yyreduce:
466: yylen = yyr2[yyn];
467: yyval = yyvsp[1-yylen]; /* implement default value of the action */
468:
469: #if YYDEBUG != 0
470: if (yydebug)
471: {
472: if (yylen == 1)
473: fprintf (stderr, "Reducing 1 value via line %d, ",
474: yyrline[yyn]);
475: else
476: fprintf (stderr, "Reducing %d values via line %d, ",
477: yylen, yyrline[yyn]);
478: }
479: #endif
480:
481:
482: switch (yyn) {
483:
484: case 1:
485: #line 61 "bi-parser.y"
486: { defs = yyvsp[0].def; ;
487: break;}
488: case 3:
489: #line 67 "bi-parser.y"
490: { yyvsp[0].def->next = yyvsp[-1].def; yyval.def = yyvsp[0].def; ;
491: break;}
492: case 4:
493: #line 72 "bi-parser.y"
494: { yyval.def = makedef (yyvsp[-7].string, yyvsp[-5].string, yyvsp[-2].variation); ;
495: break;}
496: case 6:
497: #line 78 "bi-parser.y"
498: { yyvsp[0].variation->next = yyvsp[-2].variation; yyval.variation = yyvsp[0].variation; ;
499: break;}
500: case 7:
501: #line 83 "bi-parser.y"
502: { yyval.variation = makevar (yyvsp[-1].string, (struct node *) NULL, (struct node *) NULL, (struct node *) NULL); ;
503: break;}
504: case 8:
505: #line 85 "bi-parser.y"
506: { yyval.variation = makevar (yyvsp[-3].string, yyvsp[-1].node, (struct node *) NULL, (struct node *) NULL); ;
507: break;}
508: case 9:
509: #line 87 "bi-parser.y"
510: { yyval.variation = makevar (yyvsp[-5].string, yyvsp[-3].node, yyvsp[-1].node, (struct node *) NULL); ;
511: break;}
512: case 10:
513: #line 89 "bi-parser.y"
514: { yyval.variation = makevar (yyvsp[-7].string, yyvsp[-5].node, yyvsp[-3].node, yyvsp[-1].node); ;
515: break;}
516: case 11:
517: #line 93 "bi-parser.y"
518: { yyval.string = ""; ;
519: break;}
520: case 12:
521: #line 94 "bi-parser.y"
522: { yyval.string = yyvsp[0].string; ;
523: break;}
524: case 13:
525: #line 99 "bi-parser.y"
526: { yyval.node = yyvsp[-1].node; ;
527: break;}
528: case 14:
529: #line 101 "bi-parser.y"
530: { yyval.node = NULL; ;
531: break;}
532: case 16:
533: #line 108 "bi-parser.y"
534: { yyvsp[-2].node->next = yyvsp[0].node; yyval.node = yyvsp[-2].node; ;
535: break;}
536: case 17:
537: #line 113 "bi-parser.y"
538: { yyval.node = makenode (yyvsp[0].string); ;
539: break;}
540: }
541: /* the action file gets copied in in place of this dollarsign */
542: #line 327 "bison.simple"
543:
544: yyvsp -= yylen;
545: yyssp -= yylen;
546: #ifdef YYLSP_NEEDED
547: yylsp -= yylen;
548: #endif
549:
550: #if YYDEBUG != 0
551: if (yydebug)
552: {
553: short *ssp1 = yyss - 1;
554: fprintf (stderr, "state stack now");
555: while (ssp1 != yyssp)
556: fprintf (stderr, " %d", *++ssp1);
557: fprintf (stderr, "\n");
558: }
559: #endif
560:
561: *++yyvsp = yyval;
562:
563: #ifdef YYLSP_NEEDED
564: yylsp++;
565: if (yylen == 0)
566: {
567: yylsp->first_line = yylloc.first_line;
568: yylsp->first_column = yylloc.first_column;
569: yylsp->last_line = (yylsp-1)->last_line;
570: yylsp->last_column = (yylsp-1)->last_column;
571: yylsp->text = 0;
572: }
573: else
574: {
575: yylsp->last_line = (yylsp+yylen-1)->last_line;
576: yylsp->last_column = (yylsp+yylen-1)->last_column;
577: }
578: #endif
579:
580: /* Now "shift" the result of the reduction.
581: Determine what state that goes to,
582: based on the state we popped back to
583: and the rule number reduced by. */
584:
585: yyn = yyr1[yyn];
586:
587: yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
588: if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
589: yystate = yytable[yystate];
590: else
591: yystate = yydefgoto[yyn - YYNTBASE];
592:
593: goto yynewstate;
594:
595: yyerrlab: /* here on detecting error */
596:
597: if (! yyerrstatus)
598: /* If not already recovering from an error, report this error. */
599: {
600: ++yynerrs;
601: yyerror("parse error");
602: }
603:
604: if (yyerrstatus == 3)
605: {
606: /* if just tried and failed to reuse lookahead token after an error, discard it. */
607:
608: /* return failure if at end of input */
609: if (yychar == YYEOF)
610: YYABORT;
611:
612: #if YYDEBUG != 0
613: if (yydebug)
614: fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
615: #endif
616:
617: yychar = YYEMPTY;
618: }
619:
620: /* Else will try to reuse lookahead token
621: after shifting the error token. */
622:
623: yyerrstatus = 3; /* Each real token shifted decrements this */
624:
625: goto yyerrhandle;
626:
627: yyerrdefault: /* current state does not do anything special for the error token. */
628:
629: #if 0
630: /* This is wrong; only states that explicitly want error tokens
631: should shift them. */
632: yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
633: if (yyn) goto yydefault;
634: #endif
635:
636: yyerrpop: /* pop the current state because it cannot handle the error token */
637:
638: if (yyssp == yyss) YYABORT;
639: yyvsp--;
640: yystate = *--yyssp;
641: #ifdef YYLSP_NEEDED
642: yylsp--;
643: #endif
644:
645: #if YYDEBUG != 0
646: if (yydebug)
647: {
648: short *ssp1 = yyss - 1;
649: fprintf (stderr, "Error: state stack now");
650: while (ssp1 != yyssp)
651: fprintf (stderr, " %d", *++ssp1);
652: fprintf (stderr, "\n");
653: }
654: #endif
655:
656: yyerrhandle:
657:
658: yyn = yypact[yystate];
659: if (yyn == YYFLAG)
660: goto yyerrdefault;
661:
662: yyn += YYTERROR;
663: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
664: goto yyerrdefault;
665:
666: yyn = yytable[yyn];
667: if (yyn < 0)
668: {
669: if (yyn == YYFLAG)
670: goto yyerrpop;
671: yyn = -yyn;
672: goto yyreduce;
673: }
674: else if (yyn == 0)
675: goto yyerrpop;
676:
677: if (yyn == YYFINAL)
678: YYACCEPT;
679:
680: #if YYDEBUG != 0
681: if (yydebug)
682: fprintf(stderr, "Shifting error token, ");
683: #endif
684:
685: *++yyvsp = yylval;
686: #ifdef YYLSP_NEEDED
687: *++yylsp = yylloc;
688: #endif
689:
690: yystate = yyn;
691: goto yynewstate;
692: }
693: #line 116 "bi-parser.y"
694:
695:
696: static struct node *
697: makenode (s)
698: char *s;
699: {
700: struct node *n;
701:
702: n = (struct node *) malloc (sizeof (struct node));
703: n->text = s;
704: n->next = NULL;
705: return n;
706: }
707:
708: static struct variation *
709: makevar (name, inputs, outputs, literals)
710: char *name;
711: struct node *inputs, *outputs, *literals;
712: {
713: struct variation *v;
714:
715: v = (struct variation *) malloc (sizeof (struct variation));
716: v->name = name;
717: v->code = ndefs++;
718: v->inputs = inputs;
719: v->outputs = outputs;
720: v->literals = literals;
721: v->next = NULL;
722: return v;
723: }
724:
725: static struct def *
726: makedef (name, template, vars)
727: char *name, *template;
728: struct variation *vars;
729: {
730: struct def *d;
731:
732: d = (struct def *) malloc (sizeof (struct def));
733: d->basename = name;
734: d->template = template;
735: d->variations = vars;
736: d->next = NULL;
737: return d;
738: }
739:
740: void
741: yyerror (s)
742: char *s;
743: {
744: fprintf (stderr, "syntax error in input\n");
745: exit (FATAL_EXIT_CODE);
746: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.