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