PIPS
syn_yacc.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.8.2. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
6  Inc.
7 
8  This program is free software: you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation, either version 3 of the License, or
11  (at your option) any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program. If not, see <https://www.gnu.org/licenses/>. */
20 
21 /* As a special exception, you may create a larger work that contains
22  part or all of the Bison parser skeleton and distribute that work
23  under terms of your choice, so long as that work isn't itself a
24  parser generator using the skeleton or a modified version thereof
25  as a parser skeleton. Alternatively, if you modify or redistribute
26  the parser skeleton itself, you may (at your option) remove this
27  special exception, which will cause the skeleton and the resulting
28  Bison output files to be licensed under the GNU General Public
29  License without this special exception.
30 
31  This special exception was added by the Free Software Foundation in
32  version 2.2 of Bison. */
33 
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35  simplifying the original so-called "semantic" parser. */
36 
37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38  especially those whose name start with YY_ or yy_. They are
39  private implementation details that can be changed or removed. */
40 
41 /* All symbols defined below should begin with yy or YY, to avoid
42  infringing on user name space. This should be done even for local
43  variables, as they might otherwise be expanded by user macros.
44  There are some unavoidable exceptions within include files to
45  define necessary library symbols; they are noted "INFRINGES ON
46  USER NAME SPACE" below. */
47 
48 /* Identify Bison output, and Bison version. */
49 #define YYBISON 30802
50 
51 /* Bison version string. */
52 #define YYBISON_VERSION "3.8.2"
53 
54 /* Skeleton name. */
55 #define YYSKELETON_NAME "yacc.c"
56 
57 /* Pure parsers. */
58 #define YYPURE 0
59 
60 /* Push parsers. */
61 #define YYPUSH 0
62 
63 /* Pull parsers. */
64 #define YYPULL 1
65 
66 
67 /* Substitute the variable and function names. */
68 #define yyparse syn_parse
69 #define yylex syn_lex
70 #define yyerror syn_error
71 #define yydebug syn_debug
72 #define yynerrs syn_nerrs
73 #define yylval syn_lval
74 #define yychar syn_char
75 
76 /* First part of user prologue. */
77 #line 282 "yacc.in"
78 
79 #ifdef HAVE_CONFIG_H
80  #include "pips_config.h"
81 #endif
82 #include <stdio.h>
83 #include <string.h>
84 #include <stdlib.h>
85 
86 #include "genC.h"
87 #include "parser_private.h"
88 #include "linear.h"
89 #include "ri.h"
90 #include "ri-util.h"
91 
92 #include "misc.h"
93 #include "properties.h"
94 
95 #include "syntax.h"
96 
97 #define YYERROR_VERBOSE 1 /* much clearer error messages with bison */
98 
99  /* local variables */
100  int ici; /* to count control specifications in IO statements */
101  type CurrentType = type_undefined; /* the type in a type or dimension
102  or common statement */
103  intptr_t CurrentTypeSize; /* number of bytes to store a value of that type */
104 
105 /* functions for DATA */
106 
107 static expression MakeDataValueSet(expression n, expression c)
108  {
109  expression repeat_factor = expression_undefined;
110  expression value_set = expression_undefined;
111  entity repeat_value = FindEntity(TOP_LEVEL_MODULE_NAME,
112  REPEAT_VALUE_NAME);
113  value vc = value_undefined;
114 
115  pips_assert("Function repeat value is defined", !entity_undefined_p(repeat_value));
116 
117  vc = EvalExpression(c);
118  if (! value_constant_p(vc)) {
119  if(!complex_constant_expression_p(c)) {
120  ParserError("MakeDataValueSet", "data value must be a constant\n");
121  }
122  }
123 
124  if(expression_undefined_p(n)) {
125  value_set = c;
126  }
127  else {
128  repeat_factor = (n == expression_undefined) ? int_to_expression(1) : n;
129  value_set = make_call_expression(repeat_value,
130  CONS(EXPRESSION, repeat_factor,
131  CONS(EXPRESSION, c, NIL)));
132  }
133 
134  return value_set;
135  }
136 
137 #line 138 "y.tab.c"
138 
139 # ifndef YY_CAST
140 # ifdef __cplusplus
141 # define YY_CAST(Type, Val) static_cast<Type> (Val)
142 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
143 # else
144 # define YY_CAST(Type, Val) ((Type) (Val))
145 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
146 # endif
147 # endif
148 # ifndef YY_NULLPTR
149 # if defined __cplusplus
150 # if 201103L <= __cplusplus
151 # define YY_NULLPTR nullptr
152 # else
153 # define YY_NULLPTR 0
154 # endif
155 # else
156 # define YY_NULLPTR ((void*)0)
157 # endif
158 # endif
159 
160 /* Use api.header.include to #include this header
161  instead of duplicating it here. */
162 #ifndef YY_SYN_Y_TAB_H_INCLUDED
163 # define YY_SYN_Y_TAB_H_INCLUDED
164 /* Debug traces. */
165 #ifndef YYDEBUG
166 # define YYDEBUG 0
167 #endif
168 #if YYDEBUG
169 extern int syn_debug;
170 #endif
171 
172 /* Token kinds. */
173 #ifndef YYTOKENTYPE
174 # define YYTOKENTYPE
175  enum yytokentype
176  {
177  YYEMPTY = -2,
178  YYEOF = 0, /* "end of file" */
179  YYerror = 256, /* error */
180  YYUNDEF = 257, /* "invalid token" */
181  TK_ASSIGN = 258, /* TK_ASSIGN */
182  TK_BACKSPACE = 259, /* TK_BACKSPACE */
183  TK_BLANK = 260, /* TK_BLANK */
184  TK_BLOCKDATA = 261, /* TK_BLOCKDATA */
185  TK_BUFFERIN = 262, /* TK_BUFFERIN */
186  TK_BUFFEROUT = 263, /* TK_BUFFEROUT */
187  TK_CALL = 264, /* TK_CALL */
188  TK_CHARACTER = 265, /* TK_CHARACTER */
189  TK_CLOSE = 266, /* TK_CLOSE */
190  TK_COMMON = 267, /* TK_COMMON */
191  TK_COMPLEX = 268, /* TK_COMPLEX */
192  TK_CONTINUE = 269, /* TK_CONTINUE */
193  TK_CYCLE = 270, /* TK_CYCLE */
194  TK_DATA = 271, /* TK_DATA */
195  TK_DIMENSION = 272, /* TK_DIMENSION */
196  TK_DOUBLEPRECISION = 273, /* TK_DOUBLEPRECISION */
197  TK_DOUBLECOMPLEX = 274, /* TK_DOUBLECOMPLEX */
198  TK_DO = 275, /* TK_DO */
199  TK_ELSEIF = 276, /* TK_ELSEIF */
200  TK_ELSE = 277, /* TK_ELSE */
201  TK_ENDFILE = 278, /* TK_ENDFILE */
202  TK_ENDDO = 279, /* TK_ENDDO */
203  TK_ENDIF = 280, /* TK_ENDIF */
204  TK_END = 281, /* TK_END */
205  TK_ENTRY = 282, /* TK_ENTRY */
206  TK_EQUIVALENCE = 283, /* TK_EQUIVALENCE */
207  TK_EXIT = 284, /* TK_EXIT */
208  TK_EXTERNAL = 285, /* TK_EXTERNAL */
209  TK_FORMAT = 286, /* TK_FORMAT */
210  TK_FUNCTION = 287, /* TK_FUNCTION */
211  TK_GOTO = 288, /* TK_GOTO */
212  TK_IF = 289, /* TK_IF */
213  TK_IMPLICIT = 290, /* TK_IMPLICIT */
214  TK_INCLUDE = 291, /* TK_INCLUDE */
215  TK_INQUIRE = 292, /* TK_INQUIRE */
216  TK_INTEGER = 293, /* TK_INTEGER */
217  TK_INTRINSIC = 294, /* TK_INTRINSIC */
218  TK_IOSTAT = 295, /* TK_IOSTAT */
219  TK_LOGICAL = 296, /* TK_LOGICAL */
220  TK_OPEN = 297, /* TK_OPEN */
221  TK_PARAMETER = 298, /* TK_PARAMETER */
222  TK_PAUSE = 299, /* TK_PAUSE */
223  TK_POINTER = 300, /* TK_POINTER */
224  TK_PRINT = 301, /* TK_PRINT */
225  TK_PROGRAM = 302, /* TK_PROGRAM */
226  TK_READ = 303, /* TK_READ */
227  TK_REAL = 304, /* TK_REAL */
228  TK_RETURN = 305, /* TK_RETURN */
229  TK_REWIND = 306, /* TK_REWIND */
230  TK_SAVE = 307, /* TK_SAVE */
231  TK_STATIC = 308, /* TK_STATIC */
232  TK_STOP = 309, /* TK_STOP */
233  TK_SUBROUTINE = 310, /* TK_SUBROUTINE */
234  TK_THEN = 311, /* TK_THEN */
235  TK_TO = 312, /* TK_TO */
236  TK_WHILE = 313, /* TK_WHILE */
237  TK_WRITE = 314, /* TK_WRITE */
238  TK_INOUT = 315, /* TK_INOUT */
239  TK_IN = 316, /* TK_IN */
240  TK_OUT = 317, /* TK_OUT */
241  TK_AND = 318, /* TK_AND */
242  TK_EQ = 319, /* TK_EQ */
243  TK_EQV = 320, /* TK_EQV */
244  TK_GE = 321, /* TK_GE */
245  TK_GT = 322, /* TK_GT */
246  TK_LE = 323, /* TK_LE */
247  TK_LT = 324, /* TK_LT */
248  TK_NE = 325, /* TK_NE */
249  TK_NEQV = 326, /* TK_NEQV */
250  TK_NOT = 327, /* TK_NOT */
251  TK_OR = 328, /* TK_OR */
252  TK_TRUE = 329, /* TK_TRUE */
253  TK_FALSE = 330, /* TK_FALSE */
254  TK_NAME = 331, /* TK_NAME */
255  TK_ICON = 332, /* TK_ICON */
256  TK_SCON = 333, /* TK_SCON */
257  TK_RCON = 334, /* TK_RCON */
258  TK_DCON = 335, /* TK_DCON */
259  TK_MINUS = 336, /* TK_MINUS */
260  TK_PLUS = 337, /* TK_PLUS */
261  TK_SLASH = 338, /* TK_SLASH */
262  TK_STAR = 339, /* TK_STAR */
263  TK_POWER = 340, /* TK_POWER */
264  TK_LPAR = 341, /* TK_LPAR */
265  TK_RPAR = 342, /* TK_RPAR */
266  TK_COMMA = 343, /* TK_COMMA */
267  TK_COLON = 344, /* TK_COLON */
268  TK_EQUALS = 345, /* TK_EQUALS */
269  TK_CURRENCY = 346, /* TK_CURRENCY */
270  TK_CONCAT = 347, /* TK_CONCAT */
271  TK_EOS = 348, /* TK_EOS */
272  TK_IOLPAR = 349 /* TK_IOLPAR */
273  };
274  typedef enum yytokentype yytoken_kind_t;
275 #endif
276 /* Token kinds. */
277 #define YYEMPTY -2
278 #define YYEOF 0
279 #define YYerror 256
280 #define YYUNDEF 257
281 #define TK_ASSIGN 258
282 #define TK_BACKSPACE 259
283 #define TK_BLANK 260
284 #define TK_BLOCKDATA 261
285 #define TK_BUFFERIN 262
286 #define TK_BUFFEROUT 263
287 #define TK_CALL 264
288 #define TK_CHARACTER 265
289 #define TK_CLOSE 266
290 #define TK_COMMON 267
291 #define TK_COMPLEX 268
292 #define TK_CONTINUE 269
293 #define TK_CYCLE 270
294 #define TK_DATA 271
295 #define TK_DIMENSION 272
296 #define TK_DOUBLEPRECISION 273
297 #define TK_DOUBLECOMPLEX 274
298 #define TK_DO 275
299 #define TK_ELSEIF 276
300 #define TK_ELSE 277
301 #define TK_ENDFILE 278
302 #define TK_ENDDO 279
303 #define TK_ENDIF 280
304 #define TK_END 281
305 #define TK_ENTRY 282
306 #define TK_EQUIVALENCE 283
307 #define TK_EXIT 284
308 #define TK_EXTERNAL 285
309 #define TK_FORMAT 286
310 #define TK_FUNCTION 287
311 #define TK_GOTO 288
312 #define TK_IF 289
313 #define TK_IMPLICIT 290
314 #define TK_INCLUDE 291
315 #define TK_INQUIRE 292
316 #define TK_INTEGER 293
317 #define TK_INTRINSIC 294
318 #define TK_IOSTAT 295
319 #define TK_LOGICAL 296
320 #define TK_OPEN 297
321 #define TK_PARAMETER 298
322 #define TK_PAUSE 299
323 #define TK_POINTER 300
324 #define TK_PRINT 301
325 #define TK_PROGRAM 302
326 #define TK_READ 303
327 #define TK_REAL 304
328 #define TK_RETURN 305
329 #define TK_REWIND 306
330 #define TK_SAVE 307
331 #define TK_STATIC 308
332 #define TK_STOP 309
333 #define TK_SUBROUTINE 310
334 #define TK_THEN 311
335 #define TK_TO 312
336 #define TK_WHILE 313
337 #define TK_WRITE 314
338 #define TK_INOUT 315
339 #define TK_IN 316
340 #define TK_OUT 317
341 #define TK_AND 318
342 #define TK_EQ 319
343 #define TK_EQV 320
344 #define TK_GE 321
345 #define TK_GT 322
346 #define TK_LE 323
347 #define TK_LT 324
348 #define TK_NE 325
349 #define TK_NEQV 326
350 #define TK_NOT 327
351 #define TK_OR 328
352 #define TK_TRUE 329
353 #define TK_FALSE 330
354 #define TK_NAME 331
355 #define TK_ICON 332
356 #define TK_SCON 333
357 #define TK_RCON 334
358 #define TK_DCON 335
359 #define TK_MINUS 336
360 #define TK_PLUS 337
361 #define TK_SLASH 338
362 #define TK_STAR 339
363 #define TK_POWER 340
364 #define TK_LPAR 341
365 #define TK_RPAR 342
366 #define TK_COMMA 343
367 #define TK_COLON 344
368 #define TK_EQUALS 345
369 #define TK_CURRENCY 346
370 #define TK_CONCAT 347
371 #define TK_EOS 348
372 #define TK_IOLPAR 349
373 
374 /* Value type. */
375 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
376 union YYSTYPE
377 {
378 #line 358 "yacc.in"
379 
380  basic basic;
381  chain chain;
382  char character;
383  cons * liste;
384  dataval dataval;
385  datavar datavar;
386  dimension dimension;
387  entity entity;
388  expression expression;
389  instruction instruction;
390  int integer;
391  range range;
392  string string;
393  syntax syntax;
394  tag tag;
395  type type;
396  value value;
397 
398 #line 399 "y.tab.c"
399 
400 };
401 typedef union YYSTYPE YYSTYPE;
402 # define YYSTYPE_IS_TRIVIAL 1
403 # define YYSTYPE_IS_DECLARED 1
404 #endif
405 
406 
407 extern YYSTYPE syn_lval;
408 
409 
410 int syn_parse (void);
411 
412 
413 #endif /* !YY_SYN_Y_TAB_H_INCLUDED */
414 /* Symbol kind. */
415 enum yysymbol_kind_t
416 {
417  YYSYMBOL_YYEMPTY = -2,
418  YYSYMBOL_YYEOF = 0, /* "end of file" */
419  YYSYMBOL_YYerror = 1, /* error */
420  YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
421  YYSYMBOL_TK_ASSIGN = 3, /* TK_ASSIGN */
422  YYSYMBOL_TK_BACKSPACE = 4, /* TK_BACKSPACE */
423  YYSYMBOL_TK_BLANK = 5, /* TK_BLANK */
424  YYSYMBOL_TK_BLOCKDATA = 6, /* TK_BLOCKDATA */
425  YYSYMBOL_TK_BUFFERIN = 7, /* TK_BUFFERIN */
426  YYSYMBOL_TK_BUFFEROUT = 8, /* TK_BUFFEROUT */
427  YYSYMBOL_TK_CALL = 9, /* TK_CALL */
428  YYSYMBOL_TK_CHARACTER = 10, /* TK_CHARACTER */
429  YYSYMBOL_TK_CLOSE = 11, /* TK_CLOSE */
430  YYSYMBOL_TK_COMMON = 12, /* TK_COMMON */
431  YYSYMBOL_TK_COMPLEX = 13, /* TK_COMPLEX */
432  YYSYMBOL_TK_CONTINUE = 14, /* TK_CONTINUE */
433  YYSYMBOL_TK_CYCLE = 15, /* TK_CYCLE */
434  YYSYMBOL_TK_DATA = 16, /* TK_DATA */
435  YYSYMBOL_TK_DIMENSION = 17, /* TK_DIMENSION */
436  YYSYMBOL_TK_DOUBLEPRECISION = 18, /* TK_DOUBLEPRECISION */
437  YYSYMBOL_TK_DOUBLECOMPLEX = 19, /* TK_DOUBLECOMPLEX */
438  YYSYMBOL_TK_DO = 20, /* TK_DO */
439  YYSYMBOL_TK_ELSEIF = 21, /* TK_ELSEIF */
440  YYSYMBOL_TK_ELSE = 22, /* TK_ELSE */
441  YYSYMBOL_TK_ENDFILE = 23, /* TK_ENDFILE */
442  YYSYMBOL_TK_ENDDO = 24, /* TK_ENDDO */
443  YYSYMBOL_TK_ENDIF = 25, /* TK_ENDIF */
444  YYSYMBOL_TK_END = 26, /* TK_END */
445  YYSYMBOL_TK_ENTRY = 27, /* TK_ENTRY */
446  YYSYMBOL_TK_EQUIVALENCE = 28, /* TK_EQUIVALENCE */
447  YYSYMBOL_TK_EXIT = 29, /* TK_EXIT */
448  YYSYMBOL_TK_EXTERNAL = 30, /* TK_EXTERNAL */
449  YYSYMBOL_TK_FORMAT = 31, /* TK_FORMAT */
450  YYSYMBOL_TK_FUNCTION = 32, /* TK_FUNCTION */
451  YYSYMBOL_TK_GOTO = 33, /* TK_GOTO */
452  YYSYMBOL_TK_IF = 34, /* TK_IF */
453  YYSYMBOL_TK_IMPLICIT = 35, /* TK_IMPLICIT */
454  YYSYMBOL_TK_INCLUDE = 36, /* TK_INCLUDE */
455  YYSYMBOL_TK_INQUIRE = 37, /* TK_INQUIRE */
456  YYSYMBOL_TK_INTEGER = 38, /* TK_INTEGER */
457  YYSYMBOL_TK_INTRINSIC = 39, /* TK_INTRINSIC */
458  YYSYMBOL_TK_IOSTAT = 40, /* TK_IOSTAT */
459  YYSYMBOL_TK_LOGICAL = 41, /* TK_LOGICAL */
460  YYSYMBOL_TK_OPEN = 42, /* TK_OPEN */
461  YYSYMBOL_TK_PARAMETER = 43, /* TK_PARAMETER */
462  YYSYMBOL_TK_PAUSE = 44, /* TK_PAUSE */
463  YYSYMBOL_TK_POINTER = 45, /* TK_POINTER */
464  YYSYMBOL_TK_PRINT = 46, /* TK_PRINT */
465  YYSYMBOL_TK_PROGRAM = 47, /* TK_PROGRAM */
466  YYSYMBOL_TK_READ = 48, /* TK_READ */
467  YYSYMBOL_TK_REAL = 49, /* TK_REAL */
468  YYSYMBOL_TK_RETURN = 50, /* TK_RETURN */
469  YYSYMBOL_TK_REWIND = 51, /* TK_REWIND */
470  YYSYMBOL_TK_SAVE = 52, /* TK_SAVE */
471  YYSYMBOL_TK_STATIC = 53, /* TK_STATIC */
472  YYSYMBOL_TK_STOP = 54, /* TK_STOP */
473  YYSYMBOL_TK_SUBROUTINE = 55, /* TK_SUBROUTINE */
474  YYSYMBOL_TK_THEN = 56, /* TK_THEN */
475  YYSYMBOL_TK_TO = 57, /* TK_TO */
476  YYSYMBOL_TK_WHILE = 58, /* TK_WHILE */
477  YYSYMBOL_TK_WRITE = 59, /* TK_WRITE */
478  YYSYMBOL_TK_INOUT = 60, /* TK_INOUT */
479  YYSYMBOL_TK_IN = 61, /* TK_IN */
480  YYSYMBOL_TK_OUT = 62, /* TK_OUT */
481  YYSYMBOL_TK_AND = 63, /* TK_AND */
482  YYSYMBOL_TK_EQ = 64, /* TK_EQ */
483  YYSYMBOL_TK_EQV = 65, /* TK_EQV */
484  YYSYMBOL_TK_GE = 66, /* TK_GE */
485  YYSYMBOL_TK_GT = 67, /* TK_GT */
486  YYSYMBOL_TK_LE = 68, /* TK_LE */
487  YYSYMBOL_TK_LT = 69, /* TK_LT */
488  YYSYMBOL_TK_NE = 70, /* TK_NE */
489  YYSYMBOL_TK_NEQV = 71, /* TK_NEQV */
490  YYSYMBOL_TK_NOT = 72, /* TK_NOT */
491  YYSYMBOL_TK_OR = 73, /* TK_OR */
492  YYSYMBOL_TK_TRUE = 74, /* TK_TRUE */
493  YYSYMBOL_TK_FALSE = 75, /* TK_FALSE */
494  YYSYMBOL_TK_NAME = 76, /* TK_NAME */
495  YYSYMBOL_TK_ICON = 77, /* TK_ICON */
496  YYSYMBOL_TK_SCON = 78, /* TK_SCON */
497  YYSYMBOL_TK_RCON = 79, /* TK_RCON */
498  YYSYMBOL_TK_DCON = 80, /* TK_DCON */
499  YYSYMBOL_TK_MINUS = 81, /* TK_MINUS */
500  YYSYMBOL_TK_PLUS = 82, /* TK_PLUS */
501  YYSYMBOL_TK_SLASH = 83, /* TK_SLASH */
502  YYSYMBOL_TK_STAR = 84, /* TK_STAR */
503  YYSYMBOL_TK_POWER = 85, /* TK_POWER */
504  YYSYMBOL_TK_LPAR = 86, /* TK_LPAR */
505  YYSYMBOL_TK_RPAR = 87, /* TK_RPAR */
506  YYSYMBOL_TK_COMMA = 88, /* TK_COMMA */
507  YYSYMBOL_TK_COLON = 89, /* TK_COLON */
508  YYSYMBOL_TK_EQUALS = 90, /* TK_EQUALS */
509  YYSYMBOL_TK_CURRENCY = 91, /* TK_CURRENCY */
510  YYSYMBOL_TK_CONCAT = 92, /* TK_CONCAT */
511  YYSYMBOL_TK_EOS = 93, /* TK_EOS */
512  YYSYMBOL_TK_IOLPAR = 94, /* TK_IOLPAR */
513  YYSYMBOL_YYACCEPT = 95, /* $accept */
514  YYSYMBOL_lprg_exec = 96, /* lprg_exec */
515  YYSYMBOL_prg_exec = 97, /* prg_exec */
516  YYSYMBOL_98_1 = 98, /* $@1 */
517  YYSYMBOL_99_2 = 99, /* $@2 */
518  YYSYMBOL_100_3 = 100, /* $@3 */
519  YYSYMBOL_begin_inst = 101, /* begin_inst */
520  YYSYMBOL_entry_inst = 102, /* entry_inst */
521  YYSYMBOL_end_inst = 103, /* end_inst */
522  YYSYMBOL_linstruction = 104, /* linstruction */
523  YYSYMBOL_instruction = 105, /* instruction */
524  YYSYMBOL_106_4 = 106, /* $@4 */
525  YYSYMBOL_107_5 = 107, /* $@5 */
526  YYSYMBOL_inst_spec = 108, /* inst_spec */
527  YYSYMBOL_inst_exec = 109, /* inst_exec */
528  YYSYMBOL_return_inst = 110, /* return_inst */
529  YYSYMBOL_call_inst = 111, /* call_inst */
530  YYSYMBOL_tk_call = 112, /* tk_call */
531  YYSYMBOL_parameters = 113, /* parameters */
532  YYSYMBOL_arguments = 114, /* arguments */
533  YYSYMBOL_io_inst = 115, /* io_inst */
534  YYSYMBOL_io_f_u_id = 116, /* io_f_u_id */
535  YYSYMBOL_lci = 117, /* lci */
536  YYSYMBOL_ci = 118, /* ci */
537  YYSYMBOL_opt_lio_elem = 119, /* opt_lio_elem */
538  YYSYMBOL_lio_elem = 120, /* lio_elem */
539  YYSYMBOL_io_elem = 121, /* io_elem */
540  YYSYMBOL_pause_inst = 122, /* pause_inst */
541  YYSYMBOL_stop_inst = 123, /* stop_inst */
542  YYSYMBOL_continue_inst = 124, /* continue_inst */
543  YYSYMBOL_do_inst = 125, /* do_inst */
544  YYSYMBOL_bdo_inst = 126, /* bdo_inst */
545  YYSYMBOL_wdo_inst = 127, /* wdo_inst */
546  YYSYMBOL_do_plage = 128, /* do_plage */
547  YYSYMBOL_endif_inst = 129, /* endif_inst */
548  YYSYMBOL_enddo_inst = 130, /* enddo_inst */
549  YYSYMBOL_else_inst = 131, /* else_inst */
550  YYSYMBOL_elseif_inst = 132, /* elseif_inst */
551  YYSYMBOL_blockif_inst = 133, /* blockif_inst */
552  YYSYMBOL_logicalif_inst = 134, /* logicalif_inst */
553  YYSYMBOL_arithmif_inst = 135, /* arithmif_inst */
554  YYSYMBOL_goto_inst = 136, /* goto_inst */
555  YYSYMBOL_licon = 137, /* licon */
556  YYSYMBOL_assignment_inst = 138, /* assignment_inst */
557  YYSYMBOL_format_inst = 139, /* format_inst */
558  YYSYMBOL_save_inst = 140, /* save_inst */
559  YYSYMBOL_lsavename = 141, /* lsavename */
560  YYSYMBOL_savename = 142, /* savename */
561  YYSYMBOL_intrinsic_inst = 143, /* intrinsic_inst */
562  YYSYMBOL_external_inst = 144, /* external_inst */
563  YYSYMBOL_type_inst = 145, /* type_inst */
564  YYSYMBOL_declaration = 146, /* declaration */
565  YYSYMBOL_decl_tableau = 147, /* decl_tableau */
566  YYSYMBOL_ldim_tableau = 148, /* ldim_tableau */
567  YYSYMBOL_dim_tableau = 149, /* dim_tableau */
568  YYSYMBOL_common_inst = 150, /* common_inst */
569  YYSYMBOL_common = 151, /* common */
570  YYSYMBOL_common_name = 152, /* common_name */
571  YYSYMBOL_pointer_inst = 153, /* pointer_inst */
572  YYSYMBOL_equivalence_inst = 154, /* equivalence_inst */
573  YYSYMBOL_lequivchain = 155, /* lequivchain */
574  YYSYMBOL_equivchain = 156, /* equivchain */
575  YYSYMBOL_latom = 157, /* latom */
576  YYSYMBOL_dimension_inst = 158, /* dimension_inst */
577  YYSYMBOL_dimension = 159, /* dimension */
578  YYSYMBOL_data_inst = 160, /* data_inst */
579  YYSYMBOL_ldatavar = 161, /* ldatavar */
580  YYSYMBOL_ldataval = 162, /* ldataval */
581  YYSYMBOL_dataval = 163, /* dataval */
582  YYSYMBOL_dataconst = 164, /* dataconst */
583  YYSYMBOL_datavar = 165, /* datavar */
584  YYSYMBOL_dataidl = 166, /* dataidl */
585  YYSYMBOL_implicit_inst = 167, /* implicit_inst */
586  YYSYMBOL_limplicit = 168, /* limplicit */
587  YYSYMBOL_implicit = 169, /* implicit */
588  YYSYMBOL_l_letter_letter = 170, /* l_letter_letter */
589  YYSYMBOL_letter_letter = 171, /* letter_letter */
590  YYSYMBOL_letter = 172, /* letter */
591  YYSYMBOL_parameter_inst = 173, /* parameter_inst */
592  YYSYMBOL_lparametre = 174, /* lparametre */
593  YYSYMBOL_parametre = 175, /* parametre */
594  YYSYMBOL_entity_name = 176, /* entity_name */
595  YYSYMBOL_name = 177, /* name */
596  YYSYMBOL_module_name = 178, /* module_name */
597  YYSYMBOL_global_entity_name = 179, /* global_entity_name */
598  YYSYMBOL_functional_entity_name = 180, /* functional_entity_name */
599  YYSYMBOL_global_name = 181, /* global_name */
600  YYSYMBOL_opt_lformalparameter = 182, /* opt_lformalparameter */
601  YYSYMBOL_lformalparameter = 183, /* lformalparameter */
602  YYSYMBOL_opt_fortran_type = 184, /* opt_fortran_type */
603  YYSYMBOL_fortran_type = 185, /* fortran_type */
604  YYSYMBOL_fortran_basic_type = 186, /* fortran_basic_type */
605  YYSYMBOL_lg_fortran_type = 187, /* lg_fortran_type */
606  YYSYMBOL_atom = 188, /* atom */
607  YYSYMBOL_indices = 189, /* indices */
608  YYSYMBOL_lexpression = 190, /* lexpression */
609  YYSYMBOL_opt_expression = 191, /* opt_expression */
610  YYSYMBOL_expression = 192, /* expression */
611  YYSYMBOL_sous_expression = 193, /* sous_expression */
612  YYSYMBOL_io_expr = 194, /* io_expr */
613  YYSYMBOL_unpar_io_expr = 195, /* unpar_io_expr */
614  YYSYMBOL_const_simple = 196, /* const_simple */
615  YYSYMBOL_unsigned_const_simple = 197, /* unsigned_const_simple */
616  YYSYMBOL_icon = 198, /* icon */
617  YYSYMBOL_label = 199, /* label */
618  YYSYMBOL_ival = 200, /* ival */
619  YYSYMBOL_opt_signe = 201, /* opt_signe */
620  YYSYMBOL_signe = 202, /* signe */
621  YYSYMBOL_oper_rela = 203, /* oper_rela */
622  YYSYMBOL_io_keyword = 204, /* io_keyword */
623  YYSYMBOL_iobuf_keyword = 205, /* iobuf_keyword */
624  YYSYMBOL_psf_keyword = 206, /* psf_keyword */
625  YYSYMBOL_opt_virgule = 207 /* opt_virgule */
626 };
627 typedef enum yysymbol_kind_t yysymbol_kind_t;
628 
629 
630 
631 
632 #ifdef short
633 # undef short
634 #endif
635 
636 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
637  <limits.h> and (if available) <stdint.h> are included
638  so that the code can choose integer types of a good width. */
639 
640 #ifndef __PTRDIFF_MAX__
641 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
642 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
643 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
644 # define YY_STDINT_H
645 # endif
646 #endif
647 
648 /* Narrow types that promote to a signed type and that can represent a
649  signed or unsigned integer of at least N bits. In tables they can
650  save space and decrease cache pressure. Promoting to a signed type
651  helps avoid bugs in integer arithmetic. */
652 
653 #ifdef __INT_LEAST8_MAX__
654 typedef __INT_LEAST8_TYPE__ yytype_int8;
655 #elif defined YY_STDINT_H
656 typedef int_least8_t yytype_int8;
657 #else
658 typedef signed char yytype_int8;
659 #endif
660 
661 #ifdef __INT_LEAST16_MAX__
662 typedef __INT_LEAST16_TYPE__ yytype_int16;
663 #elif defined YY_STDINT_H
664 typedef int_least16_t yytype_int16;
665 #else
666 typedef short yytype_int16;
667 #endif
668 
669 /* Work around bug in HP-UX 11.23, which defines these macros
670  incorrectly for preprocessor constants. This workaround can likely
671  be removed in 2023, as HPE has promised support for HP-UX 11.23
672  (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
673  <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
674 #ifdef __hpux
675 # undef UINT_LEAST8_MAX
676 # undef UINT_LEAST16_MAX
677 # define UINT_LEAST8_MAX 255
678 # define UINT_LEAST16_MAX 65535
679 #endif
680 
681 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
682 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
683 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
684  && UINT_LEAST8_MAX <= INT_MAX)
685 typedef uint_least8_t yytype_uint8;
686 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
687 typedef unsigned char yytype_uint8;
688 #else
689 typedef short yytype_uint8;
690 #endif
691 
692 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
693 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
694 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
695  && UINT_LEAST16_MAX <= INT_MAX)
696 typedef uint_least16_t yytype_uint16;
697 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
698 typedef unsigned short yytype_uint16;
699 #else
700 typedef int yytype_uint16;
701 #endif
702 
703 #ifndef YYPTRDIFF_T
704 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
705 # define YYPTRDIFF_T __PTRDIFF_TYPE__
706 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
707 # elif defined PTRDIFF_MAX
708 # ifndef ptrdiff_t
709 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
710 # endif
711 # define YYPTRDIFF_T ptrdiff_t
712 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
713 # else
714 # define YYPTRDIFF_T long
715 # define YYPTRDIFF_MAXIMUM LONG_MAX
716 # endif
717 #endif
718 
719 #ifndef YYSIZE_T
720 # ifdef __SIZE_TYPE__
721 # define YYSIZE_T __SIZE_TYPE__
722 # elif defined size_t
723 # define YYSIZE_T size_t
724 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
725 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
726 # define YYSIZE_T size_t
727 # else
728 # define YYSIZE_T unsigned
729 # endif
730 #endif
731 
732 #define YYSIZE_MAXIMUM \
733  YY_CAST (YYPTRDIFF_T, \
734  (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
735  ? YYPTRDIFF_MAXIMUM \
736  : YY_CAST (YYSIZE_T, -1)))
737 
738 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
739 
740 
741 /* Stored state numbers (used for stacks). */
742 typedef yytype_int16 yy_state_t;
743 
744 /* State numbers in computations. */
745 typedef int yy_state_fast_t;
746 
747 #ifndef YY_
748 # if defined YYENABLE_NLS && YYENABLE_NLS
749 # if ENABLE_NLS
750 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
751 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
752 # endif
753 # endif
754 # ifndef YY_
755 # define YY_(Msgid) Msgid
756 # endif
757 #endif
758 
759 
760 #ifndef YY_ATTRIBUTE_PURE
761 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
762 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
763 # else
764 # define YY_ATTRIBUTE_PURE
765 # endif
766 #endif
767 
768 #ifndef YY_ATTRIBUTE_UNUSED
769 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
770 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
771 # else
772 # define YY_ATTRIBUTE_UNUSED
773 # endif
774 #endif
775 
776 /* Suppress unused-variable warnings by "using" E. */
777 #if ! defined lint || defined __GNUC__
778 # define YY_USE(E) ((void) (E))
779 #else
780 # define YY_USE(E) /* empty */
781 #endif
782 
783 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
784 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
785 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407
786 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
787  _Pragma ("GCC diagnostic push") \
788  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
789 # else
790 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
791  _Pragma ("GCC diagnostic push") \
792  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
793  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
794 # endif
795 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
796  _Pragma ("GCC diagnostic pop")
797 #else
798 # define YY_INITIAL_VALUE(Value) Value
799 #endif
800 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
801 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
802 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
803 #endif
804 #ifndef YY_INITIAL_VALUE
805 # define YY_INITIAL_VALUE(Value) /* Nothing. */
806 #endif
807 
808 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
809 # define YY_IGNORE_USELESS_CAST_BEGIN \
810  _Pragma ("GCC diagnostic push") \
811  _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
812 # define YY_IGNORE_USELESS_CAST_END \
813  _Pragma ("GCC diagnostic pop")
814 #endif
815 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
816 # define YY_IGNORE_USELESS_CAST_BEGIN
817 # define YY_IGNORE_USELESS_CAST_END
818 #endif
819 
820 
821 #define YY_ASSERT(E) ((void) (0 && (E)))
822 
823 #if !defined yyoverflow
824 
825 /* The parser invokes alloca or malloc; define the necessary symbols. */
826 
827 # ifdef YYSTACK_USE_ALLOCA
828 # if YYSTACK_USE_ALLOCA
829 # ifdef __GNUC__
830 # define YYSTACK_ALLOC __builtin_alloca
831 # elif defined __BUILTIN_VA_ARG_INCR
832 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
833 # elif defined _AIX
834 # define YYSTACK_ALLOC __alloca
835 # elif defined _MSC_VER
836 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
837 # define alloca _alloca
838 # else
839 # define YYSTACK_ALLOC alloca
840 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
841 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
842  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
843 # ifndef EXIT_SUCCESS
844 # define EXIT_SUCCESS 0
845 # endif
846 # endif
847 # endif
848 # endif
849 # endif
850 
851 # ifdef YYSTACK_ALLOC
852  /* Pacify GCC's 'empty if-body' warning. */
853 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
854 # ifndef YYSTACK_ALLOC_MAXIMUM
855  /* The OS might guarantee only one guard page at the bottom of the stack,
856  and a page size can be as small as 4096 bytes. So we cannot safely
857  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
858  to allow for a few compiler-allocated temporary stack slots. */
859 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
860 # endif
861 # else
862 # define YYSTACK_ALLOC YYMALLOC
863 # define YYSTACK_FREE YYFREE
864 # ifndef YYSTACK_ALLOC_MAXIMUM
865 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
866 # endif
867 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
868  && ! ((defined YYMALLOC || defined malloc) \
869  && (defined YYFREE || defined free)))
870 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
871 # ifndef EXIT_SUCCESS
872 # define EXIT_SUCCESS 0
873 # endif
874 # endif
875 # ifndef YYMALLOC
876 # define YYMALLOC malloc
877 # if ! defined malloc && ! defined EXIT_SUCCESS
878 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
879 # endif
880 # endif
881 # ifndef YYFREE
882 # define YYFREE free
883 # if ! defined free && ! defined EXIT_SUCCESS
884 void free (void *); /* INFRINGES ON USER NAME SPACE */
885 # endif
886 # endif
887 # endif
888 #endif /* !defined yyoverflow */
889 
890 #if (! defined yyoverflow \
891  && (! defined __cplusplus \
892  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
893 
894 /* A type that is properly aligned for any stack member. */
895 union yyalloc
896 {
897  yy_state_t yyss_alloc;
898  YYSTYPE yyvs_alloc;
899 };
900 
901 /* The size of the maximum gap between one aligned stack and the next. */
902 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
903 
904 /* The size of an array large to enough to hold all stacks, each with
905  N elements. */
906 # define YYSTACK_BYTES(N) \
907  ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
908  + YYSTACK_GAP_MAXIMUM)
909 
910 # define YYCOPY_NEEDED 1
911 
912 /* Relocate STACK from its old location to the new one. The
913  local variables YYSIZE and YYSTACKSIZE give the old and new number of
914  elements in the stack, and YYPTR gives the new location of the
915  stack. Advance YYPTR to a properly aligned location for the next
916  stack. */
917 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
918  do \
919  { \
920  YYPTRDIFF_T yynewbytes; \
921  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
922  Stack = &yyptr->Stack_alloc; \
923  yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
924  yyptr += yynewbytes / YYSIZEOF (*yyptr); \
925  } \
926  while (0)
927 
928 #endif
929 
930 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
931 /* Copy COUNT objects from SRC to DST. The source and destination do
932  not overlap. */
933 # ifndef YYCOPY
934 # if defined __GNUC__ && 1 < __GNUC__
935 # define YYCOPY(Dst, Src, Count) \
936  __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
937 # else
938 # define YYCOPY(Dst, Src, Count) \
939  do \
940  { \
941  YYPTRDIFF_T yyi; \
942  for (yyi = 0; yyi < (Count); yyi++) \
943  (Dst)[yyi] = (Src)[yyi]; \
944  } \
945  while (0)
946 # endif
947 # endif
948 #endif /* !YYCOPY_NEEDED */
949 
950 /* YYFINAL -- State number of the termination state. */
951 #define YYFINAL 14
952 /* YYLAST -- Last index in YYTABLE. */
953 #define YYLAST 1222
954 
955 /* YYNTOKENS -- Number of terminals. */
956 #define YYNTOKENS 95
957 /* YYNNTS -- Number of nonterminals. */
958 #define YYNNTS 113
959 /* YYNRULES -- Number of rules. */
960 #define YYNRULES 271
961 /* YYNSTATES -- Number of states. */
962 #define YYNSTATES 465
963 
964 /* YYMAXUTOK -- Last valid token kind. */
965 #define YYMAXUTOK 349
966 
967 
968 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
969  as returned by yylex, with out-of-bounds checking. */
970 #define YYTRANSLATE(YYX) \
971  (0 <= (YYX) && (YYX) <= YYMAXUTOK \
972  ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
973  : YYSYMBOL_YYUNDEF)
974 
975 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
976  as returned by yylex. */
977 static const yytype_int8 yytranslate[] =
978 {
979  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
980  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
981  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
982  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
983  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
984  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
985  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
986  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
987  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
988  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
989  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
990  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
991  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
992  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
993  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
994  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
995  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
996  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
997  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
998  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
999  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1000  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1001  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1002  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1003  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1004  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1005  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1006  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1007  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1008  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1009  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1010  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1011  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1012  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1013  85, 86, 87, 88, 89, 90, 91, 92, 93, 94
1014 };
1015 
1016 #if YYDEBUG
1017 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1018 static const yytype_int16 yyrline[] =
1019 {
1020  0, 380, 380, 381, 386, 386, 386, 387, 387, 390,
1021  397, 413, 417, 418, 419, 423, 443, 443, 444, 444,
1022  449, 455, 456, 457, 458, 459, 460, 461, 462, 463,
1023  464, 467, 469, 471, 473, 475, 477, 479, 481, 483,
1024  485, 487, 489, 491, 493, 495, 497, 499, 501, 503,
1025  507, 511, 514, 518, 522, 524, 528, 532, 536, 543,
1026  553, 557, 561, 563, 568, 569, 573, 575, 586, 603,
1027  623, 642, 643, 647, 649, 653, 657, 661, 665, 669,
1028  676, 683, 690, 699, 705, 714, 718, 722, 726, 737,
1029  746, 754, 763, 767, 773, 783, 795, 799, 805, 816,
1030  830, 838, 840, 841, 844, 845, 848, 850, 854, 858,
1031  864, 869, 875, 877, 880, 919, 922, 928, 932, 938,
1032  949, 955, 961, 976, 981, 986, 991, 999, 1005, 1009,
1033  1015, 1021, 1024, 1025, 1028, 1032, 1036, 1044, 1047, 1052,
1034  1058, 1063, 1070, 1074, 1081, 1085, 1091, 1095, 1101, 1105,
1035  1109, 1143, 1147, 1151, 1160, 1167, 1170, 1175, 1180, 1183,
1036  1188, 1197, 1208, 1214, 1217, 1218, 1221, 1227, 1249, 1253,
1037  1264, 1272, 1280, 1285, 1288, 1292, 1300, 1304, 1312, 1316,
1038  1326, 1331, 1336, 1349, 1354, 1359, 1364, 1369, 1374, 1379,
1039  1387, 1398, 1402, 1406, 1412, 1417, 1422, 1426, 1432, 1434,
1040  1438, 1442, 1448, 1455, 1458, 1460, 1462, 1471, 1473, 1477,
1041  1481, 1485, 1492, 1496, 1500, 1504, 1508, 1513, 1517, 1522,
1042  1527, 1533, 1539, 1544, 1551, 1552, 1556, 1561, 1565, 1572,
1043  1576, 1580, 1584, 1588, 1593, 1600, 1610, 1614, 1618, 1622,
1044  1628, 1633, 1640, 1647, 1653, 1661, 1664, 1670, 1674, 1680,
1045  1684, 1688, 1692, 1696, 1700, 1706, 1708, 1710, 1712, 1714,
1046  1716, 1718, 1720, 1722, 1726, 1728, 1732, 1734, 1737, 1740,
1047  1744, 1745
1048 };
1049 #endif
1050 
1051 /** Accessing symbol of state STATE. */
1052 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
1053 
1054 #if YYDEBUG || 0
1055 /* The user-facing name of the symbol whose (internal) number is
1056  YYSYMBOL. No bounds checking. */
1057 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
1058 
1059 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1060  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1061 static const char *const yytname[] =
1062 {
1063  "\"end of file\"", "error", "\"invalid token\"", "TK_ASSIGN",
1064  "TK_BACKSPACE", "TK_BLANK", "TK_BLOCKDATA", "TK_BUFFERIN",
1065  "TK_BUFFEROUT", "TK_CALL", "TK_CHARACTER", "TK_CLOSE", "TK_COMMON",
1066  "TK_COMPLEX", "TK_CONTINUE", "TK_CYCLE", "TK_DATA", "TK_DIMENSION",
1067  "TK_DOUBLEPRECISION", "TK_DOUBLECOMPLEX", "TK_DO", "TK_ELSEIF",
1068  "TK_ELSE", "TK_ENDFILE", "TK_ENDDO", "TK_ENDIF", "TK_END", "TK_ENTRY",
1069  "TK_EQUIVALENCE", "TK_EXIT", "TK_EXTERNAL", "TK_FORMAT", "TK_FUNCTION",
1070  "TK_GOTO", "TK_IF", "TK_IMPLICIT", "TK_INCLUDE", "TK_INQUIRE",
1071  "TK_INTEGER", "TK_INTRINSIC", "TK_IOSTAT", "TK_LOGICAL", "TK_OPEN",
1072  "TK_PARAMETER", "TK_PAUSE", "TK_POINTER", "TK_PRINT", "TK_PROGRAM",
1073  "TK_READ", "TK_REAL", "TK_RETURN", "TK_REWIND", "TK_SAVE", "TK_STATIC",
1074  "TK_STOP", "TK_SUBROUTINE", "TK_THEN", "TK_TO", "TK_WHILE", "TK_WRITE",
1075  "TK_INOUT", "TK_IN", "TK_OUT", "TK_AND", "TK_EQ", "TK_EQV", "TK_GE",
1076  "TK_GT", "TK_LE", "TK_LT", "TK_NE", "TK_NEQV", "TK_NOT", "TK_OR",
1077  "TK_TRUE", "TK_FALSE", "TK_NAME", "TK_ICON", "TK_SCON", "TK_RCON",
1078  "TK_DCON", "TK_MINUS", "TK_PLUS", "TK_SLASH", "TK_STAR", "TK_POWER",
1079  "TK_LPAR", "TK_RPAR", "TK_COMMA", "TK_COLON", "TK_EQUALS", "TK_CURRENCY",
1080  "TK_CONCAT", "TK_EOS", "TK_IOLPAR", "$accept", "lprg_exec", "prg_exec",
1081  "$@1", "$@2", "$@3", "begin_inst", "entry_inst", "end_inst",
1082  "linstruction", "instruction", "$@4", "$@5", "inst_spec", "inst_exec",
1083  "return_inst", "call_inst", "tk_call", "parameters", "arguments",
1084  "io_inst", "io_f_u_id", "lci", "ci", "opt_lio_elem", "lio_elem",
1085  "io_elem", "pause_inst", "stop_inst", "continue_inst", "do_inst",
1086  "bdo_inst", "wdo_inst", "do_plage", "endif_inst", "enddo_inst",
1087  "else_inst", "elseif_inst", "blockif_inst", "logicalif_inst",
1088  "arithmif_inst", "goto_inst", "licon", "assignment_inst", "format_inst",
1089  "save_inst", "lsavename", "savename", "intrinsic_inst", "external_inst",
1090  "type_inst", "declaration", "decl_tableau", "ldim_tableau",
1091  "dim_tableau", "common_inst", "common", "common_name", "pointer_inst",
1092  "equivalence_inst", "lequivchain", "equivchain", "latom",
1093  "dimension_inst", "dimension", "data_inst", "ldatavar", "ldataval",
1094  "dataval", "dataconst", "datavar", "dataidl", "implicit_inst",
1095  "limplicit", "implicit", "l_letter_letter", "letter_letter", "letter",
1096  "parameter_inst", "lparametre", "parametre", "entity_name", "name",
1097  "module_name", "global_entity_name", "functional_entity_name",
1098  "global_name", "opt_lformalparameter", "lformalparameter",
1099  "opt_fortran_type", "fortran_type", "fortran_basic_type",
1100  "lg_fortran_type", "atom", "indices", "lexpression", "opt_expression",
1101  "expression", "sous_expression", "io_expr", "unpar_io_expr",
1102  "const_simple", "unsigned_const_simple", "icon", "label", "ival",
1103  "opt_signe", "signe", "oper_rela", "io_keyword", "iobuf_keyword",
1104  "psf_keyword", "opt_virgule", YY_NULLPTR
1105 };
1106 
1107 static const char *
1108 yysymbol_name (yysymbol_kind_t yysymbol)
1109 {
1110  return yytname[yysymbol];
1111 }
1112 #endif
1113 
1114 #define YYPACT_NINF (-310)
1115 
1116 #define yypact_value_is_default(Yyn) \
1117  ((Yyn) == YYPACT_NINF)
1118 
1119 #define YYTABLE_NINF (-271)
1120 
1121 #define yytable_value_is_error(Yyn) \
1122  ((Yyn) == YYTABLE_NINF)
1123 
1124 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1125  STATE-NUM. */
1126 static const yytype_int16 yypact[] =
1127 {
1128  32, -310, -310, -310, -310, -310, -310, -310, 22, -310,
1129  -5, 17, -310, -51, -310, -310, 447, 29, -310, -310,
1130  -310, -310, 3, -21, -310, -38, -310, -310, 653, -3,
1131  691, 602, -310, -57, 5, -310, -310, -18, -310, -310,
1132  213, -310, -310, -38, -8, -310, -310, 14, -310, -310,
1133  29, 36, -310, -310, -310, 24, 42, 32, 3, 40,
1134  46, -7, -7, -310, -310, 34, 48, 57, -11, -7,
1135  -310, -310, 61, 42, -310, -310, 42, 75, -310, -310,
1136  -310, -310, -310, -310, -33, 87, -310, -310, -310, -310,
1137  42, -47, 119, -310, -310, 1097, -310, -310, 1097, -310,
1138  1097, -310, -310, -310, -310, -310, 42, -310, -310, -310,
1139  -310, -310, -310, -310, -310, -310, -310, -310, -310, -310,
1140  -310, -310, -310, 92, 1110, 143, -310, -38, -310, -50,
1141  120, 1097, -310, -310, -310, -310, -310, -310, -310, -310,
1142  151, 1097, -310, 712, -310, -310, -310, 1097, 156, 33,
1143  -38, 251, 169, -310, -310, 42, 173, -310, -310, -310,
1144  175, -310, 180, -310, -310, 42, 42, 3, -310, 179,
1145  -310, -310, -310, 179, 3, 42, 42, 42, -26, -310,
1146  42, 184, 42, -310, -310, 220, 192, -310, 190, -41,
1147  1097, -18, 205, 60, -310, 1097, -310, 982, -310, -310,
1148  200, 1097, -310, 1123, 208, -310, 12, 19, -310, 427,
1149  1123, 4, -310, -310, -310, -35, -310, 127, -310, 682,
1150  1097, -310, 1097, -310, -310, -310, -310, -310, 1097, 1097,
1151  1097, 1097, 1097, 1097, 1097, -310, 1097, 1097, 219, -38,
1152  94, 25, -310, 222, -310, -310, 147, -310, -310, -310,
1153  54, 223, 350, 1097, 99, -310, 24, 32, 232, 101,
1154  -310, 230, 221, 239, -7, -310, -310, -310, -310, 42,
1155  -310, 369, -51, -310, 42, 1097, 1097, -310, 248, 42,
1156  742, -310, 128, -310, 253, 772, 1055, -310, 982, 427,
1157  -310, 130, -310, 250, 85, 1097, 427, 427, 427, 427,
1158  427, 427, 259, -310, 257, 33, -310, 2, -310, 1097,
1159  127, 1009, 1009, 511, 78, 78, 219, 219, 219, 234,
1160  1036, 30, 258, -310, 33, 33, -310, -310, 1097, 1097,
1161  272, -310, 42, -310, -310, -310, 149, -310, 266, -310,
1162  42, 1097, 42, -310, -310, -310, -310, 275, 277, 802,
1163  -310, -310, 832, 862, 1097, 190, 310, 279, 205, 205,
1164  508, 286, -310, 155, 982, 279, 1123, 1136, -310, -310,
1165  282, -310, 982, 96, 96, 259, 259, 259, 268, 1123,
1166  52, -310, -310, 190, 285, 892, 288, 94, -310, -310,
1167  982, 290, 1097, -310, -310, 232, 232, -310, 982, 184,
1168  -310, 369, 1071, -310, 1097, 922, -310, -310, 1097, -310,
1169  163, -310, -310, 291, -310, -310, 1084, 1097, -310, -310,
1170  165, 1097, 295, -310, 297, 1097, -310, -310, 298, -310,
1171  301, -310, -310, 303, -310, -310, 982, 952, -310, 982,
1172  -310, 205, 315, 982, -310, -310, 308, -310, 190, -310,
1173  -310, -310, 1097, 305, -310, 427, 312, 982, 205, 313,
1174  -310, -310, 427, 316, -310
1175 };
1176 
1177 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1178  Performed when YYTABLE does not specify something else to do. Zero
1179  means the default is an error. */
1180 static const yytype_int16 yydefact[] =
1181 {
1182  181, 189, 187, 185, 188, 183, 186, 184, 181, 2,
1183  4, 0, 180, 190, 1, 3, 18, 0, 269, 268,
1184  266, 267, 0, 0, 182, 0, 100, 12, 18, 0,
1185  0, 0, 20, 270, 0, 8, 172, 173, 169, 244,
1186  0, 193, 168, 0, 0, 142, 152, 194, 167, 151,
1187  0, 0, 13, 127, 139, 0, 0, 0, 0, 0,
1188  0, 101, 0, 17, 30, 29, 28, 27, 270, 0,
1189  24, 25, 23, 0, 22, 21, 0, 0, 261, 264,
1190  265, 53, 258, 78, 0, 0, 87, 260, 86, 85,
1191  0, 0, 0, 263, 259, 203, 255, 257, 203, 262,
1192  203, 256, 49, 19, 47, 46, 0, 48, 45, 44,
1193  43, 40, 41, 42, 38, 39, 37, 36, 35, 34,
1194  33, 32, 31, 0, 0, 0, 271, 0, 11, 0,
1195  0, 0, 236, 237, 242, 240, 241, 239, 248, 247,
1196  0, 0, 209, 0, 204, 210, 238, 0, 0, 245,
1197  0, 203, 195, 6, 14, 0, 131, 132, 171, 110,
1198  154, 155, 0, 108, 170, 0, 0, 0, 128, 102,
1199  104, 107, 106, 103, 0, 0, 0, 271, 0, 123,
1200  0, 115, 0, 137, 112, 0, 0, 243, 0, 270,
1201  0, 173, 0, 95, 92, 0, 76, 202, 50, 77,
1202  51, 0, 65, 0, 60, 226, 0, 224, 227, 0,
1203  0, 0, 177, 174, 176, 0, 9, 222, 191, 0,
1204  0, 249, 0, 253, 254, 252, 251, 250, 0, 0,
1205  0, 0, 0, 0, 0, 192, 0, 0, 211, 0,
1206  245, 0, 144, 146, 150, 148, 0, 246, 143, 198,
1207  0, 0, 200, 203, 0, 135, 0, 0, 0, 0,
1208  164, 0, 0, 0, 0, 109, 111, 113, 125, 0,
1209  124, 0, 190, 138, 0, 0, 0, 80, 0, 0,
1210  0, 10, 0, 96, 0, 0, 0, 52, 99, 0,
1211  70, 0, 66, 167, 0, 71, 0, 0, 0, 0,
1212  0, 0, 228, 224, 0, 245, 175, 0, 205, 0,
1213  221, 218, 219, 220, 213, 212, 215, 214, 216, 223,
1214  217, 194, 0, 140, 245, 245, 235, 199, 0, 203,
1215  0, 134, 0, 133, 156, 162, 0, 158, 160, 163,
1216  0, 0, 0, 129, 105, 126, 120, 0, 117, 119,
1217  114, 98, 0, 0, 0, 0, 0, 270, 0, 0,
1218  0, 0, 54, 0, 56, 270, 0, 0, 225, 61,
1219  72, 73, 75, 230, 229, 232, 231, 233, 234, 0,
1220  0, 179, 178, 209, 0, 200, 0, 245, 145, 147,
1221  201, 0, 203, 136, 157, 0, 0, 165, 166, 115,
1222  116, 0, 0, 81, 0, 0, 79, 88, 0, 97,
1223  0, 89, 90, 0, 58, 55, 0, 71, 67, 69,
1224  224, 0, 0, 141, 0, 0, 206, 153, 0, 196,
1225  0, 159, 161, 0, 118, 121, 122, 83, 82, 93,
1226  94, 0, 0, 57, 62, 74, 0, 207, 209, 149,
1227  197, 130, 0, 0, 59, 0, 0, 84, 0, 224,
1228  208, 91, 0, 224, 63
1229 };
1230 
1231 /* YYPGOTO[NTERM-NUM]. */
1232 static const yytype_int16 yypgoto[] =
1233 {
1234  -310, -310, 394, -310, -310, -310, -310, -310, 354, -310,
1235  377, -310, -310, -310, 47, -310, -310, -310, -310, -310,
1236  -310, -122, -310, 43, -9, -310, -15, -310, -310, -310,
1237  -310, -310, -310, -309, -310, -310, -310, -310, -310, -310,
1238  -310, -310, 51, -310, -310, -310, 349, 148, -310, -310,
1239  -310, -49, 28, 23, -310, -310, -310, -54, -310, -310,
1240  -310, 172, -310, -310, -310, -310, -24, 124, 116, 129,
1241  -134, -310, -310, -310, 195, -310, 63, 65, -310, -310,
1242  122, 307, -52, -310, 293, -86, -14, 278, -310, -310,
1243  -29, -310, 196, -25, -310, 161, -89, -30, -310, -142,
1244  -119, -237, 59, 397, -77, -310, -310, -66, -310, -310,
1245  -310, -310, -55
1246 };
1247 
1248 /* YYDEFGOTO[NTERM-NUM]. */
1249 static const yytype_int16 yydefgoto[] =
1250 {
1251  0, 8, 9, 16, 50, 17, 10, 102, 35, 28,
1252  29, 30, 31, 63, 103, 104, 105, 106, 287, 363,
1253  107, 290, 291, 292, 369, 370, 371, 108, 109, 110,
1254  111, 112, 113, 277, 114, 115, 116, 117, 118, 119,
1255  120, 121, 282, 122, 32, 64, 169, 170, 65, 66,
1256  67, 179, 272, 347, 348, 68, 69, 171, 70, 71,
1257  156, 157, 254, 72, 73, 33, 44, 241, 242, 243,
1258  45, 46, 74, 160, 161, 336, 337, 338, 75, 259,
1259  260, 47, 48, 37, 163, 159, 164, 130, 215, 11,
1260  12, 13, 24, 142, 152, 250, 196, 197, 144, 206,
1261  303, 245, 145, 146, 283, 41, 246, 147, 237, 124,
1262  125, 22, 127
1263 };
1264 
1265 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1266  positive, shift that token. If negative, reduce the rule whose
1267  number is the opposite. If YYTABLE_NINF, syntax error. */
1268 static const yytype_int16 yytable[] =
1269 {
1270  49, 76, 204, 322, 158, 207, 123, 189, 38, 198,
1271  143, 199, 386, 178, 194, 180, 248, 278, 49, 148,
1272  200, -7, 14, 18, 183, 186, 42, 184, 162, 42,
1273  187, 126, 1, 23, 212, 2, -15, 213, 42, 192,
1274  3, 4, 1, 42, 187, 2, 406, 126, 43, 19,
1275  3, 4, 306, 307, 158, 34, 39, 167, 209, 188,
1276  5, 294, 251, 6, 20, 40, 168, 302, 129, 42,
1277  5, 7, 21, 6, 424, 149, 167, 177, 42, 36,
1278  150, 7, -26, 247, 207, 168, 381, 305, 304, 266,
1279  52, 207, 150, 296, 297, 298, 299, 300, 128, 205,
1280  151, 217, 49, 211, 301, 248, -64, -64, 323, 42,
1281  155, 219, -64, 324, 138, 139, 151, 238, 42, 240,
1282  276, 252, 174, 158, 269, 49, 165, 267, 268, 154,
1283  255, 270, 166, 273, 279, 423, 175, 209, 284, 456,
1284  324, 327, 328, 209, 209, 176, -270, 294, 126, 182,
1285  428, 293, 134, 263, 373, 374, 375, 376, 377, 378,
1286  280, 232, 233, 234, 330, 285, 296, 297, 298, 299,
1287  300, 288, 368, 190, 247, 138, 139, 301, 205, 298,
1288  299, 300, 201, 208, 205, 205, 331, 332, 339, 340,
1289  310, 221, 311, 223, 224, 225, 226, 227, 312, 313,
1290  314, 315, 316, 317, 318, 195, 319, 320, 230, 231,
1291  232, 233, 234, 216, 49, 357, 358, 365, 366, 236,
1292  345, 132, 133, 209, 134, 135, 136, 137, 162, 210,
1293  209, 209, 209, 209, 209, 209, 394, 395, 218, 247,
1294  391, 349, 415, 416, 239, 352, 353, 207, 420, 351,
1295  440, 358, -68, -68, 355, 253, 364, 422, 247, 247,
1296  207, 256, 208, 257, 205, 372, 258, 264, 208, 208,
1297  271, 205, 205, 205, 205, 205, 205, 274, 275, 385,
1298  276, 409, 187, 413, 383, 131, 286, 132, 133, 42,
1299  134, 135, 136, 137, 138, 139, 295, 140, 390, 141,
1300  209, 209, 408, 430, 234, 326, 325, 393, 335, 342,
1301  417, 398, 329, 209, 293, 230, 231, 232, 233, 234,
1302  341, 247, 343, 131, 405, 132, 133, 42, 134, 135,
1303  136, 137, 138, 139, 354, 123, 459, 141, 249, 359,
1304  367, 205, 205, 463, 300, 379, 387, 396, 208, 296,
1305  297, 298, 299, 300, 205, 208, 208, 208, 208, 208,
1306  208, 392, 400, 414, 453, 401, 407, 126, 172, 172,
1307  421, 349, 436, 425, 437, 427, 181, 429, 439, 441,
1308  181, 461, 446, 181, 447, 449, 443, 372, 450, 209,
1309  451, 372, 454, 458, 455, 390, 209, 191, 193, 460,
1310  448, 462, 15, 464, 153, 51, 445, 412, 444, 418,
1311  410, 173, 344, 220, 221, 222, 223, 224, 225, 226,
1312  227, 228, 457, 229, 434, 208, 208, 433, 333, 380,
1313  205, 230, 231, 232, 233, 234, 214, 205, 208, -202,
1314  388, 131, 236, 132, 133, 42, 134, 135, 136, 137,
1315  138, 139, 334, 346, 389, 141, 244, -16, 431, -16,
1316  -16, 432, 397, 25, -16, -16, -16, 265, 350, 281,
1317  384, 0, 261, 262, 185, -16, 0, -16, 26, 0,
1318  0, 0, -16, 181, 181, -16, -16, 181, -16, 181,
1319  -16, 0, -16, 0, 0, 0, -16, 0, 0, -16,
1320  -16, 132, 133, 42, 134, 135, 136, 137, 138, 139,
1321  0, 77, 78, 289, 208, 79, 80, 81, 0, 82,
1322  0, 208, 83, 0, 0, 0, 0, 0, 84, 85,
1323  86, 87, 88, 89, 0, 90, 0, 0, 0, 0,
1324  27, 91, 92, 0, 0, 93, 321, 0, 0, 0,
1325  94, 0, 95, 0, 96, 0, 97, 0, 98, 99,
1326  0, 0, 100, 0, 411, 0, 0, 101, 0, 0,
1327  0, 172, 0, 0, 220, 221, 181, 223, 224, 225,
1328  226, 227, 0, 0, 42, 187, 0, 0, 0, 0,
1329  0, 0, 230, 231, 232, 233, 234, 0, 0, 0,
1330  0, 0, 0, 236, 0, 77, 78, 0, 0, 79,
1331  80, 81, 244, 82, 382, 0, 83, 0, 0, 0,
1332  0, 0, 84, 85, 86, 87, 88, 89, 0, 90,
1333  0, 244, 244, 0, 0, 91, 92, 0, 0, 93,
1334  0, 0, 0, 0, 94, 0, 95, 261, 96, 399,
1335  97, 0, 98, 99, 0, 0, 100, 0, 0, 0,
1336  0, 101, 0, -16, 0, -16, -16, 0, 0, 25,
1337  -16, -16, -16, 0, 0, 0, 0, 0, 42, -5,
1338  0, -16, 0, -16, 26, 0, 0, 0, -16, 0,
1339  0, -16, -16, 0, -16, 0, -16, 0, -16, 0,
1340  0, 1, -16, 53, 2, -16, -16, 0, 54, 3,
1341  4, 0, 0, 0, 0, 0, 0, 0, 0, 55,
1342  0, 56, 0, 0, 0, 0, 57, 0, 0, 5,
1343  58, 0, 6, 0, 59, 0, 60, 0, 0, 0,
1344  7, 0, 0, 61, 62, 220, 221, 222, 223, 224,
1345  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1346  0, 0, 0, 230, 231, 232, 233, 234, 0, 308,
1347  309, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1348  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1349  0, 0, 0, 230, 231, 232, 233, 234, 0, 235,
1350  0, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1351  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1352  0, 0, 0, 230, 231, 232, 233, 234, 0, 356,
1353  0, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1354  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1355  0, 0, 0, 230, 231, 232, 233, 234, 0, 360,
1356  0, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1357  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1358  0, 0, 0, 230, 231, 232, 233, 234, 0, 0,
1359  0, 402, 0, 0, 236, 220, 221, 222, 223, 224,
1360  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1361  0, 0, 0, 230, 231, 232, 233, 234, 0, 403,
1362  0, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1363  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1364  0, 0, 0, 230, 231, 232, 233, 234, 0, 0,
1365  404, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1366  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1367  0, 0, 0, 230, 231, 232, 233, 234, 0, 426,
1368  0, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1369  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1370  0, 0, 0, 230, 231, 232, 233, 234, 0, 438,
1371  0, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1372  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1373  0, 0, 0, 230, 231, 232, 233, 234, 0, 0,
1374  452, 0, 0, 0, 236, 220, 221, 222, 223, 224,
1375  225, 226, 227, 228, 0, 229, 0, 0, 0, 0,
1376  0, 0, 0, 230, 231, 232, 233, 234, 0, 0,
1377  0, 0, 220, 221, 236, 223, 224, 225, 226, 227,
1378  0, 0, 229, 0, 0, 0, 0, 0, 0, 0,
1379  230, 231, 232, 233, 234, 0, 0, 0, 0, 0,
1380  -271, 236, -271, -271, -271, -271, -271, 0, 0, 0,
1381  0, 0, 0, 0, 0, 0, 0, 230, 231, 232,
1382  233, 234, 0, 0, 0, 0, 0, 131, 236, 132,
1383  133, 42, 134, 135, 136, 137, 138, 139, 0, 361,
1384  0, 141, 362, 131, 0, 132, 133, 42, 134, 135,
1385  136, 137, 138, 139, 0, 435, 131, 141, 132, 133,
1386  42, 134, 135, 136, 137, 138, 139, 0, 442, 131,
1387  141, 132, 133, 42, 134, 135, 136, 137, 138, 139,
1388  0, 0, 0, 141, 132, 133, 42, 134, 135, 136,
1389  137, 138, 139, 0, 202, 0, 203, 132, 133, 42,
1390  134, 135, 136, 137, 138, 139, 0, 202, 0, 289,
1391  132, 133, 42, 134, 135, 136, 137, 138, 139, 0,
1392  419, 0, 289
1393 };
1394 
1395 static const yytype_int16 yycheck[] =
1396 {
1397  25, 30, 124, 240, 56, 124, 31, 84, 22, 98,
1398  40, 100, 321, 68, 91, 69, 150, 58, 43, 43,
1399  106, 26, 0, 6, 73, 58, 76, 76, 57, 76,
1400  77, 88, 10, 84, 84, 13, 93, 87, 76, 86,
1401  18, 19, 10, 76, 77, 13, 355, 88, 86, 32,
1402  18, 19, 87, 88, 106, 26, 77, 83, 124, 84,
1403  38, 203, 151, 41, 47, 86, 92, 209, 86, 76,
1404  38, 49, 55, 41, 383, 83, 83, 88, 76, 76,
1405  88, 49, 93, 149, 203, 92, 84, 83, 210, 175,
1406  93, 210, 88, 81, 82, 83, 84, 85, 93, 124,
1407  86, 131, 127, 127, 92, 239, 87, 88, 83, 76,
1408  86, 141, 93, 88, 81, 82, 86, 147, 76, 86,
1409  90, 151, 88, 175, 178, 150, 86, 176, 177, 93,
1410  155, 180, 86, 182, 189, 83, 88, 203, 193, 448,
1411  88, 87, 88, 209, 210, 88, 86, 289, 88, 88,
1412  387, 203, 77, 167, 296, 297, 298, 299, 300, 301,
1413  190, 83, 84, 85, 253, 195, 81, 82, 83, 84,
1414  85, 201, 87, 86, 240, 81, 82, 92, 203, 83,
1415  84, 85, 90, 124, 209, 210, 87, 88, 87, 88,
1416  220, 64, 222, 66, 67, 68, 69, 70, 228, 229,
1417  230, 231, 232, 233, 234, 86, 236, 237, 81, 82,
1418  83, 84, 85, 93, 239, 87, 88, 87, 88, 92,
1419  269, 74, 75, 289, 77, 78, 79, 80, 257, 86,
1420  296, 297, 298, 299, 300, 301, 87, 88, 87, 305,
1421  329, 271, 87, 88, 88, 275, 276, 366, 367, 274,
1422  87, 88, 87, 88, 279, 86, 286, 379, 324, 325,
1423  379, 88, 203, 88, 289, 295, 86, 88, 209, 210,
1424  86, 296, 297, 298, 299, 300, 301, 57, 86, 309,
1425  90, 358, 77, 360, 309, 72, 86, 74, 75, 76,
1426  77, 78, 79, 80, 81, 82, 88, 84, 328, 86,
1427  366, 367, 357, 392, 85, 246, 84, 332, 76, 88,
1428  365, 341, 89, 379, 366, 81, 82, 83, 84, 85,
1429  90, 387, 83, 72, 354, 74, 75, 76, 77, 78,
1430  79, 80, 81, 82, 86, 360, 455, 86, 87, 86,
1431  90, 366, 367, 462, 85, 88, 88, 81, 289, 81,
1432  82, 83, 84, 85, 379, 296, 297, 298, 299, 300,
1433  301, 89, 87, 77, 441, 88, 56, 88, 61, 62,
1434  88, 401, 402, 88, 404, 87, 69, 87, 408, 88,
1435  73, 458, 87, 76, 87, 87, 416, 417, 87, 455,
1436  87, 421, 77, 88, 86, 425, 462, 90, 91, 87,
1437  425, 88, 8, 87, 50, 28, 421, 360, 417, 366,
1438  359, 62, 264, 63, 64, 65, 66, 67, 68, 69,
1439  70, 71, 452, 73, 401, 366, 367, 399, 256, 305,
1440  455, 81, 82, 83, 84, 85, 129, 462, 379, 89,
1441  324, 72, 92, 74, 75, 76, 77, 78, 79, 80,
1442  81, 82, 257, 84, 325, 86, 149, 10, 395, 12,
1443  13, 396, 340, 16, 17, 18, 19, 174, 272, 191,
1444  309, -1, 165, 166, 77, 28, -1, 30, 31, -1,
1445  -1, -1, 35, 176, 177, 38, 39, 180, 41, 182,
1446  43, -1, 45, -1, -1, -1, 49, -1, -1, 52,
1447  53, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1448  -1, 3, 4, 86, 455, 7, 8, 9, -1, 11,
1449  -1, 462, 14, -1, -1, -1, -1, -1, 20, 21,
1450  22, 23, 24, 25, -1, 27, -1, -1, -1, -1,
1451  93, 33, 34, -1, -1, 37, 239, -1, -1, -1,
1452  42, -1, 44, -1, 46, -1, 48, -1, 50, 51,
1453  -1, -1, 54, -1, 56, -1, -1, 59, -1, -1,
1454  -1, 264, -1, -1, 63, 64, 269, 66, 67, 68,
1455  69, 70, -1, -1, 76, 77, -1, -1, -1, -1,
1456  -1, -1, 81, 82, 83, 84, 85, -1, -1, -1,
1457  -1, -1, -1, 92, -1, 3, 4, -1, -1, 7,
1458  8, 9, 305, 11, 307, -1, 14, -1, -1, -1,
1459  -1, -1, 20, 21, 22, 23, 24, 25, -1, 27,
1460  -1, 324, 325, -1, -1, 33, 34, -1, -1, 37,
1461  -1, -1, -1, -1, 42, -1, 44, 340, 46, 342,
1462  48, -1, 50, 51, -1, -1, 54, -1, -1, -1,
1463  -1, 59, -1, 10, -1, 12, 13, -1, -1, 16,
1464  17, 18, 19, -1, -1, -1, -1, -1, 76, 26,
1465  -1, 28, -1, 30, 31, -1, -1, -1, 35, -1,
1466  -1, 38, 39, -1, 41, -1, 43, -1, 45, -1,
1467  -1, 10, 49, 12, 13, 52, 53, -1, 17, 18,
1468  19, -1, -1, -1, -1, -1, -1, -1, -1, 28,
1469  -1, 30, -1, -1, -1, -1, 35, -1, -1, 38,
1470  39, -1, 41, -1, 43, -1, 45, -1, -1, -1,
1471  49, -1, -1, 52, 53, 63, 64, 65, 66, 67,
1472  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1473  -1, -1, -1, 81, 82, 83, 84, 85, -1, 87,
1474  88, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1475  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1476  -1, -1, -1, 81, 82, 83, 84, 85, -1, 87,
1477  -1, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1478  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1479  -1, -1, -1, 81, 82, 83, 84, 85, -1, 87,
1480  -1, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1481  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1482  -1, -1, -1, 81, 82, 83, 84, 85, -1, 87,
1483  -1, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1484  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1485  -1, -1, -1, 81, 82, 83, 84, 85, -1, -1,
1486  -1, 89, -1, -1, 92, 63, 64, 65, 66, 67,
1487  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1488  -1, -1, -1, 81, 82, 83, 84, 85, -1, 87,
1489  -1, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1490  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1491  -1, -1, -1, 81, 82, 83, 84, 85, -1, -1,
1492  88, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1493  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1494  -1, -1, -1, 81, 82, 83, 84, 85, -1, 87,
1495  -1, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1496  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1497  -1, -1, -1, 81, 82, 83, 84, 85, -1, 87,
1498  -1, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1499  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1500  -1, -1, -1, 81, 82, 83, 84, 85, -1, -1,
1501  88, -1, -1, -1, 92, 63, 64, 65, 66, 67,
1502  68, 69, 70, 71, -1, 73, -1, -1, -1, -1,
1503  -1, -1, -1, 81, 82, 83, 84, 85, -1, -1,
1504  -1, -1, 63, 64, 92, 66, 67, 68, 69, 70,
1505  -1, -1, 73, -1, -1, -1, -1, -1, -1, -1,
1506  81, 82, 83, 84, 85, -1, -1, -1, -1, -1,
1507  64, 92, 66, 67, 68, 69, 70, -1, -1, -1,
1508  -1, -1, -1, -1, -1, -1, -1, 81, 82, 83,
1509  84, 85, -1, -1, -1, -1, -1, 72, 92, 74,
1510  75, 76, 77, 78, 79, 80, 81, 82, -1, 84,
1511  -1, 86, 87, 72, -1, 74, 75, 76, 77, 78,
1512  79, 80, 81, 82, -1, 84, 72, 86, 74, 75,
1513  76, 77, 78, 79, 80, 81, 82, -1, 84, 72,
1514  86, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1515  -1, -1, -1, 86, 74, 75, 76, 77, 78, 79,
1516  80, 81, 82, -1, 84, -1, 86, 74, 75, 76,
1517  77, 78, 79, 80, 81, 82, -1, 84, -1, 86,
1518  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
1519  84, -1, 86
1520 };
1521 
1522 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
1523  state STATE-NUM. */
1524 static const yytype_uint8 yystos[] =
1525 {
1526  0, 10, 13, 18, 19, 38, 41, 49, 96, 97,
1527  101, 184, 185, 186, 0, 97, 98, 100, 6, 32,
1528  47, 55, 206, 84, 187, 16, 31, 93, 104, 105,
1529  106, 107, 139, 160, 26, 103, 76, 178, 181, 77,
1530  86, 200, 76, 86, 161, 165, 166, 176, 177, 188,
1531  99, 105, 93, 12, 17, 28, 30, 35, 39, 43,
1532  45, 52, 53, 108, 140, 143, 144, 145, 150, 151,
1533  153, 154, 158, 159, 167, 173, 185, 3, 4, 7,
1534  8, 9, 11, 14, 20, 21, 22, 23, 24, 25,
1535  27, 33, 34, 37, 42, 44, 46, 48, 50, 51,
1536  54, 59, 102, 109, 110, 111, 112, 115, 122, 123,
1537  124, 125, 126, 127, 129, 130, 131, 132, 133, 134,
1538  135, 136, 138, 188, 204, 205, 88, 207, 93, 86,
1539  182, 72, 74, 75, 77, 78, 79, 80, 81, 82,
1540  84, 86, 188, 192, 193, 197, 198, 202, 161, 83,
1541  88, 86, 189, 103, 93, 86, 155, 156, 177, 180,
1542  168, 169, 185, 179, 181, 86, 86, 83, 92, 141,
1543  142, 152, 176, 141, 88, 88, 88, 88, 207, 146,
1544  152, 176, 88, 146, 146, 198, 58, 77, 188, 199,
1545  86, 176, 86, 176, 199, 86, 191, 192, 191, 191,
1546  180, 90, 84, 86, 116, 188, 194, 195, 197, 202,
1547  86, 161, 84, 87, 176, 183, 93, 192, 87, 192,
1548  63, 64, 65, 66, 67, 68, 69, 70, 71, 73,
1549  81, 82, 83, 84, 85, 87, 92, 203, 192, 88,
1550  86, 162, 163, 164, 176, 196, 201, 202, 165, 87,
1551  190, 191, 192, 86, 157, 188, 88, 88, 86, 174,
1552  175, 176, 176, 181, 88, 179, 180, 146, 146, 152,
1553  146, 86, 147, 146, 57, 86, 90, 128, 58, 207,
1554  192, 182, 137, 199, 207, 192, 86, 113, 192, 86,
1555  116, 117, 118, 177, 194, 88, 81, 82, 83, 84,
1556  85, 92, 194, 195, 116, 83, 87, 88, 87, 88,
1557  192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
1558  192, 176, 196, 83, 88, 84, 197, 87, 88, 89,
1559  191, 87, 88, 156, 169, 76, 170, 171, 172, 87,
1560  88, 90, 88, 83, 142, 146, 84, 148, 149, 192,
1561  187, 188, 192, 192, 86, 188, 87, 87, 88, 86,
1562  87, 84, 87, 114, 192, 87, 88, 90, 87, 119,
1563  120, 121, 192, 194, 194, 194, 194, 194, 194, 88,
1564  162, 84, 176, 188, 190, 192, 128, 88, 163, 164,
1565  192, 191, 89, 188, 87, 88, 81, 175, 192, 176,
1566  87, 88, 89, 87, 88, 192, 128, 56, 207, 199,
1567  137, 56, 109, 199, 77, 87, 88, 207, 118, 84,
1568  195, 88, 116, 83, 128, 88, 87, 87, 196, 87,
1569  191, 171, 172, 147, 148, 84, 192, 192, 87, 192,
1570  87, 88, 84, 192, 119, 121, 87, 87, 188, 87,
1571  87, 87, 88, 199, 77, 86, 128, 192, 88, 195,
1572  87, 199, 88, 195, 87
1573 };
1574 
1575 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
1576 static const yytype_uint8 yyr1[] =
1577 {
1578  0, 95, 96, 96, 98, 99, 97, 100, 97, 101,
1579  102, 103, 104, 104, 104, 105, 106, 105, 107, 105,
1580  105, 108, 108, 108, 108, 108, 108, 108, 108, 108,
1581  108, 109, 109, 109, 109, 109, 109, 109, 109, 109,
1582  109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
1583  110, 111, 111, 112, 113, 113, 114, 114, 114, 114,
1584  115, 115, 115, 115, 116, 116, 117, 117, 118, 118,
1585  118, 119, 119, 120, 120, 121, 122, 123, 124, 125,
1586  126, 127, 127, 128, 128, 129, 130, 131, 132, 133,
1587  134, 135, 136, 136, 136, 136, 137, 137, 138, 138,
1588  139, 140, 140, 140, 141, 141, 142, 142, 143, 143,
1589  144, 144, 145, 145, 146, 147, 147, 148, 148, 149,
1590  149, 149, 149, 150, 150, 150, 150, 151, 152, 152,
1591  153, 154, 155, 155, 156, 157, 157, 158, 158, 159,
1592  160, 160, 161, 161, 162, 162, 163, 163, 164, 164,
1593  164, 165, 165, 166, 167, 168, 168, 169, 170, 170,
1594  171, 171, 172, 173, 174, 174, 175, 176, 177, 178,
1595  179, 180, 181, 182, 182, 182, 183, 183, 183, 183,
1596  184, 184, 185, 186, 186, 186, 186, 186, 186, 186,
1597  187, 187, 187, 187, 188, 188, 188, 188, 189, 189,
1598  190, 190, 191, 191, 192, 192, 192, 192, 192, 193,
1599  193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
1600  193, 193, 193, 193, 194, 194, 195, 195, 195, 195,
1601  195, 195, 195, 195, 195, 196, 197, 197, 197, 197,
1602  197, 197, 198, 199, 200, 201, 201, 202, 202, 203,
1603  203, 203, 203, 203, 203, 204, 204, 204, 204, 204,
1604  204, 204, 204, 204, 205, 205, 206, 206, 206, 206,
1605  207, 207
1606 };
1607 
1608 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
1609 static const yytype_int8 yyr2[] =
1610 {
1611  0, 2, 1, 2, 0, 0, 5, 0, 3, 5,
1612  3, 2, 1, 2, 3, 1, 0, 2, 0, 2,
1613  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1614  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1615  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1616  2, 2, 3, 1, 2, 3, 1, 3, 2, 4,
1617  2, 4, 6, 11, 1, 1, 1, 3, 3, 3,
1618  1, 0, 1, 1, 3, 1, 2, 2, 1, 5,
1619  3, 5, 6, 4, 6, 1, 1, 1, 5, 5,
1620  5, 9, 2, 6, 6, 2, 1, 3, 4, 3,
1621  1, 1, 2, 2, 1, 3, 1, 1, 2, 3,
1622  2, 3, 2, 3, 3, 0, 3, 1, 3, 1,
1623  1, 3, 3, 2, 3, 3, 4, 1, 1, 3,
1624  7, 2, 1, 3, 3, 1, 3, 2, 3, 1,
1625  5, 6, 1, 3, 1, 3, 1, 3, 1, 5,
1626  1, 1, 1, 6, 2, 1, 3, 4, 1, 3,
1627  1, 3, 1, 4, 1, 3, 3, 1, 1, 1,
1628  1, 1, 1, 0, 2, 3, 1, 1, 3, 3,
1629  1, 0, 2, 1, 1, 1, 1, 1, 1, 1,
1630  0, 4, 4, 2, 1, 2, 6, 7, 2, 3,
1631  1, 3, 1, 0, 1, 3, 5, 6, 8, 1,
1632  1, 2, 3, 3, 3, 3, 3, 3, 3, 3,
1633  3, 3, 2, 3, 1, 3, 1, 1, 2, 3,
1634  3, 3, 3, 3, 3, 2, 1, 1, 1, 1,
1635  1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
1636  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1637  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1638  0, 1
1639 };
1640 
1641 
1642 enum { YYENOMEM = -2 };
1643 
1644 #define yyerrok (yyerrstatus = 0)
1645 #define yyclearin (yychar = YYEMPTY)
1646 
1647 #define YYACCEPT goto yyacceptlab
1648 #define YYABORT goto yyabortlab
1649 #define YYERROR goto yyerrorlab
1650 #define YYNOMEM goto yyexhaustedlab
1651 
1652 
1653 #define YYRECOVERING() (!!yyerrstatus)
1654 
1655 #define YYBACKUP(Token, Value) \
1656  do \
1657  if (yychar == YYEMPTY) \
1658  { \
1659  yychar = (Token); \
1660  yylval = (Value); \
1661  YYPOPSTACK (yylen); \
1662  yystate = *yyssp; \
1663  goto yybackup; \
1664  } \
1665  else \
1666  { \
1667  yyerror (YY_("syntax error: cannot back up")); \
1668  YYERROR; \
1669  } \
1670  while (0)
1671 
1672 /* Backward compatibility with an undocumented macro.
1673  Use YYerror or YYUNDEF. */
1674 #define YYERRCODE YYUNDEF
1675 
1676 
1677 /* Enable debugging if requested. */
1678 #if YYDEBUG
1679 
1680 # ifndef YYFPRINTF
1681 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1682 # define YYFPRINTF fprintf
1683 # endif
1684 
1685 # define YYDPRINTF(Args) \
1686 do { \
1687  if (yydebug) \
1688  YYFPRINTF Args; \
1689 } while (0)
1690 
1691 
1692 
1693 
1694 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
1695 do { \
1696  if (yydebug) \
1697  { \
1698  YYFPRINTF (stderr, "%s ", Title); \
1699  yy_symbol_print (stderr, \
1700  Kind, Value); \
1701  YYFPRINTF (stderr, "\n"); \
1702  } \
1703 } while (0)
1704 
1705 
1706 /*-----------------------------------.
1707 | Print this symbol's value on YYO. |
1708 `-----------------------------------*/
1709 
1710 static void
1711 yy_symbol_value_print (FILE *yyo,
1712  yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1713 {
1714  FILE *yyoutput = yyo;
1715  YY_USE (yyoutput);
1716  if (!yyvaluep)
1717  return;
1718  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1719  YY_USE (yykind);
1720  YY_IGNORE_MAYBE_UNINITIALIZED_END
1721 }
1722 
1723 
1724 /*---------------------------.
1725 | Print this symbol on YYO. |
1726 `---------------------------*/
1727 
1728 static void
1729 yy_symbol_print (FILE *yyo,
1730  yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1731 {
1732  YYFPRINTF (yyo, "%s %s (",
1733  yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1734 
1735  yy_symbol_value_print (yyo, yykind, yyvaluep);
1736  YYFPRINTF (yyo, ")");
1737 }
1738 
1739 /*------------------------------------------------------------------.
1740 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1741 | TOP (included). |
1742 `------------------------------------------------------------------*/
1743 
1744 static void
1745 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1746 {
1747  YYFPRINTF (stderr, "Stack now");
1748  for (; yybottom <= yytop; yybottom++)
1749  {
1750  int yybot = *yybottom;
1751  YYFPRINTF (stderr, " %d", yybot);
1752  }
1753  YYFPRINTF (stderr, "\n");
1754 }
1755 
1756 # define YY_STACK_PRINT(Bottom, Top) \
1757 do { \
1758  if (yydebug) \
1759  yy_stack_print ((Bottom), (Top)); \
1760 } while (0)
1761 
1762 
1763 /*------------------------------------------------.
1764 | Report that the YYRULE is going to be reduced. |
1765 `------------------------------------------------*/
1766 
1767 static void
1768 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
1769  int yyrule)
1770 {
1771  int yylno = yyrline[yyrule];
1772  int yynrhs = yyr2[yyrule];
1773  int yyi;
1774  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1775  yyrule - 1, yylno);
1776  /* The symbols being reduced. */
1777  for (yyi = 0; yyi < yynrhs; yyi++)
1778  {
1779  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1780  yy_symbol_print (stderr,
1781  YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1782  &yyvsp[(yyi + 1) - (yynrhs)]);
1783  YYFPRINTF (stderr, "\n");
1784  }
1785 }
1786 
1787 # define YY_REDUCE_PRINT(Rule) \
1788 do { \
1789  if (yydebug) \
1790  yy_reduce_print (yyssp, yyvsp, Rule); \
1791 } while (0)
1792 
1793 /* Nonzero means print parse trace. It is left uninitialized so that
1794  multiple parsers can coexist. */
1795 int yydebug;
1796 #else /* !YYDEBUG */
1797 # define YYDPRINTF(Args) ((void) 0)
1798 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1799 # define YY_STACK_PRINT(Bottom, Top)
1800 # define YY_REDUCE_PRINT(Rule)
1801 #endif /* !YYDEBUG */
1802 
1803 
1804 /* YYINITDEPTH -- initial size of the parser's stacks. */
1805 #ifndef YYINITDEPTH
1806 # define YYINITDEPTH 200
1807 #endif
1808 
1809 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1810  if the built-in stack extension method is used).
1811 
1812  Do not make this value too large; the results are undefined if
1813  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1814  evaluated with infinite-precision integer arithmetic. */
1815 
1816 #ifndef YYMAXDEPTH
1817 # define YYMAXDEPTH 10000
1818 #endif
1819 
1820 
1821 
1822 
1823 
1824 
1825 /*-----------------------------------------------.
1826 | Release the memory associated to this symbol. |
1827 `-----------------------------------------------*/
1828 
1829 static void
1830 yydestruct (const char *yymsg,
1831  yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1832 {
1833  YY_USE (yyvaluep);
1834  if (!yymsg)
1835  yymsg = "Deleting";
1836  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1837 
1838  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1839  YY_USE (yykind);
1840  YY_IGNORE_MAYBE_UNINITIALIZED_END
1841 }
1842 
1843 
1844 /* Lookahead token kind. */
1845 int yychar;
1846 
1847 /* The semantic value of the lookahead symbol. */
1848 YYSTYPE yylval;
1849 /* Number of syntax errors so far. */
1850 int yynerrs;
1851 
1852 
1853 
1854 
1855 /*----------.
1856 | yyparse. |
1857 `----------*/
1858 
1859 int
1860 yyparse (void)
1861 {
1862  yy_state_fast_t yystate = 0;
1863  /* Number of tokens to shift before error messages enabled. */
1864  int yyerrstatus = 0;
1865 
1866  /* Refer to the stacks through separate pointers, to allow yyoverflow
1867  to reallocate them elsewhere. */
1868 
1869  /* Their size. */
1870  YYPTRDIFF_T yystacksize = YYINITDEPTH;
1871 
1872  /* The state stack: array, bottom, top. */
1873  yy_state_t yyssa[YYINITDEPTH];
1874  yy_state_t *yyss = yyssa;
1875  yy_state_t *yyssp = yyss;
1876 
1877  /* The semantic value stack: array, bottom, top. */
1878  YYSTYPE yyvsa[YYINITDEPTH];
1879  YYSTYPE *yyvs = yyvsa;
1880  YYSTYPE *yyvsp = yyvs;
1881 
1882  int yyn;
1883  /* The return value of yyparse. */
1884  int yyresult;
1885  /* Lookahead symbol kind. */
1886  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1887  /* The variables used to return semantic value and location from the
1888  action routines. */
1889  YYSTYPE yyval;
1890 
1891 
1892 
1893 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1894 
1895  /* The number of symbols on the RHS of the reduced rule.
1896  Keep to zero when no symbol should be popped. */
1897  int yylen = 0;
1898 
1899  YYDPRINTF ((stderr, "Starting parse\n"));
1900 
1901  yychar = YYEMPTY; /* Cause a token to be read. */
1902 
1903  goto yysetstate;
1904 
1905 
1906 /*------------------------------------------------------------.
1907 | yynewstate -- push a new state, which is found in yystate. |
1908 `------------------------------------------------------------*/
1909 yynewstate:
1910  /* In all cases, when you get here, the value and location stacks
1911  have just been pushed. So pushing a state here evens the stacks. */
1912  yyssp++;
1913 
1914 
1915 /*--------------------------------------------------------------------.
1916 | yysetstate -- set current state (the top of the stack) to yystate. |
1917 `--------------------------------------------------------------------*/
1918 yysetstate:
1919  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1920  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1921  YY_IGNORE_USELESS_CAST_BEGIN
1922  *yyssp = YY_CAST (yy_state_t, yystate);
1923  YY_IGNORE_USELESS_CAST_END
1924  YY_STACK_PRINT (yyss, yyssp);
1925 
1926  if (yyss + yystacksize - 1 <= yyssp)
1927 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1928  YYNOMEM;
1929 #else
1930  {
1931  /* Get the current used size of the three stacks, in elements. */
1932  YYPTRDIFF_T yysize = yyssp - yyss + 1;
1933 
1934 # if defined yyoverflow
1935  {
1936  /* Give user a chance to reallocate the stack. Use copies of
1937  these so that the &'s don't force the real ones into
1938  memory. */
1939  yy_state_t *yyss1 = yyss;
1940  YYSTYPE *yyvs1 = yyvs;
1941 
1942  /* Each stack pointer address is followed by the size of the
1943  data in use in that stack, in bytes. This used to be a
1944  conditional around just the two extra args, but that might
1945  be undefined if yyoverflow is a macro. */
1946  yyoverflow (YY_("memory exhausted"),
1947  &yyss1, yysize * YYSIZEOF (*yyssp),
1948  &yyvs1, yysize * YYSIZEOF (*yyvsp),
1949  &yystacksize);
1950  yyss = yyss1;
1951  yyvs = yyvs1;
1952  }
1953 # else /* defined YYSTACK_RELOCATE */
1954  /* Extend the stack our own way. */
1955  if (YYMAXDEPTH <= yystacksize)
1956  YYNOMEM;
1957  yystacksize *= 2;
1958  if (YYMAXDEPTH < yystacksize)
1959  yystacksize = YYMAXDEPTH;
1960 
1961  {
1962  yy_state_t *yyss1 = yyss;
1963  union yyalloc *yyptr =
1964  YY_CAST (union yyalloc *,
1965  YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1966  if (! yyptr)
1967  YYNOMEM;
1968  YYSTACK_RELOCATE (yyss_alloc, yyss);
1969  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1970 # undef YYSTACK_RELOCATE
1971  if (yyss1 != yyssa)
1972  YYSTACK_FREE (yyss1);
1973  }
1974 # endif
1975 
1976  yyssp = yyss + yysize - 1;
1977  yyvsp = yyvs + yysize - 1;
1978 
1979  YY_IGNORE_USELESS_CAST_BEGIN
1980  YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1981  YY_CAST (long, yystacksize)));
1982  YY_IGNORE_USELESS_CAST_END
1983 
1984  if (yyss + yystacksize - 1 <= yyssp)
1985  YYABORT;
1986  }
1987 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1988 
1989 
1990  if (yystate == YYFINAL)
1991  YYACCEPT;
1992 
1993  goto yybackup;
1994 
1995 
1996 /*-----------.
1997 | yybackup. |
1998 `-----------*/
1999 yybackup:
2000  /* Do appropriate processing given the current state. Read a
2001  lookahead token if we need one and don't already have one. */
2002 
2003  /* First try to decide what to do without reference to lookahead token. */
2004  yyn = yypact[yystate];
2005  if (yypact_value_is_default (yyn))
2006  goto yydefault;
2007 
2008  /* Not known => get a lookahead token if don't already have one. */
2009 
2010  /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
2011  if (yychar == YYEMPTY)
2012  {
2013  YYDPRINTF ((stderr, "Reading a token\n"));
2014  yychar = yylex ();
2015  }
2016 
2017  if (yychar <= YYEOF)
2018  {
2019  yychar = YYEOF;
2020  yytoken = YYSYMBOL_YYEOF;
2021  YYDPRINTF ((stderr, "Now at end of input.\n"));
2022  }
2023  else if (yychar == YYerror)
2024  {
2025  /* The scanner already issued an error message, process directly
2026  to error recovery. But do not keep the error token as
2027  lookahead, it is too special and may lead us to an endless
2028  loop in error recovery. */
2029  yychar = YYUNDEF;
2030  yytoken = YYSYMBOL_YYerror;
2031  goto yyerrlab1;
2032  }
2033  else
2034  {
2035  yytoken = YYTRANSLATE (yychar);
2036  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2037  }
2038 
2039  /* If the proper action on seeing token YYTOKEN is to reduce or to
2040  detect an error, take that action. */
2041  yyn += yytoken;
2042  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2043  goto yydefault;
2044  yyn = yytable[yyn];
2045  if (yyn <= 0)
2046  {
2047  if (yytable_value_is_error (yyn))
2048  goto yyerrlab;
2049  yyn = -yyn;
2050  goto yyreduce;
2051  }
2052 
2053  /* Count tokens shifted since error; after three, turn off error
2054  status. */
2055  if (yyerrstatus)
2056  yyerrstatus--;
2057 
2058  /* Shift the lookahead token. */
2059  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2060  yystate = yyn;
2061  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2062  *++yyvsp = yylval;
2063  YY_IGNORE_MAYBE_UNINITIALIZED_END
2064 
2065  /* Discard the shifted token. */
2066  yychar = YYEMPTY;
2067  goto yynewstate;
2068 
2069 
2070 /*-----------------------------------------------------------.
2071 | yydefault -- do the default action for the current state. |
2072 `-----------------------------------------------------------*/
2073 yydefault:
2074  yyn = yydefact[yystate];
2075  if (yyn == 0)
2076  goto yyerrlab;
2077  goto yyreduce;
2078 
2079 
2080 /*-----------------------------.
2081 | yyreduce -- do a reduction. |
2082 `-----------------------------*/
2083 yyreduce:
2084  /* yyn is the number of a rule to reduce with. */
2085  yylen = yyr2[yyn];
2086 
2087  /* If YYLEN is nonzero, implement the default value of the action:
2088  '$$ = $1'.
2089 
2090  Otherwise, the following line sets YYVAL to garbage.
2091  This behavior is undocumented and Bison
2092  users should not rely upon it. Assigning to YYVAL
2093  unconditionally makes the parser a bit smaller, and it avoids a
2094  GCC warning that YYVAL may be used uninitialized. */
2095  yyval = yyvsp[1-yylen];
2096 
2097 
2098  YY_REDUCE_PRINT (yyn);
2099  switch (yyn)
2100  {
2101  case 3: /* lprg_exec: lprg_exec prg_exec */
2102 #line 382 "yacc.in"
2103  { FatalError("parser",
2104  "Multiple modules in one file! Check fsplit!");}
2105 #line 2106 "y.tab.c"
2106  break;
2107 
2108  case 4: /* $@1: %empty */
2109 #line 386 "yacc.in"
2110  {reset_first_statement();}
2111 #line 2112 "y.tab.c"
2112  break;
2113 
2114  case 5: /* $@2: %empty */
2115 #line 386 "yacc.in"
2116  { check_first_statement();}
2117 #line 2118 "y.tab.c"
2118  break;
2119 
2120  case 7: /* $@3: %empty */
2121 #line 387 "yacc.in"
2122  {reset_first_statement(); check_first_statement();}
2123 #line 2124 "y.tab.c"
2124  break;
2125 
2126  case 9: /* begin_inst: opt_fortran_type psf_keyword module_name opt_lformalparameter TK_EOS */
2127 #line 392 "yacc.in"
2128  {
2129  MakeCurrentFunction((yyvsp[-4].type), (yyvsp[-3].integer), (yyvsp[-2].string), (yyvsp[-1].liste));
2130  }
2131 #line 2132 "y.tab.c"
2132  break;
2133 
2134  case 10: /* entry_inst: TK_ENTRY entity_name opt_lformalparameter */
2135 #line 398 "yacc.in"
2136  {
2137  /* In case the entry is a FUNCTION, you want to recover its type.
2138  * You cannot use entity_functional_name as second rule element.
2139  */
2140  if(get_bool_property("PARSER_SUBSTITUTE_ENTRIES")) {
2141  (yyval.instruction) = MakeEntry((yyvsp[-1].entity), (yyvsp[0].liste));
2142  }
2143  else {
2144  ParserError("Syntax", "ENTRY are not directly processed. "
2145  "Set property PARSER_SUBSTITUTE_ENTRIES to allow "
2146  "entry substitutions");
2147  }
2148  }
2149 #line 2150 "y.tab.c"
2150  break;
2151 
2152  case 11: /* end_inst: TK_END TK_EOS */
2153 #line 414 "yacc.in"
2154  { EndOfProcedure(); }
2155 #line 2156 "y.tab.c"
2156  break;
2157 
2158  case 15: /* instruction: data_inst */
2159 #line 424 "yacc.in"
2160  { /* can appear anywhere in specs and execs! */
2161  if (first_executable_statement_seen())
2162  {
2163  /* the DATA string to be added to declarations...
2164  * however, the information is not really available.
2165  * as a hack, I'll try to append the Stmt buffer, but it
2166  * has already been processed, thus it is quite far
2167  * from the initial statement, and may be incorrect.
2168  * I think that this parser is a mess;-) FC.
2169  */
2170  pips_user_warning(
2171  "DATA as an executable statement, moved up...\n");
2172  append_data_current_stmt_buffer_to_declarations();
2173  }
2174 
2175  /* See if we could save the DATA statements somewhere */
2176  /* dump_current_statement(); */
2177 
2178  }
2179 #line 2180 "y.tab.c"
2180  break;
2181 
2182  case 16: /* $@4: %empty */
2183 #line 443 "yacc.in"
2184  { check_in_declarations();}
2185 #line 2186 "y.tab.c"
2186  break;
2187 
2188  case 18: /* $@5: %empty */
2189 #line 444 "yacc.in"
2190  { check_first_statement();}
2191 #line 2192 "y.tab.c"
2192  break;
2193 
2194  case 19: /* instruction: $@5 inst_exec */
2195 #line 445 "yacc.in"
2196  {
2197  if ((yyvsp[0].instruction) != instruction_undefined)
2198  LinkInstToCurrentBlock((yyvsp[0].instruction), true);
2199  }
2200 #line 2201 "y.tab.c"
2201  break;
2202 
2203  case 20: /* instruction: format_inst */
2204 #line 450 "yacc.in"
2205  {
2206  LinkInstToCurrentBlock((yyvsp[0].instruction), true);
2207  }
2208 #line 2209 "y.tab.c"
2209  break;
2210 
2211  case 26: /* inst_spec: common_inst */
2212 #line 460 "yacc.in"
2213  {}
2214 #line 2215 "y.tab.c"
2215  break;
2216 
2217  case 31: /* inst_exec: assignment_inst */
2218 #line 468 "yacc.in"
2219  { (yyval.instruction) = (yyvsp[0].instruction); }
2220 #line 2221 "y.tab.c"
2221  break;
2222 
2223  case 32: /* inst_exec: goto_inst */
2224 #line 470 "yacc.in"
2225  { (yyval.instruction) = (yyvsp[0].instruction); }
2226 #line 2227 "y.tab.c"
2227  break;
2228 
2229  case 33: /* inst_exec: arithmif_inst */
2230 #line 472 "yacc.in"
2231  { (yyval.instruction) = (yyvsp[0].instruction); }
2232 #line 2233 "y.tab.c"
2233  break;
2234 
2235  case 34: /* inst_exec: logicalif_inst */
2236 #line 474 "yacc.in"
2237  { (yyval.instruction) = (yyvsp[0].instruction); }
2238 #line 2239 "y.tab.c"
2239  break;
2240 
2241  case 35: /* inst_exec: blockif_inst */
2242 #line 476 "yacc.in"
2243  { (yyval.instruction) = (yyvsp[0].instruction); }
2244 #line 2245 "y.tab.c"
2245  break;
2246 
2247  case 36: /* inst_exec: elseif_inst */
2248 #line 478 "yacc.in"
2249  { (yyval.instruction) = (yyvsp[0].instruction); }
2250 #line 2251 "y.tab.c"
2251  break;
2252 
2253  case 37: /* inst_exec: else_inst */
2254 #line 480 "yacc.in"
2255  { (yyval.instruction) = instruction_undefined; }
2256 #line 2257 "y.tab.c"
2257  break;
2258 
2259  case 38: /* inst_exec: endif_inst */
2260 #line 482 "yacc.in"
2261  { (yyval.instruction) = instruction_undefined; }
2262 #line 2263 "y.tab.c"
2263  break;
2264 
2265  case 39: /* inst_exec: enddo_inst */
2266 #line 484 "yacc.in"
2267  { (yyval.instruction) = instruction_undefined; }
2268 #line 2269 "y.tab.c"
2269  break;
2270 
2271  case 40: /* inst_exec: do_inst */
2272 #line 486 "yacc.in"
2273  { (yyval.instruction) = instruction_undefined; }
2274 #line 2275 "y.tab.c"
2275  break;
2276 
2277  case 41: /* inst_exec: bdo_inst */
2278 #line 488 "yacc.in"
2279  { (yyval.instruction) = instruction_undefined; }
2280 #line 2281 "y.tab.c"
2281  break;
2282 
2283  case 42: /* inst_exec: wdo_inst */
2284 #line 490 "yacc.in"
2285  { (yyval.instruction) = instruction_undefined; }
2286 #line 2287 "y.tab.c"
2287  break;
2288 
2289  case 43: /* inst_exec: continue_inst */
2290 #line 492 "yacc.in"
2291  { (yyval.instruction) = (yyvsp[0].instruction); }
2292 #line 2293 "y.tab.c"
2293  break;
2294 
2295  case 44: /* inst_exec: stop_inst */
2296 #line 494 "yacc.in"
2297  { (yyval.instruction) = (yyvsp[0].instruction); }
2298 #line 2299 "y.tab.c"
2299  break;
2300 
2301  case 45: /* inst_exec: pause_inst */
2302 #line 496 "yacc.in"
2303  { (yyval.instruction) = (yyvsp[0].instruction); }
2304 #line 2305 "y.tab.c"
2305  break;
2306 
2307  case 46: /* inst_exec: call_inst */
2308 #line 498 "yacc.in"
2309  { (yyval.instruction) = (yyvsp[0].instruction); }
2310 #line 2311 "y.tab.c"
2311  break;
2312 
2313  case 47: /* inst_exec: return_inst */
2314 #line 500 "yacc.in"
2315  { (yyval.instruction) = (yyvsp[0].instruction); }
2316 #line 2317 "y.tab.c"
2317  break;
2318 
2319  case 48: /* inst_exec: io_inst */
2320 #line 502 "yacc.in"
2321  { (yyval.instruction) = (yyvsp[0].instruction); }
2322 #line 2323 "y.tab.c"
2323  break;
2324 
2325  case 49: /* inst_exec: entry_inst */
2326 #line 504 "yacc.in"
2327  { (yyval.instruction) = (yyvsp[0].instruction); }
2328 #line 2329 "y.tab.c"
2329  break;
2330 
2331  case 50: /* return_inst: TK_RETURN opt_expression */
2332 #line 508 "yacc.in"
2333  { (yyval.instruction) = MakeReturn((yyvsp[0].expression)); }
2334 #line 2335 "y.tab.c"
2335  break;
2336 
2337  case 51: /* call_inst: tk_call functional_entity_name */
2338 #line 512 "yacc.in"
2339  { (yyval.instruction) = MakeCallInst((yyvsp[0].entity), NIL); reset_alternate_returns();}
2340 #line 2341 "y.tab.c"
2341  break;
2342 
2343  case 52: /* call_inst: tk_call functional_entity_name parameters */
2344 #line 515 "yacc.in"
2345  { (yyval.instruction) = MakeCallInst((yyvsp[-1].entity), (yyvsp[0].liste)); reset_alternate_returns(); }
2346 #line 2347 "y.tab.c"
2347  break;
2348 
2349  case 53: /* tk_call: TK_CALL */
2350 #line 519 "yacc.in"
2351  { set_alternate_returns();}
2352 #line 2353 "y.tab.c"
2353  break;
2354 
2355  case 54: /* parameters: TK_LPAR TK_RPAR */
2356 #line 523 "yacc.in"
2357  { (yyval.liste) = NULL; }
2358 #line 2359 "y.tab.c"
2359  break;
2360 
2361  case 55: /* parameters: TK_LPAR arguments TK_RPAR */
2362 #line 525 "yacc.in"
2363  { (yyval.liste) = (yyvsp[-1].liste); }
2364 #line 2365 "y.tab.c"
2365  break;
2366 
2367  case 56: /* arguments: expression */
2368 #line 529 "yacc.in"
2369  {
2370  (yyval.liste) = CONS(EXPRESSION, (yyvsp[0].expression), NIL);
2371  }
2372 #line 2373 "y.tab.c"
2373  break;
2374 
2375  case 57: /* arguments: arguments TK_COMMA expression */
2376 #line 533 "yacc.in"
2377  {
2378  (yyval.liste) = gen_nconc((yyvsp[-2].liste), CONS(EXPRESSION, (yyvsp[0].expression), NIL));
2379  }
2380 #line 2381 "y.tab.c"
2381  break;
2382 
2383  case 58: /* arguments: TK_STAR TK_ICON */
2384 #line 537 "yacc.in"
2385  {
2386  add_alternate_return((yyvsp[0].string));
2387  (yyval.liste) = CONS(EXPRESSION,
2388  generate_string_for_alternate_return_argument((yyvsp[0].string)),
2389  NIL);
2390  }
2391 #line 2392 "y.tab.c"
2392  break;
2393 
2394  case 59: /* arguments: arguments TK_COMMA TK_STAR TK_ICON */
2395 #line 544 "yacc.in"
2396  {
2397  add_alternate_return((yyvsp[0].string));
2398  (yyval.liste) = gen_nconc((yyvsp[-3].liste), CONS(EXPRESSION,
2399  generate_string_for_alternate_return_argument((yyvsp[0].string)),
2400  NIL));
2401  }
2402 #line 2403 "y.tab.c"
2403  break;
2404 
2405  case 60: /* io_inst: io_keyword io_f_u_id */
2406 #line 554 "yacc.in"
2407  {
2408  (yyval.instruction) = MakeSimpleIoInst1((yyvsp[-1].integer), (yyvsp[0].expression));
2409  }
2410 #line 2411 "y.tab.c"
2411  break;
2412 
2413  case 61: /* io_inst: io_keyword io_f_u_id TK_COMMA opt_lio_elem */
2414 #line 558 "yacc.in"
2415  {
2416  (yyval.instruction) = MakeSimpleIoInst2((yyvsp[-3].integer), (yyvsp[-2].expression), (yyvsp[0].liste));
2417  }
2418 #line 2419 "y.tab.c"
2419  break;
2420 
2421  case 62: /* io_inst: io_keyword TK_LPAR lci TK_RPAR opt_virgule opt_lio_elem */
2422 #line 562 "yacc.in"
2423  { (yyval.instruction) = MakeIoInstA((yyvsp[-5].integer), (yyvsp[-3].liste), (yyvsp[0].liste)); }
2424 #line 2425 "y.tab.c"
2425  break;
2426 
2427  case 63: /* io_inst: iobuf_keyword TK_LPAR io_f_u_id TK_COMMA io_f_u_id TK_RPAR TK_LPAR unpar_io_expr TK_COMMA unpar_io_expr TK_RPAR */
2428 #line 565 "yacc.in"
2429  { (yyval.instruction) = MakeIoInstB((yyvsp[-10].integer), (yyvsp[-8].expression), (yyvsp[-6].expression), (yyvsp[-3].expression), (yyvsp[-1].expression)); }
2430 #line 2431 "y.tab.c"
2431  break;
2432 
2433  case 65: /* io_f_u_id: TK_STAR */
2434 #line 570 "yacc.in"
2435  { (yyval.expression) = MakeNullaryCall(CreateIntrinsic(LIST_DIRECTED_FORMAT_NAME)); }
2436 #line 2437 "y.tab.c"
2437  break;
2438 
2439  case 66: /* lci: ci */
2440 #line 574 "yacc.in"
2441  { (yyval.liste) = (yyvsp[0].liste); }
2442 #line 2443 "y.tab.c"
2443  break;
2444 
2445  case 67: /* lci: lci TK_COMMA ci */
2446 #line 576 "yacc.in"
2447  {
2448  /*
2449  CDR(CDR($3)) = $1;
2450  $$ = $3;
2451  */
2452  (yyval.liste) = gen_nconc((yyvsp[-2].liste), (yyvsp[0].liste));
2453  }
2454 #line 2455 "y.tab.c"
2455  break;
2456 
2457  case 68: /* ci: name TK_EQUALS unpar_io_expr */
2458 #line 587 "yacc.in"
2459  {
2460  char buffer[20];
2461  (void) strcpy(buffer, (yyvsp[-2].string));
2462  free((yyvsp[-2].string));
2463 
2464  if(strcmp(buffer,"END")==0||strcmp(buffer,"ERR")==0) {
2465  ;
2466  }
2467 
2468  (void) strcat(buffer, "=");
2469 
2470  (yyval.liste) = CONS(EXPRESSION,
2471  MakeCharacterConstantExpression(buffer),
2472  CONS(EXPRESSION, (yyvsp[0].expression), NULL));
2473  ici += 2;
2474  }
2475 #line 2476 "y.tab.c"
2476  break;
2477 
2478  case 69: /* ci: name TK_EQUALS TK_STAR */
2479 #line 604 "yacc.in"
2480  {
2481  char buffer[20];
2482  (void) strcpy(buffer, (yyvsp[-2].string));
2483  free((yyvsp[-2].string));
2484 
2485  if(strcmp(buffer,"UNIT")!=0 && strcmp(buffer,"FMT")!=0) {
2486  ParserError("parser",
2487  "Illegal default option '*' in IO control list\n");
2488  }
2489 
2490  (void) strcat(buffer, "=");
2491 
2492  (yyval.liste) = CONS(EXPRESSION,
2493  MakeCharacterConstantExpression(buffer),
2494  CONS(EXPRESSION,
2495  MakeNullaryCall(CreateIntrinsic(LIST_DIRECTED_FORMAT_NAME))
2496  , NULL));
2497  ici += 2;
2498  }
2499 #line 2500 "y.tab.c"
2500  break;
2501 
2502  case 70: /* ci: io_f_u_id */
2503 #line 624 "yacc.in"
2504  {
2505  if(ici==1 || ici==2) {
2506  (yyval.liste) = CONS(EXPRESSION,
2507  MakeCharacterConstantExpression(ici == 1 ?
2508  "UNIT=" :
2509  "FMT="),
2510  CONS(EXPRESSION, (yyvsp[0].expression), NULL));
2511  }
2512  else {
2513  ParserError("Syntax", "The unit identifier and the format identifier"
2514  " must be first and second in the control info list (standard Page F-12)");
2515  }
2516  ici += 1;
2517  }
2518 #line 2519 "y.tab.c"
2519  break;
2520 
2521  case 71: /* opt_lio_elem: %empty */
2522 #line 642 "yacc.in"
2523  { (yyval.liste) = NULL; }
2524 #line 2525 "y.tab.c"
2525  break;
2526 
2527  case 72: /* opt_lio_elem: lio_elem */
2528 #line 644 "yacc.in"
2529  { (yyval.liste) = MakeIoList((yyvsp[0].liste)); }
2530 #line 2531 "y.tab.c"
2531  break;
2532 
2533  case 73: /* lio_elem: io_elem */
2534 #line 648 "yacc.in"
2535  { (yyval.liste) = CONS(EXPRESSION, (yyvsp[0].expression), NULL); }
2536 #line 2537 "y.tab.c"
2537  break;
2538 
2539  case 74: /* lio_elem: lio_elem TK_COMMA io_elem */
2540 #line 650 "yacc.in"
2541  { (yyval.liste) = CONS(EXPRESSION, (yyvsp[0].expression), (yyvsp[-2].liste)); }
2542 #line 2543 "y.tab.c"
2543  break;
2544 
2545  case 75: /* io_elem: expression */
2546 #line 654 "yacc.in"
2547  { (yyval.expression) = (yyvsp[0].expression); }
2548 #line 2549 "y.tab.c"
2549  break;
2550 
2551  case 76: /* pause_inst: TK_PAUSE opt_expression */
2552 #line 658 "yacc.in"
2553  { (yyval.instruction) = MakeZeroOrOneArgCallInst("PAUSE", (yyvsp[0].expression)); }
2554 #line 2555 "y.tab.c"
2555  break;
2556 
2557  case 77: /* stop_inst: TK_STOP opt_expression */
2558 #line 662 "yacc.in"
2559  { (yyval.instruction) = MakeZeroOrOneArgCallInst("STOP", (yyvsp[0].expression)); }
2560 #line 2561 "y.tab.c"
2561  break;
2562 
2563  case 78: /* continue_inst: TK_CONTINUE */
2564 #line 666 "yacc.in"
2565  { (yyval.instruction) = MakeZeroOrOneArgCallInst("CONTINUE", expression_undefined);}
2566 #line 2567 "y.tab.c"
2567  break;
2568 
2569  case 79: /* do_inst: TK_DO label opt_virgule atom do_plage */
2570 #line 670 "yacc.in"
2571  {
2572  MakeDoInst((yyvsp[-1].syntax), (yyvsp[0].range), (yyvsp[-3].string));
2573  (yyval.instruction) = instruction_undefined;
2574  }
2575 #line 2576 "y.tab.c"
2576  break;
2577 
2578  case 80: /* bdo_inst: TK_DO atom do_plage */
2579 #line 677 "yacc.in"
2580  {
2581  MakeDoInst((yyvsp[-1].syntax), (yyvsp[0].range), "BLOCKDO");
2582  (yyval.instruction) = instruction_undefined;
2583  }
2584 #line 2585 "y.tab.c"
2585  break;
2586 
2587  case 81: /* wdo_inst: TK_DO TK_WHILE TK_LPAR expression TK_RPAR */
2588 #line 684 "yacc.in"
2589  {
2590  if(expression_implied_do_p((yyvsp[-1].expression)))
2591  ParserError("Syntax", "Unexpected implied DO\n");
2592  MakeWhileDoInst((yyvsp[-1].expression), "BLOCKDO");
2593  (yyval.instruction) = instruction_undefined;
2594  }
2595 #line 2596 "y.tab.c"
2596  break;
2597 
2598  case 82: /* wdo_inst: TK_DO label TK_WHILE TK_LPAR expression TK_RPAR */
2599 #line 691 "yacc.in"
2600  {
2601  if(expression_implied_do_p((yyvsp[-1].expression)))
2602  ParserError("Syntax", "Unexpected implied DO\n");
2603  MakeWhileDoInst((yyvsp[-1].expression), (yyvsp[-4].string));
2604  (yyval.instruction) = instruction_undefined;
2605  }
2606 #line 2607 "y.tab.c"
2607  break;
2608 
2609  case 83: /* do_plage: TK_EQUALS expression TK_COMMA expression */
2610 #line 700 "yacc.in"
2611  {
2612  if(expression_implied_do_p((yyvsp[-2].expression)) || expression_implied_do_p((yyvsp[0].expression)))
2613  ParserError("Syntax", "Unexpected implied DO\n");
2614  (yyval.range) = make_range((yyvsp[-2].expression), (yyvsp[0].expression), int_to_expression(1));
2615  }
2616 #line 2617 "y.tab.c"
2617  break;
2618 
2619  case 84: /* do_plage: TK_EQUALS expression TK_COMMA expression TK_COMMA expression */
2620 #line 706 "yacc.in"
2621  {
2622  if(expression_implied_do_p((yyvsp[-4].expression)) || expression_implied_do_p((yyvsp[-2].expression))
2623  || expression_implied_do_p((yyvsp[0].expression)))
2624  ParserError("Syntax", "Unexpected implied DO\n");
2625  (yyval.range) = make_range((yyvsp[-4].expression), (yyvsp[-2].expression), (yyvsp[0].expression));
2626  }
2627 #line 2628 "y.tab.c"
2628  break;
2629 
2630  case 85: /* endif_inst: TK_ENDIF */
2631 #line 715 "yacc.in"
2632  { MakeEndifInst(); }
2633 #line 2634 "y.tab.c"
2634  break;
2635 
2636  case 86: /* enddo_inst: TK_ENDDO */
2637 #line 719 "yacc.in"
2638  { MakeEnddoInst(); }
2639 #line 2640 "y.tab.c"
2640  break;
2641 
2642  case 87: /* else_inst: TK_ELSE */
2643 #line 723 "yacc.in"
2644  { MakeElseInst(true); }
2645 #line 2646 "y.tab.c"
2646  break;
2647 
2648  case 88: /* elseif_inst: TK_ELSEIF TK_LPAR expression TK_RPAR TK_THEN */
2649 #line 727 "yacc.in"
2650  {
2651  int elsifs = MakeElseInst(false);
2652 
2653  if(expression_implied_do_p((yyvsp[-2].expression)))
2654  ParserError("Syntax", "Unexpected implied DO\n");
2655  MakeBlockIfInst( (yyvsp[-2].expression), elsifs+1 );
2656  (yyval.instruction) = instruction_undefined;
2657  }
2658 #line 2659 "y.tab.c"
2659  break;
2660 
2661  case 89: /* blockif_inst: TK_IF TK_LPAR expression TK_RPAR TK_THEN */
2662 #line 738 "yacc.in"
2663  {
2664  if(expression_implied_do_p((yyvsp[-2].expression)))
2665  ParserError("Syntax", "Unexpected implied DO\n");
2666  MakeBlockIfInst((yyvsp[-2].expression),0);
2667  (yyval.instruction) = instruction_undefined;
2668  }
2669 #line 2670 "y.tab.c"
2670  break;
2671 
2672  case 90: /* logicalif_inst: TK_IF TK_LPAR expression TK_RPAR inst_exec */
2673 #line 747 "yacc.in"
2674  {
2675  if(expression_implied_do_p((yyvsp[-2].expression)))
2676  ParserError("Syntax", "Unexpected implied DO\n");
2677  (yyval.instruction) = MakeLogicalIfInst((yyvsp[-2].expression), (yyvsp[0].instruction));
2678  }
2679 #line 2680 "y.tab.c"
2680  break;
2681 
2682  case 91: /* arithmif_inst: TK_IF TK_LPAR expression TK_RPAR label TK_COMMA label TK_COMMA label */
2683 #line 756 "yacc.in"
2684  {
2685  if(expression_implied_do_p((yyvsp[-6].expression)))
2686  ParserError("Syntax", "Unexpected implied DO\n");
2687  (yyval.instruction) = MakeArithmIfInst((yyvsp[-6].expression), (yyvsp[-4].string), (yyvsp[-2].string), (yyvsp[0].string));
2688  }
2689 #line 2690 "y.tab.c"
2690  break;
2691 
2692  case 92: /* goto_inst: TK_GOTO label */
2693 #line 764 "yacc.in"
2694  {
2695  (yyval.instruction) = MakeGotoInst((yyvsp[0].string));
2696  }
2697 #line 2698 "y.tab.c"
2698  break;
2699 
2700  case 93: /* goto_inst: TK_GOTO TK_LPAR licon TK_RPAR opt_virgule expression */
2701 #line 768 "yacc.in"
2702  {
2703  if(expression_implied_do_p((yyvsp[0].expression)))
2704  ParserError("Syntax", "Unexpected implied DO\n");
2705  (yyval.instruction) = MakeComputedGotoInst((yyvsp[-3].liste), (yyvsp[0].expression));
2706  }
2707 #line 2708 "y.tab.c"
2708  break;
2709 
2710  case 94: /* goto_inst: TK_GOTO entity_name opt_virgule TK_LPAR licon TK_RPAR */
2711 #line 774 "yacc.in"
2712  {
2713  if(get_bool_property("PARSER_SUBSTITUTE_ASSIGNED_GOTO")) {
2714  (yyval.instruction) = MakeAssignedGotoInst((yyvsp[-1].liste), (yyvsp[-4].entity));
2715  }
2716  else {
2717  ParserError("parser", "assigned goto statement prohibited"
2718  " unless property PARSER_SUBSTITUTE_ASSIGNED_GOTO is set\n");
2719  }
2720  }
2721 #line 2722 "y.tab.c"
2722  break;
2723 
2724  case 95: /* goto_inst: TK_GOTO entity_name */
2725 #line 784 "yacc.in"
2726  {
2727  if(get_bool_property("PARSER_SUBSTITUTE_ASSIGNED_GOTO")) {
2728  ParserError("parser", "assigned goto statement cannot be"
2729  " desugared without a target list\n");
2730  }
2731  else {
2732  ParserError("parser", "assigned goto statement prohibited\n");
2733  }
2734  }
2735 #line 2736 "y.tab.c"
2736  break;
2737 
2738  case 96: /* licon: label */
2739 #line 796 "yacc.in"
2740  {
2741  (yyval.liste) = CONS(STRING, (yyvsp[0].string), NIL);
2742  }
2743 #line 2744 "y.tab.c"
2744  break;
2745 
2746  case 97: /* licon: licon TK_COMMA label */
2747 #line 800 "yacc.in"
2748  {
2749  (yyval.liste) = CONS(STRING, (yyvsp[0].string), (yyvsp[-2].liste));
2750  }
2751 #line 2752 "y.tab.c"
2752  break;
2753 
2754  case 98: /* assignment_inst: TK_ASSIGN icon TK_TO atom */
2755 #line 806 "yacc.in"
2756  {
2757  if(get_bool_property("PARSER_SUBSTITUTE_ASSIGNED_GOTO")) {
2758  expression e = entity_to_expression((yyvsp[-2].entity));
2759  (yyval.instruction) = MakeAssignInst((yyvsp[0].syntax), e);
2760  }
2761  else {
2762  ParserError("parser", "ASSIGN statement prohibited by PIPS"
2763  " unless property PARSER_SUBSTITUTE_ASSIGNED_GOTO is set\n");
2764  }
2765  }
2766 #line 2767 "y.tab.c"
2767  break;
2768 
2769  case 99: /* assignment_inst: atom TK_EQUALS expression */
2770 #line 817 "yacc.in"
2771  {
2772  syntax s = (yyvsp[-2].syntax);
2773  syntax new_s = syntax_undefined;
2774 
2775  if(expression_implied_do_p((yyvsp[0].expression)))
2776  ParserError("Syntax", "Unexpected implied DO\n");
2777 
2778  new_s = CheckLeftHandSide(s);
2779 
2780  (yyval.instruction) = MakeAssignInst(new_s, (yyvsp[0].expression));
2781  }
2782 #line 2783 "y.tab.c"
2783  break;
2784 
2785  case 100: /* format_inst: TK_FORMAT */
2786 #line 831 "yacc.in"
2787  {
2788  set_first_format_statement();
2789  (yyval.instruction) = MakeZeroOrOneArgCallInst("FORMAT",
2790  MakeCharacterConstantExpression(FormatValue));
2791  }
2792 #line 2793 "y.tab.c"
2793  break;
2794 
2795  case 101: /* save_inst: TK_SAVE */
2796 #line 839 "yacc.in"
2797  { save_all_entities(); }
2798 #line 2799 "y.tab.c"
2799  break;
2800 
2801  case 106: /* savename: entity_name */
2802 #line 849 "yacc.in"
2803  { ProcessSave((yyvsp[0].entity)); }
2804 #line 2805 "y.tab.c"
2805  break;
2806 
2807  case 107: /* savename: common_name */
2808 #line 851 "yacc.in"
2809  { SaveCommon((yyvsp[0].entity)); }
2810 #line 2811 "y.tab.c"
2811  break;
2812 
2813  case 108: /* intrinsic_inst: TK_INTRINSIC global_entity_name */
2814 #line 855 "yacc.in"
2815  {
2816  (void) DeclareIntrinsic((yyvsp[0].entity));
2817  }
2818 #line 2819 "y.tab.c"
2819  break;
2820 
2821  case 109: /* intrinsic_inst: intrinsic_inst TK_COMMA global_entity_name */
2822 #line 859 "yacc.in"
2823  {
2824  (void) DeclareIntrinsic((yyvsp[0].entity));
2825  }
2826 #line 2827 "y.tab.c"
2827  break;
2828 
2829  case 110: /* external_inst: TK_EXTERNAL functional_entity_name */
2830 #line 865 "yacc.in"
2831  {
2832  CurrentType = type_undefined;
2833  (void) DeclareExternalFunction((yyvsp[0].entity));
2834  }
2835 #line 2836 "y.tab.c"
2836  break;
2837 
2838  case 111: /* external_inst: external_inst TK_COMMA functional_entity_name */
2839 #line 870 "yacc.in"
2840  {
2841  (void) DeclareExternalFunction((yyvsp[0].entity));
2842  }
2843 #line 2844 "y.tab.c"
2844  break;
2845 
2846  case 112: /* type_inst: fortran_type declaration */
2847 #line 876 "yacc.in"
2848  {}
2849 #line 2850 "y.tab.c"
2850  break;
2851 
2852  case 114: /* declaration: entity_name decl_tableau lg_fortran_type */
2853 #line 881 "yacc.in"
2854  {
2855  /* the size returned by lg_fortran_type should be
2856  consistent with CurrentType unless it is of type string
2857  or undefined */
2858  type t = CurrentType;
2859 
2860  if(t != type_undefined) {
2861  basic b;
2862 
2863  if(!type_variable_p(CurrentType))
2864  FatalError("yyparse", "ill. type for CurrentType\n");
2865 
2866  b = variable_basic(type_variable(CurrentType));
2867 
2868  /* character [*len1] foo [*len2]:
2869  * if len2 is "default" then len1
2870  */
2871  if(basic_string_p(b))
2872  t = value_intrinsic_p((yyvsp[0].value))? /* ??? default */
2873  copy_type(t):
2874  MakeTypeVariable
2875  (make_basic(is_basic_string, (yyvsp[0].value)), NIL);
2876 
2877  DeclareVariable((yyvsp[-2].entity), t, (yyvsp[-1].liste),
2878  storage_undefined, value_undefined);
2879 
2880  if(basic_string_p(b))
2881  free_type(t);
2882  }
2883  else
2884  DeclareVariable((yyvsp[-2].entity), t, (yyvsp[-1].liste),
2885  storage_undefined, value_undefined);
2886 
2887  (yyval.entity) = (yyvsp[-2].entity);
2888  }
2889 #line 2890 "y.tab.c"
2890  break;
2891 
2892  case 115: /* decl_tableau: %empty */
2893 #line 919 "yacc.in"
2894  {
2895  (yyval.liste) = NULL;
2896  }
2897 #line 2898 "y.tab.c"
2898  break;
2899 
2900  case 116: /* decl_tableau: TK_LPAR ldim_tableau TK_RPAR */
2901 #line 923 "yacc.in"
2902  {
2903  (yyval.liste) = (yyvsp[-1].liste);
2904  }
2905 #line 2906 "y.tab.c"
2906  break;
2907 
2908  case 117: /* ldim_tableau: dim_tableau */
2909 #line 929 "yacc.in"
2910  {
2911  (yyval.liste) = CONS(DIMENSION, (yyvsp[0].dimension), NULL);
2912  }
2913 #line 2914 "y.tab.c"
2914  break;
2915 
2916  case 118: /* ldim_tableau: dim_tableau TK_COMMA ldim_tableau */
2917 #line 933 "yacc.in"
2918  {
2919  (yyval.liste) = CONS(DIMENSION, (yyvsp[-2].dimension), (yyvsp[0].liste));
2920  }
2921 #line 2922 "y.tab.c"
2922  break;
2923 
2924  case 119: /* dim_tableau: expression */
2925 #line 939 "yacc.in"
2926  {
2927  expression e = (yyvsp[0].expression);
2928  type t = expression_to_type(e);
2929  if(scalar_integer_type_p(t))
2930  (yyval.dimension) = make_dimension(int_to_expression(1), e, NIL);
2931  else // Not OK with gfortran, maybe OK with f77
2932  ParserError("Syntax",
2933  "Array sized with a non-integer expression");
2934  free_type(t);
2935  }
2936 #line 2937 "y.tab.c"
2937  break;
2938 
2939  case 120: /* dim_tableau: TK_STAR */
2940 #line 950 "yacc.in"
2941  {
2942  (yyval.dimension) = make_dimension(int_to_expression(1),
2943  MakeNullaryCall(CreateIntrinsic(UNBOUNDED_DIMENSION_NAME)),
2944  NIL);
2945  }
2946 #line 2947 "y.tab.c"
2947  break;
2948 
2949  case 121: /* dim_tableau: expression TK_COLON TK_STAR */
2950 #line 956 "yacc.in"
2951  {
2952  (yyval.dimension) = make_dimension((yyvsp[-2].expression),
2953  MakeNullaryCall(CreateIntrinsic(UNBOUNDED_DIMENSION_NAME)),
2954  NIL);
2955  }
2956 #line 2957 "y.tab.c"
2957  break;
2958 
2959  case 122: /* dim_tableau: expression TK_COLON expression */
2960 #line 962 "yacc.in"
2961  {
2962  expression e1 = (yyvsp[-2].expression);
2963  type t1 = expression_to_type(e1);
2964  expression e2 = (yyvsp[0].expression);
2965  type t2 = expression_to_type(e2);
2966  if(scalar_integer_type_p(t1) && scalar_integer_type_p(t2))
2967  (yyval.dimension) = make_dimension(e1, e2, NIL);
2968  else // Not OK with gfortran, maybe OK with f77
2969  ParserError("Syntax",
2970  "Array sized with a non-integer expression");
2971  free_type(t1), free_type(t2);
2972  }
2973 #line 2974 "y.tab.c"
2974  break;
2975 
2976  case 123: /* common_inst: common declaration */
2977 #line 977 "yacc.in"
2978  {
2979  (yyval.entity) = NameToCommon(BLANK_COMMON_LOCAL_NAME);
2980  AddVariableToCommon((yyval.entity), (yyvsp[0].entity));
2981  }
2982 #line 2983 "y.tab.c"
2983  break;
2984 
2985  case 124: /* common_inst: common common_name declaration */
2986 #line 982 "yacc.in"
2987  {
2988  (yyval.entity) = (yyvsp[-1].entity);
2989  AddVariableToCommon((yyval.entity), (yyvsp[0].entity));
2990  }
2991 #line 2992 "y.tab.c"
2992  break;
2993 
2994  case 125: /* common_inst: common_inst TK_COMMA declaration */
2995 #line 987 "yacc.in"
2996  {
2997  (yyval.entity) = (yyvsp[-2].entity);
2998  AddVariableToCommon((yyval.entity), (yyvsp[0].entity));
2999  }
3000 #line 3001 "y.tab.c"
3001  break;
3002 
3003  case 126: /* common_inst: common_inst opt_virgule common_name declaration */
3004 #line 992 "yacc.in"
3005  {
3006  (yyval.entity) = (yyvsp[-1].entity);
3007  AddVariableToCommon((yyval.entity), (yyvsp[0].entity));
3008  }
3009 #line 3010 "y.tab.c"
3010  break;
3011 
3012  case 127: /* common: TK_COMMON */
3013 #line 1000 "yacc.in"
3014  {
3015  CurrentType = type_undefined;
3016  }
3017 #line 3018 "y.tab.c"
3018  break;
3019 
3020  case 128: /* common_name: TK_CONCAT */
3021 #line 1006 "yacc.in"
3022  {
3023  (yyval.entity) = NameToCommon(BLANK_COMMON_LOCAL_NAME);
3024  }
3025 #line 3026 "y.tab.c"
3026  break;
3027 
3028  case 129: /* common_name: TK_SLASH global_name TK_SLASH */
3029 #line 1010 "yacc.in"
3030  {
3031  (yyval.entity) = NameToCommon((yyvsp[-1].string));
3032  }
3033 #line 3034 "y.tab.c"
3034  break;
3035 
3036  case 130: /* pointer_inst: TK_POINTER TK_LPAR entity_name TK_COMMA entity_name decl_tableau TK_RPAR */
3037 #line 1016 "yacc.in"
3038  {
3039  DeclarePointer((yyvsp[-4].entity), (yyvsp[-2].entity), (yyvsp[-1].liste));
3040  }
3041 #line 3042 "y.tab.c"
3042  break;
3043 
3044  case 134: /* equivchain: TK_LPAR latom TK_RPAR */
3045 #line 1029 "yacc.in"
3046  { StoreEquivChain((yyvsp[-1].chain)); }
3047 #line 3048 "y.tab.c"
3048  break;
3049 
3050  case 135: /* latom: atom */
3051 #line 1033 "yacc.in"
3052  {
3053  (yyval.chain) = make_chain(CONS(ATOM, MakeEquivAtom((yyvsp[0].syntax)), (cons*) NULL));
3054  }
3055 #line 3056 "y.tab.c"
3056  break;
3057 
3058  case 136: /* latom: latom TK_COMMA atom */
3059 #line 1037 "yacc.in"
3060  {
3061  chain_atoms((yyvsp[-2].chain)) = CONS(ATOM, MakeEquivAtom((yyvsp[0].syntax)),
3062  chain_atoms((yyvsp[-2].chain)));
3063  (yyval.chain) = (yyvsp[-2].chain);
3064  }
3065 #line 3066 "y.tab.c"
3066  break;
3067 
3068  case 137: /* dimension_inst: dimension declaration */
3069 #line 1045 "yacc.in"
3070  {
3071  }
3072 #line 3073 "y.tab.c"
3073  break;
3074 
3075  case 138: /* dimension_inst: dimension_inst TK_COMMA declaration */
3076 #line 1048 "yacc.in"
3077  {
3078  }
3079 #line 3080 "y.tab.c"
3080  break;
3081 
3082  case 139: /* dimension: TK_DIMENSION */
3083 #line 1053 "yacc.in"
3084  {
3085  CurrentType = type_undefined;
3086  }
3087 #line 3088 "y.tab.c"
3088  break;
3089 
3090  case 140: /* data_inst: TK_DATA ldatavar TK_SLASH ldataval TK_SLASH */
3091 #line 1059 "yacc.in"
3092  {
3093  /* AnalyzeData($2, $4); */
3094  MakeDataStatement((yyvsp[-3].liste), (yyvsp[-1].liste));
3095  }
3096 #line 3097 "y.tab.c"
3097  break;
3098 
3099  case 141: /* data_inst: data_inst opt_virgule ldatavar TK_SLASH ldataval TK_SLASH */
3100 #line 1064 "yacc.in"
3101  {
3102  /* AnalyzeData($3, $5); */
3103  MakeDataStatement((yyvsp[-3].liste), (yyvsp[-1].liste));
3104  }
3105 #line 3106 "y.tab.c"
3106  break;
3107 
3108  case 142: /* ldatavar: datavar */
3109 #line 1071 "yacc.in"
3110  {
3111  (yyval.liste) = CONS(EXPRESSION, (yyvsp[0].expression), NIL);
3112  }
3113 #line 3114 "y.tab.c"
3114  break;
3115 
3116  case 143: /* ldatavar: ldatavar TK_COMMA datavar */
3117 #line 1075 "yacc.in"
3118  {
3119  (yyval.liste) = gen_nconc((yyvsp[-2].liste), CONS(EXPRESSION, (yyvsp[0].expression), NIL));
3120  }
3121 #line 3122 "y.tab.c"
3122  break;
3123 
3124  case 144: /* ldataval: dataval */
3125 #line 1082 "yacc.in"
3126  {
3127  (yyval.liste) = CONS(EXPRESSION, (yyvsp[0].expression), NIL);
3128  }
3129 #line 3130 "y.tab.c"
3130  break;
3131 
3132  case 145: /* ldataval: ldataval TK_COMMA dataval */
3133 #line 1086 "yacc.in"
3134  {
3135  (yyval.liste) = gen_nconc((yyvsp[-2].liste), CONS(EXPRESSION, (yyvsp[0].expression), NIL));
3136  }
3137 #line 3138 "y.tab.c"
3138  break;
3139 
3140  case 146: /* dataval: dataconst */
3141 #line 1092 "yacc.in"
3142  {
3143  (yyval.expression) = MakeDataValueSet(expression_undefined, (yyvsp[0].expression));
3144  }
3145 #line 3146 "y.tab.c"
3146  break;
3147 
3148  case 147: /* dataval: dataconst TK_STAR dataconst */
3149 #line 1096 "yacc.in"
3150  {
3151  (yyval.expression) = MakeDataValueSet((yyvsp[-2].expression), (yyvsp[0].expression));
3152  }
3153 #line 3154 "y.tab.c"
3154  break;
3155 
3156  case 148: /* dataconst: const_simple */
3157 #line 1102 "yacc.in"
3158  {
3159  (yyval.expression) = (yyvsp[0].expression);
3160  }
3161 #line 3162 "y.tab.c"
3162  break;
3163 
3164  case 149: /* dataconst: TK_LPAR const_simple TK_COMMA const_simple TK_RPAR */
3165 #line 1106 "yacc.in"
3166  {
3167  (yyval.expression) = MakeComplexConstantExpression((yyvsp[-3].expression), (yyvsp[-1].expression));
3168  }
3169 #line 3170 "y.tab.c"
3170  break;
3171 
3172  case 150: /* dataconst: entity_name */
3173 #line 1110 "yacc.in"
3174  {
3175  /* Cachan bug 4: there should be a check about the entity
3176  * returned as $1 because MakeDatVal() is going to try
3177  * to evaluate that expression. The entity must be a
3178  * parameter.
3179  */
3180  if(symbolic_constant_entity_p((yyvsp[0].entity))) {
3181  (yyval.expression) = make_expression(make_syntax(is_syntax_call,
3182  make_call((yyvsp[0].entity), NIL)),
3183  normalized_undefined);
3184  }
3185  else {
3186  user_warning("gram", "Symbolic constant expected: %s\n",
3187  entity_local_name((yyvsp[0].entity)));
3188  if(strcmp("Z", entity_local_name((yyvsp[0].entity)))==0) {
3189  user_warning("gram",
3190  "Might be a non supported hexadecimal constant\n");
3191  }
3192  ParserError("gram", "Error in initializer");
3193  }
3194  }
3195 #line 3196 "y.tab.c"
3196  break;
3197 
3198  case 151: /* datavar: atom */
3199 #line 1144 "yacc.in"
3200  {
3201  (yyval.expression) = make_expression((yyvsp[0].syntax), normalized_undefined);
3202  }
3203 #line 3204 "y.tab.c"
3204  break;
3205 
3206  case 152: /* datavar: dataidl */
3207 #line 1148 "yacc.in"
3208  { (yyval.expression) = (yyvsp[0].expression); }
3209 #line 3210 "y.tab.c"
3210  break;
3211 
3212  case 153: /* dataidl: TK_LPAR ldatavar TK_COMMA entity_name do_plage TK_RPAR */
3213 #line 1152 "yacc.in"
3214  {
3215  /* $$ = MakeDataVar($2, $5); */
3216  reference r = make_reference((yyvsp[-2].entity), NIL);
3217  syntax s = make_syntax(is_syntax_reference, r);
3218  (yyval.expression) = MakeImpliedDo(s, (yyvsp[-1].range), (yyvsp[-4].liste));
3219  }
3220 #line 3221 "y.tab.c"
3221  break;
3222 
3223  case 154: /* implicit_inst: TK_IMPLICIT limplicit */
3224 #line 1161 "yacc.in"
3225  {
3226  /* Formal parameters have inherited default implicit types */
3227  retype_formal_parameters();
3228  }
3229 #line 3230 "y.tab.c"
3230  break;
3231 
3232  case 155: /* limplicit: implicit */
3233 #line 1168 "yacc.in"
3234  {
3235  }
3236 #line 3237 "y.tab.c"
3237  break;
3238 
3239  case 156: /* limplicit: limplicit TK_COMMA implicit */
3240 #line 1171 "yacc.in"
3241  {
3242  }
3243 #line 3244 "y.tab.c"
3244  break;
3245 
3246  case 157: /* implicit: fortran_type TK_LPAR l_letter_letter TK_RPAR */
3247 #line 1176 "yacc.in"
3248  {
3249  }
3250 #line 3251 "y.tab.c"
3251  break;
3252 
3253  case 158: /* l_letter_letter: letter_letter */
3254 #line 1181 "yacc.in"
3255  {
3256  }
3257 #line 3258 "y.tab.c"
3258  break;
3259 
3260  case 159: /* l_letter_letter: l_letter_letter TK_COMMA letter_letter */
3261 #line 1184 "yacc.in"
3262  {
3263  }
3264 #line 3265 "y.tab.c"
3265  break;
3266 
3267  case 160: /* letter_letter: letter */
3268 #line 1189 "yacc.in"
3269  {
3270  basic b;
3271 
3272  pips_assert("gram.y", type_variable_p(CurrentType));
3273  b = variable_basic(type_variable(CurrentType));
3274 
3275  cr_implicit(basic_tag(b), SizeOfElements(b), (yyvsp[0].character), (yyvsp[0].character));
3276  }
3277 #line 3278 "y.tab.c"
3278  break;
3279 
3280  case 161: /* letter_letter: letter TK_MINUS letter */
3281 #line 1198 "yacc.in"
3282  {
3283  basic b;
3284 
3285  pips_assert("gram.y", type_variable_p(CurrentType));
3286  b = variable_basic(type_variable(CurrentType));
3287 
3288  cr_implicit(basic_tag(b), SizeOfElements(b), (yyvsp[-2].character), (yyvsp[0].character));
3289  }
3290 #line 3291 "y.tab.c"
3291  break;
3292 
3293  case 162: /* letter: TK_NAME */
3294 #line 1209 "yacc.in"
3295  {
3296  (yyval.character) = (yyvsp[0].string)[0]; free((yyvsp[0].string));
3297  }
3298 #line 3299 "y.tab.c"
3299  break;
3300 
3301  case 166: /* parametre: entity_name TK_EQUALS expression */
3302 #line 1222 "yacc.in"
3303  {
3304  AddEntityToDeclarations(MakeParameter((yyvsp[-2].entity), (yyvsp[0].expression)), get_current_module_entity());
3305  }
3306 #line 3307 "y.tab.c"
3307  break;
3308 
3309  case 167: /* entity_name: name */
3310 #line 1228 "yacc.in"
3311  {
3312  /* malloc_verify(); */
3313  /* if SafeFind were always used, intrinsic would mask local
3314  variables, either when the module declarations are not
3315  available or when a new entity still has to be
3316  declared. See Validation/capture01.f */
3317  /* Let's try not to search intrinsics in SafeFindOrCreateEntity(). */
3318  /* Do not declare undeclared variables, because it generates
3319  a problem when processing entries. */
3320  /* $$ = SafeFindOrCreateEntity(CurrentPackage, $1); */
3321 
3322  if(!entity_undefined_p(get_current_module_entity())) {
3323  (yyval.entity) = SafeFindOrCreateEntity(CurrentPackage, (yyvsp[0].string));
3324  /* AddEntityToDeclarations($$, get_current_module_entity()); */
3325  }
3326  else
3327  (yyval.entity) = FindOrCreateEntity(CurrentPackage, (yyvsp[0].string));
3328  free((yyvsp[0].string));
3329  }
3330 #line 3331 "y.tab.c"
3331  break;
3332 
3333  case 168: /* name: TK_NAME */
3334 #line 1250 "yacc.in"
3335  { (yyval.string) = (yyvsp[0].string); }
3336 #line 3337 "y.tab.c"
3337  break;
3338 
3339  case 169: /* module_name: global_name */
3340 #line 1254 "yacc.in"
3341  {
3342  /* $$ = FindOrCreateEntity(CurrentPackage, $1); */
3343  /* $$ = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, $1); */
3344  CurrentPackage = strdup((yyvsp[0].string));
3345  BeginingOfProcedure();
3346  free((yyvsp[0].string));
3347  (yyval.string) = (char*)CurrentPackage;
3348  }
3349 #line 3350 "y.tab.c"
3350  break;
3351 
3352  case 170: /* global_entity_name: global_name */
3353 #line 1265 "yacc.in"
3354  {
3355  /* $$ = FindOrCreateEntity(CurrentPackage, $1); */
3356  (yyval.entity) = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, (yyvsp[0].string));
3357  free((yyvsp[0].string));
3358  }
3359 #line 3360 "y.tab.c"
3360  break;
3361 
3362  case 171: /* functional_entity_name: name */
3363 #line 1273 "yacc.in"
3364  {
3365  /* This includes BLOCKDATA modules because of EXTERNAL */
3366  (yyval.entity) = NameToFunctionalEntity((yyvsp[0].string));
3367  free((yyvsp[0].string));
3368  }
3369 #line 3370 "y.tab.c"
3370  break;
3371 
3372  case 172: /* global_name: TK_NAME */
3373 #line 1281 "yacc.in"
3374  { (yyval.string) = (yyvsp[0].string); }
3375 #line 3376 "y.tab.c"
3376  break;
3377 
3378  case 173: /* opt_lformalparameter: %empty */
3379 #line 1285 "yacc.in"
3380  {
3381  (yyval.liste) = NULL;
3382  }
3383 #line 3384 "y.tab.c"
3384  break;
3385 
3386  case 174: /* opt_lformalparameter: TK_LPAR TK_RPAR */
3387 #line 1289 "yacc.in"
3388  {
3389  (yyval.liste) = NULL;
3390  }
3391 #line 3392 "y.tab.c"
3392  break;
3393 
3394  case 175: /* opt_lformalparameter: TK_LPAR lformalparameter TK_RPAR */
3395 #line 1293 "yacc.in"
3396  {
3397  /* Too early: the current module is still unknown */
3398  /* $$ = add_formal_return_code($2); */
3399  (yyval.liste) = (yyvsp[-1].liste);
3400  }
3401 #line 3402 "y.tab.c"
3402  break;
3403 
3404  case 176: /* lformalparameter: entity_name */
3405 #line 1301 "yacc.in"
3406  {
3407  (yyval.liste) = CONS(ENTITY, (yyvsp[0].entity), NULL);
3408  }
3409 #line 3410 "y.tab.c"
3410  break;
3411 
3412  case 177: /* lformalparameter: TK_STAR */
3413 #line 1305 "yacc.in"
3414  {
3415  uses_alternate_return(true);
3416  (yyval.liste) = CONS(ENTITY,
3417  generate_pseudo_formal_variable_for_formal_label
3418  (CurrentPackage, get_current_number_of_alternate_returns()),
3419  NIL);
3420  }
3421 #line 3422 "y.tab.c"
3422  break;
3423 
3424  case 178: /* lformalparameter: lformalparameter TK_COMMA entity_name */
3425 #line 1313 "yacc.in"
3426  {
3427  (yyval.liste) = gen_nconc((yyvsp[-2].liste), CONS(ENTITY, (yyvsp[0].entity), NIL));
3428  }
3429 #line 3430 "y.tab.c"
3430  break;
3431 
3432  case 179: /* lformalparameter: lformalparameter TK_COMMA TK_STAR */
3433 #line 1317 "yacc.in"
3434  {
3435  uses_alternate_return(true);
3436  (yyval.liste) = gen_nconc((yyvsp[-2].liste), CONS(ENTITY,
3437  generate_pseudo_formal_variable_for_formal_label
3438  (CurrentPackage, get_current_number_of_alternate_returns()),
3439  NIL));
3440  }
3441 #line 3442 "y.tab.c"
3442  break;
3443 
3444  case 180: /* opt_fortran_type: fortran_type */
3445 #line 1327 "yacc.in"
3446  {
3447  (yyval.type) = CurrentType = (yyvsp[0].type) ;
3448  }
3449 #line 3450 "y.tab.c"
3450  break;
3451 
3452  case 181: /* opt_fortran_type: %empty */
3453 #line 1331 "yacc.in"
3454  {
3455  (yyval.type) = CurrentType = type_undefined;
3456  }
3457 #line 3458 "y.tab.c"
3458  break;
3459 
3460  case 182: /* fortran_type: fortran_basic_type lg_fortran_type */
3461 #line 1337 "yacc.in"
3462  {
3463  if (value_intrinsic_p((yyvsp[0].value))) /* ??? default! */
3464  {
3465  free_value((yyvsp[0].value));
3466  (yyvsp[0].value) = make_value_constant(
3467  make_constant_int( CurrentTypeSize));
3468  }
3469 
3470  (yyval.type) = CurrentType = MakeFortranType((yyvsp[-1].tag), (yyvsp[0].value));
3471  }
3472 #line 3473 "y.tab.c"
3473  break;
3474 
3475  case 183: /* fortran_basic_type: TK_INTEGER */
3476 #line 1350 "yacc.in"
3477  {
3478  (yyval.tag) = is_basic_int;
3479  CurrentTypeSize = DEFAULT_INTEGER_TYPE_SIZE;
3480  }
3481 #line 3482 "y.tab.c"
3482  break;
3483 
3484  case 184: /* fortran_basic_type: TK_REAL */
3485 #line 1355 "yacc.in"
3486  {
3487  (yyval.tag) = is_basic_float;
3488  CurrentTypeSize = DEFAULT_REAL_TYPE_SIZE;
3489  }
3490 #line 3491 "y.tab.c"
3491  break;
3492 
3493  case 185: /* fortran_basic_type: TK_DOUBLEPRECISION */
3494 #line 1360 "yacc.in"
3495  {
3496  (yyval.tag) = is_basic_float;
3497  CurrentTypeSize = DEFAULT_DOUBLEPRECISION_TYPE_SIZE;
3498  }
3499 #line 3500 "y.tab.c"
3500  break;
3501 
3502  case 186: /* fortran_basic_type: TK_LOGICAL */
3503 #line 1365 "yacc.in"
3504  {
3505  (yyval.tag) = is_basic_logical;
3506  CurrentTypeSize = DEFAULT_LOGICAL_TYPE_SIZE;
3507  }
3508 #line 3509 "y.tab.c"
3509  break;
3510 
3511  case 187: /* fortran_basic_type: TK_COMPLEX */
3512 #line 1370 "yacc.in"
3513  {
3514  (yyval.tag) = is_basic_complex;
3515  CurrentTypeSize = DEFAULT_COMPLEX_TYPE_SIZE;
3516  }
3517 #line 3518 "y.tab.c"
3518  break;
3519 
3520  case 188: /* fortran_basic_type: TK_DOUBLECOMPLEX */
3521 #line 1375 "yacc.in"
3522  {
3523  (yyval.tag) = is_basic_complex;
3524  CurrentTypeSize = DEFAULT_DOUBLECOMPLEX_TYPE_SIZE;
3525  }
3526 #line 3527 "y.tab.c"
3527  break;
3528 
3529  case 189: /* fortran_basic_type: TK_CHARACTER */
3530 #line 1380 "yacc.in"
3531  {
3532  (yyval.tag) = is_basic_string;
3533  CurrentTypeSize = DEFAULT_CHARACTER_TYPE_SIZE;
3534  }
3535 #line 3536 "y.tab.c"
3536  break;
3537 
3538  case 190: /* lg_fortran_type: %empty */
3539 #line 1387 "yacc.in"
3540  {
3541  (yyval.value) = make_value(is_value_intrinsic, UU); /* ??? default! */
3542  /* was: $$ = make_value(is_value_constant,
3543  * make_constant(is_constant_int, CurrentTypeSize));
3544  * then how to differentiate character*len1 foo[*len2]
3545  * if len2 is 1 or whatever... the issue is that
3546  * there should be two lg_..., one for the default that
3547  * would change CurrentTypeSize at ival, and the other not...
3548  * FC, 13/06/96
3549  */
3550  }
3551 #line 3552 "y.tab.c"
3552  break;
3553 
3554  case 191: /* lg_fortran_type: TK_STAR TK_LPAR TK_STAR TK_RPAR */
3555 #line 1399 "yacc.in"
3556  {
3557  (yyval.value) = make_value_unknown();
3558  }
3559 #line 3560 "y.tab.c"
3560  break;
3561 
3562  case 192: /* lg_fortran_type: TK_STAR TK_LPAR expression TK_RPAR */
3563 #line 1403 "yacc.in"
3564  {
3565  (yyval.value) = MakeValueSymbolic((yyvsp[-1].expression));
3566  }
3567 #line 3568 "y.tab.c"
3568  break;
3569 
3570  case 193: /* lg_fortran_type: TK_STAR ival */
3571 #line 1407 "yacc.in"
3572  {
3573  (yyval.value) = make_value_constant(make_constant_int((yyvsp[0].integer)));
3574  }
3575 #line 3576 "y.tab.c"
3576  break;
3577 
3578  case 194: /* atom: entity_name */
3579 #line 1413 "yacc.in"
3580  {
3581  (yyval.syntax) = MakeAtom((yyvsp[0].entity), NIL, expression_undefined,
3582  expression_undefined, false);
3583  }
3584 #line 3585 "y.tab.c"
3585  break;
3586 
3587  case 195: /* atom: entity_name indices */
3588 #line 1418 "yacc.in"
3589  {
3590  (yyval.syntax) = MakeAtom((yyvsp[-1].entity), (yyvsp[0].liste), expression_undefined,
3591  expression_undefined, true);
3592  }
3593 #line 3594 "y.tab.c"
3594  break;
3595 
3596  case 196: /* atom: entity_name TK_LPAR opt_expression TK_COLON opt_expression TK_RPAR */
3597 #line 1423 "yacc.in"
3598  {
3599  (yyval.syntax) = MakeAtom((yyvsp[-5].entity), NIL, (yyvsp[-3].expression), (yyvsp[-1].expression), true);
3600  }
3601 #line 3602 "y.tab.c"
3602  break;
3603 
3604  case 197: /* atom: entity_name indices TK_LPAR opt_expression TK_COLON opt_expression TK_RPAR */
3605 #line 1427 "yacc.in"
3606  {
3607  (yyval.syntax) = MakeAtom((yyvsp[-6].entity), (yyvsp[-5].liste), (yyvsp[-3].expression), (yyvsp[-1].expression), true);
3608  }
3609 #line 3610 "y.tab.c"
3610  break;
3611 
3612  case 198: /* indices: TK_LPAR TK_RPAR */
3613 #line 1433 "yacc.in"
3614  { (yyval.liste) = NULL; }
3615 #line 3616 "y.tab.c"
3616  break;
3617 
3618  case 199: /* indices: TK_LPAR lexpression TK_RPAR */
3619 #line 1435 "yacc.in"
3620  { (yyval.liste) = FortranExpressionList((yyvsp[-1].liste)); }
3621 #line 3622 "y.tab.c"
3622  break;
3623 
3624  case 200: /* lexpression: expression */
3625 #line 1439 "yacc.in"
3626  {
3627  (yyval.liste) = CONS(EXPRESSION, (yyvsp[0].expression), NULL);
3628  }
3629 #line 3630 "y.tab.c"
3630  break;
3631 
3632  case 201: /* lexpression: lexpression TK_COMMA expression */
3633 #line 1443 "yacc.in"
3634  {
3635  (yyval.liste) = gen_nconc((yyvsp[-2].liste), CONS(EXPRESSION, (yyvsp[0].expression), NIL));
3636  }
3637 #line 3638 "y.tab.c"
3638  break;
3639 
3640  case 202: /* opt_expression: expression */
3641 #line 1449 "yacc.in"
3642  {
3643  if(expression_implied_do_p((yyvsp[0].expression)))
3644  ParserError("Syntax", "Unexpected implied DO\n");
3645  (yyval.expression) = (yyvsp[0].expression);
3646  }
3647 #line 3648 "y.tab.c"
3648  break;
3649 
3650  case 203: /* opt_expression: %empty */
3651 #line 1455 "yacc.in"
3652  { (yyval.expression) = expression_undefined; }
3653 #line 3654 "y.tab.c"
3654  break;
3655 
3656  case 204: /* expression: sous_expression */
3657 #line 1459 "yacc.in"
3658  { (yyval.expression) = (yyvsp[0].expression); }
3659 #line 3660 "y.tab.c"
3660  break;
3661 
3662  case 205: /* expression: TK_LPAR expression TK_RPAR */
3663 #line 1461 "yacc.in"
3664  { (yyval.expression) = (yyvsp[-1].expression); }
3665 #line 3666 "y.tab.c"
3666  break;
3667 
3668  case 206: /* expression: TK_LPAR expression TK_COMMA expression TK_RPAR */
3669 #line 1463 "yacc.in"
3670  {
3671  expression c = MakeComplexConstantExpression((yyvsp[-3].expression), (yyvsp[-1].expression));
3672 
3673  if(expression_undefined_p(c))
3674  ParserError("Syntax", "Illegal complex constant\n");
3675 
3676  (yyval.expression) = c;
3677  }
3678 #line 3679 "y.tab.c"
3679  break;
3680 
3681  case 207: /* expression: TK_LPAR expression TK_COMMA atom do_plage TK_RPAR */
3682 #line 1472 "yacc.in"
3683  { (yyval.expression) = MakeImpliedDo((yyvsp[-2].syntax), (yyvsp[-1].range), CONS(EXPRESSION, (yyvsp[-4].expression), NIL)); }
3684 #line 3685 "y.tab.c"
3685  break;
3686 
3687  case 208: /* expression: TK_LPAR expression TK_COMMA lexpression TK_COMMA atom do_plage TK_RPAR */
3688 #line 1474 "yacc.in"
3689  { (yyval.expression) = MakeImpliedDo((yyvsp[-2].syntax), (yyvsp[-1].range), CONS(EXPRESSION, (yyvsp[-6].expression), (yyvsp[-4].liste))); }
3690 #line 3691 "y.tab.c"
3691  break;
3692 
3693  case 209: /* sous_expression: atom */
3694 #line 1478 "yacc.in"
3695  {
3696  (yyval.expression) = make_expression((yyvsp[0].syntax), normalized_undefined);
3697  }
3698 #line 3699 "y.tab.c"
3699  break;
3700 
3701  case 210: /* sous_expression: unsigned_const_simple */
3702 #line 1482 "yacc.in"
3703  {
3704  (yyval.expression) = MakeNullaryCall((yyvsp[0].entity));
3705  }
3706 #line 3707 "y.tab.c"
3707  break;
3708 
3709  case 211: /* sous_expression: signe expression */
3710 #line 1486 "yacc.in"
3711  {
3712  if ((yyvsp[-1].integer) == -1)
3713  (yyval.expression) = MakeFortranUnaryCall(CreateIntrinsic("--"), (yyvsp[0].expression));
3714  else
3715  (yyval.expression) = (yyvsp[0].expression);
3716  }
3717 #line 3718 "y.tab.c"
3718  break;
3719 
3720  case 212: /* sous_expression: expression TK_PLUS expression */
3721 #line 1493 "yacc.in"
3722  {
3723  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("+"), (yyvsp[-2].expression), (yyvsp[0].expression));
3724  }
3725 #line 3726 "y.tab.c"
3726  break;
3727 
3728  case 213: /* sous_expression: expression TK_MINUS expression */
3729 #line 1497 "yacc.in"
3730  {
3731  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("-"), (yyvsp[-2].expression), (yyvsp[0].expression));
3732  }
3733 #line 3734 "y.tab.c"
3734  break;
3735 
3736  case 214: /* sous_expression: expression TK_STAR expression */
3737 #line 1501 "yacc.in"
3738  {
3739  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("*"), (yyvsp[-2].expression), (yyvsp[0].expression));
3740  }
3741 #line 3742 "y.tab.c"
3742  break;
3743 
3744  case 215: /* sous_expression: expression TK_SLASH expression */
3745 #line 1505 "yacc.in"
3746  {
3747  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("/"), (yyvsp[-2].expression), (yyvsp[0].expression));
3748  }
3749 #line 3750 "y.tab.c"
3750  break;
3751 
3752  case 216: /* sous_expression: expression TK_POWER expression */
3753 #line 1509 "yacc.in"
3754  {
3755  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("**"),
3756  (yyvsp[-2].expression), (yyvsp[0].expression));
3757  }
3758 #line 3759 "y.tab.c"
3759  break;
3760 
3761  case 217: /* sous_expression: expression oper_rela expression */
3762 #line 1514 "yacc.in"
3763  {
3764  (yyval.expression) = MakeFortranBinaryCall((yyvsp[-1].entity), (yyvsp[-2].expression), (yyvsp[0].expression));
3765  }
3766 #line 3767 "y.tab.c"
3767  break;
3768 
3769  case 218: /* sous_expression: expression TK_EQV expression */
3770 #line 1518 "yacc.in"
3771  {
3772  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic(".EQV."),
3773  (yyvsp[-2].expression), (yyvsp[0].expression));
3774  }
3775 #line 3776 "y.tab.c"
3776  break;
3777 
3778  case 219: /* sous_expression: expression TK_NEQV expression */
3779 #line 1523 "yacc.in"
3780  {
3781  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic(".NEQV."),
3782  (yyvsp[-2].expression), (yyvsp[0].expression));
3783  }
3784 #line 3785 "y.tab.c"
3785  break;
3786 
3787  case 220: /* sous_expression: expression TK_OR expression */
3788 #line 1528 "yacc.in"
3789  {
3790  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic(".OR."),
3791  fix_if_condition((yyvsp[-2].expression)),
3792  fix_if_condition((yyvsp[0].expression)));
3793  }
3794 #line 3795 "y.tab.c"
3795  break;
3796 
3797  case 221: /* sous_expression: expression TK_AND expression */
3798 #line 1534 "yacc.in"
3799  {
3800  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic(".AND."),
3801  fix_if_condition((yyvsp[-2].expression)),
3802  fix_if_condition((yyvsp[0].expression)));
3803  }
3804 #line 3805 "y.tab.c"
3805  break;
3806 
3807  case 222: /* sous_expression: TK_NOT expression */
3808 #line 1540 "yacc.in"
3809  {
3810  (yyval.expression) = MakeFortranUnaryCall(CreateIntrinsic(".NOT."),
3811  fix_if_condition((yyvsp[0].expression)));
3812  }
3813 #line 3814 "y.tab.c"
3814  break;
3815 
3816  case 223: /* sous_expression: expression TK_CONCAT expression */
3817 #line 1545 "yacc.in"
3818  {
3819  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("//"),
3820  (yyvsp[-2].expression), (yyvsp[0].expression));
3821  }
3822 #line 3823 "y.tab.c"
3823  break;
3824 
3825  case 225: /* io_expr: TK_LPAR io_expr TK_RPAR */
3826 #line 1553 "yacc.in"
3827  { (yyval.expression) = (yyvsp[-1].expression); }
3828 #line 3829 "y.tab.c"
3829  break;
3830 
3831  case 226: /* unpar_io_expr: atom */
3832 #line 1557 "yacc.in"
3833  {
3834  (yyval.expression) = make_expression((yyvsp[0].syntax), normalized_undefined);
3835  }
3836 #line 3837 "y.tab.c"
3837  break;
3838 
3839  case 227: /* unpar_io_expr: unsigned_const_simple */
3840 #line 1562 "yacc.in"
3841  {
3842  (yyval.expression) = MakeNullaryCall((yyvsp[0].entity));
3843  }
3844 #line 3845 "y.tab.c"
3845  break;
3846 
3847  case 228: /* unpar_io_expr: signe io_expr */
3848 #line 1566 "yacc.in"
3849  {
3850  if ((yyvsp[-1].integer) == -1)
3851  (yyval.expression) = MakeFortranUnaryCall(CreateIntrinsic("--"), (yyvsp[0].expression));
3852  else
3853  (yyval.expression) = (yyvsp[0].expression);
3854  }
3855 #line 3856 "y.tab.c"
3856  break;
3857 
3858  case 229: /* unpar_io_expr: io_expr TK_PLUS io_expr */
3859 #line 1573 "yacc.in"
3860  {
3861  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("+"), (yyvsp[-2].expression), (yyvsp[0].expression));
3862  }
3863 #line 3864 "y.tab.c"
3864  break;
3865 
3866  case 230: /* unpar_io_expr: io_expr TK_MINUS io_expr */
3867 #line 1577 "yacc.in"
3868  {
3869  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("-"), (yyvsp[-2].expression), (yyvsp[0].expression));
3870  }
3871 #line 3872 "y.tab.c"
3872  break;
3873 
3874  case 231: /* unpar_io_expr: io_expr TK_STAR io_expr */
3875 #line 1581 "yacc.in"
3876  {
3877  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("*"), (yyvsp[-2].expression), (yyvsp[0].expression));
3878  }
3879 #line 3880 "y.tab.c"
3880  break;
3881 
3882  case 232: /* unpar_io_expr: io_expr TK_SLASH io_expr */
3883 #line 1585 "yacc.in"
3884  {
3885  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("/"), (yyvsp[-2].expression), (yyvsp[0].expression));
3886  }
3887 #line 3888 "y.tab.c"
3888  break;
3889 
3890  case 233: /* unpar_io_expr: io_expr TK_POWER io_expr */
3891 #line 1589 "yacc.in"
3892  {
3893  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("**"),
3894  (yyvsp[-2].expression), (yyvsp[0].expression));
3895  }
3896 #line 3897 "y.tab.c"
3897  break;
3898 
3899  case 234: /* unpar_io_expr: io_expr TK_CONCAT io_expr */
3900 #line 1594 "yacc.in"
3901  {
3902  (yyval.expression) = MakeFortranBinaryCall(CreateIntrinsic("//"),
3903  (yyvsp[-2].expression), (yyvsp[0].expression));
3904  }
3905 #line 3906 "y.tab.c"
3906  break;
3907 
3908  case 235: /* const_simple: opt_signe unsigned_const_simple */
3909 #line 1601 "yacc.in"
3910  {
3911  if ((yyvsp[-1].integer) == -1)
3912  (yyval.expression) = MakeUnaryCall(CreateIntrinsic("--"),
3913  MakeNullaryCall((yyvsp[0].entity)));
3914  else
3915  (yyval.expression) = MakeNullaryCall((yyvsp[0].entity));
3916  }
3917 #line 3918 "y.tab.c"
3918  break;
3919 
3920  case 236: /* unsigned_const_simple: TK_TRUE */
3921 #line 1611 "yacc.in"
3922  {
3923  (yyval.entity) = SafeMakeConstant(".TRUE.", is_basic_logical, ParserError);
3924  }
3925 #line 3926 "y.tab.c"
3926  break;
3927 
3928  case 237: /* unsigned_const_simple: TK_FALSE */
3929 #line 1615 "yacc.in"
3930  {
3931  (yyval.entity) = SafeMakeConstant(".FALSE.", is_basic_logical, ParserError);
3932  }
3933 #line 3934 "y.tab.c"
3934  break;
3935 
3936  case 238: /* unsigned_const_simple: icon */
3937 #line 1619 "yacc.in"
3938  {
3939  (yyval.entity) = (yyvsp[0].entity);
3940  }
3941 #line 3942 "y.tab.c"
3942  break;
3943 
3944  case 239: /* unsigned_const_simple: TK_DCON */
3945 #line 1623 "yacc.in"
3946  {
3947  (yyval.entity) = make_Fortran_constant_entity((yyvsp[0].string), is_basic_float,
3948  DEFAULT_DOUBLEPRECISION_TYPE_SIZE);
3949  free((yyvsp[0].string));
3950  }
3951 #line 3952 "y.tab.c"
3952  break;
3953 
3954  case 240: /* unsigned_const_simple: TK_SCON */
3955 #line 1629 "yacc.in"
3956  {
3957  (yyval.entity) = SafeMakeConstant((yyvsp[0].string), is_basic_string, ParserError);
3958  free((yyvsp[0].string));
3959  }
3960 #line 3961 "y.tab.c"
3961  break;
3962 
3963  case 241: /* unsigned_const_simple: TK_RCON */
3964 #line 1634 "yacc.in"
3965  {
3966  (yyval.entity) = SafeMakeConstant((yyvsp[0].string), is_basic_float, ParserError);
3967  free((yyvsp[0].string));
3968  }
3969 #line 3970 "y.tab.c"
3970  break;
3971 
3972  case 242: /* icon: TK_ICON */
3973 #line 1641 "yacc.in"
3974  {
3975  (yyval.entity) = SafeMakeConstant((yyvsp[0].string), is_basic_int, ParserError);
3976  free((yyvsp[0].string));
3977  }
3978 #line 3979 "y.tab.c"
3979  break;
3980 
3981  case 243: /* label: TK_ICON */
3982 #line 1648 "yacc.in"
3983  {
3984  (yyval.string) = (yyvsp[0].string);
3985  }
3986 #line 3987 "y.tab.c"
3987  break;
3988 
3989  case 244: /* ival: TK_ICON */
3990 #line 1654 "yacc.in"
3991  {
3992  (yyval.integer) = atoi((yyvsp[0].string));
3993  free((yyvsp[0].string));
3994  }
3995 #line 3996 "y.tab.c"
3996  break;
3997 
3998  case 245: /* opt_signe: %empty */
3999 #line 1661 "yacc.in"
4000  {
4001  (yyval.integer) = 1;
4002  }
4003 #line 4004 "y.tab.c"
4004  break;
4005 
4006  case 246: /* opt_signe: signe */
4007 #line 1665 "yacc.in"
4008  {
4009  (yyval.integer) = (yyvsp[0].integer);
4010  }
4011 #line 4012 "y.tab.c"
4012  break;
4013 
4014  case 247: /* signe: TK_PLUS */
4015 #line 1671 "yacc.in"
4016  {
4017  (yyval.integer) = 1;
4018  }
4019 #line 4020 "y.tab.c"
4020  break;
4021 
4022  case 248: /* signe: TK_MINUS */
4023 #line 1675 "yacc.in"
4024  {
4025  (yyval.integer) = -1;
4026  }
4027 #line 4028 "y.tab.c"
4028  break;
4029 
4030  case 249: /* oper_rela: TK_EQ */
4031 #line 1681 "yacc.in"
4032  {
4033  (yyval.entity) = CreateIntrinsic(".EQ.");
4034  }
4035 #line 4036 "y.tab.c"
4036  break;
4037 
4038  case 250: /* oper_rela: TK_NE */
4039 #line 1685 "yacc.in"
4040  {
4041  (yyval.entity) = CreateIntrinsic(".NE.");
4042  }
4043 #line 4044 "y.tab.c"
4044  break;
4045 
4046  case 251: /* oper_rela: TK_LT */
4047 #line 1689 "yacc.in"
4048  {
4049  (yyval.entity) = CreateIntrinsic(".LT.");
4050  }
4051 #line 4052 "y.tab.c"
4052  break;
4053 
4054  case 252: /* oper_rela: TK_LE */
4055 #line 1693 "yacc.in"
4056  {
4057  (yyval.entity) = CreateIntrinsic(".LE.");
4058  }
4059 #line 4060 "y.tab.c"
4060  break;
4061 
4062  case 253: /* oper_rela: TK_GE */
4063 #line 1697 "yacc.in"
4064  {
4065  (yyval.entity) = CreateIntrinsic(".GE.");
4066  }
4067 #line 4068 "y.tab.c"
4068  break;
4069 
4070  case 254: /* oper_rela: TK_GT */
4071 #line 1701 "yacc.in"
4072  {
4073  (yyval.entity) = CreateIntrinsic(".GT.");
4074  }
4075 #line 4076 "y.tab.c"
4076  break;
4077 
4078  case 255: /* io_keyword: TK_PRINT */
4079 #line 1707 "yacc.in"
4080  { (yyval.integer) = TK_PRINT; ici = 1; }
4081 #line 4082 "y.tab.c"
4082  break;
4083 
4084  case 256: /* io_keyword: TK_WRITE */
4085 #line 1709 "yacc.in"
4086  { (yyval.integer) = TK_WRITE; ici = 1; }
4087 #line 4088 "y.tab.c"
4088  break;
4089 
4090  case 257: /* io_keyword: TK_READ */
4091 #line 1711 "yacc.in"
4092  { (yyval.integer) = TK_READ; ici = 1; }
4093 #line 4094 "y.tab.c"
4094  break;
4095 
4096  case 258: /* io_keyword: TK_CLOSE */
4097 #line 1713 "yacc.in"
4098  { (yyval.integer) = TK_CLOSE; ici = 1; }
4099 #line 4100 "y.tab.c"
4100  break;
4101 
4102  case 259: /* io_keyword: TK_OPEN */
4103 #line 1715 "yacc.in"
4104  { (yyval.integer) = TK_OPEN; ici = 1; }
4105 #line 4106 "y.tab.c"
4106  break;
4107 
4108  case 260: /* io_keyword: TK_ENDFILE */
4109 #line 1717 "yacc.in"
4110  { (yyval.integer) = TK_ENDFILE; ici = 1; }
4111 #line 4112 "y.tab.c"
4112  break;
4113 
4114  case 261: /* io_keyword: TK_BACKSPACE */
4115 #line 1719 "yacc.in"
4116  { (yyval.integer) = TK_BACKSPACE; ici = 1; }
4117 #line 4118 "y.tab.c"
4118  break;
4119 
4120  case 262: /* io_keyword: TK_REWIND */
4121 #line 1721 "yacc.in"
4122  { (yyval.integer) = TK_REWIND; ici = 1; }
4123 #line 4124 "y.tab.c"
4124  break;
4125 
4126  case 263: /* io_keyword: TK_INQUIRE */
4127 #line 1723 "yacc.in"
4128  { (yyval.integer) = TK_INQUIRE; ici = 1; }
4129 #line 4130 "y.tab.c"
4130  break;
4131 
4132  case 264: /* iobuf_keyword: TK_BUFFERIN */
4133 #line 1727 "yacc.in"
4134  { (yyval.integer) = TK_BUFFERIN; ici = 1; }
4135 #line 4136 "y.tab.c"
4136  break;
4137 
4138  case 265: /* iobuf_keyword: TK_BUFFEROUT */
4139 #line 1729 "yacc.in"
4140  { (yyval.integer) = TK_BUFFEROUT ; ici = 1; }
4141 #line 4142 "y.tab.c"
4142  break;
4143 
4144  case 266: /* psf_keyword: TK_PROGRAM */
4145 #line 1733 "yacc.in"
4146  { (yyval.integer) = TK_PROGRAM; init_ghost_variable_entities(); }
4147 #line 4148 "y.tab.c"
4148  break;
4149 
4150  case 267: /* psf_keyword: TK_SUBROUTINE */
4151 #line 1735 "yacc.in"
4152  { (yyval.integer) = TK_SUBROUTINE; init_ghost_variable_entities();
4153  set_current_number_of_alternate_returns();}
4154 #line 4155 "y.tab.c"
4155  break;
4156 
4157  case 268: /* psf_keyword: TK_FUNCTION */
4158 #line 1738 "yacc.in"
4159  { (yyval.integer) = TK_FUNCTION; init_ghost_variable_entities();
4160  set_current_number_of_alternate_returns();}
4161 #line 4162 "y.tab.c"
4162  break;
4163 
4164  case 269: /* psf_keyword: TK_BLOCKDATA */
4165 #line 1741 "yacc.in"
4166  { (yyval.integer) = TK_BLOCKDATA; init_ghost_variable_entities(); }
4167 #line 4168 "y.tab.c"
4168  break;
4169 
4170 
4171 #line 4172 "y.tab.c"
4172 
4173  default: break;
4174  }
4175  /* User semantic actions sometimes alter yychar, and that requires
4176  that yytoken be updated with the new translation. We take the
4177  approach of translating immediately before every use of yytoken.
4178  One alternative is translating here after every semantic action,
4179  but that translation would be missed if the semantic action invokes
4180  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4181  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
4182  incorrect destructor might then be invoked immediately. In the
4183  case of YYERROR or YYBACKUP, subsequent parser actions might lead
4184  to an incorrect destructor call or verbose syntax error message
4185  before the lookahead is translated. */
4186  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
4187 
4188  YYPOPSTACK (yylen);
4189  yylen = 0;
4190 
4191  *++yyvsp = yyval;
4192 
4193  /* Now 'shift' the result of the reduction. Determine what state
4194  that goes to, based on the state we popped back to and the rule
4195  number reduced by. */
4196  {
4197  const int yylhs = yyr1[yyn] - YYNTOKENS;
4198  const int yyi = yypgoto[yylhs] + *yyssp;
4199  yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
4200  ? yytable[yyi]
4201  : yydefgoto[yylhs]);
4202  }
4203 
4204  goto yynewstate;
4205 
4206 
4207 /*--------------------------------------.
4208 | yyerrlab -- here on detecting error. |
4209 `--------------------------------------*/
4210 yyerrlab:
4211  /* Make sure we have latest lookahead translation. See comments at
4212  user semantic actions for why this is necessary. */
4213  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
4214  /* If not already recovering from an error, report this error. */
4215  if (!yyerrstatus)
4216  {
4217  ++yynerrs;
4218  yyerror (YY_("syntax error"));
4219  }
4220 
4221  if (yyerrstatus == 3)
4222  {
4223  /* If just tried and failed to reuse lookahead token after an
4224  error, discard it. */
4225 
4226  if (yychar <= YYEOF)
4227  {
4228  /* Return failure if at end of input. */
4229  if (yychar == YYEOF)
4230  YYABORT;
4231  }
4232  else
4233  {
4234  yydestruct ("Error: discarding",
4235  yytoken, &yylval);
4236  yychar = YYEMPTY;
4237  }
4238  }
4239 
4240  /* Else will try to reuse lookahead token after shifting the error
4241  token. */
4242  goto yyerrlab1;
4243 
4244 
4245 /*---------------------------------------------------.
4246 | yyerrorlab -- error raised explicitly by YYERROR. |
4247 `---------------------------------------------------*/
4248 yyerrorlab:
4249  /* Pacify compilers when the user code never invokes YYERROR and the
4250  label yyerrorlab therefore never appears in user code. */
4251  if (0)
4252  YYERROR;
4253  ++yynerrs;
4254 
4255  /* Do not reclaim the symbols of the rule whose action triggered
4256  this YYERROR. */
4257  YYPOPSTACK (yylen);
4258  yylen = 0;
4259  YY_STACK_PRINT (yyss, yyssp);
4260  yystate = *yyssp;
4261  goto yyerrlab1;
4262 
4263 
4264 /*-------------------------------------------------------------.
4265 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4266 `-------------------------------------------------------------*/
4267 yyerrlab1:
4268  yyerrstatus = 3; /* Each real token shifted decrements this. */
4269 
4270  /* Pop stack until we find a state that shifts the error token. */
4271  for (;;)
4272  {
4273  yyn = yypact[yystate];
4274  if (!yypact_value_is_default (yyn))
4275  {
4276  yyn += YYSYMBOL_YYerror;
4277  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
4278  {
4279  yyn = yytable[yyn];
4280  if (0 < yyn)
4281  break;
4282  }
4283  }
4284 
4285  /* Pop the current state because it cannot handle the error token. */
4286  if (yyssp == yyss)
4287  YYABORT;
4288 
4289 
4290  yydestruct ("Error: popping",
4291  YY_ACCESSING_SYMBOL (yystate), yyvsp);
4292  YYPOPSTACK (1);
4293  yystate = *yyssp;
4294  YY_STACK_PRINT (yyss, yyssp);
4295  }
4296 
4297  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
4298  *++yyvsp = yylval;
4299  YY_IGNORE_MAYBE_UNINITIALIZED_END
4300 
4301 
4302  /* Shift the error token. */
4303  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
4304 
4305  yystate = yyn;
4306  goto yynewstate;
4307 
4308 
4309 /*-------------------------------------.
4310 | yyacceptlab -- YYACCEPT comes here. |
4311 `-------------------------------------*/
4312 yyacceptlab:
4313  yyresult = 0;
4314  goto yyreturnlab;
4315 
4316 
4317 /*-----------------------------------.
4318 | yyabortlab -- YYABORT comes here. |
4319 `-----------------------------------*/
4320 yyabortlab:
4321  yyresult = 1;
4322  goto yyreturnlab;
4323 
4324 
4325 /*-----------------------------------------------------------.
4326 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
4327 `-----------------------------------------------------------*/
4328 yyexhaustedlab:
4329  yyerror (YY_("memory exhausted"));
4330  yyresult = 2;
4331  goto yyreturnlab;
4332 
4333 
4334 /*----------------------------------------------------------.
4335 | yyreturnlab -- parsing is finished, clean up and return. |
4336 `----------------------------------------------------------*/
4337 yyreturnlab:
4338  if (yychar != YYEMPTY)
4339  {
4340  /* Make sure we have latest lookahead translation. See comments at
4341  user semantic actions for why this is necessary. */
4342  yytoken = YYTRANSLATE (yychar);
4343  yydestruct ("Cleanup: discarding lookahead",
4344  yytoken, &yylval);
4345  }
4346  /* Do not reclaim the symbols of the rule whose action triggered
4347  this YYABORT or YYACCEPT. */
4348  YYPOPSTACK (yylen);
4349  YY_STACK_PRINT (yyss, yyssp);
4350  while (yyssp != yyss)
4351  {
4352  yydestruct ("Cleanup: popping",
4353  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
4354  YYPOPSTACK (1);
4355  }
4356 #ifndef yyoverflow
4357  if (yyss != yyssa)
4358  YYSTACK_FREE (yyss);
4359 #endif
4360 
4361  return yyresult;
4362 }
4363 
4364 #line 1747 "yacc.in"
4365 
make_chain
chain make_chain(list a)
Definition: parser_private.c:94
make_call
call make_call(entity a1, list a2)
Definition: ri.c:269
make_value_unknown
value make_value_unknown(void)
Definition: ri.c:2847
make_expression
expression make_expression(syntax a1, normalized a2)
Definition: ri.c:886
make_basic
basic make_basic(enum basic_utype tag, void *val)
Definition: ri.c:155
make_value_constant
value make_value_constant(constant _field_)
Definition: ri.c:2841
copy_type
type copy_type(type p)
TYPE.
Definition: ri.c:2655
make_value
value make_value(enum value_utype tag, void *val)
Definition: ri.c:2832
make_reference
reference make_reference(entity a1, list a2)
Definition: ri.c:2083
make_constant_int
constant make_constant_int(intptr_t _field_)
Definition: ri.c:409
make_dimension
dimension make_dimension(expression a1, expression a2, list a3)
Definition: ri.c:565
free_type
void free_type(type p)
Definition: ri.c:2658
make_syntax
syntax make_syntax(enum syntax_utype tag, void *val)
Definition: ri.c:2491
make_range
range make_range(expression a1, expression a2, expression a3)
Definition: ri.c:2041
free_value
void free_value(value p)
Definition: ri.c:2787
MakeCharacterConstantExpression
expression MakeCharacterConstantExpression(string s)
END_EOLE.
Definition: constant.c:573
MakeComplexConstantExpression
expression MakeComplexConstantExpression(expression r, expression i)
Definition: constant.c:397
SafeMakeConstant
entity SafeMakeConstant(string name, tag bt, bool(*error_manager)(const char *, const char *))
END_EOLE.
Definition: constant.c:315
complex_constant_expression_p
bool complex_constant_expression_p(expression cce)
Definition: constant.c:416
MakeValueSymbolic
value MakeValueSymbolic(expression e)
this function creates a value for a symbolic constant.
Definition: constant.c:581
yysymbol_name
static const char * yysymbol_name(yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED
The user-facing name of the symbol whose (internal) number is YYSYMBOL.
Definition: cyacc.tab.c:1383
yy_symbol_print
static void yy_symbol_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
-----------------------—.
Definition: cyacc.tab.c:2447
yyrline
static const yytype_int16 yyrline[]
YYRLINE[YYN] – Source line where rule number YYN was defined.
Definition: cyacc.tab.c:1279
yy_symbol_value_print
static void yy_symbol_value_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
-------------------------------—.
Definition: cyacc.tab.c:2429
yy_reduce_print
static void yy_reduce_print(yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
--------------------------------------------—.
Definition: cyacc.tab.c:2486
yytname
static const char *const yytname[]
YYTNAME[SYMBOL-NUM] – String name of the symbol SYMBOL-NUM.
Definition: cyacc.tab.c:1327
yy_stack_print
static void yy_stack_print(yy_state_t *yybottom, yy_state_t *yytop)
--------------------------------------------------------------—.
Definition: cyacc.tab.c:2463
YYFPRINTF
#define YYFPRINTF
Enable debugging if requested.
Definition: cyacc.tab.c:2400
SafeFindOrCreateEntity
entity SafeFindOrCreateEntity(const char *package, const char *name)
Problem: A functional global entity may be referenced without parenthesis or CALL keyword in a functi...
Definition: declaration.c:1891
cr_implicit
void cr_implicit(tag t, int l, int lettre_d, int lettre_f)
this function updates the data structure used to compute implicit types.
Definition: declaration.c:1284
SaveCommon
void SaveCommon(entity c)
this function transforms a dynamic common into a static one.
Definition: declaration.c:295
DeclareVariable
void DeclareVariable(entity e, type t, list d, storage s, value v)
void DeclareVariable(e, t, d, s, v): update entity e description as declaration statements are encoun...
Definition: declaration.c:670
MakeDataStatement
void MakeDataStatement(list ldr, list ldv)
Receives as first input an implicit list of references, including implicit DO, and as second input an...
Definition: declaration.c:524
ProcessSave
void ProcessSave(entity v)
Definition: declaration.c:282
save_all_entities
void save_all_entities()
functions for the SAVE declaration
Definition: declaration.c:138
DeclareIntrinsic
void DeclareIntrinsic(entity e)
Intrinsic e is used in the current module.
Definition: declaration.c:918
NameToCommon
entity NameToCommon(string n)
Definition: declaration.c:1071
retype_formal_parameters
void retype_formal_parameters()
If an IMPLICIT statement is encountered, it must be applied to the formal parameters,...
Definition: declaration.c:1411
DeclarePointer
void DeclarePointer(entity ptr, entity pointed_array, list decl_dims)
Definition: declaration.c:546
MakeFortranType
type MakeFortranType(tag t, value v)
this function creates a type that represents a fortran type.
Definition: declaration.c:1505
AddVariableToCommon
void AddVariableToCommon(entity c, entity v)
This function adds a variable v to a common block c.
Definition: declaration.c:1108
MakeEquivAtom
atom MakeEquivAtom(syntax s)
this function creates an atom of an equivalence chain.
Definition: equivalence.c:89
StoreEquivChain
void StoreEquivChain(chain c)
This function is called when an equivalence chain has been completely parsed.
Definition: equivalence.c:176
get_bool_property
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
Definition: gfc2pips-stubs.c:173
STRING
#define STRING(x)
Definition: genC.h:87
yytokentype
yytokentype
Definition: genread.h:52
yysymbol_kind_t
yysymbol_kind_t
!YY_GENREAD_Y_TAB_H_INCLUDED
Definition: genread_yacc.c:294
yytype_int16
short yytype_int16
Definition: genread_yacc.c:378
yytype_uint8
unsigned char yytype_uint8
Work around bug in HP-UX 11.23, which defines these macros incorrectly for preprocessor constants.
Definition: genread_yacc.c:399
yy_state_fast_t
int yy_state_fast_t
State numbers in computations.
Definition: genread_yacc.c:457
yytype_int8
signed char yytype_int8
On compilers that do not define PTRDIFF_MAX etc., make sure <limits.h> and (if available) <stdint....
Definition: genread_yacc.c:370
yy_state_t
yytype_int8 yy_state_t
Stored state numbers (used for stacks).
Definition: genread_yacc.c:454
get_current_module_entity
entity get_current_module_entity(void)
Get the entity of the current module.
Definition: static.c:85
NIL
#define NIL
The empty list (nil in Lisp)
Definition: newgen_list.h:47
CONS
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
Definition: newgen_list.h:150
gen_nconc
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
Definition: list.c:344
pips_user_warning
#define pips_user_warning
Definition: misc-local.h:146
pips_assert
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
Definition: misc-local.h:172
user_warning
#define user_warning(fn,...)
Definition: misc-local.h:262
LIST_DIRECTED_FORMAT_NAME
#define LIST_DIRECTED_FORMAT_NAME
Definition: naming-local.h:97
TOP_LEVEL_MODULE_NAME
#define TOP_LEVEL_MODULE_NAME
Module containing the global variables in Fortran and C.
Definition: naming-local.h:101
BLANK_COMMON_LOCAL_NAME
#define BLANK_COMMON_LOCAL_NAME
Definition: naming-local.h:68
tag
int tag
TAG.
Definition: newgen_types.h:92
UU
#define UU
Definition: newgen_types.h:98
parser_private.h
ATOM
#define ATOM(x)
newgen_equivalences_domain_defined
Definition: parser_private.h:74
chain_atoms
#define chain_atoms(x)
Definition: parser_private.h:138
MakeCurrentFunction
void MakeCurrentFunction(type t, int msf, const char *cfn, list lfp)
this function creates one entity cf that represents the Fortran function f being analyzed.
Definition: procedure.c:1239
EndOfProcedure
void EndOfProcedure()
This function is called when the parsing of a procedure is completed.
Definition: procedure.c:979
BeginingOfProcedure
void BeginingOfProcedure()
this function is called each time a new procedure is encountered.
Definition: procedure.c:301
init_ghost_variable_entities
void init_ghost_variable_entities()
procedure.c
Definition: procedure.c:69
DeclareExternalFunction
entity DeclareExternalFunction(entity e)
Definition: procedure.c:2426
MakeEntry
instruction MakeEntry(entity e, list lfp)
An ENTRY statement is substituted by a labelled continue.
Definition: procedure.c:1810
NameToFunctionalEntity
entity NameToFunctionalEntity(string name)
Definition: procedure.c:2217
append_data_current_stmt_buffer_to_declarations
void append_data_current_stmt_buffer_to_declarations(void)
Definition: reader.c:276
UNBOUNDED_DIMENSION_NAME
#define UNBOUNDED_DIMENSION_NAME
Definition: ri-util-local.h:74
DEFAULT_LOGICAL_TYPE_SIZE
#define DEFAULT_LOGICAL_TYPE_SIZE
Definition: ri-util-local.h:1970
REPEAT_VALUE_NAME
#define REPEAT_VALUE_NAME
Definition: ri-util-local.h:77
DEFAULT_INTEGER_TYPE_SIZE
#define DEFAULT_INTEGER_TYPE_SIZE
Definition: ri-util-local.h:1929
DEFAULT_REAL_TYPE_SIZE
#define DEFAULT_REAL_TYPE_SIZE
The standard C integer types are represented as follow char = 1 short_int = 2 int = 4 long_int = 6 lo...
Definition: ri-util-local.h:1964
DEFAULT_COMPLEX_TYPE_SIZE
#define DEFAULT_COMPLEX_TYPE_SIZE
Definition: ri-util-local.h:1967
DEFAULT_DOUBLECOMPLEX_TYPE_SIZE
#define DEFAULT_DOUBLECOMPLEX_TYPE_SIZE
Definition: ri-util-local.h:1968
DEFAULT_CHARACTER_TYPE_SIZE
#define DEFAULT_CHARACTER_TYPE_SIZE
Default type sizes.
Definition: ri-util-local.h:1927
DEFAULT_DOUBLEPRECISION_TYPE_SIZE
#define DEFAULT_DOUBLEPRECISION_TYPE_SIZE
Definition: ri-util-local.h:1965
FindEntity
entity FindEntity(const char *package, const char *name)
Retrieve an entity from its package/module name and its local name.
Definition: entity.c:1503
entity_local_name
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
Definition: entity.c:453
FindOrCreateEntity
entity FindOrCreateEntity(const char *package, const char *local_name)
Problem: A functional global entity may be referenced without parenthesis or CALL keyword in a functi...
Definition: entity.c:1586
CreateIntrinsic
entity CreateIntrinsic(string name)
this function does not create an intrinsic function because they must all be created beforehand by th...
Definition: entity.c:1311
EvalExpression
value EvalExpression(expression e)
Evaluate statically an expression.
Definition: eval.c:108
make_call_expression
expression make_call_expression(entity e, list l)
Build an expression that call an function entity with an argument list.
Definition: expression.c:321
entity_to_expression
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
Definition: expression.c:165
int_to_expression
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
Definition: expression.c:1188
MakeNullaryCall
expression MakeNullaryCall(entity f)
Creates a call expression to a function with zero arguments.
Definition: expression.c:331
MakeUnaryCall
expression MakeUnaryCall(entity f, expression a)
Creates a call expression to a function with one argument.
Definition: expression.c:342
expression_implied_do_p
bool expression_implied_do_p(e)
Definition: expression.c:817
expression_to_type
type expression_to_type(expression)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
Definition: type.c:2486
scalar_integer_type_p
bool scalar_integer_type_p(type)
Definition: type.c:3276
AddEntityToDeclarations
void AddEntityToDeclarations(entity, entity)
END_EOLE.
Definition: variable.c:108
generate_pseudo_formal_variable_for_formal_label
entity generate_pseudo_formal_variable_for_formal_label(const char *, int)
Definition: variable.c:1744
generate_string_for_alternate_return_argument
expression generate_string_for_alternate_return_argument(string)
Definition: variable.c:1721
SizeOfElements
_int SizeOfElements(basic)
This function returns the length in bytes of the Fortran or C type represented by a basic,...
Definition: size.c:297
MakeTypeVariable
type MakeTypeVariable(basic, cons *)
BEGIN_EOLE.
Definition: type.c:116
symbolic_constant_entity_p
bool symbolic_constant_entity_p(entity)
BEGIN_EOLE.
Definition: variable.c:83
value_undefined
#define value_undefined
Definition: ri.h:3016
is_basic_string
@ is_basic_string
Definition: ri.h:576
is_basic_float
@ is_basic_float
Definition: ri.h:572
is_basic_int
@ is_basic_int
Definition: ri.h:571
is_basic_logical
@ is_basic_logical
Definition: ri.h:573
is_basic_complex
@ is_basic_complex
Definition: ri.h:575
normalized_undefined
#define normalized_undefined
Definition: ri.h:1745
value_intrinsic_p
#define value_intrinsic_p(x)
Definition: ri.h:3074
ENTITY
#define ENTITY(x)
ENTITY.
Definition: ri.h:2755
basic_tag
#define basic_tag(x)
Definition: ri.h:613
type_variable
#define type_variable(x)
Definition: ri.h:2949
is_value_intrinsic
@ is_value_intrinsic
Definition: ri.h:3034
is_syntax_call
@ is_syntax_call
Definition: ri.h:2693
is_syntax_reference
@ is_syntax_reference
Definition: ri.h:2691
value_constant_p
#define value_constant_p(x)
Definition: ri.h:3071
EXPRESSION
#define EXPRESSION(x)
EXPRESSION.
Definition: ri.h:1217
instruction_undefined
#define instruction_undefined
Definition: ri.h:1454
entity_undefined_p
#define entity_undefined_p(x)
Definition: ri.h:2762
expression_undefined
#define expression_undefined
Definition: ri.h:1223
expression_undefined_p
#define expression_undefined_p(x)
Definition: ri.h:1224
syntax_undefined
#define syntax_undefined
Definition: ri.h:2676
type_undefined
#define type_undefined
Definition: ri.h:2883
basic_string_p
#define basic_string_p(x)
Definition: ri.h:629
type_variable_p
#define type_variable_p(x)
Definition: ri.h:2947
variable_basic
#define variable_basic(x)
Definition: ri.h:3120
storage_undefined
#define storage_undefined
Definition: ri.h:2476
strdup
char * strdup()
DIMENSION
#define DIMENSION
Definition: sc_simplex_feasibility_fixprec.c:118
uint_least8_t
#define uint_least8_t
Definition: stdint.in.h:229
int_least16_t
#define int_least16_t
Definition: stdint.in.h:230
intptr_t
#define intptr_t
Definition: stdint.in.h:294
int_least8_t
#define int_least8_t
7.18.1.2.
Definition: stdint.in.h:228
uint_least16_t
#define uint_least16_t
Definition: stdint.in.h:231
buffer
static string buffer
Definition: string.c:113
_newgen_struct_basic_
Definition: ri.h:595
_newgen_struct_chain_
Definition: parser_private.h:132
_newgen_struct_dataval_
Definition: parser_private.h:200
_newgen_struct_datavar_
Definition: parser_private.h:236
_newgen_struct_dimension_
Definition: ri.h:971
_newgen_struct_entity_
Definition: ri.h:2778
_newgen_struct_expression_
Definition: ri.h:1239
_newgen_struct_instruction_
Definition: ri.h:1493
_newgen_struct_range_
Definition: ri.h:2279
_newgen_struct_reference_
Definition: ri.h:2318
_newgen_struct_syntax_
Definition: ri.h:2711
_newgen_struct_type_
Definition: ri.h:2922
_newgen_struct_value_
Definition: ri.h:3049
cons
The structure used to build lists in NewGen.
Definition: newgen_list.h:41
TK_EQUALS
#define TK_EQUALS
Definition: syn_yacc.c:368
TK_CLOSE
#define TK_CLOSE
Definition: syn_yacc.c:289
TK_GT
#define TK_GT
Definition: syn_yacc.c:345
TK_STATIC
#define TK_STATIC
Definition: syn_yacc.c:331
TK_STOP
#define TK_STOP
Definition: syn_yacc.c:332
TK_ENDFILE
#define TK_ENDFILE
Definition: syn_yacc.c:301
TK_LPAR
#define TK_LPAR
Definition: syn_yacc.c:364
TK_SAVE
#define TK_SAVE
Definition: syn_yacc.c:330
yyparse
#define yyparse
------—.
Definition: syn_yacc.c:68
TK_SUBROUTINE
#define TK_SUBROUTINE
Definition: syn_yacc.c:333
yyr1
static const yytype_uint8 yyr1[]
YYR1[RULE-NUM] – Symbol kind of the left-hand side of rule RULE-NUM.
Definition: syn_yacc.c:1576
syn_lval
YYSTYPE syn_lval
TK_ENDIF
#define TK_ENDIF
Definition: syn_yacc.c:303
TK_NOT
#define TK_NOT
Definition: syn_yacc.c:350
TK_WHILE
#define TK_WHILE
Definition: syn_yacc.c:336
TK_EOS
#define TK_EOS
Definition: syn_yacc.c:371
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: syn_yacc.c:801
YYMAXDEPTH
#define YYMAXDEPTH
YYMAXDEPTH – maximum size the stacks can grow to (effective only if the built-in stack extension meth...
Definition: syn_yacc.c:1817
TK_CALL
#define TK_CALL
Definition: syn_yacc.c:287
YYSTACK_FREE
#define YYSTACK_FREE
Definition: syn_yacc.c:863
TK_FALSE
#define TK_FALSE
Definition: syn_yacc.c:353
TK_ASSIGN
#define TK_ASSIGN
Definition: syn_yacc.c:281
yytranslate
static const yytype_int8 yytranslate[]
YYTRANSLATE[TOKEN-NUM] – Symbol number corresponding to TOKEN-NUM as returned by yylex.
Definition: syn_yacc.c:977
TK_POWER
#define TK_POWER
Definition: syn_yacc.c:363
yysymbol_kind_t
yysymbol_kind_t
!YY_SYN_Y_TAB_H_INCLUDED
Definition: syn_yacc.c:416
YYSYMBOL_intrinsic_inst
@ YYSYMBOL_intrinsic_inst
savename
Definition: syn_yacc.c:561
YYSYMBOL_TK_WRITE
@ YYSYMBOL_TK_WRITE
TK_WHILE
Definition: syn_yacc.c:477
YYSYMBOL_107_5
@ YYSYMBOL_107_5
$@4
Definition: syn_yacc.c:525
YYSYMBOL_TK_FORMAT
@ YYSYMBOL_TK_FORMAT
TK_EXTERNAL
Definition: syn_yacc.c:449
YYSYMBOL_TK_ENTRY
@ YYSYMBOL_TK_ENTRY
TK_END
Definition: syn_yacc.c:445
YYSYMBOL_TK_REAL
@ YYSYMBOL_TK_REAL
TK_READ
Definition: syn_yacc.c:467
YYSYMBOL_TK_SAVE
@ YYSYMBOL_TK_SAVE
TK_REWIND
Definition: syn_yacc.c:470
YYSYMBOL_equivchain
@ YYSYMBOL_equivchain
lequivchain
Definition: syn_yacc.c:574
YYSYMBOL_bdo_inst
@ YYSYMBOL_bdo_inst
do_inst
Definition: syn_yacc.c:544
YYSYMBOL_decl_tableau
@ YYSYMBOL_decl_tableau
declaration
Definition: syn_yacc.c:565
YYSYMBOL_io_f_u_id
@ YYSYMBOL_io_f_u_id
io_inst
Definition: syn_yacc.c:534
YYSYMBOL_dataconst
@ YYSYMBOL_dataconst
dataval
Definition: syn_yacc.c:582
YYSYMBOL_TK_NAME
@ YYSYMBOL_TK_NAME
TK_FALSE
Definition: syn_yacc.c:494
YYSYMBOL_TK_EQUALS
@ YYSYMBOL_TK_EQUALS
TK_COLON
Definition: syn_yacc.c:508
YYSYMBOL_TK_POWER
@ YYSYMBOL_TK_POWER
TK_STAR
Definition: syn_yacc.c:503
YYSYMBOL_TK_EQV
@ YYSYMBOL_TK_EQV
TK_EQ
Definition: syn_yacc.c:483
YYSYMBOL_licon
@ YYSYMBOL_licon
goto_inst
Definition: syn_yacc.c:555
YYSYMBOL_YYUNDEF
@ YYSYMBOL_YYUNDEF
error
Definition: syn_yacc.c:420
YYSYMBOL_TK_INQUIRE
@ YYSYMBOL_TK_INQUIRE
TK_INCLUDE
Definition: syn_yacc.c:455
YYSYMBOL_lg_fortran_type
@ YYSYMBOL_lg_fortran_type
fortran_basic_type
Definition: syn_yacc.c:605
YYSYMBOL_TK_POINTER
@ YYSYMBOL_TK_POINTER
TK_PAUSE
Definition: syn_yacc.c:463
YYSYMBOL_TK_MINUS
@ YYSYMBOL_TK_MINUS
TK_DCON
Definition: syn_yacc.c:499
YYSYMBOL_common_name
@ YYSYMBOL_common_name
common
Definition: syn_yacc.c:570
YYSYMBOL_TK_OUT
@ YYSYMBOL_TK_OUT
TK_IN
Definition: syn_yacc.c:480
YYSYMBOL_lci
@ YYSYMBOL_lci
io_f_u_id
Definition: syn_yacc.c:535
YYSYMBOL_TK_PROGRAM
@ YYSYMBOL_TK_PROGRAM
TK_PRINT
Definition: syn_yacc.c:465
YYSYMBOL_TK_ENDDO
@ YYSYMBOL_TK_ENDDO
TK_ENDFILE
Definition: syn_yacc.c:442
YYSYMBOL_ldataval
@ YYSYMBOL_ldataval
ldatavar
Definition: syn_yacc.c:580
YYSYMBOL_TK_CLOSE
@ YYSYMBOL_TK_CLOSE
TK_CHARACTER
Definition: syn_yacc.c:429
YYSYMBOL_TK_GOTO
@ YYSYMBOL_TK_GOTO
TK_FUNCTION
Definition: syn_yacc.c:451
YYSYMBOL_unsigned_const_simple
@ YYSYMBOL_unsigned_const_simple
const_simple
Definition: syn_yacc.c:615
YYSYMBOL_TK_CONTINUE
@ YYSYMBOL_TK_CONTINUE
TK_COMPLEX
Definition: syn_yacc.c:432
YYSYMBOL_TK_CONCAT
@ YYSYMBOL_TK_CONCAT
TK_CURRENCY
Definition: syn_yacc.c:510
YYSYMBOL_unpar_io_expr
@ YYSYMBOL_unpar_io_expr
io_expr
Definition: syn_yacc.c:613
YYSYMBOL_TK_EXIT
@ YYSYMBOL_TK_EXIT
TK_EQUIVALENCE
Definition: syn_yacc.c:447
YYSYMBOL_TK_LOGICAL
@ YYSYMBOL_TK_LOGICAL
TK_IOSTAT
Definition: syn_yacc.c:459
YYSYMBOL_ldatavar
@ YYSYMBOL_ldatavar
data_inst
Definition: syn_yacc.c:579
YYSYMBOL_TK_SCON
@ YYSYMBOL_TK_SCON
TK_ICON
Definition: syn_yacc.c:496
YYSYMBOL_limplicit
@ YYSYMBOL_limplicit
implicit_inst
Definition: syn_yacc.c:586
YYSYMBOL_TK_BLANK
@ YYSYMBOL_TK_BLANK
TK_BACKSPACE
Definition: syn_yacc.c:423
YYSYMBOL_TK_LPAR
@ YYSYMBOL_TK_LPAR
TK_POWER
Definition: syn_yacc.c:504
YYSYMBOL_TK_GT
@ YYSYMBOL_TK_GT
TK_GE
Definition: syn_yacc.c:485
YYSYMBOL_TK_DATA
@ YYSYMBOL_TK_DATA
TK_CYCLE
Definition: syn_yacc.c:434
YYSYMBOL_implicit_inst
@ YYSYMBOL_implicit_inst
dataidl
Definition: syn_yacc.c:585
YYSYMBOL_do_inst
@ YYSYMBOL_do_inst
continue_inst
Definition: syn_yacc.c:543
YYSYMBOL_implicit
@ YYSYMBOL_implicit
limplicit
Definition: syn_yacc.c:587
YYSYMBOL_TK_COLON
@ YYSYMBOL_TK_COLON
TK_COMMA
Definition: syn_yacc.c:507
YYSYMBOL_inst_exec
@ YYSYMBOL_inst_exec
inst_spec
Definition: syn_yacc.c:527
YYSYMBOL_TK_END
@ YYSYMBOL_TK_END
TK_ENDIF
Definition: syn_yacc.c:444
YYSYMBOL_YYerror
@ YYSYMBOL_YYerror
"end of file"
Definition: syn_yacc.c:419
YYSYMBOL_indices
@ YYSYMBOL_indices
atom
Definition: syn_yacc.c:607
YYSYMBOL_TK_FUNCTION
@ YYSYMBOL_TK_FUNCTION
TK_FORMAT
Definition: syn_yacc.c:450
YYSYMBOL_parameter_inst
@ YYSYMBOL_parameter_inst
letter
Definition: syn_yacc.c:591
YYSYMBOL_TK_DOUBLEPRECISION
@ YYSYMBOL_TK_DOUBLEPRECISION
TK_DIMENSION
Definition: syn_yacc.c:436
YYSYMBOL_io_inst
@ YYSYMBOL_io_inst
arguments
Definition: syn_yacc.c:533
YYSYMBOL_TK_IOLPAR
@ YYSYMBOL_TK_IOLPAR
TK_EOS
Definition: syn_yacc.c:512
YYSYMBOL_TK_INOUT
@ YYSYMBOL_TK_INOUT
TK_WRITE
Definition: syn_yacc.c:478
YYSYMBOL_linstruction
@ YYSYMBOL_linstruction
end_inst
Definition: syn_yacc.c:522
YYSYMBOL_opt_lio_elem
@ YYSYMBOL_opt_lio_elem
ci
Definition: syn_yacc.c:537
YYSYMBOL_l_letter_letter
@ YYSYMBOL_l_letter_letter
implicit
Definition: syn_yacc.c:588
YYSYMBOL_99_2
@ YYSYMBOL_99_2
$@1
Definition: syn_yacc.c:517
YYSYMBOL_dim_tableau
@ YYSYMBOL_dim_tableau
ldim_tableau
Definition: syn_yacc.c:567
YYSYMBOL_savename
@ YYSYMBOL_savename
lsavename
Definition: syn_yacc.c:560
YYSYMBOL_opt_virgule
@ YYSYMBOL_opt_virgule
psf_keyword
Definition: syn_yacc.c:625
YYSYMBOL_98_1
@ YYSYMBOL_98_1
prg_exec
Definition: syn_yacc.c:516
YYSYMBOL_TK_OR
@ YYSYMBOL_TK_OR
TK_NOT
Definition: syn_yacc.c:491
YYSYMBOL_prg_exec
@ YYSYMBOL_prg_exec
lprg_exec
Definition: syn_yacc.c:515
YYSYMBOL_TK_ASSIGN
@ YYSYMBOL_TK_ASSIGN
"invalid token"
Definition: syn_yacc.c:421
YYSYMBOL_wdo_inst
@ YYSYMBOL_wdo_inst
bdo_inst
Definition: syn_yacc.c:545
YYSYMBOL_TK_TRUE
@ YYSYMBOL_TK_TRUE
TK_OR
Definition: syn_yacc.c:492
YYSYMBOL_TK_TO
@ YYSYMBOL_TK_TO
TK_THEN
Definition: syn_yacc.c:475
YYSYMBOL_lequivchain
@ YYSYMBOL_lequivchain
equivalence_inst
Definition: syn_yacc.c:573
YYSYMBOL_io_expr
@ YYSYMBOL_io_expr
sous_expression
Definition: syn_yacc.c:612
YYSYMBOL_lexpression
@ YYSYMBOL_lexpression
indices
Definition: syn_yacc.c:608
YYSYMBOL_equivalence_inst
@ YYSYMBOL_equivalence_inst
pointer_inst
Definition: syn_yacc.c:572
YYSYMBOL_elseif_inst
@ YYSYMBOL_elseif_inst
else_inst
Definition: syn_yacc.c:550
YYSYMBOL_fortran_type
@ YYSYMBOL_fortran_type
opt_fortran_type
Definition: syn_yacc.c:603
YYSYMBOL_global_name
@ YYSYMBOL_global_name
functional_entity_name
Definition: syn_yacc.c:599
YYSYMBOL_letter
@ YYSYMBOL_letter
letter_letter
Definition: syn_yacc.c:590
YYSYMBOL_module_name
@ YYSYMBOL_module_name
name
Definition: syn_yacc.c:596
YYSYMBOL_TK_NE
@ YYSYMBOL_TK_NE
TK_LT
Definition: syn_yacc.c:488
YYSYMBOL_lsavename
@ YYSYMBOL_lsavename
save_inst
Definition: syn_yacc.c:559
YYSYMBOL_expression
@ YYSYMBOL_expression
opt_expression
Definition: syn_yacc.c:610
YYSYMBOL_io_keyword
@ YYSYMBOL_io_keyword
oper_rela
Definition: syn_yacc.c:622
YYSYMBOL_TK_IF
@ YYSYMBOL_TK_IF
TK_GOTO
Definition: syn_yacc.c:452
YYSYMBOL_TK_LE
@ YYSYMBOL_TK_LE
TK_GT
Definition: syn_yacc.c:486
YYSYMBOL_tk_call
@ YYSYMBOL_tk_call
call_inst
Definition: syn_yacc.c:530
YYSYMBOL_label
@ YYSYMBOL_label
icon
Definition: syn_yacc.c:617
YYSYMBOL_common
@ YYSYMBOL_common
common_inst
Definition: syn_yacc.c:569
YYSYMBOL_TK_AND
@ YYSYMBOL_TK_AND
TK_OUT
Definition: syn_yacc.c:481
YYSYMBOL_call_inst
@ YYSYMBOL_call_inst
return_inst
Definition: syn_yacc.c:529
YYSYMBOL_TK_NOT
@ YYSYMBOL_TK_NOT
TK_NEQV
Definition: syn_yacc.c:490
YYSYMBOL_TK_IN
@ YYSYMBOL_TK_IN
TK_INOUT
Definition: syn_yacc.c:479
YYSYMBOL_oper_rela
@ YYSYMBOL_oper_rela
signe
Definition: syn_yacc.c:621
YYSYMBOL_io_elem
@ YYSYMBOL_io_elem
lio_elem
Definition: syn_yacc.c:539
YYSYMBOL_latom
@ YYSYMBOL_latom
equivchain
Definition: syn_yacc.c:575
YYSYMBOL_arguments
@ YYSYMBOL_arguments
parameters
Definition: syn_yacc.c:532
YYSYMBOL_TK_THEN
@ YYSYMBOL_TK_THEN
TK_SUBROUTINE
Definition: syn_yacc.c:474
YYSYMBOL_opt_expression
@ YYSYMBOL_opt_expression
lexpression
Definition: syn_yacc.c:609
YYSYMBOL_TK_STATIC
@ YYSYMBOL_TK_STATIC
TK_SAVE
Definition: syn_yacc.c:471
YYSYMBOL_letter_letter
@ YYSYMBOL_letter_letter
l_letter_letter
Definition: syn_yacc.c:589
YYSYMBOL_iobuf_keyword
@ YYSYMBOL_iobuf_keyword
io_keyword
Definition: syn_yacc.c:623
YYSYMBOL_begin_inst
@ YYSYMBOL_begin_inst
$@3
Definition: syn_yacc.c:519
YYSYMBOL_TK_EXTERNAL
@ YYSYMBOL_TK_EXTERNAL
TK_EXIT
Definition: syn_yacc.c:448
YYSYMBOL_arithmif_inst
@ YYSYMBOL_arithmif_inst
logicalif_inst
Definition: syn_yacc.c:553
YYSYMBOL_TK_INTRINSIC
@ YYSYMBOL_TK_INTRINSIC
TK_INTEGER
Definition: syn_yacc.c:457
YYSYMBOL_atom
@ YYSYMBOL_atom
lg_fortran_type
Definition: syn_yacc.c:606
YYSYMBOL_TK_DCON
@ YYSYMBOL_TK_DCON
TK_RCON
Definition: syn_yacc.c:498
YYSYMBOL_TK_ENDIF
@ YYSYMBOL_TK_ENDIF
TK_ENDDO
Definition: syn_yacc.c:443
YYSYMBOL_const_simple
@ YYSYMBOL_const_simple
unpar_io_expr
Definition: syn_yacc.c:614
YYSYMBOL_return_inst
@ YYSYMBOL_return_inst
inst_exec
Definition: syn_yacc.c:528
YYSYMBOL_TK_DOUBLECOMPLEX
@ YYSYMBOL_TK_DOUBLECOMPLEX
TK_DOUBLEPRECISION
Definition: syn_yacc.c:437
YYSYMBOL_106_4
@ YYSYMBOL_106_4
instruction
Definition: syn_yacc.c:524
YYSYMBOL_save_inst
@ YYSYMBOL_save_inst
format_inst
Definition: syn_yacc.c:558
YYSYMBOL_TK_LT
@ YYSYMBOL_TK_LT
TK_LE
Definition: syn_yacc.c:487
YYSYMBOL_TK_REWIND
@ YYSYMBOL_TK_REWIND
TK_RETURN
Definition: syn_yacc.c:469
YYSYMBOL_TK_IMPLICIT
@ YYSYMBOL_TK_IMPLICIT
TK_IF
Definition: syn_yacc.c:453
YYSYMBOL_format_inst
@ YYSYMBOL_format_inst
assignment_inst
Definition: syn_yacc.c:557
YYSYMBOL_TK_SUBROUTINE
@ YYSYMBOL_TK_SUBROUTINE
TK_STOP
Definition: syn_yacc.c:473
YYSYMBOL_entry_inst
@ YYSYMBOL_entry_inst
begin_inst
Definition: syn_yacc.c:520
YYSYMBOL_TK_DO
@ YYSYMBOL_TK_DO
TK_DOUBLECOMPLEX
Definition: syn_yacc.c:438
YYSYMBOL_type_inst
@ YYSYMBOL_type_inst
external_inst
Definition: syn_yacc.c:563
YYSYMBOL_parametre
@ YYSYMBOL_parametre
lparametre
Definition: syn_yacc.c:593
YYSYMBOL_TK_EQUIVALENCE
@ YYSYMBOL_TK_EQUIVALENCE
TK_ENTRY
Definition: syn_yacc.c:446
YYSYMBOL_declaration
@ YYSYMBOL_declaration
type_inst
Definition: syn_yacc.c:564
YYSYMBOL_name
@ YYSYMBOL_name
entity_name
Definition: syn_yacc.c:595
YYSYMBOL_instruction
@ YYSYMBOL_instruction
linstruction
Definition: syn_yacc.c:523
YYSYMBOL_blockif_inst
@ YYSYMBOL_blockif_inst
elseif_inst
Definition: syn_yacc.c:551
YYSYMBOL_global_entity_name
@ YYSYMBOL_global_entity_name
module_name
Definition: syn_yacc.c:597
YYSYMBOL_TK_WHILE
@ YYSYMBOL_TK_WHILE
TK_TO
Definition: syn_yacc.c:476
YYSYMBOL_logicalif_inst
@ YYSYMBOL_logicalif_inst
blockif_inst
Definition: syn_yacc.c:552
YYSYMBOL_dimension
@ YYSYMBOL_dimension
dimension_inst
Definition: syn_yacc.c:577
YYSYMBOL_dataidl
@ YYSYMBOL_dataidl
datavar
Definition: syn_yacc.c:584
YYSYMBOL_TK_BACKSPACE
@ YYSYMBOL_TK_BACKSPACE
TK_ASSIGN
Definition: syn_yacc.c:422
YYSYMBOL_TK_GE
@ YYSYMBOL_TK_GE
TK_EQV
Definition: syn_yacc.c:484
YYSYMBOL_TK_INTEGER
@ YYSYMBOL_TK_INTEGER
TK_INQUIRE
Definition: syn_yacc.c:456
YYSYMBOL_endif_inst
@ YYSYMBOL_endif_inst
do_plage
Definition: syn_yacc.c:547
YYSYMBOL_pointer_inst
@ YYSYMBOL_pointer_inst
common_name
Definition: syn_yacc.c:571
YYSYMBOL_YYACCEPT
@ YYSYMBOL_YYACCEPT
TK_IOLPAR
Definition: syn_yacc.c:513
YYSYMBOL_TK_READ
@ YYSYMBOL_TK_READ
TK_PROGRAM
Definition: syn_yacc.c:466
YYSYMBOL_fortran_basic_type
@ YYSYMBOL_fortran_basic_type
fortran_type
Definition: syn_yacc.c:604
YYSYMBOL_TK_PRINT
@ YYSYMBOL_TK_PRINT
TK_POINTER
Definition: syn_yacc.c:464
YYSYMBOL_data_inst
@ YYSYMBOL_data_inst
dimension
Definition: syn_yacc.c:578
YYSYMBOL_TK_FALSE
@ YYSYMBOL_TK_FALSE
TK_TRUE
Definition: syn_yacc.c:493
YYSYMBOL_TK_RPAR
@ YYSYMBOL_TK_RPAR
TK_LPAR
Definition: syn_yacc.c:505
YYSYMBOL_TK_CALL
@ YYSYMBOL_TK_CALL
TK_BUFFEROUT
Definition: syn_yacc.c:427
YYSYMBOL_TK_COMPLEX
@ YYSYMBOL_TK_COMPLEX
TK_COMMON
Definition: syn_yacc.c:431
YYSYMBOL_TK_PAUSE
@ YYSYMBOL_TK_PAUSE
TK_PARAMETER
Definition: syn_yacc.c:462
YYSYMBOL_TK_SLASH
@ YYSYMBOL_TK_SLASH
TK_PLUS
Definition: syn_yacc.c:501
YYSYMBOL_YYEOF
@ YYSYMBOL_YYEOF
Definition: syn_yacc.c:418
YYSYMBOL_TK_INCLUDE
@ YYSYMBOL_TK_INCLUDE
TK_IMPLICIT
Definition: syn_yacc.c:454
YYSYMBOL_lprg_exec
@ YYSYMBOL_lprg_exec
$accept
Definition: syn_yacc.c:514
YYSYMBOL_pause_inst
@ YYSYMBOL_pause_inst
io_elem
Definition: syn_yacc.c:540
YYSYMBOL_TK_CURRENCY
@ YYSYMBOL_TK_CURRENCY
TK_EQUALS
Definition: syn_yacc.c:509
YYSYMBOL_TK_STOP
@ YYSYMBOL_TK_STOP
TK_STATIC
Definition: syn_yacc.c:472
YYSYMBOL_TK_CYCLE
@ YYSYMBOL_TK_CYCLE
TK_CONTINUE
Definition: syn_yacc.c:433
YYSYMBOL_TK_COMMA
@ YYSYMBOL_TK_COMMA
TK_RPAR
Definition: syn_yacc.c:506
YYSYMBOL_parameters
@ YYSYMBOL_parameters
tk_call
Definition: syn_yacc.c:531
YYSYMBOL_TK_DIMENSION
@ YYSYMBOL_TK_DIMENSION
TK_DATA
Definition: syn_yacc.c:435
YYSYMBOL_TK_EOS
@ YYSYMBOL_TK_EOS
TK_CONCAT
Definition: syn_yacc.c:511
YYSYMBOL_dimension_inst
@ YYSYMBOL_dimension_inst
latom
Definition: syn_yacc.c:576
YYSYMBOL_opt_fortran_type
@ YYSYMBOL_opt_fortran_type
lformalparameter
Definition: syn_yacc.c:602
YYSYMBOL_TK_PLUS
@ YYSYMBOL_TK_PLUS
TK_MINUS
Definition: syn_yacc.c:500
YYSYMBOL_goto_inst
@ YYSYMBOL_goto_inst
arithmif_inst
Definition: syn_yacc.c:554
YYSYMBOL_psf_keyword
@ YYSYMBOL_psf_keyword
iobuf_keyword
Definition: syn_yacc.c:624
YYSYMBOL_TK_ELSE
@ YYSYMBOL_TK_ELSE
TK_ELSEIF
Definition: syn_yacc.c:440
YYSYMBOL_enddo_inst
@ YYSYMBOL_enddo_inst
endif_inst
Definition: syn_yacc.c:548
YYSYMBOL_TK_ENDFILE
@ YYSYMBOL_TK_ENDFILE
TK_ELSE
Definition: syn_yacc.c:441
YYSYMBOL_continue_inst
@ YYSYMBOL_continue_inst
stop_inst
Definition: syn_yacc.c:542
YYSYMBOL_assignment_inst
@ YYSYMBOL_assignment_inst
licon
Definition: syn_yacc.c:556
YYSYMBOL_entity_name
@ YYSYMBOL_entity_name
parametre
Definition: syn_yacc.c:594
YYSYMBOL_ci
@ YYSYMBOL_ci
lci
Definition: syn_yacc.c:536
YYSYMBOL_TK_STAR
@ YYSYMBOL_TK_STAR
TK_SLASH
Definition: syn_yacc.c:502
YYSYMBOL_TK_BLOCKDATA
@ YYSYMBOL_TK_BLOCKDATA
TK_BLANK
Definition: syn_yacc.c:424
YYSYMBOL_YYEMPTY
@ YYSYMBOL_YYEMPTY
Definition: syn_yacc.c:417
YYSYMBOL_100_3
@ YYSYMBOL_100_3
$@2
Definition: syn_yacc.c:518
YYSYMBOL_sous_expression
@ YYSYMBOL_sous_expression
expression
Definition: syn_yacc.c:611
YYSYMBOL_TK_NEQV
@ YYSYMBOL_TK_NEQV
TK_NE
Definition: syn_yacc.c:489
YYSYMBOL_end_inst
@ YYSYMBOL_end_inst
entry_inst
Definition: syn_yacc.c:521
YYSYMBOL_TK_RCON
@ YYSYMBOL_TK_RCON
TK_SCON
Definition: syn_yacc.c:497
YYSYMBOL_ival
@ YYSYMBOL_ival
label
Definition: syn_yacc.c:618
YYSYMBOL_external_inst
@ YYSYMBOL_external_inst
intrinsic_inst
Definition: syn_yacc.c:562
YYSYMBOL_TK_COMMON
@ YYSYMBOL_TK_COMMON
TK_CLOSE
Definition: syn_yacc.c:430
YYSYMBOL_functional_entity_name
@ YYSYMBOL_functional_entity_name
global_entity_name
Definition: syn_yacc.c:598
YYSYMBOL_else_inst
@ YYSYMBOL_else_inst
enddo_inst
Definition: syn_yacc.c:549
YYSYMBOL_datavar
@ YYSYMBOL_datavar
dataconst
Definition: syn_yacc.c:583
YYSYMBOL_TK_EQ
@ YYSYMBOL_TK_EQ
TK_AND
Definition: syn_yacc.c:482
YYSYMBOL_opt_signe
@ YYSYMBOL_opt_signe
ival
Definition: syn_yacc.c:619
YYSYMBOL_icon
@ YYSYMBOL_icon
unsigned_const_simple
Definition: syn_yacc.c:616
YYSYMBOL_lformalparameter
@ YYSYMBOL_lformalparameter
opt_lformalparameter
Definition: syn_yacc.c:601
YYSYMBOL_ldim_tableau
@ YYSYMBOL_ldim_tableau
decl_tableau
Definition: syn_yacc.c:566
YYSYMBOL_TK_ELSEIF
@ YYSYMBOL_TK_ELSEIF
TK_DO
Definition: syn_yacc.c:439
YYSYMBOL_TK_RETURN
@ YYSYMBOL_TK_RETURN
TK_REAL
Definition: syn_yacc.c:468
YYSYMBOL_TK_PARAMETER
@ YYSYMBOL_TK_PARAMETER
TK_OPEN
Definition: syn_yacc.c:461
YYSYMBOL_lparametre
@ YYSYMBOL_lparametre
parameter_inst
Definition: syn_yacc.c:592
YYSYMBOL_lio_elem
@ YYSYMBOL_lio_elem
opt_lio_elem
Definition: syn_yacc.c:538
YYSYMBOL_TK_ICON
@ YYSYMBOL_TK_ICON
TK_NAME
Definition: syn_yacc.c:495
YYSYMBOL_dataval
@ YYSYMBOL_dataval
ldataval
Definition: syn_yacc.c:581
YYSYMBOL_stop_inst
@ YYSYMBOL_stop_inst
pause_inst
Definition: syn_yacc.c:541
YYSYMBOL_signe
@ YYSYMBOL_signe
opt_signe
Definition: syn_yacc.c:620
YYSYMBOL_TK_IOSTAT
@ YYSYMBOL_TK_IOSTAT
TK_INTRINSIC
Definition: syn_yacc.c:458
YYSYMBOL_TK_CHARACTER
@ YYSYMBOL_TK_CHARACTER
TK_CALL
Definition: syn_yacc.c:428
YYSYMBOL_do_plage
@ YYSYMBOL_do_plage
wdo_inst
Definition: syn_yacc.c:546
YYSYMBOL_TK_BUFFERIN
@ YYSYMBOL_TK_BUFFERIN
TK_BLOCKDATA
Definition: syn_yacc.c:425
YYSYMBOL_opt_lformalparameter
@ YYSYMBOL_opt_lformalparameter
global_name
Definition: syn_yacc.c:600
YYSYMBOL_TK_BUFFEROUT
@ YYSYMBOL_TK_BUFFEROUT
TK_BUFFERIN
Definition: syn_yacc.c:426
YYSYMBOL_TK_OPEN
@ YYSYMBOL_TK_OPEN
TK_LOGICAL
Definition: syn_yacc.c:460
YYSYMBOL_inst_spec
@ YYSYMBOL_inst_spec
$@5
Definition: syn_yacc.c:526
YYSYMBOL_common_inst
@ YYSYMBOL_common_inst
dim_tableau
Definition: syn_yacc.c:568
TK_RETURN
#define TK_RETURN
Definition: syn_yacc.c:328
TK_CURRENCY
#define TK_CURRENCY
Definition: syn_yacc.c:369
YY_ASSERT
#define YY_ASSERT(E)
Definition: syn_yacc.c:821
YY_
#define YY_(Msgid)
Definition: syn_yacc.c:755
YYNOMEM
#define YYNOMEM
Definition: syn_yacc.c:1650
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: syn_yacc.c:802
YYNSTATES
#define YYNSTATES
YYNSTATES – Number of states.
Definition: syn_yacc.c:962
YY_IGNORE_USELESS_CAST_END
#define YY_IGNORE_USELESS_CAST_END
Definition: syn_yacc.c:817
TK_CHARACTER
#define TK_CHARACTER
Definition: syn_yacc.c:288
yytype_int16
short yytype_int16
Definition: syn_yacc.c:666
yychar
#define yychar
Definition: syn_yacc.c:74
TK_BACKSPACE
#define TK_BACKSPACE
Definition: syn_yacc.c:282
YYEOF
#define YYEOF
Definition: syn_yacc.c:278
yydefact
static const yytype_int16 yydefact[]
YYDEFACT[STATE-NUM] – Default reduction number in state STATE-NUM.
Definition: syn_yacc.c:1180
TK_ICON
#define TK_ICON
Definition: syn_yacc.c:355
YYABORT
#define YYABORT
Definition: syn_yacc.c:1648
TK_STAR
#define TK_STAR
Definition: syn_yacc.c:362
TK_CYCLE
#define TK_CYCLE
Definition: syn_yacc.c:293
TK_SLASH
#define TK_SLASH
Definition: syn_yacc.c:361
TK_FUNCTION
#define TK_FUNCTION
Definition: syn_yacc.c:310
TK_DOUBLECOMPLEX
#define TK_DOUBLECOMPLEX
Definition: syn_yacc.c:297
TK_EQV
#define TK_EQV
Definition: syn_yacc.c:343
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
The size of an array large to enough to hold all stacks, each with N elements.
Definition: syn_yacc.c:906
TK_PAUSE
#define TK_PAUSE
Definition: syn_yacc.c:322
TK_RCON
#define TK_RCON
Definition: syn_yacc.c:357
TK_DIMENSION
#define TK_DIMENSION
Definition: syn_yacc.c:295
yy_state_t
yytype_int16 yy_state_t
Stored state numbers (used for stacks).
Definition: syn_yacc.c:742
TK_COMPLEX
#define TK_COMPLEX
Definition: syn_yacc.c:291
yydefgoto
static const yytype_int16 yydefgoto[]
YYDEFGOTO[NTERM-NUM].
Definition: syn_yacc.c:1249
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: syn_yacc.c:1800
YY_CAST
#define YY_CAST(Type, Val)
Definition: syn_yacc.c:144
CurrentTypeSize
intptr_t CurrentTypeSize
the type in a type or dimension or common statement
Definition: syn_yacc.c:103
yydestruct
static void yydestruct(const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
-------------------------------------------—.
Definition: syn_yacc.c:1830
TK_BUFFEROUT
#define TK_BUFFEROUT
Definition: syn_yacc.c:286
TK_DATA
#define TK_DATA
Definition: syn_yacc.c:294
TK_PLUS
#define TK_PLUS
Definition: syn_yacc.c:360
TK_PARAMETER
#define TK_PARAMETER
Definition: syn_yacc.c:321
TK_GOTO
#define TK_GOTO
Definition: syn_yacc.c:311
TK_ENDDO
#define TK_ENDDO
Definition: syn_yacc.c:302
yypact
static const yytype_int16 yypact[]
YYPACT[STATE-NUM] – Index in YYTABLE of the portion describing STATE-NUM.
Definition: syn_yacc.c:1126
yylex
#define yylex
Definition: syn_yacc.c:69
TK_EQ
#define TK_EQ
Definition: syn_yacc.c:342
YYerror
#define YYerror
Definition: syn_yacc.c:279
YY_NULLPTR
#define YY_NULLPTR
Definition: syn_yacc.c:156
TK_EXIT
#define TK_EXIT
Definition: syn_yacc.c:307
YYUNDEF
#define YYUNDEF
Definition: syn_yacc.c:280
malloc
void * malloc(YYSIZE_T)
YYFINAL
#define YYFINAL
!YYCOPY_NEEDED
Definition: syn_yacc.c:951
TK_IN
#define TK_IN
Definition: syn_yacc.c:339
TK_BUFFERIN
#define TK_BUFFERIN
Definition: syn_yacc.c:285
YY_ACCESSING_SYMBOL
#define YY_ACCESSING_SYMBOL(State)
Accessing symbol of state STATE.
Definition: syn_yacc.c:1052
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Definition: syn_yacc.c:1798
TK_INTRINSIC
#define TK_INTRINSIC
Definition: syn_yacc.c:317
yypgoto
static const yytype_int16 yypgoto[]
YYPGOTO[NTERM-NUM].
Definition: syn_yacc.c:1232
TK_ELSEIF
#define TK_ELSEIF
Definition: syn_yacc.c:299
TK_RPAR
#define TK_RPAR
Definition: syn_yacc.c:365
yylval
#define yylval
Definition: syn_yacc.c:73
YYNTOKENS
#define YYNTOKENS
YYNTOKENS – Number of terminals.
Definition: syn_yacc.c:956
TK_NEQV
#define TK_NEQV
Definition: syn_yacc.c:349
TK_ENTRY
#define TK_ENTRY
Definition: syn_yacc.c:305
syn_parse
int syn_parse(void)
yytype_uint8
unsigned char yytype_uint8
Work around bug in HP-UX 11.23, which defines these macros incorrectly for preprocessor constants.
Definition: syn_yacc.c:687
TK_IOLPAR
#define TK_IOLPAR
Definition: syn_yacc.c:372
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: syn_yacc.c:1799
YYSIZE_T
#define YYSIZE_T
Definition: syn_yacc.c:728
TK_DCON
#define TK_DCON
Definition: syn_yacc.c:358
TK_THEN
#define TK_THEN
Definition: syn_yacc.c:334
yydebug
#define yydebug
Definition: syn_yacc.c:71
YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: syn_yacc.c:816
TK_REAL
#define TK_REAL
Definition: syn_yacc.c:327
TK_COMMA
#define TK_COMMA
Definition: syn_yacc.c:366
TK_GE
#define TK_GE
Definition: syn_yacc.c:344
TK_NAME
#define TK_NAME
Definition: syn_yacc.c:354
TK_INOUT
#define TK_INOUT
Definition: syn_yacc.c:338
yyr2
static const yytype_int8 yyr2[]
YYR2[RULE-NUM] – Number of symbols on the right-hand side of rule RULE-NUM.
Definition: syn_yacc.c:1609
TK_LT
#define TK_LT
Definition: syn_yacc.c:347
TK_CONTINUE
#define TK_CONTINUE
Definition: syn_yacc.c:292
YYPTRDIFF_T
#define YYPTRDIFF_T
Definition: syn_yacc.c:714
TK_BLANK
#define TK_BLANK
Definition: syn_yacc.c:283
TK_OUT
#define TK_OUT
Definition: syn_yacc.c:340
yynerrs
#define yynerrs
Definition: syn_yacc.c:72
TK_END
#define TK_END
Definition: syn_yacc.c:304
TK_INTEGER
#define TK_INTEGER
Definition: syn_yacc.c:316
TK_LOGICAL
#define TK_LOGICAL
Definition: syn_yacc.c:319
TK_WRITE
#define TK_WRITE
Definition: syn_yacc.c:337
TK_REWIND
#define TK_REWIND
Definition: syn_yacc.c:329
TK_ELSE
#define TK_ELSE
Definition: syn_yacc.c:300
TK_COMMON
#define TK_COMMON
Definition: syn_yacc.c:290
TK_OPEN
#define TK_OPEN
Definition: syn_yacc.c:320
yytable
static const yytype_int16 yytable[]
YYTABLE[YYPACT[STATE-NUM]] – What to do in state STATE-NUM.
Definition: syn_yacc.c:1268
YYACCEPT
#define YYACCEPT
Definition: syn_yacc.c:1647
TK_TO
#define TK_TO
Definition: syn_yacc.c:335
yytable_value_is_error
#define yytable_value_is_error(Yyn)
Definition: syn_yacc.c:1121
TK_COLON
#define TK_COLON
Definition: syn_yacc.c:367
TK_IF
#define TK_IF
Definition: syn_yacc.c:312
TK_PRINT
#define TK_PRINT
Definition: syn_yacc.c:324
YYTRANSLATE
#define YYTRANSLATE(YYX)
YYTRANSLATE(TOKEN-NUM) – Symbol number corresponding to TOKEN-NUM as returned by yylex,...
Definition: syn_yacc.c:970
YYENOMEM
@ YYENOMEM
Definition: syn_yacc.c:1642
TK_PROGRAM
#define TK_PROGRAM
Definition: syn_yacc.c:325
TK_LE
#define TK_LE
Definition: syn_yacc.c:346
YY_ATTRIBUTE_UNUSED
#define YY_ATTRIBUTE_UNUSED
Definition: syn_yacc.c:772
ici
int ici
local variables
Definition: syn_yacc.c:100
TK_CONCAT
#define TK_CONCAT
Definition: syn_yacc.c:370
CurrentType
type CurrentType
to count control specifications in IO statements
Definition: syn_yacc.c:101
TK_SCON
#define TK_SCON
Definition: syn_yacc.c:356
yystos
static const yytype_uint8 yystos[]
YYSTOS[STATE-NUM] – The symbol kind of the accessing symbol of state STATE-NUM.
Definition: syn_yacc.c:1524
TK_BLOCKDATA
#define TK_BLOCKDATA
Definition: syn_yacc.c:284
TK_NE
#define TK_NE
Definition: syn_yacc.c:348
TK_DO
#define TK_DO
Definition: syn_yacc.c:298
TK_MINUS
#define TK_MINUS
Definition: syn_yacc.c:359
TK_INCLUDE
#define TK_INCLUDE
Definition: syn_yacc.c:314
TK_IOSTAT
#define TK_IOSTAT
Definition: syn_yacc.c:318
yytoken_kind_t
enum yytokentype yytoken_kind_t
Definition: syn_yacc.c:274
TK_AND
#define TK_AND
Definition: syn_yacc.c:341
TK_READ
#define TK_READ
Definition: syn_yacc.c:326
YYPOPSTACK
#define YYPOPSTACK(N)
TK_OR
#define TK_OR
Definition: syn_yacc.c:351
yy_state_fast_t
int yy_state_fast_t
State numbers in computations.
Definition: syn_yacc.c:745
TK_DOUBLEPRECISION
#define TK_DOUBLEPRECISION
Definition: syn_yacc.c:296
TK_IMPLICIT
#define TK_IMPLICIT
Definition: syn_yacc.c:313
yytype_uint16
unsigned short yytype_uint16
Definition: syn_yacc.c:698
TK_POINTER
#define TK_POINTER
Definition: syn_yacc.c:323
TK_TRUE
#define TK_TRUE
Definition: syn_yacc.c:352
YYEMPTY
#define YYEMPTY
Token kinds.
Definition: syn_yacc.c:277
MakeDataValueSet
static expression MakeDataValueSet(expression n, expression c)
number of bytes to store a value of that type
Definition: syn_yacc.c:107
YYLAST
#define YYLAST
YYLAST – Last index in YYTABLE.
Definition: syn_yacc.c:953
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Relocate STACK from its old location to the new one.
Definition: syn_yacc.c:917
yypact_value_is_default
#define yypact_value_is_default(Yyn)
Definition: syn_yacc.c:1116
TK_FORMAT
#define TK_FORMAT
Definition: syn_yacc.c:309
TK_INQUIRE
#define TK_INQUIRE
Definition: syn_yacc.c:315
YYINITDEPTH
#define YYINITDEPTH
!YYDEBUG
Definition: syn_yacc.c:1806
yytype_int8
signed char yytype_int8
On compilers that do not define PTRDIFF_MAX etc., make sure <limits.h> and (if available) <stdint....
Definition: syn_yacc.c:658
free
void free(void *)
YYERROR
#define YYERROR
Definition: syn_yacc.c:1649
YYSIZEOF
#define YYSIZEOF(X)
Definition: syn_yacc.c:738
TK_EXTERNAL
#define TK_EXTERNAL
Definition: syn_yacc.c:308
yycheck
static const yytype_int16 yycheck[]
Definition: syn_yacc.c:1395
YYSTACK_ALLOC
#define YYSTACK_ALLOC
The parser invokes alloca or malloc; define the necessary symbols.
Definition: syn_yacc.c:862
TK_EQUIVALENCE
#define TK_EQUIVALENCE
Definition: syn_yacc.c:306
YYDPRINTF
#define YYDPRINTF(Args)
Enable debugging if requested.
Definition: syn_yacc.c:1797
YY_USE
#define YY_USE(E)
Suppress unused-variable warnings by "using" E.
Definition: syn_yacc.c:778
yyerror
#define yyerror
Definition: syn_yacc.c:70
FatalError
#define FatalError(f, m)
Definition: syntax-local.h:56
MakeAtom
syntax MakeAtom(entity e, cons *indices, expression fc, expression lc, int HasParenthesis)
MakeAtom: this function creates a syntax, ie.
Definition: expression.c:222
make_Fortran_constant_entity
entity make_Fortran_constant_entity(string name, tag bt, size_t size)
Definition: expression.c:597
MakeImpliedDo
expression MakeImpliedDo(syntax v, range r, cons *l)
expressions from input output lists might contain implied do loops.
Definition: expression.c:115
MakeIoList
cons * MakeIoList(cons *l)
This function takes a list of io elements (i, j, t(i,j)), and returns the same list,...
Definition: expression.c:468
CheckLeftHandSide
syntax CheckLeftHandSide(syntax s)
If a left hand side is a call, it should be a substring operator or a macro.
Definition: expression.c:542
FortranExpressionList
list FortranExpressionList(list l)
Make sure that no call to implied do is in l.
Definition: expression.c:492
MakeParameter
entity MakeParameter(entity e, expression x)
lint
Definition: expression.c:52
MakeFortranUnaryCall
expression MakeFortranUnaryCall(entity op, expression e1)
Definition: expression.c:519
MakeFortranBinaryCall
expression MakeFortranBinaryCall(entity op, expression e1, expression e2)
Definition: expression.c:502
FormatValue
char FormatValue[FORMATLENGTH]
a string that will contain the value of the format in case of format statement
Definition: parser.c:95
ParserError
bool ParserError(const char *f, const char *m)
Definition: parser.c:116
CurrentPackage
const char * CurrentPackage
the name of the current package, i.e.
Definition: parser.c:58
set_current_number_of_alternate_returns
void set_current_number_of_alternate_returns()
Definition: return.c:187
set_alternate_returns
void set_alternate_returns()
Definition: return.c:264
uses_alternate_return
void uses_alternate_return(bool use)
Definition: return.c:171
add_alternate_return
void add_alternate_return(string label_name)
Definition: return.c:242
reset_alternate_returns
void reset_alternate_returns()
Definition: return.c:272
MakeReturn
instruction MakeReturn(expression e)
Definition: return.c:445
get_current_number_of_alternate_returns
int get_current_number_of_alternate_returns()
Definition: return.c:197
check_first_statement
void check_first_statement()
This function is called each time an executable statement is encountered but is effective the first t...
Definition: statement.c:2004
set_first_format_statement
void set_first_format_statement()
Definition: statement.c:1952
check_in_declarations
void check_in_declarations()
Definition: statement.c:1976
MakeZeroOrOneArgCallInst
instruction MakeZeroOrOneArgCallInst(char *s, expression e)
this function creates a simple Fortran statement such as RETURN, CONTINUE, ...
Definition: statement.c:669
MakeArithmIfInst
instruction MakeArithmIfInst(expression e, string l1, string l2, string l3)
this function transforms an arithmetic if statement into a set of regular tests.
Definition: statement.c:1399
MakeCallInst
instruction MakeCallInst(entity e, cons *l)
this function creates a call statement.
Definition: statement.c:1091
fix_if_condition
expression fix_if_condition(expression e)
Definition: statement.c:1293
MakeDoInst
void MakeDoInst(syntax s, range r, string l)
this function creates a do loop statement.
Definition: statement.c:1167
MakeComputedGotoInst
instruction MakeComputedGotoInst(list ll, expression e)
Definition: statement.c:727
MakeGotoInst
instruction MakeGotoInst(string n)
this function creates a goto instruction.
Definition: statement.c:686
MakeIoInstB
instruction MakeIoInstB(int keyword, expression e1, expression e2, expression e3, expression e4)
this function creates a BUFFER IN or BUFFER OUT io statement.
Definition: statement.c:1837
first_executable_statement_seen
bool first_executable_statement_seen()
Definition: statement.c:1964
MakeSimpleIoInst2
instruction MakeSimpleIoInst2(int keyword, expression f, list io_list)
Definition: statement.c:1899
MakeBlockIfInst
void MakeBlockIfInst(expression e, int elsif)
this function and the two next ones create a block if statement.
Definition: statement.c:1498
MakeAssignedGotoInst
instruction MakeAssignedGotoInst(list ll, entity i)
Definition: statement.c:734
MakeEndifInst
void MakeEndifInst()
Definition: statement.c:1578
LinkInstToCurrentBlock
void LinkInstToCurrentBlock(instruction i, bool number_it)
this function links the instruction i to the current block of statements.
Definition: statement.c:529
MakeLogicalIfInst
instruction MakeLogicalIfInst(expression e, instruction i)
this function creates a logical if statement.
Definition: statement.c:1329
MakeWhileDoInst
void MakeWhileDoInst(expression c, string l)
This function creates a while do loop statement.
Definition: statement.c:1262
MakeIoInstA
instruction MakeIoInstA(int keyword, list lci, list lio)
this function creates an IO statement.
Definition: statement.c:1715
reset_first_statement
void reset_first_statement()
Definition: statement.c:1944
MakeEnddoInst
void MakeEnddoInst()
Definition: statement.c:1611
MakeAssignInst
instruction MakeAssignInst(syntax l, expression e)
this function creates an affectation statement.
Definition: statement.c:848
MakeSimpleIoInst1
instruction MakeSimpleIoInst1(int keyword, expression unit)
Definition: statement.c:1854
MakeElseInst
int MakeElseInst(bool is_else_p)
This function is used to handle either an ELSE or an ELSEIF construct.
Definition: statement.c:1522
YYSTYPE
Value type.
Definition: genread.h:115
YYSTYPE::expression
expression expression
Definition: cyacc.h:185
YYSTYPE::syntax
syntax syntax
Definition: splitc.c:887
YYSTYPE::string
string string
Definition: cyacc.h:187
YYSTYPE::liste
cons * liste
Definition: cyacc.h:183
YYSTYPE::dimension
dimension dimension
Definition: splitc.c:881
YYSTYPE::dataval
dataval dataval
Definition: syn_yacc.c:384
YYSTYPE::range
range range
Definition: syn_yacc.c:391
YYSTYPE::datavar
datavar datavar
Definition: syn_yacc.c:385
YYSTYPE::chain
chain chain
Definition: syn_yacc.c:381
YYSTYPE::basic
basic basic
Definition: splitc.c:878
YYSTYPE::instruction
instruction instruction
Definition: syn_yacc.c:389
YYSTYPE::character
char character
Definition: splitc.c:879
YYSTYPE::value
value value
Definition: splitc.c:890
YYSTYPE::entity
entity entity
Definition: cyacc.h:184
YYSTYPE::integer
int integer
Definition: cyacc.h:190
YYSTYPE::type
type type
Definition: cyacc.h:188
yyalloc
INFRINGES ON USER NAME SPACE.
Definition: genread_yacc.c:608
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: genread_yacc.c:610
yyalloc::yyss_alloc
yy_state_t yyss_alloc
Definition: genread_yacc.c:609