![[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 / b / bin / sh_B4_420|
Return to y.tab.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / sh_B4_420 |
1.1 root 1:
2: #line 8 "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 552 "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: #ifdef YYTNAMES
99: readonly struct yytname yytnames[33] =
100: {
101: "$end", -1,
102: "error", -2,
103: "_ANDF", 256,
104: "_ASGN", 257,
105: "_CASE", 258,
106: "_CBRAC", 259,
107: "_DO", 260,
108: "_DONE", 261,
109: "_DSEMI", 262,
110: "_ELIF", 263,
111: "_ELSE", 264,
112: "_ESAC", 265,
113: "_FI", 266,
114: "_FOR", 267,
115: "_IF", 268,
116: "_IN", 269,
117: "_IORS", 270,
118: "_NAME", 271,
119: "_NULL", 272,
120: "_OBRAC", 273,
121: "_ORF", 274,
122: "_PARENS", 275,
123: "_RET", 276,
124: "_THEN", 277,
125: "_UNTIL", 278,
126: "_WHILE", 279,
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[118] = {
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, 24, 24, 24,
143: 24, 26, 28, 27, 27, 25, 25, 25,
144: 25, 25, 33, 33, 33, 33, 36, 34,
145: 35, 35, 35, 35, 35, 35, 39, 40,
146: 40, 40, 40, 40, 40, 40, 40, 40,
147: 40, 40, 40, 40, 40, 40, 32, 41,
148: 38, 29, 37, 42, 30, 30, 30, 30,
149: 30, 30, 30, 30, 43, 43, 48, 48,
150: 45, 45, 45, 49, 50, 50, 44, 44,
151: 47, 47, 47, 46, 46, 31, 31, 12,
152: 12, 12, 5, 5, 51, 51
153: };
154: readonly unsigned char yypn[118] = {
155: 2, 2, 0, 1, 2, 2, 2, 2,
156: 2, 2, 2, 2, 2, 3, 1, 2,
157: 2, 2, 2, 2, 2, 2, 2, 1,
158: 2, 2, 3, 3, 1, 3, 3, 3,
159: 1, 2, 0, 1, 1, 2, 1, 2,
160: 1, 1, 6, 1, 2, 3, 2, 1,
161: 2, 1, 1, 2, 1, 2, 1, 1,
162: 1, 2, 1, 2, 1, 2, 1, 1,
163: 1, 1, 1, 1, 1, 1, 1, 1,
164: 1, 1, 1, 1, 1, 1, 1, 1,
165: 1, 1, 1, 1, 6, 5, 6, 5,
166: 4, 6, 3, 3, 2, 0, 2, 0,
167: 3, 1, 0, 3, 3, 1, 2, 0,
168: 5, 2, 0, 1, 0, 3, 2, 1,
169: 1, 2, 1, 0, 1, 2
170: };
171: readonly unsigned char yypgo[52] = {
172: 0, 0, 2, 4, 12, 14, 48, 52,
173: 54, 56, 58, 60, 64, 70, 72, 74,
174: 76, 78, 82, 84, 86, 92, 96, 98,
175: 100, 102, 104, 106, 108, 110, 126, 128,
176: 140, 152, 158, 160, 170, 172, 180, 184,
177: 186, 188, 190, 192, 194, 200, 206, 220,
178: 224, 228, 230, 234
179: };
180: readonly unsigned int yygo[246] = {
181: YYOTHERS, 0x1, YYOTHERS, 0x5, 0x1, 0x6, 0xd, 0x31,
182: 0xe, 0x32, YYOTHERS, 0x43, YYOTHERS, 0x20, 0x10, 0x36,
183: 0x13, 0x39, 0x18, 0x3d, 0x1b, 0x3e, 0x1d, 0x40,
184: 0x1e, 0x41, 0x1f, 0x42, 0x43, 0x6d, 0x4b, 0x77,
185: 0x6f, 0x88, 0x71, 0x8b, 0x8a, 0x9e, 0x91, 0xa1,
186: 0x93, 0xa3, 0x99, 0xa7, 0x9a, 0xa8, YYOTHERS, 0x34,
187: 0xa9, 0xad, YYOTHERS, 0x70, YYOTHERS, 0x9b, YYOTHERS, 0x9c,
188: YYOTHERS, 0x21, YYOTHERS, 0x72, 0x69, 0x82, YYOTHERS, 0x68,
189: 0x66, 0x7c, 0x6c, 0x85, YYOTHERS, 0x69, YYOTHERS, 0x11,
190: YYOTHERS, 0x12, YYOTHERS, 0x14, YYOTHERS, 0x22, 0x77, 0x8e,
191: YYOTHERS, 0x23, YYOTHERS, 0x94, YYOTHERS, 0x92, 0x11, 0x37,
192: 0x12, 0x38, YYOTHERS, 0x7, 0x14, 0x3a, YYOTHERS, 0x8,
193: YYOTHERS, 0x9, YYOTHERS, 0xa, YYOTHERS, 0x24, YYOTHERS, 0x25,
194: YYOTHERS, 0x26, YYOTHERS, 0x49, YYOTHERS, 0x27, 0xa, 0x28,
195: 0x16, 0x3b, 0x17, 0x3c, 0x1c, 0x3f, 0x2b, 0x4d,
196: 0x6b, 0x83, 0x83, 0x83, YYOTHERS, 0x7e, YYOTHERS, 0x29,
197: 0x20, 0x44, 0x21, 0x45, 0x6e, 0x87, 0x8e, 0x9f,
198: 0x9b, 0xa9, YYOTHERS, 0x46, 0xa, 0x2a, 0x26, 0x4a,
199: 0x2a, 0x2a, 0x2d, 0x2a, 0x49, 0x76, YYOTHERS, 0x5f,
200: 0x2a, 0x4c, 0x2d, 0x64, YYOTHERS, 0x2b, YYOTHERS, 0x4e,
201: 0x4e, 0x78, 0x5f, 0x79, 0x61, 0x7a, 0x62, 0x7b,
202: YYOTHERS, 0x60, YYOTHERS, 0x2c, 0xa, 0x2d, 0x2a, 0x2d,
203: 0x2d, 0x2d, YYOTHERS, 0x61, 0x2b, 0x4f, YYOTHERS, 0x2e,
204: YYOTHERS, 0x62, YYOTHERS, 0x63, YYOTHERS, 0x2f, YYOTHERS, 0x30,
205: YYOTHERS, 0x6c, 0x6c, 0x86, 0x85, 0x97, YYOTHERS, 0x73,
206: 0x82, 0x95, 0x92, 0xa2, YYOTHERS, 0x7f, 0x23, 0x48,
207: 0x70, 0x89, 0x72, 0x8c, 0x94, 0xa4, 0x9c, 0xaa,
208: 0xad, 0xae, YYOTHERS, 0x47, 0xae, 0xaf, YYOTHERS, 0x9d,
209: 0x83, 0x96, YYOTHERS, 0x84, YYOTHERS, 0x80, 0x8f, 0xa0,
210: YYOTHERS, 0x81, 0x3b, 0x6a, 0x43, 0x6e, 0x66, 0x6a,
211: 0x67, 0x7d, 0x6c, 0x6a, YYOTHERS, 0x35
212: };
213: readonly unsigned short yypa[176] = {
214: 0, 2, 30, 34, 38, 40, 42, 46,
215: 52, 58, 62, 86, 88, 90, 114, 138,
216: 138, 142, 142, 138, 144, 146, 148, 148,
217: 138, 152, 154, 138, 156, 138, 138, 138,
218: 144, 144, 160, 164, 168, 170, 172, 176,
219: 178, 182, 184, 190, 194, 230, 236, 238,
220: 240, 242, 244, 246, 248, 250, 254, 256,
221: 258, 260, 262, 264, 272, 276, 278, 280,
222: 282, 284, 286, 138, 288, 292, 296, 298,
223: 302, 306, 310, 138, 312, 314, 316, 352,
224: 354, 356, 358, 360, 362, 364, 366, 368,
225: 370, 372, 374, 376, 378, 380, 382, 384,
226: 420, 422, 458, 494, 496, 498, 500, 506,
227: 510, 514, 518, 522, 526, 534, 536, 138,
228: 560, 568, 574, 578, 582, 584, 586, 588,
229: 592, 594, 596, 598, 600, 602, 606, 610,
230: 614, 618, 510, 522, 622, 292, 624, 628,
231: 630, 632, 138, 638, 640, 642, 144, 644,
232: 648, 138, 510, 138, 650, 656, 660, 662,
233: 666, 138, 138, 144, 668, 672, 676, 678,
234: 682, 684, 686, 688, 690, 692, 694, 696,
235: 698, 288, 700, 702, 704, 560, 706, 712
236: };
237: readonly unsigned int yyact[714] = {
238: 0x2002, YYOTHERS, 0x2, YYEOFVAL, 0x4, 0xa, 0x2022, 0x101,
239: 0x2022, 0x102, 0x2022, 0x10b, 0x2022, 0x10c, 0x2022, 0x10e,
240: 0x2022, 0x10f, 0x2022, 0x111, 0x2022, 0x114, 0x2022, 0x116,
241: 0x2022, 0x117, 0x2022, 0x28, 0x3, YYOTHERS, 0x4000, YYEOFVAL,
242: 0x6000, YYOTHERS, 0xb, 0xa, 0x6000, YYOTHERS, 0x2003, YYOTHERS,
243: 0x2001, YYOTHERS, 0xc, 0xa, 0x6000, YYOTHERS, 0xd, 0x3b,
244: 0xe, 0x26, 0x2017, YYOTHERS, 0xf, 0x100, 0x10, 0x112,
245: 0x201c, YYOTHERS, 0x13, 0x7c, 0x2020, YYOTHERS, 0x15, 0x101,
246: 0x16, 0x102, 0x17, 0x10b, 0x18, 0x10c, 0x19, 0x10e,
247: 0x1a, 0x10f, 0x1b, 0x111, 0x1c, 0x114, 0x1d, 0x116,
248: 0x1e, 0x117, 0x1f, 0x28, 0x6000, YYOTHERS, 0x2005, YYOTHERS,
249: 0x2004, YYOTHERS, 0x2022, 0x101, 0x2022, 0x102, 0x2022, 0x10b,
250: 0x2022, 0x10c, 0x2022, 0x10e, 0x2022, 0x10f, 0x2022, 0x111,
251: 0x2022, 0x114, 0x2022, 0x116, 0x2022, 0x117, 0x2022, 0x28,
252: 0x2019, YYOTHERS, 0x2022, 0x101, 0x2022, 0x102, 0x2022, 0x10b,
253: 0x2022, 0x10c, 0x2022, 0x10e, 0x2022, 0x10f, 0x2022, 0x111,
254: 0x2022, 0x114, 0x2022, 0x116, 0x2022, 0x117, 0x2022, 0x28,
255: 0x2018, YYOTHERS, 0x33, 0xa, 0x2073, YYOTHERS, 0x2022, YYOTHERS,
256: 0x2022, YYOTHERS, 0x2053, YYOTHERS, 0x1a, 0x10f, 0x6000, YYOTHERS,
257: 0x204f, YYOTHERS, 0x2051, YYOTHERS, 0x1a, 0x10f, 0x2028, YYOTHERS,
258: 0x206c, 0x29, 0x2022, YYOTHERS, 0x206c, 0x103, 0x2022, YYOTHERS,
259: 0x2021, YYOTHERS, 0x2023, YYOTHERS, 0x19, 0x10e, 0x2024, YYOTHERS,
260: 0x2026, YYOTHERS, 0x4b, 0x113, 0x2050, YYOTHERS, 0x2029, YYOTHERS,
261: 0x15, 0x101, 0x19, 0x10e, 0x2032, YYOTHERS, 0x1a, 0x10f,
262: 0x202f, YYOTHERS, 0x15, 0x101, 0x50, 0x102, 0x51, 0x104,
263: 0x52, 0x105, 0x53, 0x107, 0x54, 0x108, 0x55, 0x109,
264: 0x56, 0x10a, 0x57, 0x10b, 0x58, 0x10c, 0x59, 0x10d,
265: 0x19, 0x10e, 0x5a, 0x10f, 0x5b, 0x114, 0x5c, 0x115,
266: 0x5d, 0x116, 0x5e, 0x117, 0x2031, YYOTHERS, 0x15, 0x101,
267: 0x19, 0x10e, 0x2034, YYOTHERS, 0x2036, YYOTHERS, 0x204e, YYOTHERS,
268: 0x2052, YYOTHERS, 0x201b, YYOTHERS, 0x201a, YYOTHERS, 0x2074, YYOTHERS,
269: 0x2011, YYOTHERS, 0x65, 0xa, 0x2072, YYOTHERS, 0x2010, YYOTHERS,
270: 0x201d, YYOTHERS, 0x201e, YYOTHERS, 0x2012, YYOTHERS, 0x201f, YYOTHERS,
271: 0x66, 0x10d, 0x33, 0xa, 0x67, 0x3b, 0x6000, YYOTHERS,
272: 0x6b, 0x10d, 0x205d, YYOTHERS, 0x2006, YYOTHERS, 0x2014, YYOTHERS,
273: 0x2027, YYOTHERS, 0x200b, YYOTHERS, 0x200a, YYOTHERS, 0x2013, YYOTHERS,
274: 0x6f, 0x115, 0x6000, YYOTHERS, 0x71, 0x104, 0x2067, YYOTHERS,
275: 0x206b, YYOTHERS, 0x74, 0x29, 0x6000, YYOTHERS, 0x75, 0x103,
276: 0x6000, YYOTHERS, 0x19, 0x10e, 0x2025, YYOTHERS, 0x202b, YYOTHERS,
277: 0x2033, YYOTHERS, 0x2050, YYOTHERS, 0x15, 0x101, 0x50, 0x102,
278: 0x51, 0x104, 0x52, 0x105, 0x53, 0x107, 0x54, 0x108,
279: 0x55, 0x109, 0x56, 0x10a, 0x57, 0x10b, 0x58, 0x10c,
280: 0x59, 0x10d, 0x19, 0x10e, 0x5a, 0x10f, 0x5b, 0x114,
281: 0x5c, 0x115, 0x5d, 0x116, 0x5e, 0x117, 0x202e, YYOTHERS,
282: 0x2037, YYOTHERS, 0x2040, YYOTHERS, 0x2041, YYOTHERS, 0x2042, YYOTHERS,
283: 0x2043, YYOTHERS, 0x2044, YYOTHERS, 0x2045, YYOTHERS, 0x2046, YYOTHERS,
284: 0x2047, YYOTHERS, 0x2048, YYOTHERS, 0x2049, YYOTHERS, 0x203f, YYOTHERS,
285: 0x204a, YYOTHERS, 0x204b, YYOTHERS, 0x204c, YYOTHERS, 0x204d, YYOTHERS,
286: 0x15, 0x101, 0x50, 0x102, 0x51, 0x104, 0x52, 0x105,
287: 0x53, 0x107, 0x54, 0x108, 0x55, 0x109, 0x56, 0x10a,
288: 0x57, 0x10b, 0x58, 0x10c, 0x59, 0x10d, 0x19, 0x10e,
289: 0x5a, 0x10f, 0x5b, 0x114, 0x5c, 0x115, 0x5d, 0x116,
290: 0x5e, 0x117, 0x2038, YYOTHERS, 0x2030, YYOTHERS, 0x15, 0x101,
291: 0x50, 0x102, 0x51, 0x104, 0x52, 0x105, 0x53, 0x107,
292: 0x54, 0x108, 0x55, 0x109, 0x56, 0x10a, 0x57, 0x10b,
293: 0x58, 0x10c, 0x59, 0x10d, 0x19, 0x10e, 0x5a, 0x10f,
294: 0x5b, 0x114, 0x5c, 0x115, 0x5d, 0x116, 0x5e, 0x117,
295: 0x203c, YYOTHERS, 0x15, 0x101, 0x50, 0x102, 0x51, 0x104,
296: 0x52, 0x105, 0x53, 0x107, 0x54, 0x108, 0x55, 0x109,
297: 0x56, 0x10a, 0x57, 0x10b, 0x58, 0x10c, 0x59, 0x10d,
298: 0x19, 0x10e, 0x5a, 0x10f, 0x5b, 0x114, 0x5c, 0x115,
299: 0x5d, 0x116, 0x5e, 0x117, 0x203a, YYOTHERS, 0x203e, YYOTHERS,
300: 0x2035, YYOTHERS, 0x2075, YYOTHERS, 0x33, 0xa, 0x67, 0x3b,
301: 0x200e, YYOTHERS, 0x33, 0xa, 0x2070, YYOTHERS, 0x1a, 0x10f,
302: 0x2062, YYOTHERS, 0x66, 0x10d, 0x6000, YYOTHERS, 0x65, 0xa,
303: 0x206f, YYOTHERS, 0x1a, 0x10f, 0x205f, YYOTHERS, 0x71, 0x104,
304: 0x33, 0xa, 0x67, 0x3b, 0x2067, YYOTHERS, 0x206e, YYOTHERS,
305: 0x65, 0xa, 0x2072, 0x103, 0x2072, 0x104, 0x2072, 0x105,
306: 0x2072, 0x106, 0x2072, 0x107, 0x2072, 0x108, 0x2072, 0x109,
307: 0x2072, 0x10a, 0x2072, 0x115, 0x2072, 0x29, 0x2022, YYOTHERS,
308: 0x206c, 0x107, 0x206c, 0x108, 0x206c, 0x10a, 0x2022, YYOTHERS,
309: 0x33, 0xa, 0x8a, 0x3b, 0x2073, YYOTHERS, 0x206c, 0x105,
310: 0x2022, YYOTHERS, 0x8d, 0x105, 0x6000, YYOTHERS, 0x205a, YYOTHERS,
311: 0x205b, YYOTHERS, 0x202c, YYOTHERS, 0x1b, 0x111, 0x6000, YYOTHERS,
312: 0x202d, YYOTHERS, 0x2039, YYOTHERS, 0x203d, YYOTHERS, 0x203b, YYOTHERS,
313: 0x200f, YYOTHERS, 0x65, 0xa, 0x2071, YYOTHERS, 0x8f, 0x7c,
314: 0x2065, YYOTHERS, 0x90, 0x109, 0x6000, YYOTHERS, 0x91, 0x106,
315: 0x2061, YYOTHERS, 0x93, 0x29, 0x6000, YYOTHERS, 0x205c, YYOTHERS,
316: 0x98, 0x105, 0x6000, YYOTHERS, 0x206d, YYOTHERS, 0x2007, YYOTHERS,
317: 0x99, 0x107, 0x9a, 0x108, 0x206a, YYOTHERS, 0x200c, YYOTHERS,
318: 0x2066, YYOTHERS, 0x2058, YYOTHERS, 0x1a, 0x10f, 0x6000, YYOTHERS,
319: 0x2057, YYOTHERS, 0x206c, 0x106, 0x206c, 0x109, 0x2022, YYOTHERS,
320: 0xa5, 0x109, 0x6000, YYOTHERS, 0x205e, YYOTHERS, 0xa6, 0x105,
321: 0x6000, YYOTHERS, 0x2055, YYOTHERS, 0x206c, 0x10a, 0x2022, YYOTHERS,
322: 0xab, 0x10a, 0x6000, YYOTHERS, 0x200d, YYOTHERS, 0xac, 0x103,
323: 0x6000, YYOTHERS, 0x2064, YYOTHERS, 0x2016, YYOTHERS, 0x2060, YYOTHERS,
324: 0x2015, YYOTHERS, 0x2063, YYOTHERS, 0x2056, YYOTHERS, 0x2054, YYOTHERS,
325: 0x2008, YYOTHERS, 0x2009, YYOTHERS, 0x2069, YYOTHERS, 0x2059, YYOTHERS,
326: 0x202a, YYOTHERS, 0x99, 0x107, 0x9a, 0x108, 0x206a, YYOTHERS,
327: 0x2068, YYOTHERS
328: };
329: #define YYNOCHAR (-1000)
330: #define yyerrok yyerrflag=0
331: #define yyclearin yylval=YYNOCHAR
332: int yystack[YYMAXDEPTH];
333: YYSTYPE yyvstack[YYMAXDEPTH], *yyv;
334: int yychar;
335:
336: #ifdef YYDEBUG
337: int yydebug = 1; /* No sir, not in the BSS */
338: #include <stdio.h>
339: #endif
340:
341: short yyerrflag;
342: int *yys;
343:
344: yyparse()
345: {
346: register YYSTYPE *yypvt;
347: int act;
348: register unsigned *ip, yystate;
349: int pno;
350: yystate = 0;
351: yychar = YYNOCHAR;
352: yyv = &yyvstack[-1];
353: yys = &yystack[-1];
354:
355: stack:
356: if( ++yys >= &yystack[YYMAXDEPTH] ) {
357: write(2, "Stack overflow\n", 15);
358: exit(1);
359: }
360: *yys = yystate;
361: *++yyv = yyval;
362: #ifdef YYDEBUG
363: if( yydebug )
364: fprintf(stdout, "Stack state %d, char %d\n", yystate, yychar);
365: #endif
366:
367: read:
368: ip = &yyact[yypa[yystate]];
369: if( ip[1] != YYNOCHAR ) {
370: if( yychar == YYNOCHAR ) {
371: yychar = yylex();
372: #ifdef YYDEBUG
373: if( yydebug )
374: fprintf(stdout, "lex read char %d, val %d\n", yychar, yylval);
375: #endif
376: }
377: while (ip[1]!=YYNOCHAR) {
378: if (ip[1]==yychar)
379: break;
380: ip += 2;
381: }
382: }
383: act = ip[0];
384: switch( act>>YYACTSH ) {
385: case YYSHIFTACT:
386: if( ip[1]==YYNOCHAR )
387: goto YYerract;
388: if( yychar != -1 )
389: yychar = YYNOCHAR; /* dont throw away EOF */
390: yystate = act&YYAMASK;
391: yyval = yylval;
392: #ifdef YYDEBUG
393: if( yydebug )
394: fprintf(stdout, "shift %d\n", yystate);
395: #endif
396: if( yyerrflag )
397: --yyerrflag;
398: goto stack;
399:
400: case YYACCEPTACT:
401: #ifdef YYDEBUG
402: if( yydebug )
403: fprintf(stdout, "accept\n");
404: #endif
405: return(0);
406:
407: case YYERRACT:
408: YYerract:
409: switch (yyerrflag) {
410: case 0:
411: yyerror("Syntax error");
412:
413: case 1:
414: case 2:
415:
416: yyerrflag = 3;
417: while( yys >= & yystack[0] ) {
418: ip = &yyact[yypa[*yys]];
419: while( ip[1]!=YYNOCHAR )
420: ip += 2;
421: if( (*ip&~YYAMASK) == (YYSHIFTACT<<YYACTSH) ) {
422: yystate = *ip&YYAMASK;
423: goto stack;
424: }
425: #ifdef YYDEBUG
426: if( yydebug )
427: fprintf(stderr, "error recovery leaves state %d, uncovers %d\n", *yys, yys[-1]);
428: #endif
429: yys--;
430: yyv--;
431: }
432: #ifdef YYDEBUG
433: if( yydebug )
434: fprintf(stderr, "no shift on error; abort\n");
435: #endif
436: return(1);
437:
438: case 3:
439: #ifdef YYDEBUG
440: if( yydebug )
441: fprintf(stderr, "Error recovery clobbers char %o\n", yychar);
442: #endif
443: if( yychar==YYEOFVAL )
444: return(1);
445: yychar = YYNOCHAR;
446: goto read;
447: }
448:
449: case YYREDACT:
450: pno = act&YYAMASK;
451: #ifdef YYDEBUG
452: if( yydebug )
453: fprintf(stdout, "reduce %d\n", pno);
454: #endif
455: yypvt = yyv;
456: yyv -= yypn[pno];
457: yys -= yypn[pno];
458: yyval = yyv[1];
459: switch(pno) {
460:
461: case 3: {
462:
463: #line 71 "sh.y"
464:
465: sesp->s_node = NULL;
466: reset(RCMD);
467: NOTREACHED;
468: }break;
469:
470: case 4: {
471:
472: #line 77 "sh.y"
473:
474: sesp->s_node = yypvt[-1].yu_node;
475: reset(errflag ? RERR : RCMD);
476: NOTREACHED;
477: }break;
478:
479: case 5: {
480:
481: #line 82 "sh.y"
482:
483: keyflush();
484: keyflag = 1;
485: reset(RERR);
486: NOTREACHED;
487: }break;
488:
489: case 10: {
490:
491: #line 98 "sh.y"
492: yyval.yu_nval = NWHILE; }break;
493:
494: case 11: {
495:
496: #line 99 "sh.y"
497: yyval.yu_nval = NUNTIL; }break;
498:
499: case 23: {
500:
501: #line 121 "sh.y"
502:
503: yyval.yu_node = yypvt[0].yu_node;
504: }break;
505:
506: case 24: {
507:
508: #line 124 "sh.y"
509:
510: yyval.yu_node = node(NBACK, yypvt[-1].yu_node, NULL);
511: }break;
512:
513: case 25: {
514:
515: #line 127 "sh.y"
516:
517: yyval.yu_node = yypvt[-1].yu_node;
518: }break;
519:
520: case 26: {
521:
522: #line 130 "sh.y"
523:
524: yyval.yu_node = node(NBACK, yypvt[-2].yu_node, yypvt[0].yu_node);
525: }break;
526:
527: case 27: {
528:
529: #line 133 "sh.y"
530:
531: yyval.yu_node = node(NLIST, yypvt[-2].yu_node, yypvt[0].yu_node);
532: }break;
533:
534: case 28: {
535:
536: #line 139 "sh.y"
537:
538: yyval.yu_node = yypvt[0].yu_node;
539: }break;
540:
541: case 29: {
542:
543: #line 142 "sh.y"
544:
545: yyval.yu_node = node(NORF, yypvt[-2].yu_node, yypvt[0].yu_node);
546: }break;
547:
548: case 30: {
549:
550: #line 145 "sh.y"
551:
552: yyval.yu_node = node(NANDF, yypvt[-2].yu_node, yypvt[0].yu_node);
553: }break;
554:
555: case 31: {
556:
557: #line 151 "sh.y"
558:
559: yyval.yu_node = node(NPIPE, yypvt[-2].yu_node, yypvt[0].yu_node);
560: }break;
561:
562: case 32: {
563:
564: #line 154 "sh.y"
565:
566: yyval.yu_node = yypvt[0].yu_node;
567: }break;
568:
569: case 33: {
570:
571: #line 166 "sh.y"
572:
573: yyval.yu_node = yypvt[0].yu_node;
574: keypop ();
575: }break;
576:
577: case 34: {
578:
579: #line 172 "sh.y"
580:
581: keypush ();
582: keyflag = 1;
583: }break;
584:
585: case 35: {
586:
587: #line 179 "sh.y"
588:
589: yyval.yu_node = node (NCOMS, yypvt[0].yu_node, NULL);
590: }break;
591:
592: case 36: {
593:
594: #line 182 "sh.y"
595:
596: yyval.yu_node = node (NCOMS, yypvt[0].yu_node, NULL);
597: }break;
598:
599: case 37: {
600:
601: #line 185 "sh.y"
602:
603: yyval.yu_node = node (NCOMS, yypvt[-1].yu_node->n_next = yypvt[0].yu_node, NULL);
604: }break;
605:
606: case 38: {
607:
608: #line 188 "sh.y"
609:
610: yyval.yu_node = node (NCOMS, yypvt[0].yu_node, NULL);
611: }break;
612:
613: case 39: {
614:
615: #line 191 "sh.y"
616:
617: yyval.yu_node = node (NRET, yypvt[0].yu_strp, NULL);
618: }break;
619:
620: case 40: {
621:
622: #line 194 "sh.y"
623:
624: yyval.yu_node = node (NRET, "", NULL);
625: }break;
626:
627: case 41: {
628:
629: #line 200 "sh.y"
630:
631: yyval.yu_node = node (NCTRL, yypvt[0].yu_node, NULL);
632: }break;
633:
634: case 42: {
635:
636: #line 206 "sh.y"
637:
638: yyval.yu_node = node (NCTRL, node (NFUNC, yypvt[-5].yu_strp, yypvt[-1].yu_node), NULL);
639: }break;
640:
641: case 43: {
642:
643: #line 212 "sh.y"
644:
645: yyval.yu_node = yypvt[0].yu_node;
646: }break;
647:
648: case 44: {
649:
650: #line 215 "sh.y"
651:
652: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
653: }break;
654:
655: case 45: {
656:
657: #line 221 "sh.y"
658:
659: ((yyval.yu_node = yypvt[-2].yu_node)->n_next = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
660: }break;
661:
662: case 46: {
663:
664: #line 224 "sh.y"
665:
666: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
667: }break;
668:
669: case 47: {
670:
671: #line 227 "sh.y"
672:
673: yyval.yu_node = yypvt[0].yu_node;
674: }break;
675:
676: case 48: {
677:
678: #line 230 "sh.y"
679:
680: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
681: }break;
682:
683: case 49: {
684:
685: #line 233 "sh.y"
686:
687: yyval.yu_node = yypvt[0].yu_node;
688: }break;
689:
690: case 50: {
691:
692: #line 239 "sh.y"
693:
694: yyval.yu_node = yypvt[0].yu_node;
695: }break;
696:
697: case 51: {
698:
699: #line 242 "sh.y"
700:
701: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
702: }break;
703:
704: case 52: {
705:
706: #line 245 "sh.y"
707:
708: yyval.yu_node = yypvt[0].yu_node;
709: }break;
710:
711: case 53: {
712:
713: #line 248 "sh.y"
714:
715: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
716: }break;
717:
718: case 54: {
719:
720: #line 254 "sh.y"
721:
722: yyval.yu_node = yypvt[0].yu_node;
723: keyflag = 0;
724: }break;
725:
726: case 55: {
727:
728: #line 261 "sh.y"
729:
730: yyval.yu_node = yypvt[0].yu_node;
731: keyflag = 0;
732: }break;
733:
734: case 56: {
735:
736: #line 276 "sh.y"
737:
738: yyval.yu_node = yypvt[0].yu_node;
739: }break;
740:
741: case 57: {
742:
743: #line 279 "sh.y"
744:
745: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
746: }break;
747:
748: case 58: {
749:
750: #line 282 "sh.y"
751:
752: yyval.yu_node = yypvt[0].yu_node;
753: }break;
754:
755: case 59: {
756:
757: #line 285 "sh.y"
758:
759: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
760: }break;
761:
762: case 60: {
763:
764: #line 288 "sh.y"
765:
766: yyval.yu_node = yypvt[0].yu_node;
767: }break;
768:
769: case 61: {
770:
771: #line 291 "sh.y"
772:
773: (yyval.yu_node = yypvt[-1].yu_node)->n_next = yypvt[0].yu_node;
774: }break;
775:
776: case 62: {
777:
778: #line 297 "sh.y"
779:
780: yyval.yu_node = node (NARGS, duplstr (strt, 0), NULL);
781: }break;
782:
783: case 78: {
784:
785: #line 388 "sh.y"
786:
787: yyval.yu_node = node (NIORS, yypvt[0].yu_strp, NULL);
788: }break;
789:
790: case 79: {
791:
792: #line 393 "sh.y"
793:
794: yyval.yu_strp = duplstr (strt, 0);
795: }break;
796:
797: case 80: {
798:
799: #line 398 "sh.y"
800:
801: yyval.yu_node = node (NARGS, yypvt[0].yu_strp, NULL);
802: }break;
803:
804: case 81: {
805:
806: #line 403 "sh.y"
807:
808: yyval.yu_strp = duplstr (strt, 0);
809: }break;
810:
811: case 82: {
812:
813: #line 409 "sh.y"
814:
815: yyval.yu_node = node (NASSG, yypvt[0].yu_strp, NULL);
816: }break;
817:
818: case 83: {
819:
820: #line 414 "sh.y"
821:
822: yyval.yu_strp = duplstr (strt, 0);
823: }break;
824:
825: case 84: {
826:
827: #line 420 "sh.y"
828:
829: yyval.yu_node = node(NFOR, yypvt[-4].yu_strp, node(NFOR2, yypvt[-3].yu_node, node(NLIST, yypvt[-1].yu_node, NULL)));
830: yyval.yu_node->n_next->n_next->n_next = yyval.yu_node->n_next;
831: }break;
832:
833: case 85: {
834:
835: #line 424 "sh.y"
836:
837: yyval.yu_node = node(NFOR, yypvt[-3].yu_strp, node(NFOR2, yypvt[-2].yu_node, node(NLIST, yypvt[-1].yu_node, NULL)));
838: yyval.yu_node->n_next->n_next->n_next = yyval.yu_node->n_next;
839: }break;
840:
841: case 86: {
842:
843: #line 428 "sh.y"
844:
845: yyval.yu_node = node(NCASE, yypvt[-4].yu_strp, yypvt[-1].yu_node);
846: }break;
847:
848: case 87: {
849:
850: #line 431 "sh.y"
851:
852: yyval.yu_node = node(NCASE, yypvt[-3].yu_strp, yypvt[-1].yu_node);
853: }break;
854:
855: case 88: {
856:
857: #line 434 "sh.y"
858:
859: yyval.yu_node = node(yypvt[-3].yu_nval, yypvt[-2].yu_node, node(NLIST, yypvt[-1].yu_node, NULL));
860: yyval.yu_node->n_next->n_next = yyval.yu_node;
861: }break;
862:
863: case 89: {
864:
865: #line 438 "sh.y"
866:
867: yyval.yu_node = node(NIF, node(NNULL, yypvt[-4].yu_node, yypvt[-2].yu_node), yypvt[-1].yu_node);
868: }break;
869:
870: case 90: {
871:
872: #line 441 "sh.y"
873:
874: yyval.yu_node = node(NPARN, yypvt[-1].yu_node, NULL);
875: }break;
876:
877: case 91: {
878:
879: #line 444 "sh.y"
880:
881: yyval.yu_node = node(NBRAC, yypvt[-1].yu_node, NULL);
882: }break;
883:
884: case 92: {
885:
886: #line 450 "sh.y"
887:
888: yyval.yu_node = yypvt[0].yu_node;
889: }break;
890:
891: case 93: {
892:
893: #line 453 "sh.y"
894:
895: yyval.yu_node = node(NARGS, "\"$@\"", NULL);
896: }break;
897:
898: case 94: {
899:
900: #line 459 "sh.y"
901:
902: yyval.yu_node = node(NARGS, yypvt[-1].yu_strp, yypvt[0].yu_node);
903: }break;
904:
905: case 95: {
906:
907: #line 462 "sh.y"
908:
909: yyval.yu_node = NULL;
910: }break;
911:
912: case 96: {
913:
914: #line 468 "sh.y"
915:
916: register NODE *np;
917:
918: for (np=yypvt[-2].yu_node; np->n_next; np=np->n_next)
919: ;
920: np->n_next = yypvt[0].yu_node;
921: yyval.yu_node = yypvt[-2].yu_node;
922: }break;
923:
924: case 97: {
925:
926: #line 476 "sh.y"
927:
928: yyval.yu_node = yypvt[0].yu_node;
929: }break;
930:
931: case 98: {
932:
933: #line 479 "sh.y"
934:
935: yyval.yu_node = NULL;
936: }break;
937:
938: case 99: {
939:
940: #line 485 "sh.y"
941:
942: yyval.yu_node = node(NCASE2, yypvt[0].yu_node, yypvt[-2].yu_node);
943: }break;
944:
945: case 100: {
946:
947: #line 491 "sh.y"
948:
949: yyval.yu_node = node(NCASE3, yypvt[-2].yu_strp, yypvt[0].yu_node);
950: }break;
951:
952: case 101: {
953:
954: #line 494 "sh.y"
955:
956: yyval.yu_node = node(NCASE3, yypvt[0].yu_strp, NULL);
957: }break;
958:
959: case 102: {
960:
961: #line 500 "sh.y"
962:
963: yyval.yu_node = yypvt[0].yu_node;
964: }break;
965:
966: case 103: {
967:
968: #line 503 "sh.y"
969:
970: yyval.yu_node = NULL;
971: }break;
972:
973: case 104: {
974:
975: #line 509 "sh.y"
976:
977: yyval.yu_node = node(NIF, node(NNULL, yypvt[-3].yu_node, yypvt[-1].yu_node), yypvt[0].yu_node);
978: }break;
979:
980: case 105: {
981:
982: #line 512 "sh.y"
983:
984: yyval.yu_node = node(NELSE, yypvt[0].yu_node, NULL);
985: }break;
986:
987: case 106: {
988:
989: #line 515 "sh.y"
990:
991: yyval.yu_node = NULL;
992: }break;
993:
994: case 107: {
995:
996: #line 521 "sh.y"
997:
998: yyval.yu_node = yypvt[0].yu_node;
999: }break;
1000:
1001: case 108: {
1002:
1003: #line 525 "sh.y"
1004:
1005: yyval.yu_node = NULL;
1006: }break;
1007:
1008: case 109: {
1009:
1010: #line 531 "sh.y"
1011:
1012: yyval.yu_node = node(NLIST, yypvt[-2].yu_node, yypvt[0].yu_node);
1013: }break;
1014:
1015: case 110: {
1016:
1017: #line 534 "sh.y"
1018:
1019: yyval.yu_node = yypvt[-1].yu_node;
1020: }break;
1021:
1022: }
1023: ip = &yygo[ yypgo[yypdnt[pno]] ];
1024: while( *ip!=*yys && *ip!=YYNOCHAR )
1025: ip += 2;
1026: yystate = ip[1];
1027: goto stack;
1028: }
1029: }
1030:
1031:
1032:
1033:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.