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