![[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 / bin / sh|
Return to y.tab.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / sh |
1.1 root 1:
2: #line 9 "/usr/src/cmd0/sh/sh.y"
3:
4: #include "sh.h"
5:
6: #define YYERROR { yyerrflag=1; goto YYerract; }
7:
8: extern NODE *node();
9:
10: #include "y.tab.h"
11: #define YYCLEARIN yychar = -1000
12: #define YYERROK yyerrflag = 0
13: extern int yychar;
14: extern short yyerrflag;
15: #ifndef YYMAXDEPTH
16: #define YYMAXDEPTH 150
17: #endif
18: YYSTYPE yyval, yylval;
19:
20: #line 347 "/usr/src/cmd0/sh/sh.y"
21:
22: /*
23: * Create a node.
24: */
25: NODE *
26: node(type, auxp, next)
27: NODE *auxp, *next;
28: {
29: register NODE *np;
30:
31: np = (NODE *) balloc(sizeof (NODE));
32: np->n_type = type;
33: np->n_auxp = auxp;
34: np->n_next = next;
35: return np;
36: }
37:
38: #define NBPC 8
39: #define NKEY 8
40: static char keys[NKEY] = { 0 };
41: static int keyi = NKEY * NBPC;
42:
43: keyflush()
44: {
45: register char *kp;
46:
47: for (kp = keys+NKEY; kp > keys; *--kp = 0)
48: ;
49: keyi = NKEY * NBPC;
50: }
51:
52: keypop()
53: {
54: register char *kp;
55: register int km;
56:
57: if ((km = keyi++) >= NKEY * NBPC) {
58: panic(11);
59: NOTREACHED;
60: }
61: kp = keys + (km / NBPC);
62: km = 1 << (km %= NBPC);
63: keyflag = (*kp & km) ? 1 : 0;
64: *kp &= ~km;
65: }
66:
67: keypush()
68: {
69: register char *kp;
70: register int km;
71:
72: if ((km = --keyi) < 0) {
73: panic(12);
74: NOTREACHED;
75: }
76: if (keyflag) {
77: kp = keys + (km / NBPC);
78: km = 1 << (km %= NBPC);
79: *kp |= km;
80: }
81: }
82: /*
83: * The following fragments might implement named pipes.
84: * The token declaration goes in the header.
85: * The nopen production should go with the others of its ilk.
86: * The production fragment goes into arg:
87: %token _NOPEN _NCLOSE
88: nopen: _NOPEN optnls ;
89:
90: | nopen pipe_cmd ')' {
91: $$ = node(NRPIPE, $2, NULL);
92: }
93: | oparen pipe_cmd _NCLOSE {
94: $$ = node(NWPIPE, $2, NULL);
95: }
96: *
97: */
98:
99: /* end of sh/sh.y */
100: #ifdef YYTNAMES
101: readonly struct yytname yytnames[31] =
102: {
103: "$end", -1,
104: "error", -2,
105: "_ANDF", 256,
106: "_ASGN", 257,
107: "_CASE", 258,
108: "_CBRAC", 259,
109: "_DO", 260,
110: "_DONE", 261,
111: "_DSEMI", 262,
112: "_ELIF", 263,
113: "_ELSE", 264,
114: "_ESAC", 265,
115: "_FI", 266,
116: "_FOR", 267,
117: "_IF", 268,
118: "_IN", 269,
119: "_IORS", 270,
120: "_NAME", 271,
121: "_NULL", 272,
122: "_OBRAC", 273,
123: "_ORF", 274,
124: "_THEN", 275,
125: "_UNTIL", 276,
126: "_WHILE", 277,
127: "'\\n'", 10,
128: "';'", 59,
129: "'|'", 124,
130: "'('", 40,
131: "')'", 41,
132: "'&'", 38,
133: NULL
134: } ;
135: #endif
136: #include <action.h>
137: readonly unsigned char yypdnt[78] = {
138: 0, 1, 1, 2, 2, 2, 4, 6,
139: 7, 8, 9, 9, 10, 10, 11, 11,
140: 13, 14, 15, 16, 17, 18, 19, 3,
141: 3, 3, 3, 3, 20, 20, 20, 21,
142: 21, 22, 23, 24, 24, 25, 25, 25,
143: 25, 26, 27, 28, 29, 29, 29, 29,
144: 29, 29, 29, 29, 30, 30, 36, 36,
145: 32, 32, 32, 37, 38, 38, 31, 31,
146: 35, 35, 35, 34, 34, 33, 33, 12,
147: 12, 12, 5, 5, 39, 39
148: };
149: readonly unsigned char yypn[78] = {
150: 2, 2, 0, 1, 2, 2, 2, 2,
151: 2, 2, 2, 2, 2, 3, 1, 2,
152: 2, 2, 2, 2, 2, 2, 2, 1,
153: 2, 2, 3, 3, 1, 3, 3, 3,
154: 1, 2, 0, 2, 1, 1, 1, 1,
155: 1, 1, 1, 1, 6, 5, 6, 5,
156: 4, 6, 3, 3, 2, 0, 2, 0,
157: 3, 1, 0, 3, 3, 1, 2, 0,
158: 5, 2, 0, 1, 0, 3, 2, 1,
159: 1, 2, 1, 0, 1, 2
160: };
161: readonly unsigned char yypgo[40] = {
162: 0, 0, 2, 4, 12, 14, 46, 50,
163: 52, 54, 56, 58, 62, 68, 70, 72,
164: 74, 76, 78, 80, 82, 88, 92, 94,
165: 96, 100, 102, 104, 118, 120, 122, 124,
166: 130, 136, 146, 160, 164, 168, 170, 174
167: };
168: readonly unsigned int yygo[186] = {
169: YYOTHERS, 0x1, YYOTHERS, 0x5, 0x1, 0x6, 0xd, 0x29,
170: 0xe, 0x2a, YYOTHERS, 0x3a, YYOTHERS, 0x1f, 0x10, 0x2e,
171: 0x13, 0x31, 0x18, 0x35, 0x1b, 0x36, 0x1c, 0x37,
172: 0x1d, 0x38, 0x1e, 0x39, 0x3a, 0x49, 0x4b, 0x5e,
173: 0x4d, 0x61, 0x60, 0x73, 0x66, 0x75, 0x68, 0x77,
174: 0x6e, 0x7b, 0x6f, 0x7c, YYOTHERS, 0x2c, 0x7d, 0x80,
175: YYOTHERS, 0x4c, YYOTHERS, 0x70, YYOTHERS, 0x71, YYOTHERS, 0x20,
176: YYOTHERS, 0x4e, 0x45, 0x58, YYOTHERS, 0x44, 0x42, 0x52,
177: 0x48, 0x5b, YYOTHERS, 0x45, YYOTHERS, 0x11, YYOTHERS, 0x12,
178: YYOTHERS, 0x14, YYOTHERS, 0x21, YYOTHERS, 0x22, YYOTHERS, 0x69,
179: YYOTHERS, 0x67, 0x11, 0x2f, 0x12, 0x30, YYOTHERS, 0x7,
180: 0x14, 0x32, YYOTHERS, 0x8, YYOTHERS, 0x9, YYOTHERS, 0xa,
181: 0x24, 0x40, YYOTHERS, 0x23, YYOTHERS, 0x24, YYOTHERS, 0x25,
182: 0xa, 0x26, 0x16, 0x33, 0x17, 0x34, 0x24, 0x26,
183: 0x47, 0x59, 0x59, 0x59, YYOTHERS, 0x54, YYOTHERS, 0x27,
184: YYOTHERS, 0x28, YYOTHERS, 0x48, 0x48, 0x5c, 0x5b, 0x6c,
185: YYOTHERS, 0x4f, 0x58, 0x6a, 0x67, 0x76, YYOTHERS, 0x55,
186: 0x1f, 0x3b, 0x20, 0x3c, 0x4a, 0x5d, 0x70, 0x7d,
187: YYOTHERS, 0x3d, 0x22, 0x3f, 0x4c, 0x5f, 0x4e, 0x62,
188: 0x69, 0x78, 0x71, 0x7e, 0x80, 0x81, YYOTHERS, 0x3e,
189: 0x81, 0x82, YYOTHERS, 0x72, 0x59, 0x6b, YYOTHERS, 0x5a,
190: YYOTHERS, 0x56, 0x64, 0x74, YYOTHERS, 0x57, 0x33, 0x46,
191: 0x3a, 0x4a, 0x42, 0x46, 0x43, 0x53, 0x48, 0x46,
192: YYOTHERS, 0x2d
193: };
194: readonly unsigned short yypa[131] = {
195: 0, 2, 28, 32, 36, 38, 40, 44,
196: 50, 56, 60, 82, 84, 86, 108, 130,
197: 130, 134, 134, 130, 136, 138, 140, 140,
198: 130, 144, 146, 130, 130, 130, 130, 136,
199: 136, 148, 152, 156, 158, 180, 182, 184,
200: 186, 188, 190, 192, 194, 196, 200, 202,
201: 204, 206, 208, 210, 218, 222, 224, 226,
202: 228, 230, 130, 232, 236, 240, 242, 246,
203: 250, 252, 254, 260, 264, 268, 272, 276,
204: 280, 288, 290, 130, 314, 322, 328, 332,
205: 336, 338, 340, 342, 346, 350, 354, 358,
206: 264, 276, 362, 236, 364, 368, 370, 372,
207: 130, 378, 380, 382, 384, 388, 130, 264,
208: 130, 390, 396, 400, 402, 406, 130, 130,
209: 136, 408, 412, 416, 418, 420, 422, 424,
210: 426, 428, 430, 432, 434, 232, 436, 438,
211: 314, 440, 446
212: };
213: readonly unsigned int yyact[448] = {
214: 0x2002, YYOTHERS, 0x2, YYEOFVAL, 0x4, 0xa, 0x2022, 0x101,
215: 0x2022, 0x102, 0x2022, 0x10b, 0x2022, 0x10c, 0x2022, 0x10e,
216: 0x2022, 0x10f, 0x2022, 0x111, 0x2022, 0x114, 0x2022, 0x115,
217: 0x2022, 0x28, 0x3, YYOTHERS, 0x4000, YYEOFVAL, 0x6000, YYOTHERS,
218: 0xb, 0xa, 0x6000, YYOTHERS, 0x2003, YYOTHERS, 0x2001, YYOTHERS,
219: 0xc, 0xa, 0x6000, YYOTHERS, 0xd, 0x3b, 0xe, 0x26,
220: 0x2017, YYOTHERS, 0xf, 0x100, 0x10, 0x112, 0x201c, YYOTHERS,
221: 0x13, 0x7c, 0x2020, YYOTHERS, 0x15, 0x101, 0x16, 0x102,
222: 0x17, 0x10b, 0x18, 0x10c, 0x19, 0x10e, 0x1a, 0x10f,
223: 0x1b, 0x111, 0x1c, 0x114, 0x1d, 0x115, 0x1e, 0x28,
224: 0x6000, YYOTHERS, 0x2005, YYOTHERS, 0x2004, YYOTHERS, 0x2022, 0x101,
225: 0x2022, 0x102, 0x2022, 0x10b, 0x2022, 0x10c, 0x2022, 0x10e,
226: 0x2022, 0x10f, 0x2022, 0x111, 0x2022, 0x114, 0x2022, 0x115,
227: 0x2022, 0x28, 0x2019, YYOTHERS, 0x2022, 0x101, 0x2022, 0x102,
228: 0x2022, 0x10b, 0x2022, 0x10c, 0x2022, 0x10e, 0x2022, 0x10f,
229: 0x2022, 0x111, 0x2022, 0x114, 0x2022, 0x115, 0x2022, 0x28,
230: 0x2018, YYOTHERS, 0x2b, 0xa, 0x204b, YYOTHERS, 0x2022, YYOTHERS,
231: 0x2022, YYOTHERS, 0x202b, YYOTHERS, 0x1a, 0x10f, 0x6000, YYOTHERS,
232: 0x2029, YYOTHERS, 0x202a, YYOTHERS, 0x2044, 0x29, 0x2022, YYOTHERS,
233: 0x2044, 0x103, 0x2022, YYOTHERS, 0x2021, YYOTHERS, 0x15, 0x101,
234: 0x16, 0x102, 0x17, 0x10b, 0x18, 0x10c, 0x19, 0x10e,
235: 0x1a, 0x10f, 0x1b, 0x111, 0x1c, 0x114, 0x1d, 0x115,
236: 0x1e, 0x28, 0x2024, YYOTHERS, 0x2025, YYOTHERS, 0x2026, YYOTHERS,
237: 0x2027, YYOTHERS, 0x2028, YYOTHERS, 0x201b, YYOTHERS, 0x201a, YYOTHERS,
238: 0x204c, YYOTHERS, 0x2011, YYOTHERS, 0x41, 0xa, 0x204a, YYOTHERS,
239: 0x2010, YYOTHERS, 0x201d, YYOTHERS, 0x201e, YYOTHERS, 0x2012, YYOTHERS,
240: 0x201f, YYOTHERS, 0x42, 0x10d, 0x2b, 0xa, 0x43, 0x3b,
241: 0x6000, YYOTHERS, 0x47, 0x10d, 0x2035, YYOTHERS, 0x2006, YYOTHERS,
242: 0x2014, YYOTHERS, 0x200b, YYOTHERS, 0x200a, YYOTHERS, 0x2013, YYOTHERS,
243: 0x4b, 0x113, 0x6000, YYOTHERS, 0x4d, 0x104, 0x203f, YYOTHERS,
244: 0x2043, YYOTHERS, 0x50, 0x29, 0x6000, YYOTHERS, 0x51, 0x103,
245: 0x6000, YYOTHERS, 0x2023, YYOTHERS, 0x204d, YYOTHERS, 0x2b, 0xa,
246: 0x43, 0x3b, 0x200e, YYOTHERS, 0x2b, 0xa, 0x2048, YYOTHERS,
247: 0x1a, 0x10f, 0x203a, YYOTHERS, 0x42, 0x10d, 0x6000, YYOTHERS,
248: 0x41, 0xa, 0x2047, YYOTHERS, 0x1a, 0x10f, 0x2037, YYOTHERS,
249: 0x4d, 0x104, 0x2b, 0xa, 0x43, 0x3b, 0x203f, YYOTHERS,
250: 0x2046, YYOTHERS, 0x41, 0xa, 0x204a, 0x103, 0x204a, 0x104,
251: 0x204a, 0x105, 0x204a, 0x106, 0x204a, 0x107, 0x204a, 0x108,
252: 0x204a, 0x109, 0x204a, 0x10a, 0x204a, 0x113, 0x204a, 0x29,
253: 0x2022, YYOTHERS, 0x2044, 0x107, 0x2044, 0x108, 0x2044, 0x10a,
254: 0x2022, YYOTHERS, 0x2b, 0xa, 0x60, 0x3b, 0x204b, YYOTHERS,
255: 0x2044, 0x105, 0x2022, YYOTHERS, 0x63, 0x105, 0x6000, YYOTHERS,
256: 0x2032, YYOTHERS, 0x2033, YYOTHERS, 0x200f, YYOTHERS, 0x41, 0xa,
257: 0x2049, YYOTHERS, 0x64, 0x7c, 0x203d, YYOTHERS, 0x65, 0x109,
258: 0x6000, YYOTHERS, 0x66, 0x106, 0x2039, YYOTHERS, 0x68, 0x29,
259: 0x6000, YYOTHERS, 0x2034, YYOTHERS, 0x6d, 0x105, 0x6000, YYOTHERS,
260: 0x2045, YYOTHERS, 0x2007, YYOTHERS, 0x6e, 0x107, 0x6f, 0x108,
261: 0x2042, YYOTHERS, 0x200c, YYOTHERS, 0x203e, YYOTHERS, 0x2030, YYOTHERS,
262: 0x1a, 0x10f, 0x6000, YYOTHERS, 0x202f, YYOTHERS, 0x2044, 0x106,
263: 0x2044, 0x109, 0x2022, YYOTHERS, 0x79, 0x109, 0x6000, YYOTHERS,
264: 0x2036, YYOTHERS, 0x7a, 0x105, 0x6000, YYOTHERS, 0x202d, YYOTHERS,
265: 0x2044, 0x10a, 0x2022, YYOTHERS, 0x7f, 0x10a, 0x6000, YYOTHERS,
266: 0x200d, YYOTHERS, 0x203c, YYOTHERS, 0x2016, YYOTHERS, 0x2038, YYOTHERS,
267: 0x2015, YYOTHERS, 0x203b, YYOTHERS, 0x202e, YYOTHERS, 0x202c, YYOTHERS,
268: 0x2008, YYOTHERS, 0x2009, YYOTHERS, 0x2041, YYOTHERS, 0x2031, YYOTHERS,
269: 0x6e, 0x107, 0x6f, 0x108, 0x2042, YYOTHERS, 0x2040, YYOTHERS
270: };
271: #define YYNOCHAR (-1000)
272: #define yyerrok yyerrflag=0
273: #define yyclearin yylval=YYNOCHAR
274: int yystack[YYMAXDEPTH];
275: YYSTYPE yyvstack[YYMAXDEPTH], *yyv;
276: int yychar;
277:
278: #ifdef YYDEBUG
279: int yydebug = 1; /* No sir, not in the BSS */
280: #include <stdio.h>
281: #endif
282:
283: short yyerrflag;
284: int *yys;
285:
286: yyparse()
287: {
288: register YYSTYPE *yypvt;
289: int act;
290: register unsigned *ip, yystate;
291: int pno;
292: yystate = 0;
293: yychar = YYNOCHAR;
294: yyv = &yyvstack[-1];
295: yys = &yystack[-1];
296:
297: stack:
298: if( ++yys >= &yystack[YYMAXDEPTH] ) {
299: write(2, "Stack overflow\n", 15);
300: exit(1);
301: }
302: *yys = yystate;
303: *++yyv = yyval;
304: #ifdef YYDEBUG
305: if( yydebug )
306: fprintf(stdout, "Stack state %d, char %d\n", yystate, yychar);
307: #endif
308:
309: read:
310: ip = &yyact[yypa[yystate]];
311: if( ip[1] != YYNOCHAR ) {
312: if( yychar == YYNOCHAR ) {
313: yychar = yylex();
314: #ifdef YYDEBUG
315: if( yydebug )
316: fprintf(stdout, "lex read char %d, val %d\n", yychar, yylval);
317: #endif
318: }
319: while (ip[1]!=YYNOCHAR) {
320: if (ip[1]==yychar)
321: break;
322: ip += 2;
323: }
324: }
325: act = ip[0];
326: switch( act>>YYACTSH ) {
327: case YYSHIFTACT:
328: if( ip[1]==YYNOCHAR )
329: goto YYerract;
330: if( yychar != -1 )
331: yychar = YYNOCHAR; /* dont throw away EOF */
332: yystate = act&YYAMASK;
333: yyval = yylval;
334: #ifdef YYDEBUG
335: if( yydebug )
336: fprintf(stdout, "shift %d\n", yystate);
337: #endif
338: if( yyerrflag )
339: --yyerrflag;
340: goto stack;
341:
342: case YYACCEPTACT:
343: #ifdef YYDEBUG
344: if( yydebug )
345: fprintf(stdout, "accept\n");
346: #endif
347: return(0);
348:
349: case YYERRACT:
350: YYerract:
351: switch (yyerrflag) {
352: case 0:
353: yyerror("Syntax error");
354:
355: case 1:
356: case 2:
357:
358: yyerrflag = 3;
359: while( yys >= & yystack[0] ) {
360: ip = &yyact[yypa[*yys]];
361: while( ip[1]!=YYNOCHAR )
362: ip += 2;
363: if( (*ip&~YYAMASK) == (YYSHIFTACT<<YYACTSH) ) {
364: yystate = *ip&YYAMASK;
365: goto stack;
366: }
367: #ifdef YYDEBUG
368: if( yydebug )
369: fprintf(stderr, "error recovery leaves state %d, uncovers %d\n", *yys, yys[-1]);
370: #endif
371: yys--;
372: yyv--;
373: }
374: #ifdef YYDEBUG
375: if( yydebug )
376: fprintf(stderr, "no shift on error; abort\n");
377: #endif
378: return(1);
379:
380: case 3:
381: #ifdef YYDEBUG
382: if( yydebug )
383: fprintf(stderr, "Error recovery clobbers char %o\n", yychar);
384: #endif
385: if( yychar==YYEOFVAL )
386: return(1);
387: yychar = YYNOCHAR;
388: goto read;
389: }
390:
391: case YYREDACT:
392: pno = act&YYAMASK;
393: #ifdef YYDEBUG
394: if( yydebug )
395: fprintf(stdout, "reduce %d\n", pno);
396: #endif
397: yypvt = yyv;
398: yyv -= yypn[pno];
399: yys -= yypn[pno];
400: yyval = yyv[1];
401: switch(pno) {
402:
403: case 3: {
404:
405: #line 64 "/usr/src/cmd0/sh/sh.y"
406:
407: sesp->s_node = NULL;
408: reset(RCMD);
409: NOTREACHED;
410: }break;
411:
412: case 4: {
413:
414: #line 70 "/usr/src/cmd0/sh/sh.y"
415:
416: sesp->s_node = yypvt[-1].yu_node;
417: reset(errflag ? RERR : RCMD);
418: NOTREACHED;
419: }break;
420:
421: case 5: {
422:
423: #line 75 "/usr/src/cmd0/sh/sh.y"
424:
425: keyflush();
426: keyflag = 1;
427: reset(RERR);
428: NOTREACHED;
429: }break;
430:
431: case 10: {
432:
433: #line 91 "/usr/src/cmd0/sh/sh.y"
434: yyval.yu_nval = NWHILE; }break;
435:
436: case 11: {
437:
438: #line 92 "/usr/src/cmd0/sh/sh.y"
439: yyval.yu_nval = NUNTIL; }break;
440:
441: case 23: {
442:
443: #line 114 "/usr/src/cmd0/sh/sh.y"
444:
445: yyval.yu_node = yypvt[0].yu_node;
446: }break;
447:
448: case 24: {
449:
450: #line 117 "/usr/src/cmd0/sh/sh.y"
451:
452: yyval.yu_node = node(NBACK, yypvt[-1].yu_node, NULL);
453: }break;
454:
455: case 25: {
456:
457: #line 120 "/usr/src/cmd0/sh/sh.y"
458:
459: yyval.yu_node = yypvt[-1].yu_node;
460: }break;
461:
462: case 26: {
463:
464: #line 123 "/usr/src/cmd0/sh/sh.y"
465:
466: yyval.yu_node = node(NBACK, yypvt[-2].yu_node, yypvt[0].yu_node);
467: }break;
468:
469: case 27: {
470:
471: #line 126 "/usr/src/cmd0/sh/sh.y"
472:
473: yyval.yu_node = node(NLIST, yypvt[-2].yu_node, yypvt[0].yu_node);
474: }break;
475:
476: case 28: {
477:
478: #line 132 "/usr/src/cmd0/sh/sh.y"
479:
480: yyval.yu_node = yypvt[0].yu_node;
481: }break;
482:
483: case 29: {
484:
485: #line 135 "/usr/src/cmd0/sh/sh.y"
486:
487: yyval.yu_node = node(NORF, yypvt[-2].yu_node, yypvt[0].yu_node);
488: }break;
489:
490: case 30: {
491:
492: #line 138 "/usr/src/cmd0/sh/sh.y"
493:
494: yyval.yu_node = node(NANDF, yypvt[-2].yu_node, yypvt[0].yu_node);
495: }break;
496:
497: case 31: {
498:
499: #line 144 "/usr/src/cmd0/sh/sh.y"
500:
501: yyval.yu_node = node(NPIPE, yypvt[-2].yu_node, yypvt[0].yu_node);
502: }break;
503:
504: case 32: {
505:
506: #line 147 "/usr/src/cmd0/sh/sh.y"
507:
508: yyval.yu_node = yypvt[0].yu_node;
509: }break;
510:
511: case 33: {
512:
513: #line 153 "/usr/src/cmd0/sh/sh.y"
514:
515: yyval.yu_node = node(NCOMS, yypvt[0].yu_node, NULL);
516: keypop();
517: }break;
518:
519: case 34: {
520:
521: #line 160 "/usr/src/cmd0/sh/sh.y"
522:
523: keypush();
524: keyflag = 1;
525: }break;
526:
527: case 35: {
528:
529: #line 167 "/usr/src/cmd0/sh/sh.y"
530:
531: if ((yypvt[-1].yu_node->n_type == NCTRL && yypvt[0].yu_node->n_type == NARGS)
532: || (yypvt[-1].yu_node->n_type == NARGS && yypvt[0].yu_node->n_type == NCTRL)) {
533: YYERROR;
534: }
535: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
536: }break;
537:
538: case 36: {
539:
540: #line 174 "/usr/src/cmd0/sh/sh.y"
541:
542: yyval.yu_node = yypvt[0].yu_node;
543: }break;
544:
545: case 37: {
546:
547: #line 180 "/usr/src/cmd0/sh/sh.y"
548:
549: yyval.yu_node = node(NIORS, yypvt[0].yu_strp, NULL);
550: }break;
551:
552: case 38: {
553:
554: #line 183 "/usr/src/cmd0/sh/sh.y"
555:
556: yyval.yu_node = node(NARGS, yypvt[0].yu_strp, NULL);
557: keyflag = 0;
558: }break;
559:
560: case 39: {
561:
562: #line 187 "/usr/src/cmd0/sh/sh.y"
563:
564: yyval.yu_node = node(NASSG, yypvt[0].yu_strp, NULL);
565: }break;
566:
567: case 40: {
568:
569: #line 190 "/usr/src/cmd0/sh/sh.y"
570:
571: if (!keyflag) {
572: YYERROR;
573: }
574: yyval.yu_node = node(NCTRL, yypvt[0].yu_node, NULL);
575: keyflag = 0;
576: }break;
577:
578: case 41: {
579:
580: #line 199 "/usr/src/cmd0/sh/sh.y"
581:
582: yyval.yu_strp = duplstr(strt, 0);
583: }break;
584:
585: case 42: {
586:
587: #line 204 "/usr/src/cmd0/sh/sh.y"
588:
589: yyval.yu_strp = duplstr(strt, 0);
590: }break;
591:
592: case 43: {
593:
594: #line 209 "/usr/src/cmd0/sh/sh.y"
595:
596: yyval.yu_strp = duplstr(strt, 0);
597: }break;
598:
599: case 44: {
600:
601: #line 215 "/usr/src/cmd0/sh/sh.y"
602:
603: yyval.yu_node = node(NFOR, yypvt[-4].yu_strp, node(NFOR2, yypvt[-3].yu_node, node(NLIST, yypvt[-1].yu_node, NULL)));
604: yyval.yu_node->n_next->n_next->n_next = yyval.yu_node->n_next;
605: }break;
606:
607: case 45: {
608:
609: #line 219 "/usr/src/cmd0/sh/sh.y"
610:
611: yyval.yu_node = node(NFOR, yypvt[-3].yu_strp, node(NFOR2, yypvt[-2].yu_node, node(NLIST, yypvt[-1].yu_node, NULL)));
612: yyval.yu_node->n_next->n_next->n_next = yyval.yu_node->n_next;
613: }break;
614:
615: case 46: {
616:
617: #line 223 "/usr/src/cmd0/sh/sh.y"
618:
619: yyval.yu_node = node(NCASE, yypvt[-4].yu_strp, yypvt[-1].yu_node);
620: }break;
621:
622: case 47: {
623:
624: #line 226 "/usr/src/cmd0/sh/sh.y"
625:
626: yyval.yu_node = node(NCASE, yypvt[-3].yu_strp, yypvt[-1].yu_node);
627: }break;
628:
629: case 48: {
630:
631: #line 229 "/usr/src/cmd0/sh/sh.y"
632:
633: yyval.yu_node = node(yypvt[-3].yu_nval, yypvt[-2].yu_node, node(NLIST, yypvt[-1].yu_node, NULL));
634: yyval.yu_node->n_next->n_next = yyval.yu_node;
635: }break;
636:
637: case 49: {
638:
639: #line 233 "/usr/src/cmd0/sh/sh.y"
640:
641: yyval.yu_node = node(NIF, node(NNULL, yypvt[-4].yu_node, yypvt[-2].yu_node), yypvt[-1].yu_node);
642: }break;
643:
644: case 50: {
645:
646: #line 236 "/usr/src/cmd0/sh/sh.y"
647:
648: yyval.yu_node = node(NPARN, yypvt[-1].yu_node, NULL);
649: }break;
650:
651: case 51: {
652:
653: #line 239 "/usr/src/cmd0/sh/sh.y"
654:
655: yyval.yu_node = node(NBRAC, yypvt[-1].yu_node, NULL);
656: }break;
657:
658: case 52: {
659:
660: #line 245 "/usr/src/cmd0/sh/sh.y"
661:
662: yyval.yu_node = yypvt[0].yu_node;
663: }break;
664:
665: case 53: {
666:
667: #line 248 "/usr/src/cmd0/sh/sh.y"
668:
669: yyval.yu_node = node(NARGS, "\"$@\"", NULL);
670: }break;
671:
672: case 54: {
673:
674: #line 254 "/usr/src/cmd0/sh/sh.y"
675:
676: yyval.yu_node = node(NARGS, yypvt[-1].yu_strp, yypvt[0].yu_node);
677: }break;
678:
679: case 55: {
680:
681: #line 257 "/usr/src/cmd0/sh/sh.y"
682:
683: yyval.yu_node = NULL;
684: }break;
685:
686: case 56: {
687:
688: #line 263 "/usr/src/cmd0/sh/sh.y"
689:
690: register NODE *np;
691:
692: for (np=yypvt[-2].yu_node; np->n_next; np=np->n_next)
693: ;
694: np->n_next = yypvt[0].yu_node;
695: yyval.yu_node = yypvt[-2].yu_node;
696: }break;
697:
698: case 57: {
699:
700: #line 271 "/usr/src/cmd0/sh/sh.y"
701:
702: yyval.yu_node = yypvt[0].yu_node;
703: }break;
704:
705: case 58: {
706:
707: #line 274 "/usr/src/cmd0/sh/sh.y"
708:
709: yyval.yu_node = NULL;
710: }break;
711:
712: case 59: {
713:
714: #line 280 "/usr/src/cmd0/sh/sh.y"
715:
716: yyval.yu_node = node(NCASE2, yypvt[0].yu_node, yypvt[-2].yu_node);
717: }break;
718:
719: case 60: {
720:
721: #line 286 "/usr/src/cmd0/sh/sh.y"
722:
723: yyval.yu_node = node(NCASE3, yypvt[-2].yu_strp, yypvt[0].yu_node);
724: }break;
725:
726: case 61: {
727:
728: #line 289 "/usr/src/cmd0/sh/sh.y"
729:
730: yyval.yu_node = node(NCASE3, yypvt[0].yu_strp, NULL);
731: }break;
732:
733: case 62: {
734:
735: #line 295 "/usr/src/cmd0/sh/sh.y"
736:
737: yyval.yu_node = yypvt[0].yu_node;
738: }break;
739:
740: case 63: {
741:
742: #line 298 "/usr/src/cmd0/sh/sh.y"
743:
744: yyval.yu_node = NULL;
745: }break;
746:
747: case 64: {
748:
749: #line 304 "/usr/src/cmd0/sh/sh.y"
750:
751: yyval.yu_node = node(NIF, node(NNULL, yypvt[-3].yu_node, yypvt[-1].yu_node), yypvt[0].yu_node);
752: }break;
753:
754: case 65: {
755:
756: #line 307 "/usr/src/cmd0/sh/sh.y"
757:
758: yyval.yu_node = node(NELSE, yypvt[0].yu_node, NULL);
759: }break;
760:
761: case 66: {
762:
763: #line 310 "/usr/src/cmd0/sh/sh.y"
764:
765: yyval.yu_node = NULL;
766: }break;
767:
768: case 67: {
769:
770: #line 316 "/usr/src/cmd0/sh/sh.y"
771:
772: yyval.yu_node = yypvt[0].yu_node;
773: }break;
774:
775: case 68: {
776:
777: #line 320 "/usr/src/cmd0/sh/sh.y"
778:
779: yyval.yu_node = NULL;
780: }break;
781:
782: case 69: {
783:
784: #line 326 "/usr/src/cmd0/sh/sh.y"
785:
786: yyval.yu_node = node(NLIST, yypvt[-2].yu_node, yypvt[0].yu_node);
787: }break;
788:
789: case 70: {
790:
791: #line 329 "/usr/src/cmd0/sh/sh.y"
792:
793: yyval.yu_node = yypvt[-1].yu_node;
794: }break;
795:
796: }
797: ip = &yygo[ yypgo[yypdnt[pno]] ];
798: while( *ip!=*yys && *ip!=YYNOCHAR )
799: ip += 2;
800: yystate = ip[1];
801: goto stack;
802: }
803: }
804:
805:
806:
807:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.