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