![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gram.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / sf77|
Return to gram.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / sf77 |
1.1 root 1: # define SEOS 1
2: # define SCOMMENT 2
3: # define SLABEL 3
4: # define SUNKNOWN 4
5: # define SHOLLERITH 5
6: # define SICON 6
7: # define SRCON 7
8: # define SDCON 8
9: # define SBITCON 9
10: # define SOCTCON 10
11: # define SHEXCON 11
12: # define STRUE 12
13: # define SFALSE 13
14: # define SNAME 14
15: # define SNAMEEQ 15
16: # define SFIELD 16
17: # define SSCALE 17
18: # define SINCLUDE 18
19: # define SLET 19
20: # define SASSIGN 20
21: # define SAUTOMATIC 21
22: # define SBACKSPACE 22
23: # define SBLOCK 23
24: # define SCALL 24
25: # define SCHARACTER 25
26: # define SCLOSE 26
27: # define SCOMMON 27
28: # define SCOMPLEX 28
29: # define SCONTINUE 29
30: # define SDATA 30
31: # define SDCOMPLEX 31
32: # define SDIMENSION 32
33: # define SDO 33
34: # define SDOUBLE 34
35: # define SELSE 35
36: # define SELSEIF 36
37: # define SEND 37
38: # define SENDFILE 38
39: # define SENDIF 39
40: # define SENTRY 40
41: # define SEQUIV 41
42: # define SEXTERNAL 42
43: # define SFORMAT 43
44: # define SFUNCTION 44
45: # define SGOTO 45
46: # define SASGOTO 46
47: # define SCOMPGOTO 47
48: # define SARITHIF 48
49: # define SLOGIF 49
50: # define SIMPLICIT 50
51: # define SINQUIRE 51
52: # define SINTEGER 52
53: # define SINTRINSIC 53
54: # define SLOGICAL 54
55: # define SNAMELIST 55
56: # define SOPEN 56
57: # define SPARAM 57
58: # define SPAUSE 58
59: # define SPRINT 59
60: # define SPROGRAM 60
61: # define SPUNCH 61
62: # define SREAD 62
63: # define SREAL 63
64: # define SRETURN 64
65: # define SREWIND 65
66: # define SSAVE 66
67: # define SSTATIC 67
68: # define SSTOP 68
69: # define SSUBROUTINE 69
70: # define STHEN 70
71: # define STO 71
72: # define SUNDEFINED 72
73: # define SWRITE 73
74: # define SLPAR 74
75: # define SRPAR 75
76: # define SEQUALS 76
77: # define SCOLON 77
78: # define SCOMMA 78
79: # define SCURRENCY 79
80: # define SPLUS 80
81: # define SMINUS 81
82: # define SSTAR 82
83: # define SSLASH 83
84: # define SPOWER 84
85: # define SCONCAT 85
86: # define SAND 86
87: # define SOR 87
88: # define SNEQV 88
89: # define SEQV 89
90: # define SNOT 90
91: # define SEQ 91
92: # define SLT 92
93: # define SGT 93
94: # define SLE 94
95: # define SGE 95
96: # define SNE 96
97:
98: # line 98 "gram.in"
99: # include "defs"
100:
101: #ifdef SDB
102: # include <a.out.h>
103: char *stabline();
104: # ifdef UCBVAXASM
105: char *stabdline();
106: # endif
107:
108: # ifndef N_SO
109: # include <stab.h>
110: # endif
111: #endif
112:
113: static int nstars;
114: static int ndim;
115: static int vartype;
116: static ftnint varleng;
117: static struct { expptr lb, ub; } dims[MAXDIM+1];
118: static struct Labelblock *labarray[MAXLABLIST];
119: static int lastwasbranch = NO;
120: static int thiswasbranch = NO;
121: extern ftnint yystno;
122: extern flag intonly;
123:
124: ftnint convci();
125: double convcd();
126: Addrp nextdata();
127: expptr mklogcon(), mkaddcon(), mkrealcon(), mkstrcon(), mkbitcon();
128: expptr mkcxcon();
129: struct Listblock *mklist();
130: struct Listblock *mklist();
131: struct Impldoblock *mkiodo();
132: struct Extsym *comblock();
133:
134:
135: # line 137 "gram.in"
136: typedef union {
137: int ival;
138: char *charpval;
139: chainp chval;
140: tagptr tagval;
141: expptr expval;
142: struct Labelblock *labval;
143: struct Nameblock *namval;
144: struct Eqvchain *eqvval;
145: struct Extsym *extval;
146: } YYSTYPE;
147: #define yyclearin yychar = -1
148: #define yyerrok yyerrflag = 0
149: extern int yychar;
150: extern short yyerrflag;
151: #ifndef YYMAXDEPTH
152: #define YYMAXDEPTH 150
153: #endif
154: YYSTYPE yylval, yyval;
155: # define YYERRCODE 256
156: short yyexca[] ={
157: -1, 1,
158: 0, -1,
159: -2, 0,
160: -1, 20,
161: 1, 31,
162: -2, 214,
163: -1, 24,
164: 1, 35,
165: -2, 214,
166: -1, 148,
167: 1, 230,
168: -2, 178,
169: -1, 168,
170: 1, 251,
171: 78, 251,
172: -2, 178,
173: -1, 218,
174: 77, 164,
175: -2, 130,
176: -1, 240,
177: 74, 214,
178: -2, 211,
179: -1, 266,
180: 1, 272,
181: -2, 134,
182: -1, 270,
183: 1, 281,
184: 78, 281,
185: -2, 136,
186: -1, 315,
187: 77, 165,
188: -2, 132,
189: -1, 345,
190: 1, 253,
191: 14, 253,
192: 74, 253,
193: 78, 253,
194: -2, 179,
195: -1, 407,
196: 91, 0,
197: 92, 0,
198: 93, 0,
199: 94, 0,
200: 95, 0,
201: 96, 0,
202: -2, 144,
203: -1, 424,
204: 1, 275,
205: 78, 275,
206: -2, 134,
207: -1, 426,
208: 1, 277,
209: 78, 277,
210: -2, 134,
211: -1, 428,
212: 1, 279,
213: 78, 279,
214: -2, 134,
215: -1, 479,
216: 78, 275,
217: -2, 134,
218: };
219: # define YYNPROD 286
220: # define YYLAST 1293
221: short yyact[]={
222:
223: 232, 269, 446, 229, 386, 393, 445, 444, 385, 438,
224: 267, 437, 343, 261, 196, 344, 313, 285, 126, 224,
225: 98, 217, 456, 247, 184, 114, 304, 268, 5, 265,
226: 17, 199, 192, 116, 288, 194, 323, 177, 178, 206,
227: 118, 104, 117, 255, 119, 109, 302, 300, 231, 162,
228: 163, 321, 322, 323, 329, 188, 102, 100, 112, 486,
229: 330, 332, 331, 334, 333, 335, 162, 163, 321, 322,
230: 323, 259, 102, 93, 127, 155, 443, 155, 321, 322,
231: 323, 442, 128, 129, 130, 131, 135, 133, 94, 95,
232: 96, 461, 484, 489, 511, 162, 163, 321, 322, 323,
233: 329, 328, 327, 326, 325, 101, 330, 332, 331, 334,
234: 333, 335, 102, 398, 115, 162, 163, 321, 322, 323,
235: 329, 328, 327, 153, 287, 153, 330, 332, 331, 334,
236: 333, 335, 179, 283, 180, 181, 97, 510, 187, 421,
237: 287, 225, 235, 235, 162, 163, 253, 254, 255, 256,
238: 497, 459, 155, 417, 460, 252, 155, 234, 236, 238,
239: 435, 495, 210, 436, 213, 215, 155, 208, 214, 102,
240: 99, 182, 263, 227, 270, 270, 260, 155, 99, 462,
241: 101, 101, 101, 101, 209, 183, 253, 254, 255, 432,
242: 186, 295, 189, 190, 191, 418, 294, 431, 417, 202,
243: 153, 272, 430, 358, 153, 279, 280, 423, 290, 307,
244: 308, 414, 399, 297, 153, 189, 211, 212, 311, 383,
245: 315, 281, 306, 317, 291, 153, 320, 364, 282, 301,
246: 337, 240, 299, 242, 339, 340, 320, 363, 118, 341,
247: 117, 362, 336, 390, 252, 378, 391, 155, 379, 264,
248: 273, 203, 349, 155, 155, 155, 155, 155, 252, 252,
249: 372, 342, 346, 373, 318, 347, 310, 319, 171, 101,
250: 320, 110, 286, 337, 108, 270, 107, 106, 252, 357,
251: 105, 4, 366, 103, 162, 163, 253, 254, 255, 256,
252: 115, 218, 305, 489, 392, 153, 216, 189, 502, 367,
253: 501, 153, 153, 153, 153, 153, 370, 374, 320, 320,
254: 382, 337, 320, 500, 395, 496, 320, 371, 320, 499,
255: 245, 225, 403, 404, 405, 406, 407, 408, 409, 410,
256: 411, 412, 359, 494, 488, 360, 361, 468, 320, 402,
257: 320, 320, 320, 397, 266, 266, 377, 470, 155, 252,
258: 320, 416, 316, 252, 252, 252, 252, 252, 162, 163,
259: 253, 254, 255, 256, 289, 185, 270, 270, 270, 298,
260: 241, 419, 422, 425, 427, 429, 237, 189, 439, 221,
261: 147, 218, 447, 193, 207, 448, 205, 389, 154, 102,
262: 433, 434, 102, 165, 464, 148, 153, 168, 457, 139,
263: 235, 472, 338, 400, 320, 320, 320, 320, 320, 320,
264: 320, 320, 320, 320, 467, 471, 465, 473, 463, 469,
265: 102, 252, 387, 204, 274, 275, 276, 239, 30, 475,
266: 451, 230, 220, 476, 270, 270, 270, 422, 439, 477,
267: 320, 425, 427, 429, 447, 365, 478, 448, 483, 263,
268: 487, 485, 198, 480, 481, 482, 164, 166, 170, 91,
269: 286, 121, 6, 244, 80, 320, 491, 79, 450, 490,
270: 458, 78, 235, 320, 493, 77, 134, 167, 305, 498,
271: 466, 76, 75, 338, 74, 59, 504, 447, 48, 506,
272: 448, 508, 451, 505, 503, 47, 451, 44, 32, 320,
273: 162, 163, 253, 254, 255, 320, 152, 111, 152, 320,
274: 458, 509, 512, 320, 201, 345, 384, 458, 458, 458,
275: 162, 163, 253, 254, 255, 256, 200, 513, 368, 369,
276: 450, 376, 375, 381, 450, 451, 424, 426, 428, 380,
277: 243, 197, 132, 303, 257, 113, 26, 25, 24, 492,
278: 23, 22, 21, 9, 258, 162, 163, 321, 322, 323,
279: 329, 328, 8, 7, 197, 277, 330, 332, 331, 334,
280: 333, 335, 2, 450, 162, 163, 321, 322, 323, 329,
281: 292, 20, 449, 152, 50, 507, 284, 152, 474, 223,
282: 314, 312, 158, 159, 160, 161, 388, 152, 262, 156,
283: 157, 102, 296, 195, 479, 426, 428, 90, 152, 250,
284: 52, 324, 19, 54, 158, 159, 160, 161, 455, 454,
285: 453, 156, 157, 102, 36, 293, 338, 219, 3, 1,
286: 197, 0, 0, 0, 0, 348, 0, 0, 0, 0,
287: 0, 352, 353, 354, 355, 356, 415, 0, 0, 0,
288: 0, 162, 163, 321, 322, 323, 329, 328, 327, 326,
289: 325, 0, 330, 332, 331, 334, 333, 335, 0, 0,
290: 0, 0, 0, 0, 0, 0, 0, 0, 152, 0,
291: 0, 0, 0, 452, 152, 152, 152, 152, 152, 162,
292: 163, 0, 262, 413, 0, 262, 262, 0, 162, 163,
293: 321, 322, 323, 329, 328, 327, 326, 325, 0, 330,
294: 332, 331, 334, 333, 335, 0, 0, 0, 0, 0,
295: 0, 0, 0, 0, 0, 0, 0, 197, 0, 0,
296: 0, 0, 401, 0, 0, 0, 420, 162, 163, 321,
297: 322, 323, 329, 328, 327, 326, 325, 0, 330, 332,
298: 331, 334, 333, 335, 394, 0, 0, 0, 0, 162,
299: 163, 321, 322, 323, 329, 328, 327, 326, 325, 0,
300: 330, 332, 331, 334, 333, 335, 0, 0, 0, 152,
301: 162, 163, 321, 322, 323, 329, 328, 327, 326, 325,
302: 262, 330, 332, 331, 334, 333, 335, 72, 0, 0,
303: 0, 69, 0, 0, 65, 0, 0, 67, 71, 0,
304: 66, 441, 0, 0, 0, 197, 0, 0, 0, 0,
305: 0, 0, 0, 0, 0, 0, 0, 0, 63, 0,
306: 68, 0, 0, 0, 0, 0, 0, 0, 0, 64,
307: 0, 0, 12, 73, 158, 159, 160, 161, 70, 0,
308: 0, 156, 157, 102, 0, 262, 10, 55, 45, 72,
309: 84, 14, 60, 69, 89, 37, 65, 46, 41, 67,
310: 71, 31, 66, 34, 33, 11, 86, 35, 18, 40,
311: 38, 28, 16, 56, 57, 58, 49, 53, 42, 87,
312: 63, 39, 68, 43, 88, 29, 61, 83, 13, 0,
313: 81, 64, 51, 85, 27, 73, 62, 15, 92, 0,
314: 70, 82, 0, 228, 0, 0, 0, 0, 0, 162,
315: 163, 350, 0, 351, 158, 159, 160, 161, 0, 233,
316: 0, 156, 157, 102, 0, 0, 0, 0, 0, 0,
317: 120, 0, 123, 124, 125, 0, 0, 0, 0, 0,
318: 0, 0, 0, 0, 136, 137, 0, 0, 138, 0,
319: 140, 141, 142, 0, 0, 143, 144, 145, 0, 146,
320: 158, 159, 160, 161, 0, 0, 0, 156, 157, 102,
321: 0, 0, 0, 0, 0, 0, 0, 0, 172, 173,
322: 174, 175, 176, 228, 222, 158, 159, 160, 161, 162,
323: 163, 226, 156, 157, 102, 0, 0, 0, 0, 233,
324: 158, 159, 160, 161, 0, 0, 0, 156, 157, 102,
325: 0, 158, 159, 160, 161, 0, 0, 0, 156, 157,
326: 102, 0, 0, 158, 159, 160, 161, 0, 0, 228,
327: 156, 157, 102, 0, 0, 162, 163, 440, 0, 0,
328: 158, 159, 160, 161, 0, 233, 0, 156, 157, 102,
329: 0, 0, 0, 0, 228, 0, 0, 0, 0, 0,
330: 162, 163, 226, 0, 158, 159, 160, 161, 0, 228,
331: 233, 156, 157, 102, 251, 162, 163, 396, 0, 0,
332: 228, 158, 159, 160, 161, 233, 162, 163, 156, 157,
333: 102, 0, 271, 0, 0, 0, 233, 0, 162, 163,
334: 0, 0, 0, 0, 0, 0, 0, 0, 233, 309,
335: 158, 159, 160, 161, 0, 162, 163, 156, 157, 102,
336: 0, 0, 0, 0, 0, 233, 0, 158, 159, 160,
337: 161, 0, 0, 246, 156, 157, 102, 0, 0, 162,
338: 163, 248, 0, 249, 55, 45, 0, 84, 0, 60,
339: 151, 89, 0, 0, 46, 0, 162, 163, 149, 0,
340: 150, 0, 0, 86, 0, 0, 0, 0, 0, 0,
341: 56, 57, 58, 49, 0, 0, 87, 0, 0, 246,
342: 0, 88, 0, 61, 83, 162, 163, 81, 0, 51,
343: 85, 0, 0, 62, 0, 122, 246, 0, 82, 0,
344: 0, 0, 162, 163, 278, 158, 159, 160, 161, 0,
345: 0, 0, 156, 157, 102, 0, 0, 0, 0, 0,
346: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
347: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
348: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
349: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
350: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
351: 0, 0, 0, 0, 151, 0, 0, 0, 0, 0,
352: 162, 163, 169 };
353: short yypact[]={
354:
355: -1000, 25, 461, 838,-1000,-1000,-1000,-1000,-1000,-1000,
356: 454,-1000,-1000,-1000,-1000,-1000,-1000, 92, 406, 205,
357: 202, 199, 198, 196, 100, 193, -25, 155,-1000,-1000,
358: -1000,-1000,1135,-1000,-1000,-1000, -8,-1000,-1000,-1000,
359: -1000,-1000,-1000,-1000, 406,-1000,-1000,-1000,-1000,-1000,
360: 325,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
361: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
362: -1000,-1000,-1000,-1000,1086, 319,1210, 319, 190,-1000,
363: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
364: -1000,-1000,-1000, 406, 406, 406, 406,-1000, 406,-1000,
365: 291,-1000,-1000, 406, -43, 406, 406, 406, 309, 378,
366: -1000,-1000, 406, 173,-1000,-1000,-1000,-1000, 409, 312,
367: -1000,-1000,-1000, 310,-1000,-1000,-1000,-1000, 155, 406,
368: 406, 309, 378,-1000, 220, 307, 426,-1000, 305, 919,
369: 1016,1016, 302, 421, 406, 296, 406,-1000,-1000,-1000,
370: -1000,1069,-1000,-1000, 278,1115,-1000,-1000,-1000,-1000,
371: -1000,-1000,-1000,-1000,-1000,1069, 98, 171,-1000,-1000,
372: 1028,1028,-1000,-1000,-1000,-1000,1132,-1000,-1000,-1000,
373: 291, 291, 406,-1000,-1000, 58, 290, 100,-1000, 290,
374: -1000,-1000,-1000, 406,-1000, 113,-1000,-1000, 378,-1000,
375: 295, 776, -36, 155, -37, 406, 421,1016,1045,-1000,
376: 406,-1000,-1000,-1000,-1000,-1000,1016,-1000,1016, 281,
377: -1000,1016,-1000, 189,-1000, 700, 421,-1000,1016,-1000,
378: -1000,-1000,1016,1016,-1000, 700,-1000,1016,-1000,-1000,
379: 100, 421,-1000, 440, 187,-1000,1115,-1000,-1000,-1000,
380: 839,-1000,1115,1115,1115,1115,1115, -41, 204, 125,
381: 375,-1000,-1000, 375, 375,-1000, 163, 159, 149, 700,
382: -1000,1028,-1000,-1000,-1000,-1000,-1000, 278,-1000,-1000,
383: -1000, 291, 290,-1000, 185,-1000,-1000,-1000, -8,-1000,
384: 406,-1000, 170,-1000,-1000, 378, 141,-1000, 408,-1000,
385: 406,-1000,-1000, 168,-1000, 218,-1000, 679, 700,1005,
386: -1000, 700, 268, 36, 134, 700, 406, 657,-1000, 990,
387: 1016,1016,1016,1016,1016,1016,1016,1016,1016,1016,
388: -1000,-1000,-1000,-1000,-1000,-1000,-1000, 618, 133, -48,
389: -31, 571, 277, 120,-1000,-1000,-1000,1069, 64, 700,
390: -1000,-1000, 104, -41, -41, -41, 420,-1000, 375, 125,
391: 129, 125,1028,1028,1028, 124, 119, 111,-1000,-1000,
392: -1000, -8,-1000, 42,-1000, 85, 965,-1000,-1000, 406,
393: -2, 609,-1000, 378, 76,-1000, 10,-1000, 101,-1000,
394: -1000, 406,1016, 406, 344,-1000, 262, 273,1016,1016,
395: -1000, 421,-1000, -4, -48, -48, -48, 494, 35, 35,
396: 475, -31, -14,-1000,1016,-1000, 421, 421, 100,-1000,
397: 278,-1000,-1000, 375,-1000,-1000,-1000,-1000,-1000,-1000,
398: 1028,1028,1028,-1000,-1000,-1000, 965,-1000,-1000, 15,
399: -1000,-1000,-1000, 609,-1000,-1000, -23, 587,-1000,-1000,
400: -1000,-1000,1016,-1000,-1000,-1000, 259,-1000, 217,-1000,
401: 408, 408, 406,-1000, 700,-1000, 17,-1000,-1000,-1000,
402: 1016, 258, 700, 83, 240, 75,-1000,1016, 244, 240,
403: 238, 225, 223,-1000, 965,-1000, 609,-1000,-1000,1016,
404: -1000,-1000,-1000,-1000,-1000, 421,-1000,-1000, 700,-1000,
405: -1000,-1000,-1000,-1000, 700,-1000,-1000, 59, 700, 16,
406: 1016, 421, 700,-1000 };
407: short yypgo[]={
408:
409: 0, 629, 628, 15, 627, 10, 13, 18, 30, 624,
410: 613, 612, 4, 0, 611, 610, 609, 607, 14, 603,
411: 602, 596, 591, 590, 22, 589, 24, 586, 585, 71,
412: 29, 27, 21, 86, 17, 584, 55, 431, 1, 173,
413: 16, 388, 320, 9, 2, 6, 19, 3, 48, 582,
414: 581, 33, 38, 37, 580, 572, 563, 562, 553, 908,
415: 73, 552, 551, 550, 548, 547, 546, 545, 44, 543,
416: 20, 34, 39, 5, 32, 542, 35, 539, 533, 7,
417: 25, 26, 532, 531, 11, 12, 31, 526, 516, 514,
418: 8, 507, 428, 498, 497, 495, 488, 485, 484, 380,
419: 482, 481, 477, 475, 471, 467, 250, 464, 463, 23 };
420: short yyr1[]={
421:
422: 0, 1, 1, 55, 55, 55, 55, 55, 55, 55,
423: 2, 56, 56, 56, 56, 56, 56, 60, 52, 33,
424: 53, 53, 26, 26, 26, 27, 27, 34, 34, 17,
425: 57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
426: 57, 57, 11, 11, 8, 9, 10, 10, 10, 10,
427: 10, 10, 10, 10, 10, 10, 10, 7, 7, 7,
428: 50, 50, 50, 50, 51, 51, 61, 61, 62, 62,
429: 63, 63, 74, 54, 54, 64, 64, 75, 76, 78,
430: 77, 77, 79, 79, 45, 45, 45, 45, 67, 67,
431: 80, 80, 69, 69, 81, 36, 18, 18, 19, 19,
432: 20, 20, 71, 71, 83, 82, 82, 84, 84, 43,
433: 43, 85, 85, 3, 65, 65, 86, 89, 87, 88,
434: 88, 90, 90, 12, 66, 66, 91, 21, 21, 68,
435: 22, 22, 23, 23, 38, 38, 38, 39, 39, 39,
436: 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
437: 39, 13, 13, 14, 14, 14, 14, 14, 14, 37,
438: 37, 37, 37, 32, 40, 40, 44, 44, 48, 48,
439: 48, 48, 48, 48, 47, 49, 49, 49, 41, 41,
440: 42, 42, 42, 42, 42, 42, 42, 42, 58, 58,
441: 58, 58, 58, 58, 58, 93, 24, 92, 92, 92,
442: 92, 92, 92, 92, 92, 92, 92, 92, 4, 94,
443: 95, 95, 95, 95, 70, 70, 35, 25, 25, 46,
444: 46, 15, 15, 28, 28, 59, 72, 73, 96, 97,
445: 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
446: 97, 97, 97, 98, 105, 105, 105, 100, 107, 107,
447: 107, 102, 102, 99, 99, 108, 108, 109, 109, 109,
448: 109, 109, 109, 16, 101, 103, 104, 104, 29, 29,
449: 6, 6, 30, 30, 30, 31, 31, 31, 31, 31,
450: 31, 5, 5, 5, 5, 106 };
451: short yyr2[]={
452:
453: 0, 0, 3, 2, 2, 2, 3, 3, 2, 1,
454: 1, 3, 3, 4, 4, 5, 3, 0, 1, 1,
455: 0, 1, 0, 2, 3, 1, 3, 1, 1, 1,
456: 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
457: 1, 5, 6, 5, 2, 1, 1, 1, 1, 1,
458: 1, 1, 1, 1, 1, 1, 1, 0, 4, 6,
459: 3, 4, 5, 3, 1, 3, 3, 3, 3, 3,
460: 3, 3, 3, 1, 3, 3, 3, 0, 4, 0,
461: 2, 3, 1, 3, 1, 2, 1, 1, 1, 3,
462: 1, 1, 1, 3, 3, 2, 1, 5, 1, 3,
463: 1, 3, 0, 3, 0, 2, 3, 1, 3, 1,
464: 1, 1, 3, 1, 3, 3, 4, 0, 2, 1,
465: 3, 1, 3, 1, 1, 2, 4, 1, 3, 0,
466: 0, 1, 1, 3, 1, 3, 1, 1, 1, 3,
467: 3, 3, 3, 2, 3, 3, 3, 3, 3, 2,
468: 3, 1, 1, 1, 1, 1, 1, 1, 1, 1,
469: 2, 4, 5, 5, 0, 1, 1, 1, 1, 1,
470: 1, 1, 1, 1, 5, 1, 1, 1, 1, 3,
471: 1, 1, 3, 3, 3, 3, 2, 3, 1, 6,
472: 2, 2, 6, 2, 2, 5, 3, 4, 5, 2,
473: 1, 1, 10, 1, 3, 4, 3, 3, 1, 1,
474: 3, 3, 7, 7, 0, 1, 3, 1, 3, 1,
475: 2, 1, 1, 1, 3, 0, 0, 0, 1, 2,
476: 2, 2, 2, 2, 2, 2, 3, 4, 4, 2,
477: 3, 1, 3, 3, 1, 1, 1, 3, 1, 1,
478: 1, 1, 1, 3, 3, 1, 3, 1, 1, 1,
479: 2, 2, 2, 1, 3, 3, 4, 4, 1, 3,
480: 1, 5, 1, 1, 1, 3, 3, 3, 3, 3,
481: 3, 1, 5, 5, 5, 0 };
482: short yychk[]={
483:
484: -1000, -1, -55, -2, 256, 3, 1, -56, -57, -58,
485: 18, 37, 4, 60, 23, 69, 44, -8, 40, -11,
486: -50, -61, -62, -63, -64, -65, -66, 66, 43, 57,
487: -92, 33, -93, 36, 35, 39, -9, 27, 42, 53,
488: 41, 30, 50, 55, -94, 20, 29, -95, -96, 48,
489: -35, 64, -15, 49, -10, 19, 45, 46, 47, -97,
490: 24, 58, 68, 52, 63, 28, 34, 31, 54, 25,
491: 72, 32, 21, 67, -98,-100,-101,-103,-104,-105,
492: -107, 62, 73, 59, 22, 65, 38, 51, 56, 26,
493: -17, 5, -59, -60, -60, -60, -60, 44, -70, 78,
494: -52, -33, 14, 78, -70, 78, 78, 78, 78, -70,
495: 78, -91, 83, -67, -80, -33, -51, 85, 83, -68,
496: -59, -92, 70, -59, -59, -59, -7, 82, -68, -68,
497: -68, -68, -75, -68, -37, -33, -59, -59, -59, 74,
498: -59, -59, -59, -59, -59, -59, -59, -99, -42, 82,
499: 84, 74, -37, -48, -41, -13, 12, 13, 5, 6,
500: 7, 8, 80, 81, -99, 74, -99,-102, -42, 82,
501: -99, 78, -59, -59, -59, -59, -59, -53, -52, -53,
502: -52, -52, -60, -33, -26, 74, -33, -51, -36, -33,
503: -33, -33, -74, 74, -76, -19, -18, -37, 74, -86,
504: -87, -89, -33, 78, 14, 74, -72, 74, -72, -36,
505: -51, -33, -33, -74, -76, -86, 76, -32, 74, -4,
506: 6, 74, 75, -25, -46, -38, 82, -39, 74, -47,
507: -37, -48, -13, 90, -40, -38, -40, 74, -3, 6,
508: -33, 74, -33, -41,-108, -42, 74,-109, 82, 84,
509: -16, 15, -13, 82, 83, 84, 85, -41, -41, -29,
510: 78, -6, -37, 74, 78, -30, -39, -5, -31, -38,
511: -47, 74, -30,-106,-106,-106,-106, -41, 82, -26,
512: -26, -52, -68, 75, -27, -34, -33, 82, -71, 74,
513: -70, -71, -54, -37, 83, 78, -20, -18, 74, -8,
514: 83, -80, 83, -69, -81, -33, -3, -38, -38, 74,
515: -36, -38, -22, -40, -23, -38, 71, -38, 75, 78,
516: -13, 82, 83, 84, -14, 89, 88, 87, 86, 85,
517: 91, 93, 92, 95, 94, 96, -3, -38, -39, -38,
518: -38, -38, -70, -85, -3, 75, 75, 78, -41, -38,
519: 82, 84, -41, -41, -41, -41, -41, 75, 78, -29,
520: -29, -29, 78, 78, 78, -39, -5, -31,-106,-106,
521: -26, -71, 75, 78, -7, -82, -83, -36, 75, 78,
522: -77, -78, -18, 78, -88, -90, -12, 14, -21, -33,
523: 75, 78, 76, -73, 75, -73, 82, 75, 77, 78,
524: -33, 75, -46, -38, -38, -38, -38, -38, -38, -38,
525: -38, -38, -38, 75, 78, 75, 74, 78, 75,-109,
526: -41, 75, -6, 78, -39, -5, -39, -5, -39, -5,
527: 78, 78, 78, -7, -34, 75, 78, -84, -43, -38,
528: 82, -37, 83, 78, -79, -45, -44, -13, -47, -49,
529: -33, -48, 74, 11, 10, 9, -24, -18, -33, 75,
530: 78, 81, 78, -81, -38, -24, -33, 70, 75, -32,
531: 74, -40, -38, -3, -39, -85, -3, -70, -24, -39,
532: -24, -24, -24, -84, 77, -79, 82, -44, 75, 76,
533: -90, -12, -33, -73, 75, 78, 75, 75, -38, 75,
534: 75, 75, 75, -43, -38, -45, -44, -28, -38, -3,
535: 78, 78, -38, -3 };
536: short yydef[]={
537:
538: 1, -2, 0, 0, 9, 10, 2, 3, 4, 5,
539: 0, 225, 8, 17, 17, 17, 17, 214, 0, 30,
540: -2, 32, 33, 34, -2, 36, 37, 38, 40, 129,
541: 188, 225, 0, 225, 225, 225, 57, 129, 129, 129,
542: 129, 77, 129, 124, 0, 225, 225, 200, 201, 225,
543: 203, 225, 225, 225, 45, 209, 225, 225, 225, 228,
544: 225, 221, 222, 46, 47, 48, 49, 50, 51, 52,
545: 53, 54, 55, 56, 0, 0, 0, 0, 241, 225,
546: 225, 225, 225, 225, 244, 245, 246, 248, 249, 250,
547: 6, 29, 7, 20, 20, 0, 0, 17, 0, 215,
548: 22, 18, 19, 0, 0, 215, 0, 0, 0, 0,
549: 117, 125, 0, 39, 88, 90, 91, 64, 0, 0,
550: 226, 190, 191, 0, 193, 194, 44, 226, 0, 0,
551: 0, 0, 0, 117, 0, 159, 0, 199, 0, 0,
552: 164, 164, 0, 0, 0, 0, 0, 229, -2, 231,
553: 232, 0, 180, 181, 0, 0, 168, 169, 170, 171,
554: 172, 173, 151, 152, 233, 0, 234, 235, -2, 252,
555: 239, 0, 285, 285, 285, 285, 0, 11, 21, 12,
556: 22, 22, 0, 129, 16, 0, 102, 214, 63, 102,
557: 67, 69, 71, 0, 76, 0, 98, 96, 0, 115,
558: 0, 0, 0, 0, 0, 0, 0, 0, 0, 60,
559: 0, 66, 68, 70, 75, 114, 0, 160, -2, 0,
560: 208, 0, 204, 0, 217, 219, 0, 134, 0, 136,
561: 137, 138, 0, 0, 206, 165, 207, 0, 210, 113,
562: -2, 0, 216, 257, 0, 178, 0, 255, 258, 259,
563: 0, 263, 0, 0, 0, 0, 0, 186, 257, 236,
564: 0, 268, 270, 0, 0, 240, -2, 273, 274, 0,
565: -2, 0, 242, 243, 247, 264, 265, 285, 285, 13,
566: 14, 22, 102, 23, 0, 25, 27, 28, 57, 104,
567: 0, 95, 0, 73, 79, 0, 0, 100, 0, 118,
568: 0, 89, 65, 0, 92, 0, 227, 0, 227, 0,
569: 61, 197, 0, 0, 131, -2, 0, 0, 205, 0,
570: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
571: 153, 154, 155, 156, 157, 158, 220, 0, 134, 143,
572: 149, 0, 0, 0, 111, -2, 254, 0, 0, 260,
573: 261, 262, 182, 183, 184, 185, 187, 253, 0, 238,
574: 0, 237, 0, 0, 0, 134, 0, 0, 266, 267,
575: 15, 57, 24, 0, 43, 0, 0, 62, 72, 0,
576: 0, 0, 99, 0, 0, 119, 121, 123, 126, 127,
577: 41, 0, 0, 0, 0, 58, 0, 161, 164, 0,
578: 198, 0, 218, 139, 140, 141, 142, -2, 145, 146,
579: 147, 148, 150, 135, 0, 195, 0, 0, 214, 256,
580: 257, 179, 269, 0, -2, 276, -2, 278, -2, 280,
581: 0, 0, 0, 42, 26, 103, 0, 105, 107, 110,
582: 109, 74, 78, 0, 80, 82, 84, 0, 86, 87,
583: 166, 167, 0, 175, 176, 177, 0, 101, 159, 116,
584: 0, 0, 0, 93, 94, 189, 0, 192, 227, 162,
585: 164, 0, 133, 0, 134, 0, 112, 0, 0, -2,
586: 0, 0, 0, 106, 0, 81, 0, 85, 97, 0,
587: 120, 122, 128, 59, 163, 0, 174, 212, 213, 271,
588: 282, 283, 284, 108, 110, 83, 84, 196, 223, 0,
589: 0, 0, 224, 202 };
590: #ifndef lint
591: static char yaccpar_sccsid[] = "@(#)yaccpar 4.1 (Berkeley) 2/11/83";
592: #endif not lint
593:
594: #
595: # define YYFLAG -1000
596: # define YYERROR goto yyerrlab
597: # define YYACCEPT return(0)
598: # define YYABORT return(1)
599:
600: /* parser for yacc output */
601:
602: #ifdef YYDEBUG
603: int yydebug = 0; /* 1 for debugging */
604: #endif
605: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
606: int yychar = -1; /* current input token number */
607: int yynerrs = 0; /* number of errors */
608: short yyerrflag = 0; /* error recovery flag */
609:
610: yyparse() {
611:
612: short yys[YYMAXDEPTH];
613: short yyj, yym;
614: register YYSTYPE *yypvt;
615: register short yystate, *yyps, yyn;
616: register YYSTYPE *yypv;
617: register short *yyxi;
618:
619: yystate = 0;
620: yychar = -1;
621: yynerrs = 0;
622: yyerrflag = 0;
623: yyps= &yys[-1];
624: yypv= &yyv[-1];
625:
626: yystack: /* put a state and value onto the stack */
627:
628: #ifdef YYDEBUG
629: if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar );
630: #endif
631: if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
632: *yyps = yystate;
633: ++yypv;
634: *yypv = yyval;
635:
636: yynewstate:
637:
638: yyn = yypact[yystate];
639:
640: if( yyn<= YYFLAG ) goto yydefault; /* simple state */
641:
642: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
643: if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
644:
645: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
646: yychar = -1;
647: yyval = yylval;
648: yystate = yyn;
649: if( yyerrflag > 0 ) --yyerrflag;
650: goto yystack;
651: }
652:
653: yydefault:
654: /* default state action */
655:
656: if( (yyn=yydef[yystate]) == -2 ) {
657: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
658: /* look through exception table */
659:
660: for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
661:
662: while( *(yyxi+=2) >= 0 ){
663: if( *yyxi == yychar ) break;
664: }
665: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
666: }
667:
668: if( yyn == 0 ){ /* error */
669: /* error ... attempt to resume parsing */
670:
671: switch( yyerrflag ){
672:
673: case 0: /* brand new error */
674:
675: yyerror( "syntax error" );
676: yyerrlab:
677: ++yynerrs;
678:
679: case 1:
680: case 2: /* incompletely recovered error ... try again */
681:
682: yyerrflag = 3;
683:
684: /* find a state where "error" is a legal shift action */
685:
686: while ( yyps >= yys ) {
687: yyn = yypact[*yyps] + YYERRCODE;
688: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
689: yystate = yyact[yyn]; /* simulate a shift of "error" */
690: goto yystack;
691: }
692: yyn = yypact[*yyps];
693:
694: /* the current yyps has no shift onn "error", pop stack */
695:
696: #ifdef YYDEBUG
697: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
698: #endif
699: --yyps;
700: --yypv;
701: }
702:
703: /* there is no state on the stack with an error shift ... abort */
704:
705: yyabort:
706: return(1);
707:
708:
709: case 3: /* no shift yet; clobber input char */
710:
711: #ifdef YYDEBUG
712: if( yydebug ) printf( "error recovery discards char %d\n", yychar );
713: #endif
714:
715: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
716: yychar = -1;
717: goto yynewstate; /* try again in the same state */
718:
719: }
720:
721: }
722:
723: /* reduction by production yyn */
724:
725: #ifdef YYDEBUG
726: if( yydebug ) printf("reduce %d\n",yyn);
727: #endif
728: yyps -= yyr2[yyn];
729: yypvt = yypv;
730: yypv -= yyr2[yyn];
731: yyval = yypv[1];
732: yym=yyn;
733: /* consult goto table to find next state */
734: yyn = yyr1[yyn];
735: yyj = yypgo[yyn] + *yyps + 1;
736: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
737: switch(yym){
738:
739: case 3:
740: # line 182 "gram.in"
741: { lastwasbranch = NO; } break;
742: case 5:
743: # line 185 "gram.in"
744: { if(yypvt[-1].labval && (yypvt[-1].labval->labelno==dorange))
745: enddo(yypvt[-1].labval->labelno);
746: if(lastwasbranch && thislabel==NULL)
747: warn("statement cannot be reached");
748: lastwasbranch = thiswasbranch;
749: thiswasbranch = NO;
750: if(yypvt[-1].labval)
751: {
752: if(yypvt[-1].labval->labtype == LABFORMAT)
753: err("label already that of a format");
754: else
755: yypvt[-1].labval->labtype = LABEXEC;
756: }
757: } break;
758: case 6:
759: # line 200 "gram.in"
760: { doinclude( yypvt[-0].charpval ); } break;
761: case 7:
762: # line 202 "gram.in"
763: { lastwasbranch = NO; endproc(); } break;
764: case 8:
765: # line 204 "gram.in"
766: { execerr("unclassifiable statement", CNULL); flline(); } break;
767: case 9:
768: # line 206 "gram.in"
769: { flline(); needkwd = NO; inioctl = NO;
770: yyerrok; yyclearin; } break;
771: case 10:
772: # line 211 "gram.in"
773: {
774: #ifdef SDB
775: char buff[10];
776: if( sdbflag )
777: {
778: # ifdef UCBVAXASM
779: p2pass( stabdline(N_SLINE, lineno) );
780: # else
781: sprintf(buff,"LL%d", ++dbglabel);
782: p2pass( stabline(0, N_SLINE, lineno, buff) );
783: p2pi("LL%d:\n", dbglabel);
784: # endif
785: }
786: #endif
787:
788: if(yystno != 0)
789: {
790: yyval.labval = thislabel = mklabel(yystno);
791: if( ! headerdone )
792: puthead(CNULL, procclass);
793: if(thislabel->labdefined)
794: execerr("label %s already defined",
795: convic(thislabel->stateno) );
796: else {
797: if(thislabel->blklevel!=0 && thislabel->blklevel<blklevel
798: && thislabel->labtype!=LABFORMAT)
799: warn1("there is a branch to label %s from outside block",
800: convic( (ftnint) (thislabel->stateno) ) );
801: thislabel->blklevel = blklevel;
802: thislabel->labdefined = YES;
803: if(thislabel->labtype != LABFORMAT)
804: putlabel(thislabel->labelno);
805: }
806: }
807: else yyval.labval = thislabel = NULL;
808: } break;
809: case 11:
810: # line 250 "gram.in"
811: {startproc(yypvt[-0].extval, CLMAIN); } break;
812: case 12:
813: # line 252 "gram.in"
814: { if(yypvt[-0].extval) NO66("named BLOCKDATA");
815: startproc(yypvt[-0].extval, CLBLOCK); } break;
816: case 13:
817: # line 255 "gram.in"
818: { entrypt(CLPROC, TYSUBR, (ftnint) 0, yypvt[-1].extval, yypvt[-0].chval); } break;
819: case 14:
820: # line 257 "gram.in"
821: { entrypt(CLPROC, TYUNKNOWN, (ftnint) 0, yypvt[-1].extval, yypvt[-0].chval); } break;
822: case 15:
823: # line 259 "gram.in"
824: { entrypt(CLPROC, yypvt[-4].ival, varleng, yypvt[-1].extval, yypvt[-0].chval); } break;
825: case 16:
826: # line 261 "gram.in"
827: { if(parstate==OUTSIDE || procclass==CLMAIN
828: || procclass==CLBLOCK)
829: execerr("misplaced entry statement", CNULL);
830: entrypt(CLENTRY, 0, (ftnint) 0, yypvt[-1].extval, yypvt[-0].chval);
831: } break;
832: case 17:
833: # line 269 "gram.in"
834: { newproc(); } break;
835: case 18:
836: # line 273 "gram.in"
837: { yyval.extval = newentry(yypvt[-0].namval); } break;
838: case 19:
839: # line 277 "gram.in"
840: { yyval.namval = mkname(toklen, token); } break;
841: case 20:
842: # line 280 "gram.in"
843: { yyval.extval = NULL; } break;
844: case 22:
845: # line 285 "gram.in"
846: { yyval.chval = 0; } break;
847: case 23:
848: # line 287 "gram.in"
849: { NO66(" () argument list");
850: yyval.chval = 0; } break;
851: case 24:
852: # line 290 "gram.in"
853: {yyval.chval = yypvt[-1].chval; } break;
854: case 25:
855: # line 294 "gram.in"
856: { yyval.chval = (yypvt[-0].namval ? mkchain(yypvt[-0].namval,CHNULL) : CHNULL ); } break;
857: case 26:
858: # line 296 "gram.in"
859: { if(yypvt[-0].namval) yypvt[-2].chval = yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].namval,CHNULL)); } break;
860: case 27:
861: # line 300 "gram.in"
862: { if(yypvt[-0].namval->vstg!=STGUNKNOWN && yypvt[-0].namval->vstg!=STGARG)
863: dclerr("name declared as argument after use", yypvt[-0].namval);
864: yypvt[-0].namval->vstg = STGARG;
865: } break;
866: case 28:
867: # line 305 "gram.in"
868: { NO66("altenate return argument");
869: yyval.namval = 0; substars = YES; } break;
870: case 29:
871: # line 312 "gram.in"
872: {
873: char *s;
874: s = copyn(toklen+1, token);
875: s[toklen] = '\0';
876: yyval.charpval = s;
877: } break;
878: case 38:
879: # line 328 "gram.in"
880: { NO66("SAVE statement");
881: saveall = YES; } break;
882: case 39:
883: # line 331 "gram.in"
884: { NO66("SAVE statement"); } break;
885: case 40:
886: # line 333 "gram.in"
887: { fmtstmt(thislabel); setfmt(thislabel); } break;
888: case 41:
889: # line 335 "gram.in"
890: { NO66("PARAMETER statement"); } break;
891: case 42:
892: # line 339 "gram.in"
893: { settype(yypvt[-3].namval, yypvt[-5].ival, yypvt[-0].ival);
894: if(ndim>0) setbound(yypvt[-3].namval,ndim,dims);
895: } break;
896: case 43:
897: # line 343 "gram.in"
898: { settype(yypvt[-2].namval, yypvt[-4].ival, yypvt[-0].ival);
899: if(ndim>0) setbound(yypvt[-2].namval,ndim,dims);
900: } break;
901: case 44:
902: # line 349 "gram.in"
903: { varleng = yypvt[-0].ival; } break;
904: case 45:
905: # line 353 "gram.in"
906: { varleng = (yypvt[-0].ival<0 || yypvt[-0].ival==TYLONG ? 0 : typesize[yypvt[-0].ival]); } break;
907: case 46:
908: # line 356 "gram.in"
909: { yyval.ival = TYLONG; } break;
910: case 47:
911: # line 357 "gram.in"
912: { yyval.ival = TYREAL; } break;
913: case 48:
914: # line 358 "gram.in"
915: { yyval.ival = TYCOMPLEX; } break;
916: case 49:
917: # line 359 "gram.in"
918: { yyval.ival = TYDREAL; } break;
919: case 50:
920: # line 360 "gram.in"
921: { NOEXT("DOUBLE COMPLEX statement"); yyval.ival = TYDCOMPLEX; } break;
922: case 51:
923: # line 361 "gram.in"
924: { yyval.ival = TYLOGICAL; } break;
925: case 52:
926: # line 362 "gram.in"
927: { NO66("CHARACTER statement"); yyval.ival = TYCHAR; } break;
928: case 53:
929: # line 363 "gram.in"
930: { yyval.ival = TYUNKNOWN; } break;
931: case 54:
932: # line 364 "gram.in"
933: { yyval.ival = TYUNKNOWN; } break;
934: case 55:
935: # line 365 "gram.in"
936: { NOEXT("AUTOMATIC statement"); yyval.ival = - STGAUTO; } break;
937: case 56:
938: # line 366 "gram.in"
939: { NOEXT("STATIC statement"); yyval.ival = - STGBSS; } break;
940: case 57:
941: # line 370 "gram.in"
942: { yyval.ival = varleng; } break;
943: case 58:
944: # line 372 "gram.in"
945: {
946: expptr p;
947: p = yypvt[-1].expval;
948: NO66("length specification *n");
949: if( ! ISICON(p) || p->constblock.const.ci<0 )
950: {
951: yyval.ival = 0;
952: dclerr("length must be a positive integer constant",
953: PNULL);
954: }
955: else yyval.ival = p->constblock.const.ci;
956: } break;
957: case 59:
958: # line 385 "gram.in"
959: { NO66("length specification *(*)"); yyval.ival = -1; } break;
960: case 60:
961: # line 389 "gram.in"
962: { incomm( yyval.extval = comblock(0, CNULL) , yypvt[-0].namval ); } break;
963: case 61:
964: # line 391 "gram.in"
965: { yyval.extval = yypvt[-1].extval; incomm(yypvt[-1].extval, yypvt[-0].namval); } break;
966: case 62:
967: # line 393 "gram.in"
968: { yyval.extval = yypvt[-2].extval; incomm(yypvt[-2].extval, yypvt[-0].namval); } break;
969: case 63:
970: # line 395 "gram.in"
971: { incomm(yypvt[-2].extval, yypvt[-0].namval); } break;
972: case 64:
973: # line 399 "gram.in"
974: { yyval.extval = comblock(0, CNULL); } break;
975: case 65:
976: # line 401 "gram.in"
977: { yyval.extval = comblock(toklen, token); } break;
978: case 66:
979: # line 405 "gram.in"
980: { setext(yypvt[-0].namval); } break;
981: case 67:
982: # line 407 "gram.in"
983: { setext(yypvt[-0].namval); } break;
984: case 68:
985: # line 411 "gram.in"
986: { NO66("INTRINSIC statement"); setintr(yypvt[-0].namval); } break;
987: case 69:
988: # line 413 "gram.in"
989: { setintr(yypvt[-0].namval); } break;
990: case 72:
991: # line 421 "gram.in"
992: {
993: struct Equivblock *p;
994: if(nequiv >= maxequiv)
995: many("equivalences", 'q');
996: p = & eqvclass[nequiv++];
997: p->eqvinit = NO;
998: p->eqvbottom = 0;
999: p->eqvtop = 0;
1000: p->equivs = yypvt[-1].eqvval;
1001: } break;
1002: case 73:
1003: # line 434 "gram.in"
1004: { yyval.eqvval=ALLOC(Eqvchain);
1005: yyval.eqvval->eqvitem.eqvlhs = (struct Primblock *)yypvt[-0].expval;
1006: } break;
1007: case 74:
1008: # line 438 "gram.in"
1009: { yyval.eqvval=ALLOC(Eqvchain);
1010: yyval.eqvval->eqvitem.eqvlhs = (struct Primblock *) yypvt[-0].expval;
1011: yyval.eqvval->eqvnextp = yypvt[-2].eqvval;
1012: } break;
1013: case 77:
1014: # line 449 "gram.in"
1015: { if(parstate == OUTSIDE)
1016: {
1017: newproc();
1018: startproc(PNULL, CLMAIN);
1019: }
1020: if(parstate < INDATA)
1021: {
1022: enddcl();
1023: parstate = INDATA;
1024: }
1025: } break;
1026: case 78:
1027: # line 463 "gram.in"
1028: { ftnint junk;
1029: if(nextdata(&junk,&junk) != NULL)
1030: {
1031: err("too few initializers");
1032: curdtp = NULL;
1033: }
1034: frdata(yypvt[-3].chval);
1035: frrpl();
1036: } break;
1037: case 79:
1038: # line 474 "gram.in"
1039: { toomanyinit = NO; } break;
1040: case 82:
1041: # line 479 "gram.in"
1042: { dataval(PNULL, yypvt[-0].expval); } break;
1043: case 83:
1044: # line 481 "gram.in"
1045: { dataval(yypvt[-2].expval, yypvt[-0].expval); } break;
1046: case 85:
1047: # line 486 "gram.in"
1048: { if( yypvt[-1].ival==OPMINUS && ISCONST(yypvt[-0].expval) )
1049: consnegop(yypvt[-0].expval);
1050: yyval.expval = yypvt[-0].expval;
1051: } break;
1052: case 90:
1053: # line 499 "gram.in"
1054: { int k;
1055: yypvt[-0].namval->vsave = YES;
1056: k = yypvt[-0].namval->vstg;
1057: if( ! ONEOF(k, M(STGUNKNOWN)|M(STGBSS)|M(STGINIT)) )
1058: dclerr("can only save static variables", yypvt[-0].namval);
1059: } break;
1060: case 91:
1061: # line 506 "gram.in"
1062: { yypvt[-0].extval->extsave = 1; } break;
1063: case 94:
1064: # line 514 "gram.in"
1065: { if(yypvt[-2].namval->vclass == CLUNKNOWN)
1066: { yypvt[-2].namval->vclass = CLPARAM;
1067: ( (struct Paramblock *) (yypvt[-2].namval) )->paramval = yypvt[-0].expval;
1068: }
1069: else dclerr("cannot make %s parameter", yypvt[-2].namval);
1070: } break;
1071: case 95:
1072: # line 523 "gram.in"
1073: { if(ndim>0) setbound(yypvt[-1].namval, ndim, dims); } break;
1074: case 96:
1075: # line 527 "gram.in"
1076: { Namep np;
1077: np = ( (struct Primblock *) yypvt[-0].expval) -> namep;
1078: vardcl(np);
1079: if(np->vstg == STGCOMMON)
1080: extsymtab[np->vardesc.varno].extinit = YES;
1081: else if(np->vstg==STGEQUIV)
1082: eqvclass[np->vardesc.varno].eqvinit = YES;
1083: else if(np->vstg!=STGINIT && np->vstg!=STGBSS)
1084: dclerr("inconsistent storage classes", np);
1085: yyval.chval = mkchain(yypvt[-0].expval, CHNULL);
1086: } break;
1087: case 97:
1088: # line 539 "gram.in"
1089: { chainp p; struct Impldoblock *q;
1090: q = ALLOC(Impldoblock);
1091: q->tag = TIMPLDO;
1092: q->varnp = (Namep) (yypvt[-1].chval->datap);
1093: p = yypvt[-1].chval->nextp;
1094: if(p) { q->implb = (expptr)(p->datap); p = p->nextp; }
1095: if(p) { q->impub = (expptr)(p->datap); p = p->nextp; }
1096: if(p) { q->impstep = (expptr)(p->datap); p = p->nextp; }
1097: frchain( & (yypvt[-1].chval) );
1098: yyval.chval = mkchain(q, CHNULL);
1099: q->datalist = hookup(yypvt[-3].chval, yyval.chval);
1100: } break;
1101: case 98:
1102: # line 554 "gram.in"
1103: { curdtp = yypvt[-0].chval; curdtelt = 0; } break;
1104: case 99:
1105: # line 556 "gram.in"
1106: { yyval.chval = hookup(yypvt[-2].chval, yypvt[-0].chval); } break;
1107: case 101:
1108: # line 561 "gram.in"
1109: { yyval.chval = hookup(yypvt[-2].chval, yypvt[-0].chval); } break;
1110: case 102:
1111: # line 565 "gram.in"
1112: { ndim = 0; } break;
1113: case 104:
1114: # line 569 "gram.in"
1115: { ndim = 0; } break;
1116: case 107:
1117: # line 574 "gram.in"
1118: { if(ndim == maxdim)
1119: err("too many dimensions");
1120: else if(ndim < maxdim)
1121: { dims[ndim].lb = 0;
1122: dims[ndim].ub = yypvt[-0].expval;
1123: }
1124: ++ndim;
1125: } break;
1126: case 108:
1127: # line 583 "gram.in"
1128: { if(ndim == maxdim)
1129: err("too many dimensions");
1130: else if(ndim < maxdim)
1131: { dims[ndim].lb = yypvt[-2].expval;
1132: dims[ndim].ub = yypvt[-0].expval;
1133: }
1134: ++ndim;
1135: } break;
1136: case 109:
1137: # line 594 "gram.in"
1138: { yyval.expval = 0; } break;
1139: case 111:
1140: # line 599 "gram.in"
1141: { nstars = 1; labarray[0] = yypvt[-0].labval; } break;
1142: case 112:
1143: # line 601 "gram.in"
1144: { if(nstars < MAXLABLIST) labarray[nstars++] = yypvt[-0].labval; } break;
1145: case 113:
1146: # line 605 "gram.in"
1147: { yyval.labval = execlab( convci(toklen, token) ); } break;
1148: case 114:
1149: # line 609 "gram.in"
1150: { NO66("IMPLICIT statement"); } break;
1151: case 117:
1152: # line 616 "gram.in"
1153: { needkwd = 1; } break;
1154: case 118:
1155: # line 617 "gram.in"
1156: { vartype = yypvt[-0].ival; } break;
1157: case 121:
1158: # line 625 "gram.in"
1159: { setimpl(vartype, varleng, yypvt[-0].ival, yypvt[-0].ival); } break;
1160: case 122:
1161: # line 627 "gram.in"
1162: { setimpl(vartype, varleng, yypvt[-2].ival, yypvt[-0].ival); } break;
1163: case 123:
1164: # line 631 "gram.in"
1165: { if(toklen!=1 || token[0]<'a' || token[0]>'z')
1166: {
1167: dclerr("implicit item must be single letter", PNULL);
1168: yyval.ival = 0;
1169: }
1170: else yyval.ival = token[0];
1171: } break;
1172: case 126:
1173: # line 645 "gram.in"
1174: {
1175: if(yypvt[-2].namval->vclass == CLUNKNOWN)
1176: {
1177: yypvt[-2].namval->vclass = CLNAMELIST;
1178: yypvt[-2].namval->vtype = TYINT;
1179: yypvt[-2].namval->vstg = STGINIT;
1180: yypvt[-2].namval->varxptr.namelist = yypvt[-0].chval;
1181: yypvt[-2].namval->vardesc.varno = ++lastvarno;
1182: }
1183: else dclerr("cannot be a namelist name", yypvt[-2].namval);
1184: } break;
1185: case 127:
1186: # line 659 "gram.in"
1187: { yyval.chval = mkchain(yypvt[-0].namval, CHNULL); } break;
1188: case 128:
1189: # line 661 "gram.in"
1190: { yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].namval, CHNULL)); } break;
1191: case 129:
1192: # line 665 "gram.in"
1193: { switch(parstate)
1194: {
1195: case OUTSIDE: newproc();
1196: startproc(PNULL, CLMAIN);
1197: case INSIDE: parstate = INDCL;
1198: case INDCL: break;
1199:
1200: default:
1201: dclerr("declaration among executables", PNULL);
1202: }
1203: } break;
1204: case 130:
1205: # line 678 "gram.in"
1206: { yyval.chval = 0; } break;
1207: case 132:
1208: # line 683 "gram.in"
1209: { yyval.chval = mkchain(yypvt[-0].expval, CHNULL); } break;
1210: case 133:
1211: # line 685 "gram.in"
1212: { yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].expval,CHNULL) ); } break;
1213: case 135:
1214: # line 690 "gram.in"
1215: { yyval.expval = yypvt[-1].expval; } break;
1216: case 139:
1217: # line 697 "gram.in"
1218: { yyval.expval = mkexpr(yypvt[-1].ival, yypvt[-2].expval, yypvt[-0].expval); } break;
1219: case 140:
1220: # line 699 "gram.in"
1221: { yyval.expval = mkexpr(OPSTAR, yypvt[-2].expval, yypvt[-0].expval); } break;
1222: case 141:
1223: # line 701 "gram.in"
1224: { yyval.expval = mkexpr(OPSLASH, yypvt[-2].expval, yypvt[-0].expval); } break;
1225: case 142:
1226: # line 703 "gram.in"
1227: { yyval.expval = mkexpr(OPPOWER, yypvt[-2].expval, yypvt[-0].expval); } break;
1228: case 143:
1229: # line 705 "gram.in"
1230: { if(yypvt[-1].ival == OPMINUS)
1231: yyval.expval = mkexpr(OPNEG, yypvt[-0].expval, ENULL);
1232: else yyval.expval = yypvt[-0].expval;
1233: } break;
1234: case 144:
1235: # line 710 "gram.in"
1236: { yyval.expval = mkexpr(yypvt[-1].ival, yypvt[-2].expval, yypvt[-0].expval); } break;
1237: case 145:
1238: # line 712 "gram.in"
1239: { NO66(".EQV. operator");
1240: yyval.expval = mkexpr(OPEQV, yypvt[-2].expval,yypvt[-0].expval); } break;
1241: case 146:
1242: # line 715 "gram.in"
1243: { NO66(".NEQV. operator");
1244: yyval.expval = mkexpr(OPNEQV, yypvt[-2].expval, yypvt[-0].expval); } break;
1245: case 147:
1246: # line 718 "gram.in"
1247: { yyval.expval = mkexpr(OPOR, yypvt[-2].expval, yypvt[-0].expval); } break;
1248: case 148:
1249: # line 720 "gram.in"
1250: { yyval.expval = mkexpr(OPAND, yypvt[-2].expval, yypvt[-0].expval); } break;
1251: case 149:
1252: # line 722 "gram.in"
1253: { yyval.expval = mkexpr(OPNOT, yypvt[-0].expval, ENULL); } break;
1254: case 150:
1255: # line 724 "gram.in"
1256: { NO66("concatenation operator //");
1257: yyval.expval = mkexpr(OPCONCAT, yypvt[-2].expval, yypvt[-0].expval); } break;
1258: case 151:
1259: # line 728 "gram.in"
1260: { yyval.ival = OPPLUS; } break;
1261: case 152:
1262: # line 729 "gram.in"
1263: { yyval.ival = OPMINUS; } break;
1264: case 153:
1265: # line 732 "gram.in"
1266: { yyval.ival = OPEQ; } break;
1267: case 154:
1268: # line 733 "gram.in"
1269: { yyval.ival = OPGT; } break;
1270: case 155:
1271: # line 734 "gram.in"
1272: { yyval.ival = OPLT; } break;
1273: case 156:
1274: # line 735 "gram.in"
1275: { yyval.ival = OPGE; } break;
1276: case 157:
1277: # line 736 "gram.in"
1278: { yyval.ival = OPLE; } break;
1279: case 158:
1280: # line 737 "gram.in"
1281: { yyval.ival = OPNE; } break;
1282: case 159:
1283: # line 741 "gram.in"
1284: { yyval.expval = mkprim(yypvt[-0].namval, PNULL, CHNULL); } break;
1285: case 160:
1286: # line 743 "gram.in"
1287: { NO66("substring operator :");
1288: yyval.expval = mkprim(yypvt[-1].namval, PNULL, yypvt[-0].chval); } break;
1289: case 161:
1290: # line 746 "gram.in"
1291: { yyval.expval = mkprim(yypvt[-3].namval, mklist(yypvt[-1].chval), CHNULL); } break;
1292: case 162:
1293: # line 748 "gram.in"
1294: { NO66("substring operator :");
1295: yyval.expval = mkprim(yypvt[-4].namval, mklist(yypvt[-2].chval), yypvt[-0].chval); } break;
1296: case 163:
1297: # line 753 "gram.in"
1298: { yyval.chval = mkchain(yypvt[-3].expval, mkchain(yypvt[-1].expval,CHNULL)); } break;
1299: case 164:
1300: # line 757 "gram.in"
1301: { yyval.expval = 0; } break;
1302: case 166:
1303: # line 762 "gram.in"
1304: { if(yypvt[-0].namval->vclass == CLPARAM)
1305: yyval.expval = (expptr) cpexpr(
1306: ( (struct Paramblock *) (yypvt[-0].namval) ) -> paramval);
1307: } break;
1308: case 168:
1309: # line 769 "gram.in"
1310: { yyval.expval = mklogcon(1); } break;
1311: case 169:
1312: # line 770 "gram.in"
1313: { yyval.expval = mklogcon(0); } break;
1314: case 170:
1315: # line 771 "gram.in"
1316: { yyval.expval = mkstrcon(toklen, token); } break;
1317: case 171:
1318: # line 772 "gram.in"
1319: { yyval.expval = mkintcon( convci(toklen, token) ); } break;
1320: case 172:
1321: # line 773 "gram.in"
1322: { yyval.expval = mkrealcon(TYREAL, convcd(toklen, token)); } break;
1323: case 173:
1324: # line 774 "gram.in"
1325: { yyval.expval = mkrealcon(TYDREAL, convcd(toklen, token)); } break;
1326: case 174:
1327: # line 778 "gram.in"
1328: { yyval.expval = mkcxcon(yypvt[-3].expval,yypvt[-1].expval); } break;
1329: case 175:
1330: # line 782 "gram.in"
1331: { NOEXT("hex constant");
1332: yyval.expval = mkbitcon(4, toklen, token); } break;
1333: case 176:
1334: # line 785 "gram.in"
1335: { NOEXT("octal constant");
1336: yyval.expval = mkbitcon(3, toklen, token); } break;
1337: case 177:
1338: # line 788 "gram.in"
1339: { NOEXT("binary constant");
1340: yyval.expval = mkbitcon(1, toklen, token); } break;
1341: case 179:
1342: # line 794 "gram.in"
1343: { yyval.expval = yypvt[-1].expval; } break;
1344: case 182:
1345: # line 800 "gram.in"
1346: { yyval.expval = mkexpr(yypvt[-1].ival, yypvt[-2].expval, yypvt[-0].expval); } break;
1347: case 183:
1348: # line 802 "gram.in"
1349: { yyval.expval = mkexpr(OPSTAR, yypvt[-2].expval, yypvt[-0].expval); } break;
1350: case 184:
1351: # line 804 "gram.in"
1352: { yyval.expval = mkexpr(OPSLASH, yypvt[-2].expval, yypvt[-0].expval); } break;
1353: case 185:
1354: # line 806 "gram.in"
1355: { yyval.expval = mkexpr(OPPOWER, yypvt[-2].expval, yypvt[-0].expval); } break;
1356: case 186:
1357: # line 808 "gram.in"
1358: { if(yypvt[-1].ival == OPMINUS)
1359: yyval.expval = mkexpr(OPNEG, yypvt[-0].expval, ENULL);
1360: else yyval.expval = yypvt[-0].expval;
1361: } break;
1362: case 187:
1363: # line 813 "gram.in"
1364: { NO66("concatenation operator //");
1365: yyval.expval = mkexpr(OPCONCAT, yypvt[-2].expval, yypvt[-0].expval); } break;
1366: case 189:
1367: # line 818 "gram.in"
1368: {
1369: if(yypvt[-2].labval->labdefined)
1370: execerr("no backward DO loops", CNULL);
1371: yypvt[-2].labval->blklevel = blklevel+1;
1372: exdo(yypvt[-2].labval->labelno, yypvt[-0].chval);
1373: } break;
1374: case 190:
1375: # line 825 "gram.in"
1376: { exendif(); thiswasbranch = NO; } break;
1377: case 192:
1378: # line 828 "gram.in"
1379: { exelif(yypvt[-2].expval); lastwasbranch = NO; } break;
1380: case 193:
1381: # line 830 "gram.in"
1382: { exelse(); lastwasbranch = NO; } break;
1383: case 194:
1384: # line 832 "gram.in"
1385: { exendif(); lastwasbranch = NO; } break;
1386: case 195:
1387: # line 836 "gram.in"
1388: { exif(yypvt[-1].expval); } break;
1389: case 196:
1390: # line 840 "gram.in"
1391: { yyval.chval = mkchain(yypvt[-2].namval, yypvt[-0].chval); } break;
1392: case 197:
1393: # line 844 "gram.in"
1394: { exequals(yypvt[-2].expval, yypvt[-0].expval); } break;
1395: case 198:
1396: # line 846 "gram.in"
1397: { exassign(yypvt[-0].namval, yypvt[-2].labval); } break;
1398: case 201:
1399: # line 850 "gram.in"
1400: { inioctl = NO; } break;
1401: case 202:
1402: # line 852 "gram.in"
1403: { exarif(yypvt[-6].expval, yypvt[-4].labval, yypvt[-2].labval, yypvt[-0].labval); thiswasbranch = YES; } break;
1404: case 203:
1405: # line 854 "gram.in"
1406: { excall(yypvt[-0].namval, PNULL, 0, labarray); } break;
1407: case 204:
1408: # line 856 "gram.in"
1409: { excall(yypvt[-2].namval, PNULL, 0, labarray); } break;
1410: case 205:
1411: # line 858 "gram.in"
1412: { if(nstars < MAXLABLIST)
1413: excall(yypvt[-3].namval, mklist(yypvt[-1].chval), nstars, labarray);
1414: else
1415: err("too many alternate returns");
1416: } break;
1417: case 206:
1418: # line 864 "gram.in"
1419: { exreturn(yypvt[-0].expval); thiswasbranch = YES; } break;
1420: case 207:
1421: # line 866 "gram.in"
1422: { exstop(yypvt[-2].ival, yypvt[-0].expval); thiswasbranch = yypvt[-2].ival; } break;
1423: case 208:
1424: # line 870 "gram.in"
1425: { yyval.labval = mklabel( convci(toklen, token) ); } break;
1426: case 209:
1427: # line 874 "gram.in"
1428: { if(parstate == OUTSIDE)
1429: {
1430: newproc();
1431: startproc(PNULL, CLMAIN);
1432: }
1433: } break;
1434: case 210:
1435: # line 883 "gram.in"
1436: { exgoto(yypvt[-0].labval); thiswasbranch = YES; } break;
1437: case 211:
1438: # line 885 "gram.in"
1439: { exasgoto(yypvt[-0].namval); thiswasbranch = YES; } break;
1440: case 212:
1441: # line 887 "gram.in"
1442: { exasgoto(yypvt[-4].namval); thiswasbranch = YES; } break;
1443: case 213:
1444: # line 889 "gram.in"
1445: { if(nstars < MAXLABLIST)
1446: putcmgo(fixtype(yypvt[-0].expval), nstars, labarray);
1447: else
1448: err("computed GOTO list too long");
1449: } break;
1450: case 216:
1451: # line 901 "gram.in"
1452: { nstars = 0; yyval.namval = yypvt[-0].namval; } break;
1453: case 217:
1454: # line 905 "gram.in"
1455: { yyval.chval = (yypvt[-0].expval ? mkchain(yypvt[-0].expval,CHNULL) : CHNULL); } break;
1456: case 218:
1457: # line 907 "gram.in"
1458: { if(yypvt[-0].expval)
1459: if(yypvt[-2].chval) yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].expval,CHNULL));
1460: else yyval.chval = mkchain(yypvt[-0].expval,CHNULL);
1461: else
1462: yyval.chval = yypvt[-2].chval;
1463: } break;
1464: case 220:
1465: # line 917 "gram.in"
1466: { if(nstars<MAXLABLIST) labarray[nstars++] = yypvt[-0].labval; yyval.expval = 0; } break;
1467: case 221:
1468: # line 921 "gram.in"
1469: { yyval.ival = 0; } break;
1470: case 222:
1471: # line 923 "gram.in"
1472: { yyval.ival = 1; } break;
1473: case 223:
1474: # line 927 "gram.in"
1475: { yyval.chval = mkchain(yypvt[-0].expval, CHNULL); } break;
1476: case 224:
1477: # line 929 "gram.in"
1478: { yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].expval,CHNULL) ); } break;
1479: case 225:
1480: # line 933 "gram.in"
1481: { if(parstate == OUTSIDE)
1482: {
1483: newproc();
1484: startproc(PNULL, CLMAIN);
1485: }
1486: if(parstate < INDATA) enddcl();
1487: } break;
1488: case 226:
1489: # line 943 "gram.in"
1490: { intonly = YES; } break;
1491: case 227:
1492: # line 947 "gram.in"
1493: { intonly = NO; } break;
1494: case 228:
1495: # line 952 "gram.in"
1496: { endio(); } break;
1497: case 230:
1498: # line 957 "gram.in"
1499: { ioclause(IOSUNIT, yypvt[-0].expval); endioctl(); } break;
1500: case 231:
1501: # line 959 "gram.in"
1502: { ioclause(IOSUNIT, PNULL); endioctl(); } break;
1503: case 232:
1504: # line 961 "gram.in"
1505: { ioclause(IOSUNIT, IOSTDERR); endioctl(); } break;
1506: case 234:
1507: # line 964 "gram.in"
1508: { doio(PNULL); } break;
1509: case 235:
1510: # line 966 "gram.in"
1511: { doio(PNULL); } break;
1512: case 236:
1513: # line 968 "gram.in"
1514: { doio(yypvt[-0].chval); } break;
1515: case 237:
1516: # line 970 "gram.in"
1517: { doio(yypvt[-0].chval); } break;
1518: case 238:
1519: # line 972 "gram.in"
1520: { doio(yypvt[-0].chval); } break;
1521: case 239:
1522: # line 974 "gram.in"
1523: { doio(PNULL); } break;
1524: case 240:
1525: # line 976 "gram.in"
1526: { doio(yypvt[-0].chval); } break;
1527: case 241:
1528: # line 978 "gram.in"
1529: { doio(PNULL); } break;
1530: case 242:
1531: # line 980 "gram.in"
1532: { doio(yypvt[-0].chval); } break;
1533: case 244:
1534: # line 987 "gram.in"
1535: { iostmt = IOBACKSPACE; } break;
1536: case 245:
1537: # line 989 "gram.in"
1538: { iostmt = IOREWIND; } break;
1539: case 246:
1540: # line 991 "gram.in"
1541: { iostmt = IOENDFILE; } break;
1542: case 248:
1543: # line 998 "gram.in"
1544: { iostmt = IOINQUIRE; } break;
1545: case 249:
1546: # line 1000 "gram.in"
1547: { iostmt = IOOPEN; } break;
1548: case 250:
1549: # line 1002 "gram.in"
1550: { iostmt = IOCLOSE; } break;
1551: case 251:
1552: # line 1006 "gram.in"
1553: {
1554: ioclause(IOSUNIT, PNULL);
1555: ioclause(IOSFMT, yypvt[-0].expval);
1556: endioctl();
1557: } break;
1558: case 252:
1559: # line 1012 "gram.in"
1560: {
1561: ioclause(IOSUNIT, PNULL);
1562: ioclause(IOSFMT, PNULL);
1563: endioctl();
1564: } break;
1565: case 253:
1566: # line 1020 "gram.in"
1567: { if(yypvt[-1].expval->headblock.vtype == TYCHAR)
1568: {
1569: ioclause(IOSUNIT, PNULL);
1570: ioclause(IOSFMT, yypvt[-1].expval);
1571: }
1572: else
1573: ioclause(IOSUNIT, yypvt[-1].expval);
1574: endioctl();
1575: } break;
1576: case 254:
1577: # line 1030 "gram.in"
1578: { endioctl(); } break;
1579: case 257:
1580: # line 1038 "gram.in"
1581: { ioclause(IOSPOSITIONAL, yypvt[-0].expval); } break;
1582: case 258:
1583: # line 1040 "gram.in"
1584: { ioclause(IOSPOSITIONAL, PNULL); } break;
1585: case 259:
1586: # line 1042 "gram.in"
1587: { ioclause(IOSPOSITIONAL, IOSTDERR); } break;
1588: case 260:
1589: # line 1044 "gram.in"
1590: { ioclause(yypvt[-1].ival, yypvt[-0].expval); } break;
1591: case 261:
1592: # line 1046 "gram.in"
1593: { ioclause(yypvt[-1].ival, PNULL); } break;
1594: case 262:
1595: # line 1048 "gram.in"
1596: { ioclause(yypvt[-1].ival, IOSTDERR); } break;
1597: case 263:
1598: # line 1052 "gram.in"
1599: { yyval.ival = iocname(); } break;
1600: case 264:
1601: # line 1056 "gram.in"
1602: { iostmt = IOREAD; } break;
1603: case 265:
1604: # line 1060 "gram.in"
1605: { iostmt = IOWRITE; } break;
1606: case 266:
1607: # line 1064 "gram.in"
1608: {
1609: iostmt = IOWRITE;
1610: ioclause(IOSUNIT, PNULL);
1611: ioclause(IOSFMT, yypvt[-1].expval);
1612: endioctl();
1613: } break;
1614: case 267:
1615: # line 1071 "gram.in"
1616: {
1617: iostmt = IOWRITE;
1618: ioclause(IOSUNIT, PNULL);
1619: ioclause(IOSFMT, PNULL);
1620: endioctl();
1621: } break;
1622: case 268:
1623: # line 1080 "gram.in"
1624: { yyval.chval = mkchain(yypvt[-0].tagval, CHNULL); } break;
1625: case 269:
1626: # line 1082 "gram.in"
1627: { yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].tagval, CHNULL)); } break;
1628: case 270:
1629: # line 1086 "gram.in"
1630: { yyval.tagval = (tagptr) yypvt[-0].expval; } break;
1631: case 271:
1632: # line 1088 "gram.in"
1633: { yyval.tagval = (tagptr) mkiodo(yypvt[-1].chval,yypvt[-3].chval); } break;
1634: case 272:
1635: # line 1092 "gram.in"
1636: { yyval.chval = mkchain(yypvt[-0].expval, CHNULL); } break;
1637: case 273:
1638: # line 1094 "gram.in"
1639: { yyval.chval = mkchain(yypvt[-0].tagval, CHNULL); } break;
1640: case 275:
1641: # line 1099 "gram.in"
1642: { yyval.chval = mkchain(yypvt[-2].expval, mkchain(yypvt[-0].expval, CHNULL) ); } break;
1643: case 276:
1644: # line 1101 "gram.in"
1645: { yyval.chval = mkchain(yypvt[-2].expval, mkchain(yypvt[-0].tagval, CHNULL) ); } break;
1646: case 277:
1647: # line 1103 "gram.in"
1648: { yyval.chval = mkchain(yypvt[-2].tagval, mkchain(yypvt[-0].expval, CHNULL) ); } break;
1649: case 278:
1650: # line 1105 "gram.in"
1651: { yyval.chval = mkchain(yypvt[-2].tagval, mkchain(yypvt[-0].tagval, CHNULL) ); } break;
1652: case 279:
1653: # line 1107 "gram.in"
1654: { yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].expval, CHNULL) ); } break;
1655: case 280:
1656: # line 1109 "gram.in"
1657: { yyval.chval = hookup(yypvt[-2].chval, mkchain(yypvt[-0].tagval, CHNULL) ); } break;
1658: case 281:
1659: # line 1113 "gram.in"
1660: { yyval.tagval = (tagptr) yypvt[-0].expval; } break;
1661: case 282:
1662: # line 1115 "gram.in"
1663: { yyval.tagval = (tagptr) mkiodo(yypvt[-1].chval, mkchain(yypvt[-3].expval, CHNULL) ); } break;
1664: case 283:
1665: # line 1117 "gram.in"
1666: { yyval.tagval = (tagptr) mkiodo(yypvt[-1].chval, mkchain(yypvt[-3].tagval, CHNULL) ); } break;
1667: case 284:
1668: # line 1119 "gram.in"
1669: { yyval.tagval = (tagptr) mkiodo(yypvt[-1].chval, yypvt[-3].chval); } break;
1670: case 285:
1671: # line 1123 "gram.in"
1672: { startioctl(); } break;
1673: }
1674: goto yystack; /* stack new state and value */
1675:
1676: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.