![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to y.tab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / lib / scn / obj386|
Return to y.tab.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / lib / scn / obj386 |
1.1 root 1:
2: #line 1 "../scn.y"
3:
4: #include <scnbld.h>
5:
6: clump *clumps, *lastc, *thisc;
7: loc *locs, *last, *this;
8:
9: /*
10: * Generate a unique name.
11: */
12: static char *
13: genname()
14: {
15: char buf[20];
16: static int i = 0;
17:
18: sprintf(buf, "L%04d", ++i);
19: return(newcpy(buf));
20: }
21:
22:
23: #include "y.tab.h"
24: #define YYCLEARIN yychar = -1000
25: #define YYERROK yyerrflag = 0
26: extern int yychar;
27: extern short yyerrflag;
28: #ifndef YYMAXDEPTH
29: #define YYMAXDEPTH 150
30: #endif
31: YYSTYPE yyval, yylval;
32: #ifdef YYTNAMES
33: readonly struct yytname yytnames[18] =
34: {
35: "$end", -1,
36: "error", -2,
37: "NAME", 256,
38: "STRING", 257,
39: "NUMBER", 258,
40: "EXT", 259,
41: "RONLY", 260,
42: "LONG", 261,
43: "DEFAULT", 262,
44: "SKIP", 263,
45: "GROUP", 264,
46: "HELP", 265,
47: "VERIFY", 266,
48: "NL", 267,
49: "DO", 268,
50: "DONE", 269,
51: "DESIG", 270,
52: NULL
53: } ;
54: #endif
55: #include <action.h>
56: readonly unsigned char yypdnt[25] = {
57: 0, 1, 1, 1, 2, 2, 2, 4,
58: 3, 3, 3, 3, 5, 5, 5, 6,
59: 6, 6, 6, 6, 6, 6, 6, 6,
60: 6
61: };
62: readonly unsigned char yypn[25] = {
63: 2, 1, 2, 0, 2, 1, 2, 0,
64: 4, 2, 3, 1, 1, 2, 0, 1,
65: 1, 1, 2, 2, 2, 2, 2, 2,
66: 2
67: };
68: readonly unsigned char yypgo[7] = {
69: 0, 0, 2, 6, 8, 10, 12
70: };
71: readonly unsigned int yygo[16] = {
72: YYOTHERS, 0x7, 0x7, 0xF, YYOTHERS, 0x8, YYOTHERS, 0x9,
73: YYOTHERS, 0x11, YYOTHERS, 0x1A, 0x1A, 0x23, YYOTHERS, 0x1B
74: };
75: readonly unsigned char yypa[36] = {
76: 0, 14, 18, 22, 24, 28, 30, 34,
77: 48, 50, 54, 56, 58, 62, 64, 68,
78: 70, 72, 88, 90, 92, 94, 96, 102,
79: 108, 114, 118, 134, 136, 138, 140, 142,
80: 144, 146, 148, 150
81: };
82: readonly unsigned int yyact[152] = {
83: 0x2, 0x100, 0x3, 0x10B, 0x4, 0x10C, 0x5, 0x10D,
84: 0x6, 0x10E, 0x2003, YYEOFVAL, 0x1, YYOTHERS, 0xA, 0x10B,
85: 0x6000, YYOTHERS, 0xB, 0x102, 0x6000, YYOTHERS, 0x2005, YYOTHERS,
86: 0xC, 0x102, 0x6000, YYOTHERS, 0x200B, YYOTHERS, 0xD, 0x101,
87: 0x6000, YYOTHERS, 0xE, YYEOFVAL, 0x2, 0x100, 0x3, 0x10B,
88: 0x4, 0x10C, 0x5, 0x10D, 0x6, 0x10E, 0x1, YYOTHERS,
89: 0x2001, YYOTHERS, 0x10, 0x10B, 0x6000, YYOTHERS, 0x2006, YYOTHERS,
90: 0x2007, YYOTHERS, 0x12, 0x100, 0x6000, YYOTHERS, 0x2009, YYOTHERS,
91: 0x4000, YYEOFVAL, 0x6000, YYOTHERS, 0x2002, YYOTHERS, 0x2004, YYOTHERS,
92: 0x13, 0x103, 0x14, 0x104, 0x15, 0x105, 0x16, 0x106,
93: 0x17, 0x107, 0x18, 0x109, 0x19, 0x10A, 0x200E, YYOTHERS,
94: 0x200A, YYOTHERS, 0x2011, YYOTHERS, 0x2010, YYOTHERS, 0x200F, YYOTHERS,
95: 0x1C, 0x100, 0x1D, 0x101, 0x6000, YYOTHERS, 0x1E, 0x102,
96: 0x1F, 0x108, 0x6000, YYOTHERS, 0x20, 0x100, 0x21, 0x101,
97: 0x6000, YYOTHERS, 0x22, 0x100, 0x6000, YYOTHERS, 0x13, 0x103,
98: 0x14, 0x104, 0x15, 0x105, 0x16, 0x106, 0x17, 0x107,
99: 0x18, 0x109, 0x19, 0x10A, 0x2008, YYOTHERS, 0x200C, YYOTHERS,
100: 0x2013, YYOTHERS, 0x2012, YYOTHERS, 0x2016, YYOTHERS, 0x2018, YYOTHERS,
101: 0x2015, YYOTHERS, 0x2014, YYOTHERS, 0x2017, YYOTHERS, 0x200D, YYOTHERS
102: };
103: #define YYNOCHAR (-1000)
104: #define yyerrok yyerrflag=0
105: #define yyclearin yylval=YYNOCHAR
106: int yystack[YYMAXDEPTH];
107: YYSTYPE yyvstack[YYMAXDEPTH], *yyv;
108: int yychar;
109:
110: #ifdef YYDEBUG
111: int yydebug = 1; /* No sir, not in the BSS */
112: #include <stdio.h>
113: #endif
114:
115: short yyerrflag;
116: int *yys;
117:
118: yyparse()
119: {
120: register YYSTYPE *yypvt;
121: int act;
122: register unsigned *ip, yystate;
123: int pno;
124: yystate = 0;
125: yychar = YYNOCHAR;
126: yyv = &yyvstack[-1];
127: yys = &yystack[-1];
128:
129: stack:
130: if( ++yys >= &yystack[YYMAXDEPTH] ) {
131: write(2, "Stack overflow\n", 15);
132: exit(1);
133: }
134: *yys = yystate;
135: *++yyv = yyval;
136: #ifdef YYDEBUG
137: if( yydebug )
138: fprintf(stdout, "Stack state %d, char %d\n", yystate, yychar);
139: #endif
140:
141: read:
142: ip = &yyact[yypa[yystate]];
143: if( ip[1] != YYNOCHAR ) {
144: if( yychar == YYNOCHAR ) {
145: yychar = yylex();
146: #ifdef YYDEBUG
147: if( yydebug )
148: fprintf(stdout, "lex read char %d, val %d\n", yychar, yylval);
149: #endif
150: }
151: while (ip[1]!=YYNOCHAR) {
152: if (ip[1]==yychar)
153: break;
154: ip += 2;
155: }
156: }
157: act = ip[0];
158: switch( act>>YYACTSH ) {
159: case YYSHIFTACT:
160: if( ip[1]==YYNOCHAR )
161: goto YYerract;
162: if( yychar != -1 )
163: yychar = YYNOCHAR; /* dont throw away EOF */
164: yystate = act&YYAMASK;
165: yyval = yylval;
166: #ifdef YYDEBUG
167: if( yydebug )
168: fprintf(stdout, "shift %d\n", yystate);
169: #endif
170: if( yyerrflag )
171: --yyerrflag;
172: goto stack;
173:
174: case YYACCEPTACT:
175: #ifdef YYDEBUG
176: if( yydebug )
177: fprintf(stdout, "accept\n");
178: #endif
179: return(0);
180:
181: case YYERRACT:
182: YYerract:
183: switch (yyerrflag) {
184: case 0:
185: yyerror("Syntax error");
186:
187: case 1:
188: case 2:
189:
190: yyerrflag = 3;
191: while( yys >= & yystack[0] ) {
192: ip = &yyact[yypa[*yys]];
193: while( ip[1]!=YYNOCHAR )
194: ip += 2;
195: if( (*ip&~YYAMASK) == (YYSHIFTACT<<YYACTSH) ) {
196: yystate = *ip&YYAMASK;
197: goto stack;
198: }
199: #ifdef YYDEBUG
200: if( yydebug )
201: fprintf(stderr, "error recovery leaves state %d, uncovers %d\n", *yys, yys[-1]);
202: #endif
203: yys--;
204: yyv--;
205: }
206: #ifdef YYDEBUG
207: if( yydebug )
208: fprintf(stderr, "no shift on error; abort\n");
209: #endif
210: return(1);
211:
212: case 3:
213: #ifdef YYDEBUG
214: if( yydebug )
215: fprintf(stderr, "Error recovery clobbers char %o\n", yychar);
216: #endif
217: if( yychar==YYEOFVAL )
218: return(1);
219: yychar = YYNOCHAR;
220: goto read;
221: }
222:
223: case YYREDACT:
224: pno = act&YYAMASK;
225: #ifdef YYDEBUG
226: if( yydebug )
227: fprintf(stdout, "reduce %d\n", pno);
228: #endif
229: yypvt = yyv;
230: yyv -= yypn[pno];
231: yys -= yypn[pno];
232: yyval = yyv[1];
233: switch(pno) {
234:
235: case 6: {
236:
237: #line 50 "../scn.y"
238:
239: yyerrok;
240: }break;
241:
242: case 7: {
243:
244: #line 54 "../scn.y"
245:
246: if (0 >= yypvt[0].val)
247: yyerror("Invalid field size");
248: this = alloc(sizeof(*this));
249: if (NULL == locs)
250: last = locs = this;
251: else
252: last = last->next = this;
253:
254: this->field = yypvt[-1].string;
255: this->len = yypvt[0].val;
256:
257: if ((NULL != thisc) && (!thisc->count++))
258: thisc->from = this;
259: }break;
260:
261: case 9: {
262:
263: #line 70 "../scn.y"
264:
265: extern char fieldDesig;
266:
267: fieldDesig = yypvt[0].string[1];
268: }break;
269:
270: case 10: {
271:
272: #line 76 "../scn.y"
273:
274: if (NULL != thisc)
275: yyerror("Nested do statements");
276: if (0 >= yypvt[-1].val)
277: yyerror("Invalid repeat count");
278:
279: thisc = alloc(sizeof(*thisc));
280: if (NULL == clumps)
281: lastc = clumps = thisc;
282: else
283: lastc = lastc->next = thisc;
284:
285: thisc->times = yypvt[-1].val;
286:
287: fprintf(ohp, "#define %s %d\n", yypvt[0].string, yypvt[-1].val);
288: }break;
289:
290: case 11: {
291:
292: #line 93 "../scn.y"
293:
294: if (NULL == thisc)
295: yyerror("Unmatched done statement");
296: thisc = NULL;
297: }break;
298:
299: case 15: {
300:
301: #line 101 "../scn.y"
302: this->flags |= LONGFIELD; }break;
303:
304: case 16: {
305:
306: #line 102 "../scn.y"
307: this->flags |= READONLY; }break;
308:
309: case 17: {
310:
311: #line 103 "../scn.y"
312: this->flags |= EXTERNAL; }break;
313:
314: case 18: {
315:
316: #line 104 "../scn.y"
317:
318: if (NULL != this->Default)
319: yyerror("Default already set");
320: this->Default = genname();
321: fprintf(ofp, "static char %s[] = %s;\n", this->Default, yypvt[0].string);
322: }break;
323:
324: case 19: {
325:
326: #line 110 "../scn.y"
327:
328: if (NULL != this->Default)
329: yyerror("Default already set");
330: this->Default = yypvt[0].string;
331: }break;
332:
333: case 20: {
334:
335: #line 115 "../scn.y"
336:
337: if (NULL != this->help)
338: yyerror("Help already set");
339: this->help = genname();
340: fprintf(ofp, "static char %s[] = %s;\n", this->help, yypvt[0].string);
341: }break;
342:
343: case 21: {
344:
345: #line 121 "../scn.y"
346:
347: if (NULL != this->help)
348: yyerror("Help already set");
349: this->help = yypvt[0].string;
350: }break;
351:
352: case 22: {
353:
354: #line 126 "../scn.y"
355:
356: if (0 >= yypvt[0].val || 254 < yypvt[0].val)
357: yyerror("Invalid skip number");
358: if (this->skipf)
359: yyerror("Skip factor already set");
360: this->skipf = yypvt[0].val;
361: }break;
362:
363: case 23: {
364:
365: #line 133 "../scn.y"
366:
367: if (NULL != this->verify)
368: yyerror("Verify already set");
369: this->verify = yypvt[0].string;
370: }break;
371:
372: case 24: {
373:
374: #line 138 "../scn.y"
375:
376: if (this->skipf)
377: yyerror("Skip factor already set");
378: if (NULL == thisc)
379: yyerror("group must be in do");
380: else
381: this->skipf = 255;
382: }break;
383:
384: }
385: ip = &yygo[ yypgo[yypdnt[pno]] ];
386: while( *ip!=*yys && *ip!=YYNOCHAR )
387: ip += 2;
388: yystate = ip[1];
389: goto stack;
390: }
391: }
392:
393:
394:
395:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.