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