step_bison_parser.c File Reference

#include "step_lexer.h"
#include "defines-local.h"
#include "step_bison_parser.h"
#include <limits.h>
#include <stdio.h>

Include dependency graph for step_bison_parser.c:

Go to the source code of this file.

Data Structures
union	yyalloc
	INFRINGES ON USER NAME SPACE. More...

Macros
#define	YYBISON   30802
	A Bison parser, made by GNU Bison 3.8.2. More...
#define	YYBISON_VERSION   "3.8.2"
	Bison version string. More...
#define	YYSKELETON_NAME   "yacc.c"
	Skeleton name. More...
#define	YYPURE   0
	Pure parsers. More...
#define	YYPUSH   0
	Push parsers. More...
#define	YYPULL   1
	Pull parsers. More...
#define	yyparse(void)   step_lexerparse
	------—. More...
#define	yylex   step_lexerlex
#define	yyerror   step_lexererror
#define	yydebug   step_lexerdebug
#define	yynerrs   step_lexernerrs
#define	yylval   step_lexerlval
#define	yychar   step_lexerchar
#define	YY_CAST(Type, Val)   ((Type) (Val))
#define	YY_REINTERPRET_CAST(Type, Val)   ((Type) (Val))
#define	YY_NULLPTR   ((void*)0)
#define	YYPTRDIFF_T   long
#define	YYPTRDIFF_MAXIMUM   LONG_MAX
#define	YYSIZE_T   unsigned
#define	YYSIZE_MAXIMUM
#define	YYSIZEOF(X)   YY_CAST (YYPTRDIFF_T, sizeof (X))
#define	YY_(Msgid)   Msgid
#define	YY_ATTRIBUTE_PURE
#define	YY_ATTRIBUTE_UNUSED
#define	YY_USE(E)   ((void) (E))
	Suppress unused-variable warnings by "using" E. More...
#define	YY_INITIAL_VALUE(Value)   Value
	Suppress an incorrect diagnostic about yylval being uninitialized. More...
#define	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define	YY_IGNORE_MAYBE_UNINITIALIZED_END
#define	YY_IGNORE_USELESS_CAST_BEGIN
#define	YY_IGNORE_USELESS_CAST_END
#define	YY_ASSERT(E)   ((void) (0 && (E)))
#define	YYSTACK_ALLOC   YYMALLOC
	The parser invokes alloca or malloc; define the necessary symbols. More...
#define	YYSTACK_FREE   YYFREE
#define	YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
#define	YYMALLOC   malloc
#define	YYFREE   free
	INFRINGES ON USER NAME SPACE. More...
#define	YYSTACK_GAP_MAXIMUM   (YYSIZEOF (union yyalloc) - 1)
	The size of the maximum gap between one aligned stack and the next. More...
#define	YYSTACK_BYTES(N)
	The size of an array large to enough to hold all stacks, each with N elements. More...
#define	YYCOPY_NEEDED   1
#define	YYSTACK_RELOCATE(Stack_alloc, Stack)
	Relocate STACK from its old location to the new one. More...
#define	YYCOPY(Dst, Src, Count)
	Copy COUNT objects from SRC to DST. More...
#define	YYFINAL   7
	!YYCOPY_NEEDED More...
#define	YYLAST   94
	YYLAST – Last index in YYTABLE. More...
#define	YYNTOKENS   31
	YYNTOKENS – Number of terminals. More...
#define	YYNNTS   34
	YYNNTS – Number of nonterminals. More...
#define	YYNRULES   69
	YYNRULES – Number of rules. More...
#define	YYNSTATES   105
	YYNSTATES – Number of states. More...
#define	YYMAXUTOK   285
	YYMAXUTOK – Last valid token kind. More...
#define	YYTRANSLATE(YYX)
	YYTRANSLATE(TOKEN-NUM) – Symbol number corresponding to TOKEN-NUM as returned by yylex, with out-of-bounds checking. More...
#define	YY_ACCESSING_SYMBOL(State)   YY_CAST (yysymbol_kind_t, yystos[State])
	Accessing symbol of state STATE. More...
#define	YYPACT_NINF   (-76)
#define	yypact_value_is_default(Yyn)    ((Yyn) == YYPACT_NINF)
#define	YYTABLE_NINF   (-41)
#define	yytable_value_is_error(Yyn)    0
#define	yyerrok   (yyerrstatus = 0)
#define	yyclearin   (yychar = YYEMPTY)
#define	YYACCEPT   goto yyacceptlab
#define	YYABORT   goto yyabortlab
#define	YYERROR   goto yyerrorlab
#define	YYNOMEM   goto yyexhaustedlab
#define	YYRECOVERING()   (!!yyerrstatus)
#define	YYBACKUP(Token, Value)
#define	YYERRCODE   YYUNDEF
	Backward compatibility with an undocumented macro. More...
#define	YYFPRINTF   fprintf
	Enable debugging if requested. More...
#define	YYDPRINTF(Args)
#define	YY_SYMBOL_PRINT(Title, Kind, Value, Location)
#define	YY_STACK_PRINT(Bottom, Top)
#define	YY_REDUCE_PRINT(Rule)
#define	YYINITDEPTH   200
	!YYDEBUG More...
#define	YYMAXDEPTH   10000
	YYMAXDEPTH – maximum size the stacks can grow to (effective only if the built-in stack extension method is used). More...
#define	YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))

Typedefs
typedef enum yysymbol_kind_t	yysymbol_kind_t
typedef signed char	yytype_int8
	On compilers that do not define PTRDIFF_MAX etc., make sure <limits.h> and (if available) <stdint.h> are included so that the code can choose integer types of a good width. More...
typedef short	yytype_int16
typedef unsigned char	yytype_uint8
	Work around bug in HP-UX 11.23, which defines these macros incorrectly for preprocessor constants. More...
typedef unsigned short	yytype_uint16
typedef yytype_int8	yy_state_t
	Stored state numbers (used for stacks). More...
typedef int	yy_state_fast_t
	State numbers in computations. More...

Enumerations
enum	yysymbol_kind_t {   YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 ,   YYSYMBOL_CHUNK_BEGIN = 3 , YYSYMBOL_VECTOR_BEGIN = 4 , YYSYMBOL_ARROW_BEGIN = 5 , YYSYMBOL_READ_BOOL = 6 ,   YYSYMBOL_TABULATED_BEGIN = 7 , YYSYMBOL_LP = 8 , YYSYMBOL_RP = 9 , YYSYMBOL_LC = 10 ,   YYSYMBOL_RC = 11 , YYSYMBOL_LB = 12 , YYSYMBOL_SHARED_POINTER = 13 , YYSYMBOL_READ_EXTERNAL = 14 ,   YYSYMBOL_READ_DEF = 15 , YYSYMBOL_READ_REF = 16 , YYSYMBOL_READ_NULL = 17 , YYSYMBOL_READ_LIST_UNDEFINED = 18 ,   YYSYMBOL_READ_SET_UNDEFINED = 19 , YYSYMBOL_READ_ARRAY_UNDEFINED = 20 , YYSYMBOL_READ_STRING = 21 , YYSYMBOL_READ_UNIT = 22 ,   YYSYMBOL_READ_CHAR = 23 , YYSYMBOL_READ_INT = 24 , YYSYMBOL_READ_FLOAT = 25 , YYSYMBOL_YYACCEPT = 26 ,   YYSYMBOL_Read = 27 , YYSYMBOL_Nb_of_shared_pointers = 28 , YYSYMBOL_Contents = 29 , YYSYMBOL_Chunk = 30 ,   YYSYMBOL_31_1 = 31 , YYSYMBOL_Shared_chunk = 32 , YYSYMBOL_Type = 33 , YYSYMBOL_Datas = 34 ,   YYSYMBOL_Datas2 = 35 , YYSYMBOL_Datas3 = 36 , YYSYMBOL_Sparse_Datas = 37 , YYSYMBOL_Data = 38 ,   YYSYMBOL_Basis = 39 , YYSYMBOL_Int = 40 , YYSYMBOL_String = 41 , YYSYMBOL_YYEMPTY = -2 ,   YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_COMMA = 3 ,   YYSYMBOL_COLUMN = 4 , YYSYMBOL_SEMI_COLUMN = 5 , YYSYMBOL_AND = 6 , YYSYMBOL_OR = 7 ,   YYSYMBOL_ARROW = 8 , YYSYMBOL_STAR = 9 , YYSYMBOL_LB = 10 , YYSYMBOL_RB = 11 ,   YYSYMBOL_LR = 12 , YYSYMBOL_RR = 13 , YYSYMBOL_EQUAL = 14 , YYSYMBOL_FROM = 15 ,   YYSYMBOL_GRAM_EXTERNAL = 16 , YYSYMBOL_GRAM_IMPORT = 17 , YYSYMBOL_TABULATED = 18 , YYSYMBOL_PERSISTANT = 19 ,   YYSYMBOL_IDENT = 20 , YYSYMBOL_GRAM_FILE = 21 , YYSYMBOL_GRAM_INT = 22 , YYSYMBOL_YYACCEPT = 23 ,   YYSYMBOL_Specification = 24 , YYSYMBOL_25_1 = 25 , YYSYMBOL_Externals = 26 , YYSYMBOL_Imports = 27 ,   YYSYMBOL_File = 28 , YYSYMBOL_Definitions = 29 , YYSYMBOL_Definition = 30 , YYSYMBOL_Tabulated = 31 ,   YYSYMBOL_Domain = 32 , YYSYMBOL_Simple = 33 , YYSYMBOL_Persistant = 34 , YYSYMBOL_Basis = 35 ,   YYSYMBOL_Constructed = 36 , YYSYMBOL_Namelist = 37 , YYSYMBOL_Dimensions = 38 , YYSYMBOL_Int = 39 ,   YYSYMBOL_Name = 40 , YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 ,   YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_ACCFERM = 3 , YYSYMBOL_ACCOUVR = 4 , YYSYMBOL_CONSTANTE = 5 ,   YYSYMBOL_EGAL = 6 , YYSYMBOL_IDENT = 7 , YYSYMBOL_INF = 8 , YYSYMBOL_INFEGAL = 9 ,   YYSYMBOL_MOINS = 10 , YYSYMBOL_PLUS = 11 , YYSYMBOL_SUP = 12 , YYSYMBOL_SUPEGAL = 13 ,   YYSYMBOL_VAR = 14 , YYSYMBOL_VIRG = 15 , YYSYMBOL_YYACCEPT = 16 , YYSYMBOL_system = 17 ,   YYSYMBOL_inisys = 18 , YYSYMBOL_defvar = 19 , YYSYMBOL_l_var = 20 , YYSYMBOL_l_eq = 21 ,   YYSYMBOL_eq = 22 , YYSYMBOL_debeq = 23 , YYSYMBOL_feq = 24 , YYSYMBOL_membre = 25 ,   YYSYMBOL_26_1 = 26 , YYSYMBOL_terme = 27 , YYSYMBOL_ident = 28 , YYSYMBOL_newid = 29 ,   YYSYMBOL_const = 30 , YYSYMBOL_op = 31 , YYSYMBOL_addop = 32 , YYSYMBOL_multi_membre = 33 ,   YYSYMBOL_fin_mult_membre = 34 , YYSYMBOL_virg_opt = 35 , YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 ,   YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_ACCFERM = 3 , YYSYMBOL_ACCOUVR = 4 ,   YYSYMBOL_CONSTANTE = 5 , YYSYMBOL_EGAL = 6 , YYSYMBOL_IDENT = 7 , YYSYMBOL_INF = 8 ,   YYSYMBOL_INFEGAL = 9 , YYSYMBOL_MOINS = 10 , YYSYMBOL_PLUS = 11 , YYSYMBOL_SUP = 12 ,   YYSYMBOL_SUPEGAL = 13 , YYSYMBOL_VAR = 14 , YYSYMBOL_VIRG = 15 , YYSYMBOL_YYACCEPT = 16 ,   YYSYMBOL_s_list = 17 , YYSYMBOL_inisl = 18 , YYSYMBOL_endsl = 19 , YYSYMBOL_defvar = 20 ,   YYSYMBOL_l_var = 21 , YYSYMBOL_newid = 22 , YYSYMBOL_l_sys = 23 , YYSYMBOL_system = 24 ,   YYSYMBOL_inisys = 25 , YYSYMBOL_endsys = 26 , YYSYMBOL_l_eq = 27 , YYSYMBOL_eq = 28 ,   YYSYMBOL_debeq = 29 , YYSYMBOL_feq = 30 , YYSYMBOL_membre = 31 , YYSYMBOL_32_1 = 32 ,   YYSYMBOL_terme = 33 , YYSYMBOL_ident = 34 , YYSYMBOL_const = 35 , YYSYMBOL_op = 36 ,   YYSYMBOL_addop = 37 , YYSYMBOL_multi_membre = 38 , YYSYMBOL_fin_mult_membre = 39 , YYSYMBOL_virg_opt = 40 ,   YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 ,   YYSYMBOL_TK_IDENT = 3 , YYSYMBOL_TK_CHARCON = 4 , YYSYMBOL_TK_INTCON = 5 , YYSYMBOL_TK_FLOATCON = 6 ,   YYSYMBOL_TK_NAMED_TYPE = 7 , YYSYMBOL_TK_STRINGCON = 8 , YYSYMBOL_TK_WSTRINGCON = 9 , YYSYMBOL_TK_EOF = 10 ,   YYSYMBOL_TK_CHAR = 11 , YYSYMBOL_TK_INT = 12 , YYSYMBOL_TK_INT128 = 13 , YYSYMBOL_TK_UINT128 = 14 ,   YYSYMBOL_TK_DOUBLE = 15 , YYSYMBOL_TK_FLOAT = 16 , YYSYMBOL_TK_VOID = 17 , YYSYMBOL_TK_COMPLEX = 18 ,   YYSYMBOL_TK_ENUM = 19 , YYSYMBOL_TK_STRUCT = 20 , YYSYMBOL_TK_TYPEDEF = 21 , YYSYMBOL_TK_UNION = 22 ,   YYSYMBOL_TK_SIGNED = 23 , YYSYMBOL_TK_UNSIGNED = 24 , YYSYMBOL_TK_LONG = 25 , YYSYMBOL_TK_SHORT = 26 ,   YYSYMBOL_TK_VOLATILE = 27 , YYSYMBOL_TK_EXTERN = 28 , YYSYMBOL_TK_STATIC = 29 , YYSYMBOL_TK_STATIC_DIMENSION = 30 ,   YYSYMBOL_TK_CONST = 31 , YYSYMBOL_TK_RESTRICT = 32 , YYSYMBOL_TK_AUTO = 33 , YYSYMBOL_TK_REGISTER = 34 ,   YYSYMBOL_TK_THREAD = 35 , YYSYMBOL_TK_SIZEOF = 36 , YYSYMBOL_TK_ALIGNOF = 37 , YYSYMBOL_TK_EQ = 38 ,   YYSYMBOL_TK_PLUS_EQ = 39 , YYSYMBOL_TK_MINUS_EQ = 40 , YYSYMBOL_TK_STAR_EQ = 41 , YYSYMBOL_TK_SLASH_EQ = 42 ,   YYSYMBOL_TK_PERCENT_EQ = 43 , YYSYMBOL_TK_AND_EQ = 44 , YYSYMBOL_TK_PIPE_EQ = 45 , YYSYMBOL_TK_CIRC_EQ = 46 ,   YYSYMBOL_TK_INF_INF_EQ = 47 , YYSYMBOL_TK_SUP_SUP_EQ = 48 , YYSYMBOL_TK_ARROW = 49 , YYSYMBOL_TK_DOT = 50 ,   YYSYMBOL_TK_EQ_EQ = 51 , YYSYMBOL_TK_EXCLAM_EQ = 52 , YYSYMBOL_TK_INF = 53 , YYSYMBOL_TK_SUP = 54 ,   YYSYMBOL_TK_INF_EQ = 55 , YYSYMBOL_TK_SUP_EQ = 56 , YYSYMBOL_TK_PLUS = 57 , YYSYMBOL_TK_MINUS = 58 ,   YYSYMBOL_TK_STAR = 59 , YYSYMBOL_TK_SLASH = 60 , YYSYMBOL_TK_PERCENT = 61 , YYSYMBOL_TK_TILDE = 62 ,   YYSYMBOL_TK_AND = 63 , YYSYMBOL_TK_PIPE = 64 , YYSYMBOL_TK_CIRC = 65 , YYSYMBOL_TK_EXCLAM = 66 ,   YYSYMBOL_TK_AND_AND = 67 , YYSYMBOL_TK_PIPE_PIPE = 68 , YYSYMBOL_TK_INF_INF = 69 , YYSYMBOL_TK_SUP_SUP = 70 ,   YYSYMBOL_TK_PLUS_PLUS = 71 , YYSYMBOL_TK_MINUS_MINUS = 72 , YYSYMBOL_TK_RPAREN = 73 , YYSYMBOL_TK_LPAREN = 74 ,   YYSYMBOL_TK_RBRACE = 75 , YYSYMBOL_TK_LBRACE = 76 , YYSYMBOL_TK_LBRACKET = 77 , YYSYMBOL_TK_RBRACKET = 78 ,   YYSYMBOL_TK_COLON = 79 , YYSYMBOL_TK_SEMICOLON = 80 , YYSYMBOL_TK_COMMA = 81 , YYSYMBOL_TK_ELLIPSIS = 82 ,   YYSYMBOL_TK_QUEST = 83 , YYSYMBOL_TK_BREAK = 84 , YYSYMBOL_TK_CONTINUE = 85 , YYSYMBOL_TK_GOTO = 86 ,   YYSYMBOL_TK_RETURN = 87 , YYSYMBOL_TK_SWITCH = 88 , YYSYMBOL_TK_CASE = 89 , YYSYMBOL_TK_DEFAULT = 90 ,   YYSYMBOL_TK_WHILE = 91 , YYSYMBOL_TK_DO = 92 , YYSYMBOL_TK_FOR = 93 , YYSYMBOL_TK_IF = 94 ,   YYSYMBOL_TK_ELSE = 95 , YYSYMBOL_TK_ATTRIBUTE = 96 , YYSYMBOL_TK_INLINE = 97 , YYSYMBOL_TK_ASM = 98 ,   YYSYMBOL_TK_TYPEOF = 99 , YYSYMBOL_TK_FUNCTION__ = 100 , YYSYMBOL_TK_PRETTY_FUNCTION__ = 101 , YYSYMBOL_TK_LABEL__ = 102 ,   YYSYMBOL_TK_BUILTIN_VA_ARG = 103 , YYSYMBOL_TK_BUILTIN_VA_LIST = 104 , YYSYMBOL_TK_BLOCKATTRIBUTE = 105 , YYSYMBOL_TK_DECLSPEC = 106 ,   YYSYMBOL_TK_MSASM = 107 , YYSYMBOL_TK_MSATTR = 108 , YYSYMBOL_TK_PRAGMA = 109 , YYSYMBOL_TK__Pragma = 110 ,   YYSYMBOL_TK_AT_TRANSFORM = 111 , YYSYMBOL_TK_AT_TRANSFORMEXPR = 112 , YYSYMBOL_TK_AT_SPECIFIER = 113 , YYSYMBOL_TK_AT_EXPR = 114 ,   YYSYMBOL_TK_AT_NAME = 115 , YYSYMBOL_TK_COMPLEXCON = 116 , YYSYMBOL_TK_CAST = 117 , YYSYMBOL_TK_ADDROF = 118 ,   YYSYMBOL_YYACCEPT = 119 , YYSYMBOL_interpret = 120 , YYSYMBOL_file = 121 , YYSYMBOL_globals = 122 ,   YYSYMBOL_123_1 = 123 , YYSYMBOL_location = 124 , YYSYMBOL_global = 125 , YYSYMBOL_126_2 = 126 ,   YYSYMBOL_id_or_typename = 127 , YYSYMBOL_maybecomma = 128 , YYSYMBOL_expression = 129 , YYSYMBOL_constant = 130 ,   YYSYMBOL_string_constant = 131 , YYSYMBOL_one_string_constant = 132 , YYSYMBOL_string_list = 133 , YYSYMBOL_wstring_list = 134 ,   YYSYMBOL_one_string = 135 , YYSYMBOL_init_expression = 136 , YYSYMBOL_initializer_list = 137 , YYSYMBOL_initializer_list_opt = 138 ,   YYSYMBOL_initializer = 139 , YYSYMBOL_eq_opt = 140 , YYSYMBOL_init_designators = 141 , YYSYMBOL_init_designators_opt = 142 ,   YYSYMBOL_gcc_init_designators = 143 , YYSYMBOL_arguments = 144 , YYSYMBOL_opt_expression = 145 , YYSYMBOL_comma_expression = 146 ,   YYSYMBOL_comma_expression_opt = 147 , YYSYMBOL_statement_paren_comma_expression = 148 , YYSYMBOL_paren_comma_expression = 149 , YYSYMBOL_bracket_comma_expression = 150 ,   YYSYMBOL_statements_inside_block = 151 , YYSYMBOL_152_3 = 152 , YYSYMBOL_block = 153 , YYSYMBOL_block_attrs = 154 ,   YYSYMBOL_statement_list = 155 , YYSYMBOL_local_labels = 156 , YYSYMBOL_local_label_names = 157 , YYSYMBOL_label = 158 ,   YYSYMBOL_pragma = 159 , YYSYMBOL_pragmas = 160 , YYSYMBOL_statement = 161 , YYSYMBOL_statement_without_pragma = 162 ,   YYSYMBOL_163_4 = 163 , YYSYMBOL_164_5 = 164 , YYSYMBOL_165_6 = 165 , YYSYMBOL_166_7 = 166 ,   YYSYMBOL_167_8 = 167 , YYSYMBOL_168_9 = 168 , YYSYMBOL_169_10 = 169 , YYSYMBOL_for_clause = 170 ,   YYSYMBOL_171_11 = 171 , YYSYMBOL_declaration = 172 , YYSYMBOL_init_declarator_list = 173 , YYSYMBOL_init_declarator = 174 ,   YYSYMBOL_decl_spec_list = 175 , YYSYMBOL_176_12 = 176 , YYSYMBOL_my_decl_spec_list = 177 , YYSYMBOL_decl_spec_list_opt = 178 ,   YYSYMBOL_decl_spec_list_opt_no_named = 179 , YYSYMBOL_type_spec = 180 , YYSYMBOL_181_13 = 181 , YYSYMBOL_182_14 = 182 ,   YYSYMBOL_183_15 = 183 , YYSYMBOL_184_16 = 184 , YYSYMBOL_struct_decl_list = 185 , YYSYMBOL_186_17 = 186 ,   YYSYMBOL_field_decl_list = 187 , YYSYMBOL_field_decl = 188 , YYSYMBOL_enum_list = 189 , YYSYMBOL_enumerator = 190 ,   YYSYMBOL_declarator = 191 , YYSYMBOL_direct_decl = 192 , YYSYMBOL_193_18 = 193 , YYSYMBOL_parameter_list_startscope = 194 ,   YYSYMBOL_rest_par_list = 195 , YYSYMBOL_rest_par_list1 = 196 , YYSYMBOL_197_19 = 197 , YYSYMBOL_198_20 = 198 ,   YYSYMBOL_parameter_decl = 199 , YYSYMBOL_old_proto_decl = 200 , YYSYMBOL_direct_old_proto_decl = 201 , YYSYMBOL_202_21 = 202 ,   YYSYMBOL_old_parameter_list_ne = 203 , YYSYMBOL_old_pardef_list = 204 , YYSYMBOL_old_pardef = 205 , YYSYMBOL_pointer = 206 ,   YYSYMBOL_pointer_opt = 207 , YYSYMBOL_type_name = 208 , YYSYMBOL_abstract_decl = 209 , YYSYMBOL_abs_direct_decl = 210 ,   YYSYMBOL_211_22 = 211 , YYSYMBOL_abs_direct_decl_opt = 212 , YYSYMBOL_function_def = 213 , YYSYMBOL_214_23 = 214 ,   YYSYMBOL_function_def_start = 215 , YYSYMBOL_216_24 = 216 , YYSYMBOL_217_25 = 217 , YYSYMBOL_attributes = 218 ,   YYSYMBOL_attributes_with_asm = 219 , YYSYMBOL_attribute = 220 , YYSYMBOL_asmattr = 221 , YYSYMBOL_asmoutputs = 222 ,   YYSYMBOL_asmoperands = 223 , YYSYMBOL_asmoperandsne = 224 , YYSYMBOL_asmoperand = 225 , YYSYMBOL_asminputs = 226 ,   YYSYMBOL_asmclobber = 227 , YYSYMBOL_asmcloberlst_ne = 228 , YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 ,   YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_PROGRAM = 3 , YYSYMBOL_MODULE = 4 ,   YYSYMBOL_MAIN = 5 , YYSYMBOL_COMMON = 6 , YYSYMBOL_TK_CALLEES = 7 , YYSYMBOL_CALLERS = 8 ,   YYSYMBOL_ALL = 9 , YYSYMBOL_SELECT = 10 , YYSYMBOL_COMPILATION_UNIT = 11 , YYSYMBOL_REQUIRED = 12 ,   YYSYMBOL_PRODUCED = 13 , YYSYMBOL_MODIFIED = 14 , YYSYMBOL_PRESERVED = 15 , YYSYMBOL_PRE_TRANSFORMATION = 16 ,   YYSYMBOL_POST_TRANSFORMATION = 17 , YYSYMBOL_DOT = 18 , YYSYMBOL_NAME = 19 , YYSYMBOL_YYACCEPT = 20 ,   YYSYMBOL_rules = 21 , YYSYMBOL_rule = 22 , YYSYMBOL_deps = 23 , YYSYMBOL_dir = 24 ,   YYSYMBOL_virtuals = 25 , YYSYMBOL_virtual = 26 , YYSYMBOL_owner = 27 , YYSYMBOL_phase = 28 ,   YYSYMBOL_resource = 29 , YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 ,   YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_TK_IDENT = 3 , YYSYMBOL_TK_CHARCON = 4 , YYSYMBOL_TK_INTCON = 5 ,   YYSYMBOL_TK_FLOATCON = 6 , YYSYMBOL_TK_NAMED_TYPE = 7 , YYSYMBOL_TK_STRINGCON = 8 , YYSYMBOL_TK_WSTRINGCON = 9 ,   YYSYMBOL_TK_EOF = 10 , YYSYMBOL_TK_CHAR = 11 , YYSYMBOL_TK_INT = 12 , YYSYMBOL_TK_INT128 = 13 ,   YYSYMBOL_TK_UINT128 = 14 , YYSYMBOL_TK_DOUBLE = 15 , YYSYMBOL_TK_FLOAT = 16 , YYSYMBOL_TK_VOID = 17 ,   YYSYMBOL_TK_COMPLEX = 18 , YYSYMBOL_TK_ENUM = 19 , YYSYMBOL_TK_STRUCT = 20 , YYSYMBOL_TK_TYPEDEF = 21 ,   YYSYMBOL_TK_UNION = 22 , YYSYMBOL_TK_SIGNED = 23 , YYSYMBOL_TK_UNSIGNED = 24 , YYSYMBOL_TK_LONG = 25 ,   YYSYMBOL_TK_SHORT = 26 , YYSYMBOL_TK_VOLATILE = 27 , YYSYMBOL_TK_EXTERN = 28 , YYSYMBOL_TK_STATIC = 29 ,   YYSYMBOL_TK_CONST = 30 , YYSYMBOL_TK_RESTRICT = 31 , YYSYMBOL_TK_AUTO = 32 , YYSYMBOL_TK_REGISTER = 33 ,   YYSYMBOL_TK_THREAD = 34 , YYSYMBOL_TK_STATIC_DIMENSION = 35 , YYSYMBOL_TK_SIZEOF = 36 , YYSYMBOL_TK_ALIGNOF = 37 ,   YYSYMBOL_TK_EQ = 38 , YYSYMBOL_TK_PLUS_EQ = 39 , YYSYMBOL_TK_MINUS_EQ = 40 , YYSYMBOL_TK_STAR_EQ = 41 ,   YYSYMBOL_TK_SLASH_EQ = 42 , YYSYMBOL_TK_PERCENT_EQ = 43 , YYSYMBOL_TK_AND_EQ = 44 , YYSYMBOL_TK_PIPE_EQ = 45 ,   YYSYMBOL_TK_CIRC_EQ = 46 , YYSYMBOL_TK_INF_INF_EQ = 47 , YYSYMBOL_TK_SUP_SUP_EQ = 48 , YYSYMBOL_TK_ARROW = 49 ,   YYSYMBOL_TK_DOT = 50 , YYSYMBOL_TK_EQ_EQ = 51 , YYSYMBOL_TK_EXCLAM_EQ = 52 , YYSYMBOL_TK_INF = 53 ,   YYSYMBOL_TK_SUP = 54 , YYSYMBOL_TK_INF_EQ = 55 , YYSYMBOL_TK_SUP_EQ = 56 , YYSYMBOL_TK_PLUS = 57 ,   YYSYMBOL_TK_MINUS = 58 , YYSYMBOL_TK_STAR = 59 , YYSYMBOL_TK_SLASH = 60 , YYSYMBOL_TK_PERCENT = 61 ,   YYSYMBOL_TK_TILDE = 62 , YYSYMBOL_TK_AND = 63 , YYSYMBOL_TK_PIPE = 64 , YYSYMBOL_TK_CIRC = 65 ,   YYSYMBOL_TK_EXCLAM = 66 , YYSYMBOL_TK_AND_AND = 67 , YYSYMBOL_TK_PIPE_PIPE = 68 , YYSYMBOL_TK_INF_INF = 69 ,   YYSYMBOL_TK_SUP_SUP = 70 , YYSYMBOL_TK_PLUS_PLUS = 71 , YYSYMBOL_TK_MINUS_MINUS = 72 , YYSYMBOL_TK_RPAREN = 73 ,   YYSYMBOL_TK_LPAREN = 74 , YYSYMBOL_TK_RBRACE = 75 , YYSYMBOL_TK_LBRACE = 76 , YYSYMBOL_TK_LBRACKET = 77 ,   YYSYMBOL_TK_RBRACKET = 78 , YYSYMBOL_TK_COLON = 79 , YYSYMBOL_TK_SEMICOLON = 80 , YYSYMBOL_TK_COMMA = 81 ,   YYSYMBOL_TK_ELLIPSIS = 82 , YYSYMBOL_TK_QUEST = 83 , YYSYMBOL_TK_BREAK = 84 , YYSYMBOL_TK_CONTINUE = 85 ,   YYSYMBOL_TK_GOTO = 86 , YYSYMBOL_TK_RETURN = 87 , YYSYMBOL_TK_SWITCH = 88 , YYSYMBOL_TK_CASE = 89 ,   YYSYMBOL_TK_DEFAULT = 90 , YYSYMBOL_TK_WHILE = 91 , YYSYMBOL_TK_DO = 92 , YYSYMBOL_TK_FOR = 93 ,   YYSYMBOL_TK_IF = 94 , YYSYMBOL_TK_ELSE = 95 , YYSYMBOL_TK_ATTRIBUTE = 96 , YYSYMBOL_TK_INLINE = 97 ,   YYSYMBOL_TK_ASM = 98 , YYSYMBOL_TK_TYPEOF = 99 , YYSYMBOL_TK_FUNCTION__ = 100 , YYSYMBOL_TK_PRETTY_FUNCTION__ = 101 ,   YYSYMBOL_TK_LABEL__ = 102 , YYSYMBOL_TK_BUILTIN_VA_ARG = 103 , YYSYMBOL_TK_BUILTIN_VA_LIST = 104 , YYSYMBOL_TK_BLOCKATTRIBUTE = 105 ,   YYSYMBOL_TK_DECLSPEC = 106 , YYSYMBOL_TK_MSASM = 107 , YYSYMBOL_TK_MSATTR = 108 , YYSYMBOL_TK_PRAGMA = 109 ,   YYSYMBOL_TK_AT_TRANSFORM = 110 , YYSYMBOL_TK_AT_TRANSFORMEXPR = 111 , YYSYMBOL_TK_AT_SPECIFIER = 112 , YYSYMBOL_TK_AT_EXPR = 113 ,   YYSYMBOL_TK_AT_NAME = 114 , YYSYMBOL_TK_COMPLEXCON = 115 , YYSYMBOL_TK_CAST = 116 , YYSYMBOL_TK_ADDROF = 117 ,   YYSYMBOL_YYACCEPT = 118 , YYSYMBOL_interpret = 119 , YYSYMBOL_file = 120 , YYSYMBOL_globals = 121 ,   YYSYMBOL_location = 122 , YYSYMBOL_global = 123 , YYSYMBOL_id_or_typename = 124 , YYSYMBOL_maybecomma = 125 ,   YYSYMBOL_expression = 126 , YYSYMBOL_constant = 127 , YYSYMBOL_string_constant = 128 , YYSYMBOL_one_string_constant = 129 ,   YYSYMBOL_string_list = 130 , YYSYMBOL_wstring_list = 131 , YYSYMBOL_one_string = 132 , YYSYMBOL_init_expression = 133 ,   YYSYMBOL_initializer_list = 134 , YYSYMBOL_initializer_list_opt = 135 , YYSYMBOL_initializer = 136 , YYSYMBOL_eq_opt = 137 ,   YYSYMBOL_init_designators = 138 , YYSYMBOL_init_designators_opt = 139 , YYSYMBOL_gcc_init_designators = 140 , YYSYMBOL_arguments = 141 ,   YYSYMBOL_opt_expression = 142 , YYSYMBOL_comma_expression = 143 , YYSYMBOL_comma_expression_opt = 144 , YYSYMBOL_paren_comma_expression = 145 ,   YYSYMBOL_bracket_comma_expression = 146 , YYSYMBOL_block = 147 , YYSYMBOL_148_1 = 148 , YYSYMBOL_149_2 = 149 ,   YYSYMBOL_block_attrs = 150 , YYSYMBOL_declaration_list = 151 , YYSYMBOL_statement_list = 152 , YYSYMBOL_local_labels = 153 ,   YYSYMBOL_local_label_names = 154 , YYSYMBOL_statement = 155 , YYSYMBOL_156_3 = 156 , YYSYMBOL_157_4 = 157 ,   YYSYMBOL_158_5 = 158 , YYSYMBOL_159_6 = 159 , YYSYMBOL_160_7 = 160 , YYSYMBOL_for_clause = 161 ,   YYSYMBOL_declaration = 162 , YYSYMBOL_init_declarator_list = 163 , YYSYMBOL_init_declarator = 164 , YYSYMBOL_decl_spec_list = 165 ,   YYSYMBOL_decl_spec_list_opt = 166 , YYSYMBOL_decl_spec_list_opt_no_named = 167 , YYSYMBOL_168_8 = 168 , YYSYMBOL_type_spec = 169 ,   YYSYMBOL_struct_decl_list = 170 , YYSYMBOL_field_decl_list = 171 , YYSYMBOL_field_decl = 172 , YYSYMBOL_enum_list = 173 ,   YYSYMBOL_enumerator = 174 , YYSYMBOL_declarator = 175 , YYSYMBOL_direct_decl = 176 , YYSYMBOL_parameter_list_startscope = 177 ,   YYSYMBOL_rest_par_list = 178 , YYSYMBOL_rest_par_list1 = 179 , YYSYMBOL_parameter_decl = 180 , YYSYMBOL_old_proto_decl = 181 ,   YYSYMBOL_direct_old_proto_decl = 182 , YYSYMBOL_old_parameter_list_ne = 183 , YYSYMBOL_old_pardef_list = 184 , YYSYMBOL_old_pardef = 185 ,   YYSYMBOL_pointer = 186 , YYSYMBOL_pointer_opt = 187 , YYSYMBOL_type_name = 188 , YYSYMBOL_abstract_decl = 189 ,   YYSYMBOL_abs_direct_decl = 190 , YYSYMBOL_abs_direct_decl_opt = 191 , YYSYMBOL_function_def = 192 , YYSYMBOL_function_def_start = 193 ,   YYSYMBOL_attributes = 194 , YYSYMBOL_attributes_with_asm = 195 , YYSYMBOL_attribute = 196 , YYSYMBOL_attr = 197 ,   YYSYMBOL_attr_list_ne = 198 , YYSYMBOL_paren_attr_list_ne = 199 , YYSYMBOL_asmattr = 200 , YYSYMBOL_asmtemplate = 201 ,   YYSYMBOL_asmoutputs = 202 , YYSYMBOL_asmoperands = 203 , YYSYMBOL_asmoperandsne = 204 , YYSYMBOL_asmoperand = 205 ,   YYSYMBOL_asminputs = 206 , YYSYMBOL_asmclobber = 207 , YYSYMBOL_asmcloberlst_ne = 208 , YYSYMBOL_YYEMPTY = -2 ,   YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_UNKNOWN_TOK = 3 ,   YYSYMBOL_REFERENCE_TOK = 4 , YYSYMBOL_QI_REF_TOK = 5 , YYSYMBOL_HI_REF_TOK = 6 , YYSYMBOL_SI_REF_TOK = 7 ,   YYSYMBOL_DI_REF_TOK = 8 , YYSYMBOL_SF_REF_TOK = 9 , YYSYMBOL_DF_REF_TOK = 10 , YYSYMBOL_SC_REF_TOK = 11 ,   YYSYMBOL_DC_REF_TOK = 12 , YYSYMBOL_LOG_REF_TOK = 13 , YYSYMBOL_CONSTANT_TOK = 14 , YYSYMBOL_ASSIGN_OPERATOR_TOK = 15 ,   YYSYMBOL_PLUS_OPERATOR_TOK = 16 , YYSYMBOL_MINUS_OPERATOR_TOK = 17 , YYSYMBOL_UNARY_MINUS_OPERATOR_TOK = 18 , YYSYMBOL_MULTIPLY_OPERATOR_TOK = 19 ,   YYSYMBOL_MULADD_OPERATOR_TOK = 20 , YYSYMBOL_DIVIDE_OPERATOR_TOK = 21 , YYSYMBOL_INVERSE_OPERATOR_TOK = 22 , YYSYMBOL_POWER_OPERATOR_TOK = 23 ,   YYSYMBOL_MODULO_OPERATOR_TOK = 24 , YYSYMBOL_MIN_OPERATOR_TOK = 25 , YYSYMBOL_COS_OPERATOR_TOK = 26 , YYSYMBOL_SIN_OPERATOR_TOK = 27 ,   YYSYMBOL_MIN0_OPERATOR_TOK = 28 , YYSYMBOL_AMIN1_OPERATOR_TOK = 29 , YYSYMBOL_DMIN1_OPERATOR_TOK = 30 , YYSYMBOL_MAX_OPERATOR_TOK = 31 ,   YYSYMBOL_MAX0_OPERATOR_TOK = 32 , YYSYMBOL_AMAX1_OPERATOR_TOK = 33 , YYSYMBOL_DMAX1_OPERATOR_TOK = 34 , YYSYMBOL_ABS_OPERATOR_TOK = 35 ,   YYSYMBOL_IABS_OPERATOR_TOK = 36 , YYSYMBOL_DABS_OPERATOR_TOK = 37 , YYSYMBOL_CABS_OPERATOR_TOK = 38 , YYSYMBOL_AND_OPERATOR_TOK = 39 ,   YYSYMBOL_OR_OPERATOR_TOK = 40 , YYSYMBOL_NOT_OPERATOR_TOK = 41 , YYSYMBOL_NON_EQUAL_OPERATOR_TOK = 42 , YYSYMBOL_EQUIV_OPERATOR_TOK = 43 ,   YYSYMBOL_NON_EQUIV_OPERATOR_TOK = 44 , YYSYMBOL_TRUE_OPERATOR_TOK = 45 , YYSYMBOL_FALSE_OPERATOR_TOK = 46 , YYSYMBOL_GREATER_OR_EQUAL_OPERATOR_TOK = 47 ,   YYSYMBOL_GREATER_THAN_OPERATOR_TOK = 48 , YYSYMBOL_LESS_OR_EQUAL_OPERATOR_TOK = 49 , YYSYMBOL_LESS_THAN_OPERATOR_TOK = 50 , YYSYMBOL_EQUAL_OPERATOR_TOK = 51 ,   YYSYMBOL_PHI_TOK = 52 , YYSYMBOL_INTEGER_TOK = 53 , YYSYMBOL_FLOAT_TOK = 54 , YYSYMBOL_IDENTIFIER_TOK = 55 ,   YYSYMBOL_56_ = 56 , YYSYMBOL_57_ = 57 , YYSYMBOL_58_ = 58 , YYSYMBOL_59_ = 59 ,   YYSYMBOL_60_ = 60 , YYSYMBOL_61_ = 61 , YYSYMBOL_62_ = 62 , YYSYMBOL_YYACCEPT = 63 ,   YYSYMBOL_definitions = 64 , YYSYMBOL_definitions_list = 65 , YYSYMBOL_definition = 66 , YYSYMBOL_operation = 67 ,   YYSYMBOL_opcodes_list = 68 , YYSYMBOL_opcode = 69 , YYSYMBOL_pattern = 70 , YYSYMBOL_types_list = 71 ,   YYSYMBOL_type = 72 , YYSYMBOL_tokens_list = 73 , YYSYMBOL_token = 74 , YYSYMBOL_merge_arguments = 75 ,   YYSYMBOL_arguments_list = 76 , YYSYMBOL_argument = 77 , YYSYMBOL_transformation = 78 , YYSYMBOL_mappings = 79 ,   YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 ,   YYSYMBOL_TK_EOL = 3 , YYSYMBOL_TK_ERROR = 4 , YYSYMBOL_TK_LPAREN = 5 , YYSYMBOL_TK_RPAREN = 6 ,   YYSYMBOL_TK_COLON = 7 , YYSYMBOL_TK_COMMA = 8 , YYSYMBOL_TK_IDENT = 9 , YYSYMBOL_TK_COMMENT = 10 ,   YYSYMBOL_TK_OPERATOR = 11 , YYSYMBOL_TK_RAW = 12 , YYSYMBOL_TK_OMP_PRAGMA = 13 , YYSYMBOL_TK_OMP_PARALLEL = 14 ,   YYSYMBOL_TK_OMP_LOOP = 15 , YYSYMBOL_TK_OMP_END = 16 , YYSYMBOL_TK_OMP_BARRIER = 17 , YYSYMBOL_TK_OMP_MASTER = 18 ,   YYSYMBOL_TK_OMP_SINGLE = 19 , YYSYMBOL_TK_OMP_THREADPRIVATE = 20 , YYSYMBOL_TK_OMP_SHARED = 21 , YYSYMBOL_TK_OMP_PRIVATE = 22 ,   YYSYMBOL_TK_OMP_NOWAIT = 23 , YYSYMBOL_TK_OMP_REDUCTION = 24 , YYSYMBOL_TK_OMP_DEFAULT = 25 , YYSYMBOL_TK_OMP_COPYIN = 26 ,   YYSYMBOL_TK_OMP_FIRSTPRIVATE = 27 , YYSYMBOL_TK_OMP_SCHEDULE = 28 , YYSYMBOL_TK_STEP_PRAGMA = 29 , YYSYMBOL_TK_STEP_TRANSFORMATION = 30 ,   YYSYMBOL_YYACCEPT = 31 , YYSYMBOL_pragma = 32 , YYSYMBOL_33_1 = 33 , YYSYMBOL_34_2 = 34 ,   YYSYMBOL_step_transformation = 35 , YYSYMBOL_omp_comment = 36 , YYSYMBOL_omp_directive = 37 , YYSYMBOL_38_3 = 38 ,   YYSYMBOL_39_4 = 39 , YYSYMBOL_40_5 = 40 , YYSYMBOL_41_6 = 41 , YYSYMBOL_omp_parallel_clauses = 42 ,   YYSYMBOL_omp_loop_clauses = 43 , YYSYMBOL_omp_end_loop_clauses = 44 , YYSYMBOL_omp_parallel_loop_clauses = 45 , YYSYMBOL_omp_shared = 46 ,   YYSYMBOL_47_7 = 47 , YYSYMBOL_omp_private = 48 , YYSYMBOL_49_8 = 49 , YYSYMBOL_omp_copyin = 50 ,   YYSYMBOL_51_9 = 51 , YYSYMBOL_omp_threadprivate_listvar = 52 , YYSYMBOL_53_10 = 53 , YYSYMBOL_omp_firstprivate = 54 ,   YYSYMBOL_55_11 = 55 , YYSYMBOL_omp_schedule = 56 , YYSYMBOL_57_12 = 57 , YYSYMBOL_omp_reduction = 58 ,   YYSYMBOL_59_13 = 59 , YYSYMBOL_60_14 = 60 , YYSYMBOL_omp_default = 61 , YYSYMBOL_62_15 = 62 ,   YYSYMBOL_string_list = 63 , YYSYMBOL_ident_list = 64 , YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 ,   YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_TK_ASSIGN = 3 , YYSYMBOL_TK_BACKSPACE = 4 ,   YYSYMBOL_TK_BLANK = 5 , YYSYMBOL_TK_BLOCKDATA = 6 , YYSYMBOL_TK_BUFFERIN = 7 , YYSYMBOL_TK_BUFFEROUT = 8 ,   YYSYMBOL_TK_CALL = 9 , YYSYMBOL_TK_CHARACTER = 10 , YYSYMBOL_TK_CLOSE = 11 , YYSYMBOL_TK_COMMON = 12 ,   YYSYMBOL_TK_COMPLEX = 13 , YYSYMBOL_TK_CONTINUE = 14 , YYSYMBOL_TK_CYCLE = 15 , YYSYMBOL_TK_DATA = 16 ,   YYSYMBOL_TK_DIMENSION = 17 , YYSYMBOL_TK_DOUBLEPRECISION = 18 , YYSYMBOL_TK_DOUBLECOMPLEX = 19 , YYSYMBOL_TK_DO = 20 ,   YYSYMBOL_TK_ELSEIF = 21 , YYSYMBOL_TK_ELSE = 22 , YYSYMBOL_TK_ENDFILE = 23 , YYSYMBOL_TK_ENDDO = 24 ,   YYSYMBOL_TK_ENDIF = 25 , YYSYMBOL_TK_END = 26 , YYSYMBOL_TK_ENTRY = 27 , YYSYMBOL_TK_EQUIVALENCE = 28 ,   YYSYMBOL_TK_EXIT = 29 , YYSYMBOL_TK_EXTERNAL = 30 , YYSYMBOL_TK_FORMAT = 31 , YYSYMBOL_TK_FUNCTION = 32 ,   YYSYMBOL_TK_GOTO = 33 , YYSYMBOL_TK_IF = 34 , YYSYMBOL_TK_IMPLICIT = 35 , YYSYMBOL_TK_INCLUDE = 36 ,   YYSYMBOL_TK_INQUIRE = 37 , YYSYMBOL_TK_INTEGER = 38 , YYSYMBOL_TK_INTRINSIC = 39 , YYSYMBOL_TK_IOSTAT = 40 ,   YYSYMBOL_TK_LOGICAL = 41 , YYSYMBOL_TK_OPEN = 42 , YYSYMBOL_TK_PARAMETER = 43 , YYSYMBOL_TK_PAUSE = 44 ,   YYSYMBOL_TK_POINTER = 45 , YYSYMBOL_TK_PRINT = 46 , YYSYMBOL_TK_PROGRAM = 47 , YYSYMBOL_TK_READ = 48 ,   YYSYMBOL_TK_REAL = 49 , YYSYMBOL_TK_RETURN = 50 , YYSYMBOL_TK_REWIND = 51 , YYSYMBOL_TK_SAVE = 52 ,   YYSYMBOL_TK_STATIC = 53 , YYSYMBOL_TK_STOP = 54 , YYSYMBOL_TK_SUBROUTINE = 55 , YYSYMBOL_TK_THEN = 56 ,   YYSYMBOL_TK_TO = 57 , YYSYMBOL_TK_WHILE = 58 , YYSYMBOL_TK_WRITE = 59 , YYSYMBOL_TK_INOUT = 60 ,   YYSYMBOL_TK_IN = 61 , YYSYMBOL_TK_OUT = 62 , YYSYMBOL_TK_AND = 63 , YYSYMBOL_TK_EQ = 64 ,   YYSYMBOL_TK_EQV = 65 , YYSYMBOL_TK_GE = 66 , YYSYMBOL_TK_GT = 67 , YYSYMBOL_TK_LE = 68 ,   YYSYMBOL_TK_LT = 69 , YYSYMBOL_TK_NE = 70 , YYSYMBOL_TK_NEQV = 71 , YYSYMBOL_TK_NOT = 72 ,   YYSYMBOL_TK_OR = 73 , YYSYMBOL_TK_TRUE = 74 , YYSYMBOL_TK_FALSE = 75 , YYSYMBOL_TK_NAME = 76 ,   YYSYMBOL_TK_ICON = 77 , YYSYMBOL_TK_SCON = 78 , YYSYMBOL_TK_RCON = 79 , YYSYMBOL_TK_DCON = 80 ,   YYSYMBOL_TK_MINUS = 81 , YYSYMBOL_TK_PLUS = 82 , YYSYMBOL_TK_SLASH = 83 , YYSYMBOL_TK_STAR = 84 ,   YYSYMBOL_TK_POWER = 85 , YYSYMBOL_TK_LPAR = 86 , YYSYMBOL_TK_RPAR = 87 , YYSYMBOL_TK_COMMA = 88 ,   YYSYMBOL_TK_COLON = 89 , YYSYMBOL_TK_EQUALS = 90 , YYSYMBOL_TK_CURRENCY = 91 , YYSYMBOL_TK_CONCAT = 92 ,   YYSYMBOL_TK_EOS = 93 , YYSYMBOL_TK_IOLPAR = 94 , YYSYMBOL_YYACCEPT = 95 , YYSYMBOL_lprg_exec = 96 ,   YYSYMBOL_prg_exec = 97 , YYSYMBOL_98_1 = 98 , YYSYMBOL_99_2 = 99 , YYSYMBOL_100_3 = 100 ,   YYSYMBOL_begin_inst = 101 , YYSYMBOL_entry_inst = 102 , YYSYMBOL_end_inst = 103 , YYSYMBOL_linstruction = 104 ,   YYSYMBOL_instruction = 105 , YYSYMBOL_106_4 = 106 , YYSYMBOL_107_5 = 107 , YYSYMBOL_inst_spec = 108 ,   YYSYMBOL_inst_exec = 109 , YYSYMBOL_return_inst = 110 , YYSYMBOL_call_inst = 111 , YYSYMBOL_tk_call = 112 ,   YYSYMBOL_parameters = 113 , YYSYMBOL_arguments = 114 , YYSYMBOL_io_inst = 115 , YYSYMBOL_io_f_u_id = 116 ,   YYSYMBOL_lci = 117 , YYSYMBOL_ci = 118 , YYSYMBOL_opt_lio_elem = 119 , YYSYMBOL_lio_elem = 120 ,   YYSYMBOL_io_elem = 121 , YYSYMBOL_pause_inst = 122 , YYSYMBOL_stop_inst = 123 , YYSYMBOL_continue_inst = 124 ,   YYSYMBOL_do_inst = 125 , YYSYMBOL_bdo_inst = 126 , YYSYMBOL_wdo_inst = 127 , YYSYMBOL_do_plage = 128 ,   YYSYMBOL_endif_inst = 129 , YYSYMBOL_enddo_inst = 130 , YYSYMBOL_else_inst = 131 , YYSYMBOL_elseif_inst = 132 ,   YYSYMBOL_blockif_inst = 133 , YYSYMBOL_logicalif_inst = 134 , YYSYMBOL_arithmif_inst = 135 , YYSYMBOL_goto_inst = 136 ,   YYSYMBOL_licon = 137 , YYSYMBOL_assignment_inst = 138 , YYSYMBOL_format_inst = 139 , YYSYMBOL_save_inst = 140 ,   YYSYMBOL_lsavename = 141 , YYSYMBOL_savename = 142 , YYSYMBOL_intrinsic_inst = 143 , YYSYMBOL_external_inst = 144 ,   YYSYMBOL_type_inst = 145 , YYSYMBOL_declaration = 146 , YYSYMBOL_decl_tableau = 147 , YYSYMBOL_ldim_tableau = 148 ,   YYSYMBOL_dim_tableau = 149 , YYSYMBOL_common_inst = 150 , YYSYMBOL_common = 151 , YYSYMBOL_common_name = 152 ,   YYSYMBOL_pointer_inst = 153 , YYSYMBOL_equivalence_inst = 154 , YYSYMBOL_lequivchain = 155 , YYSYMBOL_equivchain = 156 ,   YYSYMBOL_latom = 157 , YYSYMBOL_dimension_inst = 158 , YYSYMBOL_dimension = 159 , YYSYMBOL_data_inst = 160 ,   YYSYMBOL_ldatavar = 161 , YYSYMBOL_ldataval = 162 , YYSYMBOL_dataval = 163 , YYSYMBOL_dataconst = 164 ,   YYSYMBOL_datavar = 165 , YYSYMBOL_dataidl = 166 , YYSYMBOL_implicit_inst = 167 , YYSYMBOL_limplicit = 168 ,   YYSYMBOL_implicit = 169 , YYSYMBOL_l_letter_letter = 170 , YYSYMBOL_letter_letter = 171 , YYSYMBOL_letter = 172 ,   YYSYMBOL_parameter_inst = 173 , YYSYMBOL_lparametre = 174 , YYSYMBOL_parametre = 175 , YYSYMBOL_entity_name = 176 ,   YYSYMBOL_name = 177 , YYSYMBOL_module_name = 178 , YYSYMBOL_global_entity_name = 179 , YYSYMBOL_functional_entity_name = 180 ,   YYSYMBOL_global_name = 181 , YYSYMBOL_opt_lformalparameter = 182 , YYSYMBOL_lformalparameter = 183 , YYSYMBOL_opt_fortran_type = 184 ,   YYSYMBOL_fortran_type = 185 , YYSYMBOL_fortran_basic_type = 186 , YYSYMBOL_lg_fortran_type = 187 , YYSYMBOL_atom = 188 ,   YYSYMBOL_indices = 189 , YYSYMBOL_lexpression = 190 , YYSYMBOL_opt_expression = 191 , YYSYMBOL_expression = 192 ,   YYSYMBOL_sous_expression = 193 , YYSYMBOL_io_expr = 194 , YYSYMBOL_unpar_io_expr = 195 , YYSYMBOL_const_simple = 196 ,   YYSYMBOL_unsigned_const_simple = 197 , YYSYMBOL_icon = 198 , YYSYMBOL_label = 199 , YYSYMBOL_ival = 200 ,   YYSYMBOL_opt_signe = 201 , YYSYMBOL_signe = 202 , YYSYMBOL_oper_rela = 203 , YYSYMBOL_io_keyword = 204 ,   YYSYMBOL_iobuf_keyword = 205 , YYSYMBOL_psf_keyword = 206 , YYSYMBOL_opt_virgule = 207 , YYSYMBOL_YYEMPTY = -2 ,   YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_TK_OPEN = 3 ,   YYSYMBOL_TK_CREATE = 4 , YYSYMBOL_TK_CLOSE = 5 , YYSYMBOL_TK_CHECKPOINT = 6 , YYSYMBOL_TK_DELETE = 7 ,   YYSYMBOL_TK_MODULE = 8 , YYSYMBOL_TK_MAKE = 9 , YYSYMBOL_TK_APPLY = 10 , YYSYMBOL_TK_CAPPLY = 11 ,   YYSYMBOL_TK_DISPLAY = 12 , YYSYMBOL_TK_REMOVE = 13 , YYSYMBOL_TK_ACTIVATE = 14 , YYSYMBOL_TK_SET_PROPERTY = 15 ,   YYSYMBOL_TK_GET_PROPERTY = 16 , YYSYMBOL_TK_SET_ENVIRONMENT = 17 , YYSYMBOL_TK_GET_ENVIRONMENT = 18 , YYSYMBOL_TK_UNSET_ENVIRONMENT = 19 ,   YYSYMBOL_TK_CDIR = 20 , YYSYMBOL_TK_INFO = 21 , YYSYMBOL_TK_PWD = 22 , YYSYMBOL_TK_HELP = 23 ,   YYSYMBOL_TK_SHOW = 24 , YYSYMBOL_TK_SOURCE = 25 , YYSYMBOL_TK_SHELL = 26 , YYSYMBOL_TK_ECHO = 27 ,   YYSYMBOL_TK_UNKNOWN = 28 , YYSYMBOL_TK_TIMEOUT = 29 , YYSYMBOL_TK_QUIT = 30 , YYSYMBOL_TK_EXIT = 31 ,   YYSYMBOL_TK_LINE = 32 , YYSYMBOL_TK_CHECKACTIVE = 33 , YYSYMBOL_TK_VERSION = 34 , YYSYMBOL_TK_TOUCH = 35 ,   YYSYMBOL_TK_OWNER_NAME = 36 , YYSYMBOL_TK_OWNER_ALL = 37 , YYSYMBOL_TK_OWNER_ALLFUNC = 38 , YYSYMBOL_TK_OWNER_ALLCU = 39 ,   YYSYMBOL_TK_OWNER_PROGRAM = 40 , YYSYMBOL_TK_OWNER_MAIN = 41 , YYSYMBOL_TK_OWNER_MODULE = 42 , YYSYMBOL_TK_OWNER_CALLERS = 43 ,   YYSYMBOL_TK_OWNER_CALLEES = 44 , YYSYMBOL_TK_OPENPAREN = 45 , YYSYMBOL_TK_COMMA = 46 , YYSYMBOL_TK_CLOSEPAREN = 47 ,   YYSYMBOL_TK_EQUAL = 48 , YYSYMBOL_TK_NAME = 49 , YYSYMBOL_TK_A_STRING = 50 , YYSYMBOL_TK_ENDOFLINE = 51 ,   YYSYMBOL_TK_INT = 52 , YYSYMBOL_YYACCEPT = 53 , YYSYMBOL_commands = 54 , YYSYMBOL_command = 55 ,   YYSYMBOL_i_quit = 56 , YYSYMBOL_i_exit = 57 , YYSYMBOL_i_version = 58 , YYSYMBOL_i_help = 59 ,   YYSYMBOL_i_setprop = 60 , YYSYMBOL_i_shell = 61 , YYSYMBOL_i_unknown = 62 , YYSYMBOL_i_echo = 63 ,   YYSYMBOL_i_info = 64 , YYSYMBOL_i_cd = 65 , YYSYMBOL_i_pwd = 66 , YYSYMBOL_i_getenv = 67 ,   YYSYMBOL_i_setenv = 68 , YYSYMBOL_i_unsetenv = 69 , YYSYMBOL_i_timeout = 70 , YYSYMBOL_i_checkpoint = 71 ,   YYSYMBOL_i_open = 72 , YYSYMBOL_workspace_name = 73 , YYSYMBOL_i_create = 74 , YYSYMBOL_i_close = 75 ,   YYSYMBOL_i_delete = 76 , YYSYMBOL_i_module = 77 , YYSYMBOL_i_make = 78 , YYSYMBOL_i_apply = 79 ,   YYSYMBOL_i_capply = 80 , YYSYMBOL_i_display = 81 , YYSYMBOL_i_touch = 82 , YYSYMBOL_i_show = 83 ,   YYSYMBOL_i_rm = 84 , YYSYMBOL_i_activate = 85 , YYSYMBOL_i_checkactive = 86 , YYSYMBOL_i_get = 87 ,   YYSYMBOL_i_source = 88 , YYSYMBOL_rulename = 89 , YYSYMBOL_filename_list = 90 , YYSYMBOL_filename = 91 ,   YYSYMBOL_resource_id = 92 , YYSYMBOL_rule_id = 93 , YYSYMBOL_owner = 94 , YYSYMBOL_list_of_owner_name = 95 ,   YYSYMBOL_propname = 96 , YYSYMBOL_phasename = 97 , YYSYMBOL_resourcename = 98 }
	Symbol kind. More...
enum	{ YYENOMEM = -2 }

Functions
void	set_current_transform (int transform)
	First part of user prologue. More...
entity	entity_from_user_name (string name)
void	remove_old_pragma (void)
step_directive	begin_omp_construct (int type, string s)
step_directive	end_omp_construct (int type)
static step_directive	concat_drt_clauses (step_directive drt, cons *liste_clauses)
static step_clause	step_handle_reduction_clause (cons *ident_liste, int op)
static cons *	step_add_to_ident_list (string name, cons *list)
void	step_lexererror (const char *s)
	step_bison_parser.c More...
void *	malloc (YYSIZE_T)
void	free (void *)
static const char *	yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED
	The user-facing name of the symbol whose (internal) number is YYSYMBOL. More...
static void	yy_symbol_value_print (FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
	-------------------------------—. More...
static void	yy_symbol_print (FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
	-----------------------—. More...
static void	yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
	--------------------------------------------------------------—. More...
static void	yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
	--------------------------------------------—. More...
static void	yydestruct (const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
	-------------------------------------------—. More...
void	step_bison_parse (pragma pgm, statement stmt)

Variables
static string	pragma_str_original =NULL
static const yytype_int8	yytranslate []
	YYTRANSLATE[TOKEN-NUM] – Symbol number corresponding to TOKEN-NUM as returned by yylex. More...
static const yytype_int16	yyrline []
	YYRLINE[YYN] – Source line where rule number YYN was defined. More...
static const char *const	yytname []
	YYTNAME[SYMBOL-NUM] – String name of the symbol SYMBOL-NUM. More...
static const yytype_int8	yypact []
	YYPACT[STATE-NUM] – Index in YYTABLE of the portion describing STATE-NUM. More...
static const yytype_int8	yydefact []
	YYDEFACT[STATE-NUM] – Default reduction number in state STATE-NUM. More...
static const yytype_int8	yypgoto []
	YYPGOTO[NTERM-NUM]. More...
static const yytype_int8	yydefgoto []
	YYDEFGOTO[NTERM-NUM]. More...
static const yytype_int8	yytable []
	YYTABLE[YYPACT[STATE-NUM]] – What to do in state STATE-NUM. More...
static const yytype_int8	yycheck []
static const yytype_int8	yystos []
	YYSTOS[STATE-NUM] – The symbol kind of the accessing symbol of state STATE-NUM. More...
static const yytype_int8	yyr1 []
	YYR1[RULE-NUM] – Symbol kind of the left-hand side of rule RULE-NUM. More...
static const yytype_int8	yyr2 []
	YYR2[RULE-NUM] – Number of symbols on the right-hand side of rule RULE-NUM. More...
int	yydebug
	Nonzero means print parse trace. More...
int	yychar
	Lookahead token kind. More...
YYSTYPE	yylval
	The semantic value of the lookahead symbol. More...
int	yynerrs
	Number of syntax errors so far. More...

Macro Definition Documentation

YY_

#define YY_

(

Msgid

)

Msgid

Definition at line 333 of file step_bison_parser.c.

YY_ACCESSING_SYMBOL

#define YY_ACCESSING_SYMBOL

(

State

)

YY_CAST (yysymbol_kind_t, yystos[State])

Accessing symbol of state STATE.

Definition at line 603 of file step_bison_parser.c.

YY_ASSERT

#define YY_ASSERT

(

E

)

((void) (0 && (E)))

Definition at line 399 of file step_bison_parser.c.

YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE

Definition at line 342 of file step_bison_parser.c.

YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED

Definition at line 350 of file step_bison_parser.c.

YY_CAST

#define YY_CAST	(		Type,
			Val
	)		((Type) (Val))

Definition at line 118 of file step_bison_parser.c.

YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 379 of file step_bison_parser.c.

YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 380 of file step_bison_parser.c.

YY_IGNORE_USELESS_CAST_BEGIN

#define YY_IGNORE_USELESS_CAST_BEGIN

Definition at line 394 of file step_bison_parser.c.

YY_IGNORE_USELESS_CAST_END

#define YY_IGNORE_USELESS_CAST_END

Definition at line 395 of file step_bison_parser.c.

YY_INITIAL_VALUE

#define YY_INITIAL_VALUE

(

Value

)

Value

Suppress an incorrect diagnostic about yylval being uninitialized.

Definition at line 376 of file step_bison_parser.c.

YY_NULLPTR

#define YY_NULLPTR   ((void*)0)

Definition at line 130 of file step_bison_parser.c.

YY_REDUCE_PRINT

#define YY_REDUCE_PRINT

(

Rule

)

Value:

do {                                    \
  if (yydebug)                          \
    yy_reduce_print (yyssp, yyvsp, Rule); \
} while (0)

Definition at line 919 of file step_bison_parser.c.

YY_REINTERPRET_CAST

#define YY_REINTERPRET_CAST	(		Type,
			Val
	)		((Type) (Val))

Definition at line 119 of file step_bison_parser.c.

YY_STACK_PRINT

#define YY_STACK_PRINT	(		Bottom,
			Top
	)

Value:

do {                                                            \
  if (yydebug)                                                  \
    yy_stack_print ((Bottom), (Top));                           \
} while (0)

Definition at line 888 of file step_bison_parser.c.

YY_SYMBOL_PRINT

#define YY_SYMBOL_PRINT	(		Title,
			Kind,
			Value,
			Location
	)

Value:

do {                                                                      \
  if (yydebug)                                                            \
    {                                                                     \
      YYFPRINTF (stderr, "%s ", Title);                                   \
      yy_symbol_print (stderr,                                            \
                  Kind, Value); \
      YYFPRINTF (stderr, "\n");                                           \
    }                                                                     \
} while (0)

Definition at line 826 of file step_bison_parser.c.

YY_USE

#define YY_USE

(

E

)

((void) (E))

Suppress unused-variable warnings by "using" E.

Definition at line 356 of file step_bison_parser.c.

YYABORT

#define YYABORT   goto yyabortlab

Definition at line 780 of file step_bison_parser.c.

YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 779 of file step_bison_parser.c.

YYBACKUP

#define YYBACKUP	(		Token,
			Value
	)

Value:

  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

Definition at line 787 of file step_bison_parser.c.

YYBISON

#define YYBISON   30802

A Bison parser, made by GNU Bison 3.8.2.

Bison implementation for Yacc-like parsers in C

Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, Inc.

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.
As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception.

This special exception was added by the Free Software Foundation in version 2.2 of Bison.
C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser.
DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, especially those whose name start with YY_ or yy_. They are private implementation details that can be changed or removed.
All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below.
Identify Bison output, and Bison version.

Definition at line 49 of file step_bison_parser.c.

YYBISON_VERSION

#define YYBISON_VERSION   "3.8.2"

Bison version string.

Definition at line 52 of file step_bison_parser.c.

yychar

#define yychar   step_lexerchar

Definition at line 74 of file step_bison_parser.c.

yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 777 of file step_bison_parser.c.

YYCOPY

#define YYCOPY	(		Dst,
			Src,
			Count
	)

Value:

      do                                        \
        {                                       \
          YYPTRDIFF_T yyi;                      \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)

Copy COUNT objects from SRC to DST.

The source and destination do not overlap.

Definition at line 516 of file step_bison_parser.c.

YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

Definition at line 488 of file step_bison_parser.c.

yydebug

#define yydebug   step_lexerdebug

Definition at line 71 of file step_bison_parser.c.

YYDPRINTF

#define YYDPRINTF

(

Args

)

Value:

do {                                            \
  if (yydebug)                                  \
    YYFPRINTF Args;                             \
} while (0)

Definition at line 817 of file step_bison_parser.c.

YYERRCODE

#define YYERRCODE   YYUNDEF

Backward compatibility with an undocumented macro.

Use YYerror or YYUNDEF.

Definition at line 806 of file step_bison_parser.c.

yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 776 of file step_bison_parser.c.

yyerror

#define yyerror   step_lexererror

Definition at line 70 of file step_bison_parser.c.

YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 781 of file step_bison_parser.c.

YYFINAL

#define YYFINAL   7

!YYCOPY_NEEDED

YYFINAL – State number of the termination state.

Definition at line 529 of file step_bison_parser.c.

YYFPRINTF

#define YYFPRINTF   fprintf

Enable debugging if requested.

INFRINGES ON USER NAME SPACE

Definition at line 814 of file step_bison_parser.c.

YYFREE

#define YYFREE   free

INFRINGES ON USER NAME SPACE.

Definition at line 460 of file step_bison_parser.c.

YYINITDEPTH

#define YYINITDEPTH   200

!YYDEBUG

YYINITDEPTH – initial size of the parser's stacks.

Definition at line 938 of file step_bison_parser.c.

YYLAST

#define YYLAST   94

YYLAST – Last index in YYTABLE.

Definition at line 531 of file step_bison_parser.c.

yylex

#define yylex

(

void

)

step_lexerlex

Definition at line 69 of file step_bison_parser.c.

yylval

#define yylval   step_lexerlval

Definition at line 73 of file step_bison_parser.c.

YYMALLOC

#define YYMALLOC   malloc

Definition at line 454 of file step_bison_parser.c.

YYMAXDEPTH

#define YYMAXDEPTH   10000

YYMAXDEPTH – maximum size the stacks can grow to (effective only if the built-in stack extension method is used).

Do not make this value too large; the results are undefined if YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic.

Definition at line 949 of file step_bison_parser.c.

YYMAXUTOK

#define YYMAXUTOK   285

YYMAXUTOK – Last valid token kind.

Definition at line 543 of file step_bison_parser.c.

yynerrs

#define yynerrs   step_lexernerrs

Definition at line 72 of file step_bison_parser.c.

YYNNTS

#define YYNNTS   34

YYNNTS – Number of nonterminals.

Definition at line 536 of file step_bison_parser.c.

YYNOMEM

#define YYNOMEM   goto yyexhaustedlab

Definition at line 782 of file step_bison_parser.c.

YYNRULES

#define YYNRULES   69

YYNRULES – Number of rules.

Definition at line 538 of file step_bison_parser.c.

YYNSTATES

#define YYNSTATES   105

YYNSTATES – Number of states.

Definition at line 540 of file step_bison_parser.c.

YYNTOKENS

#define YYNTOKENS   31

YYNTOKENS – Number of terminals.

Definition at line 534 of file step_bison_parser.c.

YYPACT_NINF

#define YYPACT_NINF   (-76)

Definition at line 638 of file step_bison_parser.c.

yypact_value_is_default

#define yypact_value_is_default

(

Yyn

)

((Yyn) == YYPACT_NINF)

Definition at line 640 of file step_bison_parser.c.

yyparse

#define yyparse

(

void

)

step_lexerparse

------—.

Substitute the variable and function names.

| yyparse. | `-------—

Number of tokens to shift before error messages enabled.

Refer to the stacks through separate pointers, to allow yyoverflow to reallocate them elsewhere.

Their size.

The state stack: array, bottom, top.

The semantic value stack: array, bottom, top.

The return value of yyparse.

Lookahead symbol kind.

The variables used to return semantic value and location from the action routines.

The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped.

Cause a token to be read.

--------------------------------------------------------—. | yynewstate – push a new state, which is found in yystate. | `---------------------------------------------------------—

In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks.

----------------------------------------------------------------—. | yysetstate – set current state (the top of the stack) to yystate. | `-----------------------------------------------------------------—

Get the current used size of the three stacks, in elements.

defined YYSTACK_RELOCATE

Extend the stack our own way.

!defined yyoverflow && !defined YYSTACK_RELOCATE

-------—. | yybackup. | `--------—

Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one.

First try to decide what to do without reference to lookahead token.

Not known => get a lookahead token if don't already have one.

YYCHAR is either empty, or end-of-input, or a valid lookahead.

The scanner already issued an error message, process directly to error recovery. But do not keep the error token as lookahead, it is too special and may lead us to an endless loop in error recovery.

If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action.

Count tokens shifted since error; after three, turn off error status.

Shift the lookahead token.

Discard the shifted token.

-------------------------------------------------------—. | yydefault – do the default action for the current state. | `--------------------------------------------------------—

-------------------------—. | yyreduce – do a reduction. | `--------------------------—

yyn is the number of a rule to reduce with.

If YYLEN is nonzero, implement the default value of the action: '$$ = $1'.

Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized.

pragma: TK_RAW

$@1: empty

pragma: TK_OMP_PRAGMA $@1 omp_directive omp_comment TK_EOL

$@2: empty

pragma: TK_STEP_PRAGMA $@2 step_transformation TK_EOL

step_transformation: TK_STEP_TRANSFORMATION

omp_comment: TK_COMMENT

@3: empty

omp_directive: TK_OMP_PARALLEL @3 omp_parallel_clauses

@4: empty

omp_directive: TK_OMP_LOOP @4 omp_loop_clauses

@5: empty

omp_directive: TK_OMP_PARALLEL TK_OMP_LOOP @5 omp_parallel_loop_clauses

omp_directive: TK_OMP_MASTER

omp_directive: TK_OMP_SINGLE

omp_directive: TK_OMP_BARRIER

@6: empty

omp_directive: TK_OMP_THREADPRIVATE @6 omp_threadprivate_listvar

omp_directive: TK_OMP_END TK_OMP_PARALLEL

omp_directive: TK_OMP_END TK_OMP_LOOP omp_end_loop_clauses

omp_directive: TK_OMP_END TK_OMP_PARALLEL TK_OMP_LOOP

omp_directive: TK_OMP_END TK_OMP_MASTER

omp_directive: TK_OMP_END TK_OMP_SINGLE

omp_parallel_clauses: empty

omp_parallel_clauses: omp_parallel_clauses omp_shared

omp_parallel_clauses: omp_parallel_clauses omp_private

omp_parallel_clauses: omp_parallel_clauses omp_copyin

omp_parallel_clauses: omp_parallel_clauses omp_firstprivate

omp_parallel_clauses: omp_parallel_clauses omp_reduction

omp_parallel_clauses: omp_parallel_clauses omp_default

omp_loop_clauses: empty

omp_loop_clauses: omp_loop_clauses omp_private

omp_loop_clauses: omp_loop_clauses omp_firstprivate

omp_loop_clauses: omp_loop_clauses omp_reduction

omp_loop_clauses: omp_loop_clauses omp_schedule

omp_loop_clauses: omp_loop_clauses TK_OMP_NOWAIT

omp_end_loop_clauses: empty

omp_end_loop_clauses: omp_loop_clauses TK_OMP_NOWAIT

omp_parallel_loop_clauses: empty

omp_parallel_loop_clauses: omp_parallel_loop_clauses omp_shared

omp_parallel_loop_clauses: omp_parallel_loop_clauses omp_private

omp_parallel_loop_clauses: omp_parallel_loop_clauses omp_copyin

omp_parallel_loop_clauses: omp_parallel_loop_clauses omp_firstprivate

omp_parallel_loop_clauses: omp_parallel_loop_clauses omp_reduction

omp_parallel_loop_clauses: omp_parallel_loop_clauses omp_schedule

omp_parallel_loop_clauses: omp_parallel_loop_clauses omp_default

$@7: empty

omp_shared: TK_OMP_SHARED $@7 TK_LPAREN ident_list TK_RPAREN

$@8: empty

omp_private: TK_OMP_PRIVATE $@8 TK_LPAREN ident_list TK_RPAREN

$@9: empty

omp_copyin: TK_OMP_COPYIN $@9 TK_LPAREN ident_list TK_RPAREN

$@10: empty

omp_threadprivate_listvar: $@10 TK_LPAREN ident_list TK_RPAREN

$@11: empty

omp_firstprivate: TK_OMP_FIRSTPRIVATE $@11 TK_LPAREN ident_list TK_RPAREN

$@12: empty

omp_schedule: TK_OMP_SCHEDULE $@12 TK_LPAREN string_list TK_RPAREN

$@13: empty

$@14: empty

omp_reduction: TK_OMP_REDUCTION $@13 TK_LPAREN TK_OPERATOR $@14 TK_COLON ident_list TK_RPAREN

$@15: empty

omp_default: TK_OMP_DEFAULT $@15 TK_LPAREN TK_IDENT TK_RPAREN

string_list: TK_IDENT

string_list: string_list TK_COMMA TK_IDENT

ident_list: TK_IDENT

ident_list: ident_list TK_COMMA TK_IDENT

User semantic actions sometimes alter yychar, and that requires that yytoken be updated with the new translation. We take the approach of translating immediately before every use of yytoken. One alternative is translating here after every semantic action, but that translation would be missed if the semantic action invokes YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an incorrect destructor might then be invoked immediately. In the case of YYERROR or YYBACKUP, subsequent parser actions might lead to an incorrect destructor call or verbose syntax error message before the lookahead is translated.

Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by.

----------------------------------—. | yyerrlab – here on detecting error. | `-----------------------------------—

Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary.

If not already recovering from an error, report this error.

If just tried and failed to reuse lookahead token after an error, discard it.

Return failure if at end of input.

Else will try to reuse lookahead token after shifting the error token.

-----------------------------------------------—. | yyerrorlab – error raised explicitly by YYERROR. | `------------------------------------------------—

Pacify compilers when the user code never invokes YYERROR and the label yyerrorlab therefore never appears in user code.

Do not reclaim the symbols of the rule whose action triggered this YYERROR.

---------------------------------------------------------—. | yyerrlab1 – common code for both syntax error and YYERROR. | `----------------------------------------------------------—

Each real token shifted decrements this.

Pop stack until we find a state that shifts the error token.

Pop the current state because it cannot handle the error token.

Shift the error token.

---------------------------------—. | yyacceptlab – YYACCEPT comes here. | `----------------------------------—

-------------------------------—. | yyabortlab – YYABORT comes here. | `--------------------------------—

-------------------------------------------------------—. | yyexhaustedlab – YYNOMEM (memory exhaustion) comes here. | `--------------------------------------------------------—

------------------------------------------------------—. | yyreturnlab – parsing is finished, clean up and return. | `-------------------------------------------------------—

Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary.

Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT.

Definition at line 68 of file step_bison_parser.c.

YYPOPSTACK

#define YYPOPSTACK

(

N

)

(yyvsp -= (N), yyssp -= (N))

YYPTRDIFF_MAXIMUM

#define YYPTRDIFF_MAXIMUM   LONG_MAX

Definition at line 293 of file step_bison_parser.c.

YYPTRDIFF_T

#define YYPTRDIFF_T   long

Definition at line 292 of file step_bison_parser.c.

YYPULL

#define YYPULL   1

Pull parsers.

Definition at line 64 of file step_bison_parser.c.

YYPURE

#define YYPURE   0

Pure parsers.

Definition at line 58 of file step_bison_parser.c.

YYPUSH

#define YYPUSH   0

Push parsers.

Definition at line 61 of file step_bison_parser.c.

YYRECOVERING

#define YYRECOVERING

(

)

(!!yyerrstatus)

Definition at line 785 of file step_bison_parser.c.

YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM

Value:

  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

Definition at line 310 of file step_bison_parser.c.

YYSIZE_T

#define YYSIZE_T   unsigned

Definition at line 306 of file step_bison_parser.c.

YYSIZEOF

#define YYSIZEOF

(

X

)

YY_CAST (YYPTRDIFF_T, sizeof (X))

Definition at line 316 of file step_bison_parser.c.

YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

Skeleton name.

Definition at line 55 of file step_bison_parser.c.

YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

The parser invokes alloca or malloc; define the necessary symbols.

Definition at line 440 of file step_bison_parser.c.

YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 443 of file step_bison_parser.c.

YYSTACK_BYTES

#define YYSTACK_BYTES

(

N

)

Value:

     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
      + YYSTACK_GAP_MAXIMUM)

The size of an array large to enough to hold all stacks, each with N elements.

Definition at line 484 of file step_bison_parser.c.

YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 441 of file step_bison_parser.c.

YYSTACK_GAP_MAXIMUM

#define YYSTACK_GAP_MAXIMUM   (YYSIZEOF (union yyalloc) - 1)

The size of the maximum gap between one aligned stack and the next.

Definition at line 480 of file step_bison_parser.c.

YYSTACK_RELOCATE

#define YYSTACK_RELOCATE	(		Stack_alloc,
			Stack
	)

Value:

    do                                                                  \
      {                                                                 \
        YYPTRDIFF_T yynewbytes;                                         \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
      }                                                                 \
    while (0)

Relocate STACK from its old location to the new one.

The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack.

Definition at line 495 of file step_bison_parser.c.

YYTABLE_NINF

#define YYTABLE_NINF   (-41)

Definition at line 643 of file step_bison_parser.c.

yytable_value_is_error

#define yytable_value_is_error

(

Yyn

)

0

Definition at line 645 of file step_bison_parser.c.

YYTRANSLATE

#define YYTRANSLATE

(

YYX

)

Value:

  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
   : YYSYMBOL_YYUNDEF)

YYTRANSLATE(TOKEN-NUM) – Symbol number corresponding to TOKEN-NUM as returned by yylex, with out-of-bounds checking.

Definition at line 548 of file step_bison_parser.c.

Typedef Documentation

yy_state_fast_t

typedef int yy_state_fast_t

State numbers in computations.

Definition at line 323 of file step_bison_parser.c.

yy_state_t

typedef yytype_int8 yy_state_t

Stored state numbers (used for stacks).

Definition at line 320 of file step_bison_parser.c.

yysymbol_kind_t

typedef enum yysymbol_kind_t yysymbol_kind_t

Definition at line 105 of file step_bison_parser.c.

yytype_int16

typedef short yytype_int16

Definition at line 244 of file step_bison_parser.c.

yytype_int8

typedef signed char yytype_int8

On compilers that do not define PTRDIFF_MAX etc., make sure <limits.h> and (if available) <stdint.h> are included so that the code can choose integer types of a good width.

INFRINGES ON USER NAME SPACE Narrow types that promote to a signed type and that can represent a signed or unsigned integer of at least N bits. In tables they can save space and decrease cache pressure. Promoting to a signed type helps avoid bugs in integer arithmetic.

Definition at line 236 of file step_bison_parser.c.

yytype_uint16

typedef unsigned short yytype_uint16

Definition at line 276 of file step_bison_parser.c.

yytype_uint8

typedef unsigned char yytype_uint8

Work around bug in HP-UX 11.23, which defines these macros incorrectly for preprocessor constants.

This workaround can likely be removed in 2023, as HPE has promised support for HP-UX 11.23 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf.

Definition at line 265 of file step_bison_parser.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
YYENOMEM

Definition at line 774 of file step_bison_parser.c.

{ YYENOMEM = -2 };

yysymbol_kind_t

enum yysymbol_kind_t

Symbol kind.

Enumerator
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_CHUNK_BEGIN	"invalid token"
YYSYMBOL_VECTOR_BEGIN	CHUNK_BEGIN
YYSYMBOL_ARROW_BEGIN	VECTOR_BEGIN
YYSYMBOL_READ_BOOL	ARROW_BEGIN
YYSYMBOL_TABULATED_BEGIN	READ_BOOL
YYSYMBOL_LP	TABULATED_BEGIN
YYSYMBOL_RP	LP
YYSYMBOL_LC	RP
YYSYMBOL_RC	LC
YYSYMBOL_LB	RC
YYSYMBOL_SHARED_POINTER	LB
YYSYMBOL_READ_EXTERNAL	SHARED_POINTER
YYSYMBOL_READ_DEF	READ_EXTERNAL
YYSYMBOL_READ_REF	READ_DEF
YYSYMBOL_READ_NULL	READ_REF
YYSYMBOL_READ_LIST_UNDEFINED	READ_NULL
YYSYMBOL_READ_SET_UNDEFINED	READ_LIST_UNDEFINED
YYSYMBOL_READ_ARRAY_UNDEFINED	READ_SET_UNDEFINED
YYSYMBOL_READ_STRING	READ_ARRAY_UNDEFINED
YYSYMBOL_READ_UNIT	READ_STRING
YYSYMBOL_READ_CHAR	READ_UNIT
YYSYMBOL_READ_INT	READ_CHAR
YYSYMBOL_READ_FLOAT	READ_INT
YYSYMBOL_YYACCEPT	READ_FLOAT
YYSYMBOL_Read	$accept
YYSYMBOL_Nb_of_shared_pointers	Read
YYSYMBOL_Contents	Nb_of_shared_pointers
YYSYMBOL_Chunk	Contents
YYSYMBOL_31_1	Chunk
YYSYMBOL_Shared_chunk	$@1
YYSYMBOL_Type	Shared_chunk
YYSYMBOL_Datas	Type
YYSYMBOL_Datas2	Datas
YYSYMBOL_Datas3	Datas2
YYSYMBOL_Sparse_Datas	Datas3
YYSYMBOL_Data	Sparse_Datas
YYSYMBOL_Basis	Data
YYSYMBOL_Int	Basis
YYSYMBOL_String	Int
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_COMMA	"invalid token"
YYSYMBOL_COLUMN	COMMA
YYSYMBOL_SEMI_COLUMN	COLUMN
YYSYMBOL_AND	SEMI_COLUMN
YYSYMBOL_OR	AND
YYSYMBOL_ARROW	OR
YYSYMBOL_STAR	ARROW
YYSYMBOL_LB	STAR
YYSYMBOL_RB	LB
YYSYMBOL_LR	RB
YYSYMBOL_RR	LR
YYSYMBOL_EQUAL	RR
YYSYMBOL_FROM	EQUAL
YYSYMBOL_GRAM_EXTERNAL	FROM
YYSYMBOL_GRAM_IMPORT	GRAM_EXTERNAL
YYSYMBOL_TABULATED	GRAM_IMPORT
YYSYMBOL_PERSISTANT	TABULATED
YYSYMBOL_IDENT	PERSISTANT
YYSYMBOL_GRAM_FILE	IDENT
YYSYMBOL_GRAM_INT	GRAM_FILE
YYSYMBOL_YYACCEPT	GRAM_INT
YYSYMBOL_Specification	$accept
YYSYMBOL_25_1	Specification
YYSYMBOL_Externals	$@1
YYSYMBOL_Imports	Externals
YYSYMBOL_File	Imports
YYSYMBOL_Definitions	File
YYSYMBOL_Definition	Definitions
YYSYMBOL_Tabulated	Definition
YYSYMBOL_Domain	Tabulated
YYSYMBOL_Simple	Domain
YYSYMBOL_Persistant	Simple
YYSYMBOL_Basis	Persistant
YYSYMBOL_Constructed	Basis
YYSYMBOL_Namelist	Constructed
YYSYMBOL_Dimensions	Namelist
YYSYMBOL_Int	Dimensions
YYSYMBOL_Name	Int
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_ACCFERM	"invalid token"
YYSYMBOL_ACCOUVR	ACCFERM
YYSYMBOL_CONSTANTE	ACCOUVR
YYSYMBOL_EGAL	CONSTANTE
YYSYMBOL_IDENT	EGAL
YYSYMBOL_INF	IDENT
YYSYMBOL_INFEGAL	INF
YYSYMBOL_MOINS	INFEGAL
YYSYMBOL_PLUS	MOINS
YYSYMBOL_SUP	PLUS
YYSYMBOL_SUPEGAL	SUP
YYSYMBOL_VAR	SUPEGAL
YYSYMBOL_VIRG	VAR
YYSYMBOL_YYACCEPT	VIRG
YYSYMBOL_system	$accept
YYSYMBOL_inisys	system
YYSYMBOL_defvar	inisys
YYSYMBOL_l_var	defvar
YYSYMBOL_l_eq	l_var
YYSYMBOL_eq	l_eq
YYSYMBOL_debeq	eq
YYSYMBOL_feq	debeq
YYSYMBOL_membre	feq
YYSYMBOL_26_1	membre
YYSYMBOL_terme	$@1
YYSYMBOL_ident	terme
YYSYMBOL_newid	ident
YYSYMBOL_const	newid
YYSYMBOL_op	const
YYSYMBOL_addop	op
YYSYMBOL_multi_membre	addop
YYSYMBOL_fin_mult_membre	multi_membre
YYSYMBOL_virg_opt	fin_mult_membre
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_ACCFERM	"invalid token"
YYSYMBOL_ACCOUVR	ACCFERM
YYSYMBOL_CONSTANTE	ACCOUVR
YYSYMBOL_EGAL	CONSTANTE
YYSYMBOL_IDENT	EGAL
YYSYMBOL_INF	IDENT
YYSYMBOL_INFEGAL	INF
YYSYMBOL_MOINS	INFEGAL
YYSYMBOL_PLUS	MOINS
YYSYMBOL_SUP	PLUS
YYSYMBOL_SUPEGAL	SUP
YYSYMBOL_VAR	SUPEGAL
YYSYMBOL_VIRG	VAR
YYSYMBOL_YYACCEPT	VIRG
YYSYMBOL_s_list	$accept
YYSYMBOL_inisl	s_list
YYSYMBOL_endsl	inisl
YYSYMBOL_defvar	endsl
YYSYMBOL_l_var	defvar
YYSYMBOL_newid	l_var
YYSYMBOL_l_sys	newid
YYSYMBOL_system	l_sys
YYSYMBOL_inisys	system
YYSYMBOL_endsys	inisys
YYSYMBOL_l_eq	endsys
YYSYMBOL_eq	l_eq
YYSYMBOL_debeq	eq
YYSYMBOL_feq	debeq
YYSYMBOL_membre	feq
YYSYMBOL_32_1	membre
YYSYMBOL_terme	$@1
YYSYMBOL_ident	terme
YYSYMBOL_const	ident
YYSYMBOL_op	const
YYSYMBOL_addop	op
YYSYMBOL_multi_membre	addop
YYSYMBOL_fin_mult_membre	multi_membre
YYSYMBOL_virg_opt	fin_mult_membre
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_TK_IDENT	"invalid token"
YYSYMBOL_TK_CHARCON	TK_IDENT
YYSYMBOL_TK_INTCON	TK_CHARCON
YYSYMBOL_TK_FLOATCON	TK_INTCON
YYSYMBOL_TK_NAMED_TYPE	TK_FLOATCON
YYSYMBOL_TK_STRINGCON	TK_NAMED_TYPE
YYSYMBOL_TK_WSTRINGCON	TK_STRINGCON
YYSYMBOL_TK_EOF	TK_WSTRINGCON
YYSYMBOL_TK_CHAR	TK_EOF
YYSYMBOL_TK_INT	TK_CHAR
YYSYMBOL_TK_INT128	TK_INT
YYSYMBOL_TK_UINT128	TK_INT128
YYSYMBOL_TK_DOUBLE	TK_UINT128
YYSYMBOL_TK_FLOAT	TK_DOUBLE
YYSYMBOL_TK_VOID	TK_FLOAT
YYSYMBOL_TK_COMPLEX	TK_VOID
YYSYMBOL_TK_ENUM	TK_COMPLEX
YYSYMBOL_TK_STRUCT	TK_ENUM
YYSYMBOL_TK_TYPEDEF	TK_STRUCT
YYSYMBOL_TK_UNION	TK_TYPEDEF
YYSYMBOL_TK_SIGNED	TK_UNION
YYSYMBOL_TK_UNSIGNED	TK_SIGNED
YYSYMBOL_TK_LONG	TK_UNSIGNED
YYSYMBOL_TK_SHORT	TK_LONG
YYSYMBOL_TK_VOLATILE	TK_SHORT
YYSYMBOL_TK_EXTERN	TK_VOLATILE
YYSYMBOL_TK_STATIC	TK_EXTERN
YYSYMBOL_TK_STATIC_DIMENSION	TK_STATIC
YYSYMBOL_TK_CONST	TK_STATIC_DIMENSION
YYSYMBOL_TK_RESTRICT	TK_CONST
YYSYMBOL_TK_AUTO	TK_RESTRICT
YYSYMBOL_TK_REGISTER	TK_AUTO
YYSYMBOL_TK_THREAD	TK_REGISTER
YYSYMBOL_TK_SIZEOF	TK_THREAD
YYSYMBOL_TK_ALIGNOF	TK_SIZEOF
YYSYMBOL_TK_EQ	TK_ALIGNOF
YYSYMBOL_TK_PLUS_EQ	TK_EQ
YYSYMBOL_TK_MINUS_EQ	TK_PLUS_EQ
YYSYMBOL_TK_STAR_EQ	TK_MINUS_EQ
YYSYMBOL_TK_SLASH_EQ	TK_STAR_EQ
YYSYMBOL_TK_PERCENT_EQ	TK_SLASH_EQ
YYSYMBOL_TK_AND_EQ	TK_PERCENT_EQ
YYSYMBOL_TK_PIPE_EQ	TK_AND_EQ
YYSYMBOL_TK_CIRC_EQ	TK_PIPE_EQ
YYSYMBOL_TK_INF_INF_EQ	TK_CIRC_EQ
YYSYMBOL_TK_SUP_SUP_EQ	TK_INF_INF_EQ
YYSYMBOL_TK_ARROW	TK_SUP_SUP_EQ
YYSYMBOL_TK_DOT	TK_ARROW
YYSYMBOL_TK_EQ_EQ	TK_DOT
YYSYMBOL_TK_EXCLAM_EQ	TK_EQ_EQ
YYSYMBOL_TK_INF	TK_EXCLAM_EQ
YYSYMBOL_TK_SUP	TK_INF
YYSYMBOL_TK_INF_EQ	TK_SUP
YYSYMBOL_TK_SUP_EQ	TK_INF_EQ
YYSYMBOL_TK_PLUS	TK_SUP_EQ
YYSYMBOL_TK_MINUS	TK_PLUS
YYSYMBOL_TK_STAR	TK_MINUS
YYSYMBOL_TK_SLASH	TK_STAR
YYSYMBOL_TK_PERCENT	TK_SLASH
YYSYMBOL_TK_TILDE	TK_PERCENT
YYSYMBOL_TK_AND	TK_TILDE
YYSYMBOL_TK_PIPE	TK_AND
YYSYMBOL_TK_CIRC	TK_PIPE
YYSYMBOL_TK_EXCLAM	TK_CIRC
YYSYMBOL_TK_AND_AND	TK_EXCLAM
YYSYMBOL_TK_PIPE_PIPE	TK_AND_AND
YYSYMBOL_TK_INF_INF	TK_PIPE_PIPE
YYSYMBOL_TK_SUP_SUP	TK_INF_INF
YYSYMBOL_TK_PLUS_PLUS	TK_SUP_SUP
YYSYMBOL_TK_MINUS_MINUS	TK_PLUS_PLUS
YYSYMBOL_TK_RPAREN	TK_MINUS_MINUS
YYSYMBOL_TK_LPAREN	TK_RPAREN
YYSYMBOL_TK_RBRACE	TK_LPAREN
YYSYMBOL_TK_LBRACE	TK_RBRACE
YYSYMBOL_TK_LBRACKET	TK_LBRACE
YYSYMBOL_TK_RBRACKET	TK_LBRACKET
YYSYMBOL_TK_COLON	TK_RBRACKET
YYSYMBOL_TK_SEMICOLON	TK_COLON
YYSYMBOL_TK_COMMA	TK_SEMICOLON
YYSYMBOL_TK_ELLIPSIS	TK_COMMA
YYSYMBOL_TK_QUEST	TK_ELLIPSIS
YYSYMBOL_TK_BREAK	TK_QUEST
YYSYMBOL_TK_CONTINUE	TK_BREAK
YYSYMBOL_TK_GOTO	TK_CONTINUE
YYSYMBOL_TK_RETURN	TK_GOTO
YYSYMBOL_TK_SWITCH	TK_RETURN
YYSYMBOL_TK_CASE	TK_SWITCH
YYSYMBOL_TK_DEFAULT	TK_CASE
YYSYMBOL_TK_WHILE	TK_DEFAULT
YYSYMBOL_TK_DO	TK_WHILE
YYSYMBOL_TK_FOR	TK_DO
YYSYMBOL_TK_IF	TK_FOR
YYSYMBOL_TK_ELSE	TK_IF
YYSYMBOL_TK_ATTRIBUTE	TK_ELSE
YYSYMBOL_TK_INLINE	TK_ATTRIBUTE
YYSYMBOL_TK_ASM	TK_INLINE
YYSYMBOL_TK_TYPEOF	TK_ASM
YYSYMBOL_TK_FUNCTION__	TK_TYPEOF
YYSYMBOL_TK_PRETTY_FUNCTION__	TK_FUNCTION__
YYSYMBOL_TK_LABEL__	TK_PRETTY_FUNCTION__
YYSYMBOL_TK_BUILTIN_VA_ARG	TK_LABEL__
YYSYMBOL_TK_BUILTIN_VA_LIST	TK_BUILTIN_VA_ARG
YYSYMBOL_TK_BLOCKATTRIBUTE	TK_BUILTIN_VA_LIST
YYSYMBOL_TK_DECLSPEC	TK_BLOCKATTRIBUTE
YYSYMBOL_TK_MSASM	TK_DECLSPEC
YYSYMBOL_TK_MSATTR	TK_MSASM
YYSYMBOL_TK_PRAGMA	TK_MSATTR
YYSYMBOL_TK__Pragma	TK_PRAGMA
YYSYMBOL_TK_AT_TRANSFORM	TK__Pragma
YYSYMBOL_TK_AT_TRANSFORMEXPR	TK_AT_TRANSFORM
YYSYMBOL_TK_AT_SPECIFIER	TK_AT_TRANSFORMEXPR
YYSYMBOL_TK_AT_EXPR	TK_AT_SPECIFIER
YYSYMBOL_TK_AT_NAME	TK_AT_EXPR
YYSYMBOL_TK_COMPLEXCON	TK_AT_NAME
YYSYMBOL_TK_CAST	TK_COMPLEXCON
YYSYMBOL_TK_ADDROF	TK_CAST
YYSYMBOL_YYACCEPT	TK_ADDROF
YYSYMBOL_interpret	$accept
YYSYMBOL_file	interpret
YYSYMBOL_globals	file
YYSYMBOL_123_1	globals
YYSYMBOL_location	$@1
YYSYMBOL_global	location
YYSYMBOL_126_2	global
YYSYMBOL_id_or_typename	$@2
YYSYMBOL_maybecomma	id_or_typename
YYSYMBOL_expression	maybecomma
YYSYMBOL_constant	expression
YYSYMBOL_string_constant	constant
YYSYMBOL_one_string_constant	string_constant
YYSYMBOL_string_list	one_string_constant
YYSYMBOL_wstring_list	string_list
YYSYMBOL_one_string	wstring_list
YYSYMBOL_init_expression	one_string
YYSYMBOL_initializer_list	init_expression
YYSYMBOL_initializer_list_opt	initializer_list
YYSYMBOL_initializer	initializer_list_opt
YYSYMBOL_eq_opt	initializer
YYSYMBOL_init_designators	eq_opt
YYSYMBOL_init_designators_opt	init_designators
YYSYMBOL_gcc_init_designators	init_designators_opt
YYSYMBOL_arguments	gcc_init_designators
YYSYMBOL_opt_expression	arguments
YYSYMBOL_comma_expression	opt_expression
YYSYMBOL_comma_expression_opt	comma_expression
YYSYMBOL_statement_paren_comma_expression	comma_expression_opt
YYSYMBOL_paren_comma_expression	statement_paren_comma_expression
YYSYMBOL_bracket_comma_expression	paren_comma_expression
YYSYMBOL_statements_inside_block	bracket_comma_expression
YYSYMBOL_152_3	statements_inside_block
YYSYMBOL_block	$@3
YYSYMBOL_block_attrs	block
YYSYMBOL_statement_list	block_attrs
YYSYMBOL_local_labels	statement_list
YYSYMBOL_local_label_names	local_labels
YYSYMBOL_label	local_label_names
YYSYMBOL_pragma	label
YYSYMBOL_pragmas	pragma
YYSYMBOL_statement	pragmas
YYSYMBOL_statement_without_pragma	statement
YYSYMBOL_163_4	statement_without_pragma
YYSYMBOL_164_5	$@4
YYSYMBOL_165_6	$@5
YYSYMBOL_166_7	$@6
YYSYMBOL_167_8	$@7
YYSYMBOL_168_9	$@8
YYSYMBOL_169_10	$@9
YYSYMBOL_for_clause	$@10
YYSYMBOL_171_11	for_clause
YYSYMBOL_declaration	$@11
YYSYMBOL_init_declarator_list	declaration
YYSYMBOL_init_declarator	init_declarator_list
YYSYMBOL_decl_spec_list	init_declarator
YYSYMBOL_176_12	decl_spec_list
YYSYMBOL_my_decl_spec_list	$@12
YYSYMBOL_decl_spec_list_opt	my_decl_spec_list
YYSYMBOL_decl_spec_list_opt_no_named	decl_spec_list_opt
YYSYMBOL_type_spec	decl_spec_list_opt_no_named
YYSYMBOL_181_13	type_spec
YYSYMBOL_182_14	$@13
YYSYMBOL_183_15	$@14
YYSYMBOL_184_16	$@15
YYSYMBOL_struct_decl_list	$@16
YYSYMBOL_186_17	struct_decl_list
YYSYMBOL_field_decl_list	$@17
YYSYMBOL_field_decl	field_decl_list
YYSYMBOL_enum_list	field_decl
YYSYMBOL_enumerator	enum_list
YYSYMBOL_declarator	enumerator
YYSYMBOL_direct_decl	declarator
YYSYMBOL_193_18	direct_decl
YYSYMBOL_parameter_list_startscope	$@18
YYSYMBOL_rest_par_list	parameter_list_startscope
YYSYMBOL_rest_par_list1	rest_par_list
YYSYMBOL_197_19	rest_par_list1
YYSYMBOL_198_20	$@19
YYSYMBOL_parameter_decl	$@20
YYSYMBOL_old_proto_decl	parameter_decl
YYSYMBOL_direct_old_proto_decl	old_proto_decl
YYSYMBOL_202_21	direct_old_proto_decl
YYSYMBOL_old_parameter_list_ne	$@21
YYSYMBOL_old_pardef_list	old_parameter_list_ne
YYSYMBOL_old_pardef	old_pardef_list
YYSYMBOL_pointer	old_pardef
YYSYMBOL_pointer_opt	pointer
YYSYMBOL_type_name	pointer_opt
YYSYMBOL_abstract_decl	type_name
YYSYMBOL_abs_direct_decl	abstract_decl
YYSYMBOL_211_22	abs_direct_decl
YYSYMBOL_abs_direct_decl_opt	$@22
YYSYMBOL_function_def	abs_direct_decl_opt
YYSYMBOL_214_23	function_def
YYSYMBOL_function_def_start	$@23
YYSYMBOL_216_24	function_def_start
YYSYMBOL_217_25	$@24
YYSYMBOL_attributes	$@25
YYSYMBOL_attributes_with_asm	attributes
YYSYMBOL_attribute	attributes_with_asm
YYSYMBOL_asmattr	attribute
YYSYMBOL_asmoutputs	asmattr
YYSYMBOL_asmoperands	asmoutputs
YYSYMBOL_asmoperandsne	asmoperands
YYSYMBOL_asmoperand	asmoperandsne
YYSYMBOL_asminputs	asmoperand
YYSYMBOL_asmclobber	asminputs
YYSYMBOL_asmcloberlst_ne	asmclobber
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_PROGRAM	"invalid token"
YYSYMBOL_MODULE	PROGRAM
YYSYMBOL_MAIN	MODULE
YYSYMBOL_COMMON	MAIN
YYSYMBOL_TK_CALLEES	COMMON
YYSYMBOL_CALLERS	TK_CALLEES
YYSYMBOL_ALL	CALLERS
YYSYMBOL_SELECT	ALL
YYSYMBOL_COMPILATION_UNIT	SELECT
YYSYMBOL_REQUIRED	COMPILATION_UNIT
YYSYMBOL_PRODUCED	REQUIRED
YYSYMBOL_MODIFIED	PRODUCED
YYSYMBOL_PRESERVED	MODIFIED
YYSYMBOL_PRE_TRANSFORMATION	PRESERVED
YYSYMBOL_POST_TRANSFORMATION	PRE_TRANSFORMATION
YYSYMBOL_DOT	POST_TRANSFORMATION
YYSYMBOL_NAME	DOT
YYSYMBOL_YYACCEPT	NAME
YYSYMBOL_rules	$accept
YYSYMBOL_rule	rules
YYSYMBOL_deps	rule
YYSYMBOL_dir	deps
YYSYMBOL_virtuals	dir
YYSYMBOL_virtual	virtuals
YYSYMBOL_owner	virtual
YYSYMBOL_phase	owner
YYSYMBOL_resource	phase
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_TK_IDENT	"invalid token"
YYSYMBOL_TK_CHARCON	TK_IDENT
YYSYMBOL_TK_INTCON	TK_CHARCON
YYSYMBOL_TK_FLOATCON	TK_INTCON
YYSYMBOL_TK_NAMED_TYPE	TK_FLOATCON
YYSYMBOL_TK_STRINGCON	TK_NAMED_TYPE
YYSYMBOL_TK_WSTRINGCON	TK_STRINGCON
YYSYMBOL_TK_EOF	TK_WSTRINGCON
YYSYMBOL_TK_CHAR	TK_EOF
YYSYMBOL_TK_INT	TK_CHAR
YYSYMBOL_TK_INT128	TK_INT
YYSYMBOL_TK_UINT128	TK_INT128
YYSYMBOL_TK_DOUBLE	TK_UINT128
YYSYMBOL_TK_FLOAT	TK_DOUBLE
YYSYMBOL_TK_VOID	TK_FLOAT
YYSYMBOL_TK_COMPLEX	TK_VOID
YYSYMBOL_TK_ENUM	TK_COMPLEX
YYSYMBOL_TK_STRUCT	TK_ENUM
YYSYMBOL_TK_TYPEDEF	TK_STRUCT
YYSYMBOL_TK_UNION	TK_TYPEDEF
YYSYMBOL_TK_SIGNED	TK_UNION
YYSYMBOL_TK_UNSIGNED	TK_SIGNED
YYSYMBOL_TK_LONG	TK_UNSIGNED
YYSYMBOL_TK_SHORT	TK_LONG
YYSYMBOL_TK_VOLATILE	TK_SHORT
YYSYMBOL_TK_EXTERN	TK_VOLATILE
YYSYMBOL_TK_STATIC	TK_EXTERN
YYSYMBOL_TK_CONST	TK_STATIC
YYSYMBOL_TK_RESTRICT	TK_CONST
YYSYMBOL_TK_AUTO	TK_RESTRICT
YYSYMBOL_TK_REGISTER	TK_AUTO
YYSYMBOL_TK_THREAD	TK_REGISTER
YYSYMBOL_TK_STATIC_DIMENSION	TK_THREAD
YYSYMBOL_TK_SIZEOF	TK_STATIC_DIMENSION
YYSYMBOL_TK_ALIGNOF	TK_SIZEOF
YYSYMBOL_TK_EQ	TK_ALIGNOF
YYSYMBOL_TK_PLUS_EQ	TK_EQ
YYSYMBOL_TK_MINUS_EQ	TK_PLUS_EQ
YYSYMBOL_TK_STAR_EQ	TK_MINUS_EQ
YYSYMBOL_TK_SLASH_EQ	TK_STAR_EQ
YYSYMBOL_TK_PERCENT_EQ	TK_SLASH_EQ
YYSYMBOL_TK_AND_EQ	TK_PERCENT_EQ
YYSYMBOL_TK_PIPE_EQ	TK_AND_EQ
YYSYMBOL_TK_CIRC_EQ	TK_PIPE_EQ
YYSYMBOL_TK_INF_INF_EQ	TK_CIRC_EQ
YYSYMBOL_TK_SUP_SUP_EQ	TK_INF_INF_EQ
YYSYMBOL_TK_ARROW	TK_SUP_SUP_EQ
YYSYMBOL_TK_DOT	TK_ARROW
YYSYMBOL_TK_EQ_EQ	TK_DOT
YYSYMBOL_TK_EXCLAM_EQ	TK_EQ_EQ
YYSYMBOL_TK_INF	TK_EXCLAM_EQ
YYSYMBOL_TK_SUP	TK_INF
YYSYMBOL_TK_INF_EQ	TK_SUP
YYSYMBOL_TK_SUP_EQ	TK_INF_EQ
YYSYMBOL_TK_PLUS	TK_SUP_EQ
YYSYMBOL_TK_MINUS	TK_PLUS
YYSYMBOL_TK_STAR	TK_MINUS
YYSYMBOL_TK_SLASH	TK_STAR
YYSYMBOL_TK_PERCENT	TK_SLASH
YYSYMBOL_TK_TILDE	TK_PERCENT
YYSYMBOL_TK_AND	TK_TILDE
YYSYMBOL_TK_PIPE	TK_AND
YYSYMBOL_TK_CIRC	TK_PIPE
YYSYMBOL_TK_EXCLAM	TK_CIRC
YYSYMBOL_TK_AND_AND	TK_EXCLAM
YYSYMBOL_TK_PIPE_PIPE	TK_AND_AND
YYSYMBOL_TK_INF_INF	TK_PIPE_PIPE
YYSYMBOL_TK_SUP_SUP	TK_INF_INF
YYSYMBOL_TK_PLUS_PLUS	TK_SUP_SUP
YYSYMBOL_TK_MINUS_MINUS	TK_PLUS_PLUS
YYSYMBOL_TK_RPAREN	TK_MINUS_MINUS
YYSYMBOL_TK_LPAREN	TK_RPAREN
YYSYMBOL_TK_RBRACE	TK_LPAREN
YYSYMBOL_TK_LBRACE	TK_RBRACE
YYSYMBOL_TK_LBRACKET	TK_LBRACE
YYSYMBOL_TK_RBRACKET	TK_LBRACKET
YYSYMBOL_TK_COLON	TK_RBRACKET
YYSYMBOL_TK_SEMICOLON	TK_COLON
YYSYMBOL_TK_COMMA	TK_SEMICOLON
YYSYMBOL_TK_ELLIPSIS	TK_COMMA
YYSYMBOL_TK_QUEST	TK_ELLIPSIS
YYSYMBOL_TK_BREAK	TK_QUEST
YYSYMBOL_TK_CONTINUE	TK_BREAK
YYSYMBOL_TK_GOTO	TK_CONTINUE
YYSYMBOL_TK_RETURN	TK_GOTO
YYSYMBOL_TK_SWITCH	TK_RETURN
YYSYMBOL_TK_CASE	TK_SWITCH
YYSYMBOL_TK_DEFAULT	TK_CASE
YYSYMBOL_TK_WHILE	TK_DEFAULT
YYSYMBOL_TK_DO	TK_WHILE
YYSYMBOL_TK_FOR	TK_DO
YYSYMBOL_TK_IF	TK_FOR
YYSYMBOL_TK_ELSE	TK_IF
YYSYMBOL_TK_ATTRIBUTE	TK_ELSE
YYSYMBOL_TK_INLINE	TK_ATTRIBUTE
YYSYMBOL_TK_ASM	TK_INLINE
YYSYMBOL_TK_TYPEOF	TK_ASM
YYSYMBOL_TK_FUNCTION__	TK_TYPEOF
YYSYMBOL_TK_PRETTY_FUNCTION__	TK_FUNCTION__
YYSYMBOL_TK_LABEL__	TK_PRETTY_FUNCTION__
YYSYMBOL_TK_BUILTIN_VA_ARG	TK_LABEL__
YYSYMBOL_TK_BUILTIN_VA_LIST	TK_BUILTIN_VA_ARG
YYSYMBOL_TK_BLOCKATTRIBUTE	TK_BUILTIN_VA_LIST
YYSYMBOL_TK_DECLSPEC	TK_BLOCKATTRIBUTE
YYSYMBOL_TK_MSASM	TK_DECLSPEC
YYSYMBOL_TK_MSATTR	TK_MSASM
YYSYMBOL_TK_PRAGMA	TK_MSATTR
YYSYMBOL_TK_AT_TRANSFORM	TK_PRAGMA
YYSYMBOL_TK_AT_TRANSFORMEXPR	TK_AT_TRANSFORM
YYSYMBOL_TK_AT_SPECIFIER	TK_AT_TRANSFORMEXPR
YYSYMBOL_TK_AT_EXPR	TK_AT_SPECIFIER
YYSYMBOL_TK_AT_NAME	TK_AT_EXPR
YYSYMBOL_TK_COMPLEXCON	TK_AT_NAME
YYSYMBOL_TK_CAST	TK_COMPLEXCON
YYSYMBOL_TK_ADDROF	TK_CAST
YYSYMBOL_YYACCEPT	TK_ADDROF
YYSYMBOL_interpret	$accept
YYSYMBOL_file	interpret
YYSYMBOL_globals	file
YYSYMBOL_location	globals
YYSYMBOL_global	location
YYSYMBOL_id_or_typename	global
YYSYMBOL_maybecomma	id_or_typename
YYSYMBOL_expression	maybecomma
YYSYMBOL_constant	expression
YYSYMBOL_string_constant	constant
YYSYMBOL_one_string_constant	string_constant
YYSYMBOL_string_list	one_string_constant
YYSYMBOL_wstring_list	string_list
YYSYMBOL_one_string	wstring_list
YYSYMBOL_init_expression	one_string
YYSYMBOL_initializer_list	init_expression
YYSYMBOL_initializer_list_opt	initializer_list
YYSYMBOL_initializer	initializer_list_opt
YYSYMBOL_eq_opt	initializer
YYSYMBOL_init_designators	eq_opt
YYSYMBOL_init_designators_opt	init_designators
YYSYMBOL_gcc_init_designators	init_designators_opt
YYSYMBOL_arguments	gcc_init_designators
YYSYMBOL_opt_expression	arguments
YYSYMBOL_comma_expression	opt_expression
YYSYMBOL_comma_expression_opt	comma_expression
YYSYMBOL_paren_comma_expression	comma_expression_opt
YYSYMBOL_bracket_comma_expression	paren_comma_expression
YYSYMBOL_block	bracket_comma_expression
YYSYMBOL_148_1	block
YYSYMBOL_149_2	$@1
YYSYMBOL_block_attrs	$@2
YYSYMBOL_declaration_list	block_attrs
YYSYMBOL_statement_list	declaration_list
YYSYMBOL_local_labels	statement_list
YYSYMBOL_local_label_names	local_labels
YYSYMBOL_statement	local_label_names
YYSYMBOL_156_3	statement
YYSYMBOL_157_4	$@3
YYSYMBOL_158_5	$@4
YYSYMBOL_159_6	$@5
YYSYMBOL_160_7	$@6
YYSYMBOL_for_clause	$@7
YYSYMBOL_declaration	for_clause
YYSYMBOL_init_declarator_list	declaration
YYSYMBOL_init_declarator	init_declarator_list
YYSYMBOL_decl_spec_list	init_declarator
YYSYMBOL_decl_spec_list_opt	decl_spec_list
YYSYMBOL_decl_spec_list_opt_no_named	decl_spec_list_opt
YYSYMBOL_168_8	decl_spec_list_opt_no_named
YYSYMBOL_type_spec	@8
YYSYMBOL_struct_decl_list	type_spec
YYSYMBOL_field_decl_list	struct_decl_list
YYSYMBOL_field_decl	field_decl_list
YYSYMBOL_enum_list	field_decl
YYSYMBOL_enumerator	enum_list
YYSYMBOL_declarator	enumerator
YYSYMBOL_direct_decl	declarator
YYSYMBOL_parameter_list_startscope	direct_decl
YYSYMBOL_rest_par_list	parameter_list_startscope
YYSYMBOL_rest_par_list1	rest_par_list
YYSYMBOL_parameter_decl	rest_par_list1
YYSYMBOL_old_proto_decl	parameter_decl
YYSYMBOL_direct_old_proto_decl	old_proto_decl
YYSYMBOL_old_parameter_list_ne	direct_old_proto_decl
YYSYMBOL_old_pardef_list	old_parameter_list_ne
YYSYMBOL_old_pardef	old_pardef_list
YYSYMBOL_pointer	old_pardef
YYSYMBOL_pointer_opt	pointer
YYSYMBOL_type_name	pointer_opt
YYSYMBOL_abstract_decl	type_name
YYSYMBOL_abs_direct_decl	abstract_decl
YYSYMBOL_abs_direct_decl_opt	abs_direct_decl
YYSYMBOL_function_def	abs_direct_decl_opt
YYSYMBOL_function_def_start	function_def
YYSYMBOL_attributes	function_def_start
YYSYMBOL_attributes_with_asm	attributes
YYSYMBOL_attribute	attributes_with_asm
YYSYMBOL_attr	attribute
YYSYMBOL_attr_list_ne	attr
YYSYMBOL_paren_attr_list_ne	attr_list_ne
YYSYMBOL_asmattr	paren_attr_list_ne
YYSYMBOL_asmtemplate	asmattr
YYSYMBOL_asmoutputs	asmtemplate
YYSYMBOL_asmoperands	asmoutputs
YYSYMBOL_asmoperandsne	asmoperands
YYSYMBOL_asmoperand	asmoperandsne
YYSYMBOL_asminputs	asmoperand
YYSYMBOL_asmclobber	asminputs
YYSYMBOL_asmcloberlst_ne	asmclobber
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_UNKNOWN_TOK	"invalid token"
YYSYMBOL_REFERENCE_TOK	UNKNOWN_TOK
YYSYMBOL_QI_REF_TOK	REFERENCE_TOK
YYSYMBOL_HI_REF_TOK	QI_REF_TOK
YYSYMBOL_SI_REF_TOK	HI_REF_TOK
YYSYMBOL_DI_REF_TOK	SI_REF_TOK
YYSYMBOL_SF_REF_TOK	DI_REF_TOK
YYSYMBOL_DF_REF_TOK	SF_REF_TOK
YYSYMBOL_SC_REF_TOK	DF_REF_TOK
YYSYMBOL_DC_REF_TOK	SC_REF_TOK
YYSYMBOL_LOG_REF_TOK	DC_REF_TOK
YYSYMBOL_CONSTANT_TOK	LOG_REF_TOK
YYSYMBOL_ASSIGN_OPERATOR_TOK	CONSTANT_TOK
YYSYMBOL_PLUS_OPERATOR_TOK	ASSIGN_OPERATOR_TOK
YYSYMBOL_MINUS_OPERATOR_TOK	PLUS_OPERATOR_TOK
YYSYMBOL_UNARY_MINUS_OPERATOR_TOK	MINUS_OPERATOR_TOK
YYSYMBOL_MULTIPLY_OPERATOR_TOK	UNARY_MINUS_OPERATOR_TOK
YYSYMBOL_MULADD_OPERATOR_TOK	MULTIPLY_OPERATOR_TOK
YYSYMBOL_DIVIDE_OPERATOR_TOK	MULADD_OPERATOR_TOK
YYSYMBOL_INVERSE_OPERATOR_TOK	DIVIDE_OPERATOR_TOK
YYSYMBOL_POWER_OPERATOR_TOK	INVERSE_OPERATOR_TOK
YYSYMBOL_MODULO_OPERATOR_TOK	POWER_OPERATOR_TOK
YYSYMBOL_MIN_OPERATOR_TOK	MODULO_OPERATOR_TOK
YYSYMBOL_COS_OPERATOR_TOK	MIN_OPERATOR_TOK
YYSYMBOL_SIN_OPERATOR_TOK	COS_OPERATOR_TOK
YYSYMBOL_MIN0_OPERATOR_TOK	SIN_OPERATOR_TOK
YYSYMBOL_AMIN1_OPERATOR_TOK	MIN0_OPERATOR_TOK
YYSYMBOL_DMIN1_OPERATOR_TOK	AMIN1_OPERATOR_TOK
YYSYMBOL_MAX_OPERATOR_TOK	DMIN1_OPERATOR_TOK
YYSYMBOL_MAX0_OPERATOR_TOK	MAX_OPERATOR_TOK
YYSYMBOL_AMAX1_OPERATOR_TOK	MAX0_OPERATOR_TOK
YYSYMBOL_DMAX1_OPERATOR_TOK	AMAX1_OPERATOR_TOK
YYSYMBOL_ABS_OPERATOR_TOK	DMAX1_OPERATOR_TOK
YYSYMBOL_IABS_OPERATOR_TOK	ABS_OPERATOR_TOK
YYSYMBOL_DABS_OPERATOR_TOK	IABS_OPERATOR_TOK
YYSYMBOL_CABS_OPERATOR_TOK	DABS_OPERATOR_TOK
YYSYMBOL_AND_OPERATOR_TOK	CABS_OPERATOR_TOK
YYSYMBOL_OR_OPERATOR_TOK	AND_OPERATOR_TOK
YYSYMBOL_NOT_OPERATOR_TOK	OR_OPERATOR_TOK
YYSYMBOL_NON_EQUAL_OPERATOR_TOK	NOT_OPERATOR_TOK
YYSYMBOL_EQUIV_OPERATOR_TOK	NON_EQUAL_OPERATOR_TOK
YYSYMBOL_NON_EQUIV_OPERATOR_TOK	EQUIV_OPERATOR_TOK
YYSYMBOL_TRUE_OPERATOR_TOK	NON_EQUIV_OPERATOR_TOK
YYSYMBOL_FALSE_OPERATOR_TOK	TRUE_OPERATOR_TOK
YYSYMBOL_GREATER_OR_EQUAL_OPERATOR_TOK	FALSE_OPERATOR_TOK
YYSYMBOL_GREATER_THAN_OPERATOR_TOK	GREATER_OR_EQUAL_OPERATOR_TOK
YYSYMBOL_LESS_OR_EQUAL_OPERATOR_TOK	GREATER_THAN_OPERATOR_TOK
YYSYMBOL_LESS_THAN_OPERATOR_TOK	LESS_OR_EQUAL_OPERATOR_TOK
YYSYMBOL_EQUAL_OPERATOR_TOK	LESS_THAN_OPERATOR_TOK
YYSYMBOL_PHI_TOK	EQUAL_OPERATOR_TOK
YYSYMBOL_INTEGER_TOK	PHI_TOK
YYSYMBOL_FLOAT_TOK	INTEGER_TOK
YYSYMBOL_IDENTIFIER_TOK	FLOAT_TOK
YYSYMBOL_56_	IDENTIFIER_TOK
YYSYMBOL_57_	'{'
YYSYMBOL_58_	'}'
YYSYMBOL_59_	':'
YYSYMBOL_60_	','
YYSYMBOL_61_	';'
YYSYMBOL_62_	'['
YYSYMBOL_YYACCEPT	']'
YYSYMBOL_definitions	$accept
YYSYMBOL_definitions_list	definitions
YYSYMBOL_definition	definitions_list
YYSYMBOL_operation	definition
YYSYMBOL_opcodes_list	operation
YYSYMBOL_opcode	opcodes_list
YYSYMBOL_pattern	opcode
YYSYMBOL_types_list	pattern
YYSYMBOL_type	types_list
YYSYMBOL_tokens_list	type
YYSYMBOL_token	tokens_list
YYSYMBOL_merge_arguments	token
YYSYMBOL_arguments_list	merge_arguments
YYSYMBOL_argument	arguments_list
YYSYMBOL_transformation	argument
YYSYMBOL_mappings	transformation
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_TK_EOL	"invalid token"
YYSYMBOL_TK_ERROR	TK_EOL
YYSYMBOL_TK_LPAREN	TK_ERROR
YYSYMBOL_TK_RPAREN	TK_LPAREN
YYSYMBOL_TK_COLON	TK_RPAREN
YYSYMBOL_TK_COMMA	TK_COLON
YYSYMBOL_TK_IDENT	TK_COMMA
YYSYMBOL_TK_COMMENT	TK_IDENT
YYSYMBOL_TK_OPERATOR	TK_COMMENT
YYSYMBOL_TK_RAW	TK_OPERATOR
YYSYMBOL_TK_OMP_PRAGMA	TK_RAW
YYSYMBOL_TK_OMP_PARALLEL	TK_OMP_PRAGMA
YYSYMBOL_TK_OMP_LOOP	TK_OMP_PARALLEL
YYSYMBOL_TK_OMP_END	TK_OMP_LOOP
YYSYMBOL_TK_OMP_BARRIER	TK_OMP_END
YYSYMBOL_TK_OMP_MASTER	TK_OMP_BARRIER
YYSYMBOL_TK_OMP_SINGLE	TK_OMP_MASTER
YYSYMBOL_TK_OMP_THREADPRIVATE	TK_OMP_SINGLE
YYSYMBOL_TK_OMP_SHARED	TK_OMP_THREADPRIVATE
YYSYMBOL_TK_OMP_PRIVATE	TK_OMP_SHARED
YYSYMBOL_TK_OMP_NOWAIT	TK_OMP_PRIVATE
YYSYMBOL_TK_OMP_REDUCTION	TK_OMP_NOWAIT
YYSYMBOL_TK_OMP_DEFAULT	TK_OMP_REDUCTION
YYSYMBOL_TK_OMP_COPYIN	TK_OMP_DEFAULT
YYSYMBOL_TK_OMP_FIRSTPRIVATE	TK_OMP_COPYIN
YYSYMBOL_TK_OMP_SCHEDULE	TK_OMP_FIRSTPRIVATE
YYSYMBOL_TK_STEP_PRAGMA	TK_OMP_SCHEDULE
YYSYMBOL_TK_STEP_TRANSFORMATION	TK_STEP_PRAGMA
YYSYMBOL_YYACCEPT	TK_STEP_TRANSFORMATION
YYSYMBOL_pragma	$accept
YYSYMBOL_33_1	pragma
YYSYMBOL_34_2	$@1
YYSYMBOL_step_transformation	$@2
YYSYMBOL_omp_comment	step_transformation
YYSYMBOL_omp_directive	omp_comment
YYSYMBOL_38_3	omp_directive
YYSYMBOL_39_4	@3
YYSYMBOL_40_5	@4
YYSYMBOL_41_6	@5
YYSYMBOL_omp_parallel_clauses	@6
YYSYMBOL_omp_loop_clauses	omp_parallel_clauses
YYSYMBOL_omp_end_loop_clauses	omp_loop_clauses
YYSYMBOL_omp_parallel_loop_clauses	omp_end_loop_clauses
YYSYMBOL_omp_shared	omp_parallel_loop_clauses
YYSYMBOL_47_7	omp_shared
YYSYMBOL_omp_private	$@7
YYSYMBOL_49_8	omp_private
YYSYMBOL_omp_copyin	$@8
YYSYMBOL_51_9	omp_copyin
YYSYMBOL_omp_threadprivate_listvar	$@9
YYSYMBOL_53_10	omp_threadprivate_listvar
YYSYMBOL_omp_firstprivate	$@10
YYSYMBOL_55_11	omp_firstprivate
YYSYMBOL_omp_schedule	$@11
YYSYMBOL_57_12	omp_schedule
YYSYMBOL_omp_reduction	$@12
YYSYMBOL_59_13	omp_reduction
YYSYMBOL_60_14	$@13
YYSYMBOL_omp_default	$@14
YYSYMBOL_62_15	omp_default
YYSYMBOL_string_list	$@15
YYSYMBOL_ident_list	string_list
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_TK_ASSIGN	"invalid token"
YYSYMBOL_TK_BACKSPACE	TK_ASSIGN
YYSYMBOL_TK_BLANK	TK_BACKSPACE
YYSYMBOL_TK_BLOCKDATA	TK_BLANK
YYSYMBOL_TK_BUFFERIN	TK_BLOCKDATA
YYSYMBOL_TK_BUFFEROUT	TK_BUFFERIN
YYSYMBOL_TK_CALL	TK_BUFFEROUT
YYSYMBOL_TK_CHARACTER	TK_CALL
YYSYMBOL_TK_CLOSE	TK_CHARACTER
YYSYMBOL_TK_COMMON	TK_CLOSE
YYSYMBOL_TK_COMPLEX	TK_COMMON
YYSYMBOL_TK_CONTINUE	TK_COMPLEX
YYSYMBOL_TK_CYCLE	TK_CONTINUE
YYSYMBOL_TK_DATA	TK_CYCLE
YYSYMBOL_TK_DIMENSION	TK_DATA
YYSYMBOL_TK_DOUBLEPRECISION	TK_DIMENSION
YYSYMBOL_TK_DOUBLECOMPLEX	TK_DOUBLEPRECISION
YYSYMBOL_TK_DO	TK_DOUBLECOMPLEX
YYSYMBOL_TK_ELSEIF	TK_DO
YYSYMBOL_TK_ELSE	TK_ELSEIF
YYSYMBOL_TK_ENDFILE	TK_ELSE
YYSYMBOL_TK_ENDDO	TK_ENDFILE
YYSYMBOL_TK_ENDIF	TK_ENDDO
YYSYMBOL_TK_END	TK_ENDIF
YYSYMBOL_TK_ENTRY	TK_END
YYSYMBOL_TK_EQUIVALENCE	TK_ENTRY
YYSYMBOL_TK_EXIT	TK_EQUIVALENCE
YYSYMBOL_TK_EXTERNAL	TK_EXIT
YYSYMBOL_TK_FORMAT	TK_EXTERNAL
YYSYMBOL_TK_FUNCTION	TK_FORMAT
YYSYMBOL_TK_GOTO	TK_FUNCTION
YYSYMBOL_TK_IF	TK_GOTO
YYSYMBOL_TK_IMPLICIT	TK_IF
YYSYMBOL_TK_INCLUDE	TK_IMPLICIT
YYSYMBOL_TK_INQUIRE	TK_INCLUDE
YYSYMBOL_TK_INTEGER	TK_INQUIRE
YYSYMBOL_TK_INTRINSIC	TK_INTEGER
YYSYMBOL_TK_IOSTAT	TK_INTRINSIC
YYSYMBOL_TK_LOGICAL	TK_IOSTAT
YYSYMBOL_TK_OPEN	TK_LOGICAL
YYSYMBOL_TK_PARAMETER	TK_OPEN
YYSYMBOL_TK_PAUSE	TK_PARAMETER
YYSYMBOL_TK_POINTER	TK_PAUSE
YYSYMBOL_TK_PRINT	TK_POINTER
YYSYMBOL_TK_PROGRAM	TK_PRINT
YYSYMBOL_TK_READ	TK_PROGRAM
YYSYMBOL_TK_REAL	TK_READ
YYSYMBOL_TK_RETURN	TK_REAL
YYSYMBOL_TK_REWIND	TK_RETURN
YYSYMBOL_TK_SAVE	TK_REWIND
YYSYMBOL_TK_STATIC	TK_SAVE
YYSYMBOL_TK_STOP	TK_STATIC
YYSYMBOL_TK_SUBROUTINE	TK_STOP
YYSYMBOL_TK_THEN	TK_SUBROUTINE
YYSYMBOL_TK_TO	TK_THEN
YYSYMBOL_TK_WHILE	TK_TO
YYSYMBOL_TK_WRITE	TK_WHILE
YYSYMBOL_TK_INOUT	TK_WRITE
YYSYMBOL_TK_IN	TK_INOUT
YYSYMBOL_TK_OUT	TK_IN
YYSYMBOL_TK_AND	TK_OUT
YYSYMBOL_TK_EQ	TK_AND
YYSYMBOL_TK_EQV	TK_EQ
YYSYMBOL_TK_GE	TK_EQV
YYSYMBOL_TK_GT	TK_GE
YYSYMBOL_TK_LE	TK_GT
YYSYMBOL_TK_LT	TK_LE
YYSYMBOL_TK_NE	TK_LT
YYSYMBOL_TK_NEQV	TK_NE
YYSYMBOL_TK_NOT	TK_NEQV
YYSYMBOL_TK_OR	TK_NOT
YYSYMBOL_TK_TRUE	TK_OR
YYSYMBOL_TK_FALSE	TK_TRUE
YYSYMBOL_TK_NAME	TK_FALSE
YYSYMBOL_TK_ICON	TK_NAME
YYSYMBOL_TK_SCON	TK_ICON
YYSYMBOL_TK_RCON	TK_SCON
YYSYMBOL_TK_DCON	TK_RCON
YYSYMBOL_TK_MINUS	TK_DCON
YYSYMBOL_TK_PLUS	TK_MINUS
YYSYMBOL_TK_SLASH	TK_PLUS
YYSYMBOL_TK_STAR	TK_SLASH
YYSYMBOL_TK_POWER	TK_STAR
YYSYMBOL_TK_LPAR	TK_POWER
YYSYMBOL_TK_RPAR	TK_LPAR
YYSYMBOL_TK_COMMA	TK_RPAR
YYSYMBOL_TK_COLON	TK_COMMA
YYSYMBOL_TK_EQUALS	TK_COLON
YYSYMBOL_TK_CURRENCY	TK_EQUALS
YYSYMBOL_TK_CONCAT	TK_CURRENCY
YYSYMBOL_TK_EOS	TK_CONCAT
YYSYMBOL_TK_IOLPAR	TK_EOS
YYSYMBOL_YYACCEPT	TK_IOLPAR
YYSYMBOL_lprg_exec	$accept
YYSYMBOL_prg_exec	lprg_exec
YYSYMBOL_98_1	prg_exec
YYSYMBOL_99_2	$@1
YYSYMBOL_100_3	$@2
YYSYMBOL_begin_inst	$@3
YYSYMBOL_entry_inst	begin_inst
YYSYMBOL_end_inst	entry_inst
YYSYMBOL_linstruction	end_inst
YYSYMBOL_instruction	linstruction
YYSYMBOL_106_4	instruction
YYSYMBOL_107_5	$@4
YYSYMBOL_inst_spec	$@5
YYSYMBOL_inst_exec	inst_spec
YYSYMBOL_return_inst	inst_exec
YYSYMBOL_call_inst	return_inst
YYSYMBOL_tk_call	call_inst
YYSYMBOL_parameters	tk_call
YYSYMBOL_arguments	parameters
YYSYMBOL_io_inst	arguments
YYSYMBOL_io_f_u_id	io_inst
YYSYMBOL_lci	io_f_u_id
YYSYMBOL_ci	lci
YYSYMBOL_opt_lio_elem	ci
YYSYMBOL_lio_elem	opt_lio_elem
YYSYMBOL_io_elem	lio_elem
YYSYMBOL_pause_inst	io_elem
YYSYMBOL_stop_inst	pause_inst
YYSYMBOL_continue_inst	stop_inst
YYSYMBOL_do_inst	continue_inst
YYSYMBOL_bdo_inst	do_inst
YYSYMBOL_wdo_inst	bdo_inst
YYSYMBOL_do_plage	wdo_inst
YYSYMBOL_endif_inst	do_plage
YYSYMBOL_enddo_inst	endif_inst
YYSYMBOL_else_inst	enddo_inst
YYSYMBOL_elseif_inst	else_inst
YYSYMBOL_blockif_inst	elseif_inst
YYSYMBOL_logicalif_inst	blockif_inst
YYSYMBOL_arithmif_inst	logicalif_inst
YYSYMBOL_goto_inst	arithmif_inst
YYSYMBOL_licon	goto_inst
YYSYMBOL_assignment_inst	licon
YYSYMBOL_format_inst	assignment_inst
YYSYMBOL_save_inst	format_inst
YYSYMBOL_lsavename	save_inst
YYSYMBOL_savename	lsavename
YYSYMBOL_intrinsic_inst	savename
YYSYMBOL_external_inst	intrinsic_inst
YYSYMBOL_type_inst	external_inst
YYSYMBOL_declaration	type_inst
YYSYMBOL_decl_tableau	declaration
YYSYMBOL_ldim_tableau	decl_tableau
YYSYMBOL_dim_tableau	ldim_tableau
YYSYMBOL_common_inst	dim_tableau
YYSYMBOL_common	common_inst
YYSYMBOL_common_name	common
YYSYMBOL_pointer_inst	common_name
YYSYMBOL_equivalence_inst	pointer_inst
YYSYMBOL_lequivchain	equivalence_inst
YYSYMBOL_equivchain	lequivchain
YYSYMBOL_latom	equivchain
YYSYMBOL_dimension_inst	latom
YYSYMBOL_dimension	dimension_inst
YYSYMBOL_data_inst	dimension
YYSYMBOL_ldatavar	data_inst
YYSYMBOL_ldataval	ldatavar
YYSYMBOL_dataval	ldataval
YYSYMBOL_dataconst	dataval
YYSYMBOL_datavar	dataconst
YYSYMBOL_dataidl	datavar
YYSYMBOL_implicit_inst	dataidl
YYSYMBOL_limplicit	implicit_inst
YYSYMBOL_implicit	limplicit
YYSYMBOL_l_letter_letter	implicit
YYSYMBOL_letter_letter	l_letter_letter
YYSYMBOL_letter	letter_letter
YYSYMBOL_parameter_inst	letter
YYSYMBOL_lparametre	parameter_inst
YYSYMBOL_parametre	lparametre
YYSYMBOL_entity_name	parametre
YYSYMBOL_name	entity_name
YYSYMBOL_module_name	name
YYSYMBOL_global_entity_name	module_name
YYSYMBOL_functional_entity_name	global_entity_name
YYSYMBOL_global_name	functional_entity_name
YYSYMBOL_opt_lformalparameter	global_name
YYSYMBOL_lformalparameter	opt_lformalparameter
YYSYMBOL_opt_fortran_type	lformalparameter
YYSYMBOL_fortran_type	opt_fortran_type
YYSYMBOL_fortran_basic_type	fortran_type
YYSYMBOL_lg_fortran_type	fortran_basic_type
YYSYMBOL_atom	lg_fortran_type
YYSYMBOL_indices	atom
YYSYMBOL_lexpression	indices
YYSYMBOL_opt_expression	lexpression
YYSYMBOL_expression	opt_expression
YYSYMBOL_sous_expression	expression
YYSYMBOL_io_expr	sous_expression
YYSYMBOL_unpar_io_expr	io_expr
YYSYMBOL_const_simple	unpar_io_expr
YYSYMBOL_unsigned_const_simple	const_simple
YYSYMBOL_icon	unsigned_const_simple
YYSYMBOL_label	icon
YYSYMBOL_ival	label
YYSYMBOL_opt_signe	ival
YYSYMBOL_signe	opt_signe
YYSYMBOL_oper_rela	signe
YYSYMBOL_io_keyword	oper_rela
YYSYMBOL_iobuf_keyword	io_keyword
YYSYMBOL_psf_keyword	iobuf_keyword
YYSYMBOL_opt_virgule	psf_keyword
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror	"end of file"
YYSYMBOL_YYUNDEF	error
YYSYMBOL_TK_OPEN	"invalid token"
YYSYMBOL_TK_CREATE	TK_OPEN
YYSYMBOL_TK_CLOSE	TK_CREATE
YYSYMBOL_TK_CHECKPOINT	TK_CLOSE
YYSYMBOL_TK_DELETE	TK_CHECKPOINT
YYSYMBOL_TK_MODULE	TK_DELETE
YYSYMBOL_TK_MAKE	TK_MODULE
YYSYMBOL_TK_APPLY	TK_MAKE
YYSYMBOL_TK_CAPPLY	TK_APPLY
YYSYMBOL_TK_DISPLAY	TK_CAPPLY
YYSYMBOL_TK_REMOVE	TK_DISPLAY
YYSYMBOL_TK_ACTIVATE	TK_REMOVE
YYSYMBOL_TK_SET_PROPERTY	TK_ACTIVATE
YYSYMBOL_TK_GET_PROPERTY	TK_SET_PROPERTY
YYSYMBOL_TK_SET_ENVIRONMENT	TK_GET_PROPERTY
YYSYMBOL_TK_GET_ENVIRONMENT	TK_SET_ENVIRONMENT
YYSYMBOL_TK_UNSET_ENVIRONMENT	TK_GET_ENVIRONMENT
YYSYMBOL_TK_CDIR	TK_UNSET_ENVIRONMENT
YYSYMBOL_TK_INFO	TK_CDIR
YYSYMBOL_TK_PWD	TK_INFO
YYSYMBOL_TK_HELP	TK_PWD
YYSYMBOL_TK_SHOW	TK_HELP
YYSYMBOL_TK_SOURCE	TK_SHOW
YYSYMBOL_TK_SHELL	TK_SOURCE
YYSYMBOL_TK_ECHO	TK_SHELL
YYSYMBOL_TK_UNKNOWN	TK_ECHO
YYSYMBOL_TK_TIMEOUT	TK_UNKNOWN
YYSYMBOL_TK_QUIT	TK_TIMEOUT
YYSYMBOL_TK_EXIT	TK_QUIT
YYSYMBOL_TK_LINE	TK_EXIT
YYSYMBOL_TK_CHECKACTIVE	TK_LINE
YYSYMBOL_TK_VERSION	TK_CHECKACTIVE
YYSYMBOL_TK_TOUCH	TK_VERSION
YYSYMBOL_TK_OWNER_NAME	TK_TOUCH
YYSYMBOL_TK_OWNER_ALL	TK_OWNER_NAME
YYSYMBOL_TK_OWNER_ALLFUNC	TK_OWNER_ALL
YYSYMBOL_TK_OWNER_ALLCU	TK_OWNER_ALLFUNC
YYSYMBOL_TK_OWNER_PROGRAM	TK_OWNER_ALLCU
YYSYMBOL_TK_OWNER_MAIN	TK_OWNER_PROGRAM
YYSYMBOL_TK_OWNER_MODULE	TK_OWNER_MAIN
YYSYMBOL_TK_OWNER_CALLERS	TK_OWNER_MODULE
YYSYMBOL_TK_OWNER_CALLEES	TK_OWNER_CALLERS
YYSYMBOL_TK_OPENPAREN	TK_OWNER_CALLEES
YYSYMBOL_TK_COMMA	TK_OPENPAREN
YYSYMBOL_TK_CLOSEPAREN	TK_COMMA
YYSYMBOL_TK_EQUAL	TK_CLOSEPAREN
YYSYMBOL_TK_NAME	TK_EQUAL
YYSYMBOL_TK_A_STRING	TK_NAME
YYSYMBOL_TK_ENDOFLINE	TK_A_STRING
YYSYMBOL_TK_INT	TK_ENDOFLINE
YYSYMBOL_YYACCEPT	TK_INT
YYSYMBOL_commands	$accept
YYSYMBOL_command	commands
YYSYMBOL_i_quit	command
YYSYMBOL_i_exit	i_quit
YYSYMBOL_i_version	i_exit
YYSYMBOL_i_help	i_version
YYSYMBOL_i_setprop	i_help
YYSYMBOL_i_shell	i_setprop
YYSYMBOL_i_unknown	i_shell
YYSYMBOL_i_echo	i_unknown
YYSYMBOL_i_info	i_echo
YYSYMBOL_i_cd	i_info
YYSYMBOL_i_pwd	i_cd
YYSYMBOL_i_getenv	i_pwd
YYSYMBOL_i_setenv	i_getenv
YYSYMBOL_i_unsetenv	i_setenv
YYSYMBOL_i_timeout	i_unsetenv
YYSYMBOL_i_checkpoint	i_timeout
YYSYMBOL_i_open	i_checkpoint
YYSYMBOL_workspace_name	i_open
YYSYMBOL_i_create	workspace_name
YYSYMBOL_i_close	i_create
YYSYMBOL_i_delete	i_close
YYSYMBOL_i_module	i_delete
YYSYMBOL_i_make	i_module
YYSYMBOL_i_apply	i_make
YYSYMBOL_i_capply	i_apply
YYSYMBOL_i_display	i_capply
YYSYMBOL_i_touch	i_display
YYSYMBOL_i_show	i_touch
YYSYMBOL_i_rm	i_show
YYSYMBOL_i_activate	i_rm
YYSYMBOL_i_checkactive	i_activate
YYSYMBOL_i_get	i_checkactive
YYSYMBOL_i_source	i_get
YYSYMBOL_rulename	i_source
YYSYMBOL_filename_list	rulename
YYSYMBOL_filename	filename_list
YYSYMBOL_resource_id	filename
YYSYMBOL_rule_id	resource_id
YYSYMBOL_owner	rule_id
YYSYMBOL_list_of_owner_name	owner
YYSYMBOL_propname	list_of_owner_name
YYSYMBOL_phasename	propname
YYSYMBOL_resourcename	phasename

Definition at line 136 of file step_bison_parser.c.

{
  YYSYMBOL_YYEMPTY = -2,
  YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
  YYSYMBOL_YYerror = 1,                    /* error  */
  YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
  YYSYMBOL_TK_EOL = 3,                     /* TK_EOL  */
  YYSYMBOL_TK_ERROR = 4,                   /* TK_ERROR  */
  YYSYMBOL_TK_LPAREN = 5,                  /* TK_LPAREN  */
  YYSYMBOL_TK_RPAREN = 6,                  /* TK_RPAREN  */
  YYSYMBOL_TK_COLON = 7,                   /* TK_COLON  */
  YYSYMBOL_TK_COMMA = 8,                   /* TK_COMMA  */
  YYSYMBOL_TK_IDENT = 9,                   /* TK_IDENT  */
  YYSYMBOL_TK_COMMENT = 10,                /* TK_COMMENT  */
  YYSYMBOL_TK_OPERATOR = 11,               /* TK_OPERATOR  */
  YYSYMBOL_TK_RAW = 12,                    /* TK_RAW  */
  YYSYMBOL_TK_OMP_PRAGMA = 13,             /* TK_OMP_PRAGMA  */
  YYSYMBOL_TK_OMP_PARALLEL = 14,           /* TK_OMP_PARALLEL  */
  YYSYMBOL_TK_OMP_LOOP = 15,               /* TK_OMP_LOOP  */
  YYSYMBOL_TK_OMP_END = 16,                /* TK_OMP_END  */
  YYSYMBOL_TK_OMP_BARRIER = 17,            /* TK_OMP_BARRIER  */
  YYSYMBOL_TK_OMP_MASTER = 18,             /* TK_OMP_MASTER  */
  YYSYMBOL_TK_OMP_SINGLE = 19,             /* TK_OMP_SINGLE  */
  YYSYMBOL_TK_OMP_THREADPRIVATE = 20,      /* TK_OMP_THREADPRIVATE  */
  YYSYMBOL_TK_OMP_SHARED = 21,             /* TK_OMP_SHARED  */
  YYSYMBOL_TK_OMP_PRIVATE = 22,            /* TK_OMP_PRIVATE  */
  YYSYMBOL_TK_OMP_NOWAIT = 23,             /* TK_OMP_NOWAIT  */
  YYSYMBOL_TK_OMP_REDUCTION = 24,          /* TK_OMP_REDUCTION  */
  YYSYMBOL_TK_OMP_DEFAULT = 25,            /* TK_OMP_DEFAULT  */
  YYSYMBOL_TK_OMP_COPYIN = 26,             /* TK_OMP_COPYIN  */
  YYSYMBOL_TK_OMP_FIRSTPRIVATE = 27,       /* TK_OMP_FIRSTPRIVATE  */
  YYSYMBOL_TK_OMP_SCHEDULE = 28,           /* TK_OMP_SCHEDULE  */
  YYSYMBOL_TK_STEP_PRAGMA = 29,            /* TK_STEP_PRAGMA  */
  YYSYMBOL_TK_STEP_TRANSFORMATION = 30,    /* TK_STEP_TRANSFORMATION  */
  YYSYMBOL_YYACCEPT = 31,                  /* $accept  */
  YYSYMBOL_pragma = 32,                    /* pragma  */
  YYSYMBOL_33_1 = 33,                      /* $@1  */
  YYSYMBOL_34_2 = 34,                      /* $@2  */
  YYSYMBOL_step_transformation = 35,       /* step_transformation  */
  YYSYMBOL_omp_comment = 36,               /* omp_comment  */
  YYSYMBOL_omp_directive = 37,             /* omp_directive  */
  YYSYMBOL_38_3 = 38,                      /* @3  */
  YYSYMBOL_39_4 = 39,                      /* @4  */
  YYSYMBOL_40_5 = 40,                      /* @5  */
  YYSYMBOL_41_6 = 41,                      /* @6  */
  YYSYMBOL_omp_parallel_clauses = 42,      /* omp_parallel_clauses  */
  YYSYMBOL_omp_loop_clauses = 43,          /* omp_loop_clauses  */
  YYSYMBOL_omp_end_loop_clauses = 44,      /* omp_end_loop_clauses  */
  YYSYMBOL_omp_parallel_loop_clauses = 45, /* omp_parallel_loop_clauses  */
  YYSYMBOL_omp_shared = 46,                /* omp_shared  */
  YYSYMBOL_47_7 = 47,                      /* $@7  */
  YYSYMBOL_omp_private = 48,               /* omp_private  */
  YYSYMBOL_49_8 = 49,                      /* $@8  */
  YYSYMBOL_omp_copyin = 50,                /* omp_copyin  */
  YYSYMBOL_51_9 = 51,                      /* $@9  */
  YYSYMBOL_omp_threadprivate_listvar = 52, /* omp_threadprivate_listvar  */
  YYSYMBOL_53_10 = 53,                     /* $@10  */
  YYSYMBOL_omp_firstprivate = 54,          /* omp_firstprivate  */
  YYSYMBOL_55_11 = 55,                     /* $@11  */
  YYSYMBOL_omp_schedule = 56,              /* omp_schedule  */
  YYSYMBOL_57_12 = 57,                     /* $@12  */
  YYSYMBOL_omp_reduction = 58,             /* omp_reduction  */
  YYSYMBOL_59_13 = 59,                     /* $@13  */
  YYSYMBOL_60_14 = 60,                     /* $@14  */
  YYSYMBOL_omp_default = 61,               /* omp_default  */
  YYSYMBOL_62_15 = 62,                     /* $@15  */
  YYSYMBOL_string_list = 63,               /* string_list  */
  YYSYMBOL_ident_list = 64                 /* ident_list  */
};

Function Documentation

begin_omp_construct()

step_directive begin_omp_construct	(	int	type,
		string	s
	)

In C, these OpenMP pragmas are already supported by blocks: no block conversion needed

Definition at line 159 of file parser.c.

{
  statement directive_stmt;
 
  pips_debug(1,"begin type = %d, str = %s\n", type, s);
 
  directive_stmt = current_statement;
 
  if(fortran_module_p(get_current_module_entity()))
    {
      switch(type)
        {
        case STEP_DO:
        case STEP_PARALLEL_DO:
          pips_assert("loop statement", statement_loop_p(directive_stmt)||statement_forloop_p(directive_stmt));
          insert_optional_pragma(type);
          _FALLTHROUGH_; // is that so?
        case STEP_PARALLEL:
        case STEP_MASTER:
        case STEP_SINGLE:
        case STEP_BARRIER:
          directive_stmt = make_empty_block_statement();
          break;
        case STEP_THREADPRIVATE:
          directive_stmt = make_empty_block_statement();
          break;
        default:
          pips_user_error("unknown directive type %d\n", type);
          break;
        }
    }
  else if (c_module_p(get_current_module_entity()))
    {
      switch(type)
        {
        case STEP_DO:
        case STEP_PARALLEL_DO:
          {
            statement new_stmt;
            pips_assert("loop statement", statement_loop_p(directive_stmt)||statement_forloop_p(directive_stmt));
            pips_debug(2,"Block conversion (C)\n");
 
            new_stmt = instruction_to_statement(statement_instruction(directive_stmt));
 
            move_statement_attributes(directive_stmt, new_stmt);
            statement_label(directive_stmt) = entity_empty_label();
            statement_comments(directive_stmt) = empty_comments;
            statement_declarations(directive_stmt) = NIL;
            statement_decls_text(directive_stmt) = NULL;
            statement_extensions(directive_stmt) = empty_extensions();
            statement_instruction(directive_stmt) = make_instruction_block(CONS(STATEMENT, new_stmt, NIL));
          }
        case STEP_PARALLEL:
        case STEP_MASTER:
        case STEP_SINGLE:
          /* In C, these OpenMP pragmas are already supported by blocks: no block conversion needed */
          break;
        case STEP_BARRIER:
          directive_stmt = make_empty_block_statement();
          break;
        case STEP_THREADPRIVATE:
          directive_stmt = make_empty_block_statement();
          break;
        default:
          pips_user_error("unknown directive type %d\n", type);
          break;
        }
    }
  else
    pips_user_error("language not supported");
 
  step_directive drt = new_step_directive(directive_stmt, type, s);
 
  if(fortran_module_p(get_current_module_entity()))
    {
      step_blocks_push(statement_sequence(directive_stmt));
    }
 
  pips_debug(1,"end drt = %p\n", drt);
  return drt;
}

References _FALLTHROUGH_, c_module_p(), CONS, current_statement, empty_comments, empty_extensions(), entity_empty_label(), fortran_module_p(), get_current_module_entity(), insert_optional_pragma(), instruction_to_statement(), make_empty_block_statement(), make_instruction_block(), move_statement_attributes(), new_step_directive(), NIL, pips_assert, pips_debug, pips_user_error, STATEMENT, statement_comments, statement_declarations, statement_decls_text, statement_extensions, statement_forloop_p(), statement_instruction, statement_label, statement_loop_p(), statement_sequence(), STEP_BARRIER, STEP_DO, STEP_MASTER, STEP_PARALLEL, STEP_PARALLEL_DO, STEP_SINGLE, and STEP_THREADPRIVATE.

Here is the call graph for this function:

concat_drt_clauses()

static step_directive concat_drt_clauses ( step_directive  drt, cons *  liste_clauses  )

static

Definition at line 1893 of file step_bison_parser.c.

{
  pips_debug(2, "begin\n");
  step_directive_clauses(drt)= gen_nconc(liste_clauses, step_directive_clauses(drt));
  pips_debug(2, "end\n");
  return drt;
}

References gen_nconc(), pips_debug, and step_directive_clauses.

Here is the call graph for this function:

end_omp_construct()

step_directive end_omp_construct

(

int

type

)

suppression du CONTINUE portant le pragma optionnel dans le futur block

Definition at line 248 of file parser.c.

{
  step_directive drt;
 
  pips_debug(1,"begin type = %d\n", type);
 
  drt = step_directive_undefined;
  if(fortran_module_p(get_current_module_entity()))
    {
      switch(type)
        {
        case STEP_DO:
        case STEP_PARALLEL_DO:
          {
            sequence current_block;
            statement last_stmt;
 
 
            current_block = step_blocks_head();
            last_stmt = STATEMENT(CAR(sequence_statements(current_block)));
            /* suppression du CONTINUE portant le pragma optionnel dans le futur block */
            while (empty_statement_or_labelless_continue_p(last_stmt))
              {
                pips_debug(2,"POP current_block");
                POP(sequence_statements(current_block));
                last_stmt = STATEMENT(CAR(sequence_statements(current_block)));
              }
            if(step_directives_bound_p(last_stmt))
              {
                drt = step_directives_load(last_stmt);
                if (step_directive_type(drt) != type)
                  pips_user_error("\nDirective end-loop not well formed\n");
                else
                  pips_debug(2,"loop directive already closed\n");
              }
            else if (!statement_loop_p(last_stmt))
              pips_user_error("\nDirective end-loop after a no-loop statement\n");
          }
        default:
          break;
        }
 
      if(step_directive_undefined_p(drt))
        {
          drt = get_current_step_directive(true);
          
          if (step_directive_undefined_p(drt) || step_directive_type(drt) != type)
            pips_user_error("\nDirective not well formed\n");
          
          int size = step_blocks_size();
          sequence new_seq = step_blocks_pop();
          pips_debug(2,"pop block directive\n");
          pips_debug(2, "block_stack size :%d\t new_seq_length=%d\n", size, (int)gen_length(sequence_statements(new_seq)));
          
          statement directive_stmt = step_directive_block(drt);
          sequence_statements(statement_sequence(directive_stmt)) = gen_nreverse(statement_block(directive_stmt));
        }
    }
 
  pips_debug(1, "end drt = %p\n", drt);
  return drt;
}

References CAR, empty_statement_or_labelless_continue_p(), fortran_module_p(), gen_length(), gen_nreverse(), get_current_module_entity(), get_current_step_directive(), pips_debug, pips_user_error, POP, sequence_statements, STATEMENT, statement_block(), statement_loop_p(), statement_sequence(), step_directive_block, step_directive_type, step_directive_undefined, step_directive_undefined_p, step_directives_bound_p(), step_directives_load(), STEP_DO, and STEP_PARALLEL_DO.

Here is the call graph for this function:

entity_from_user_name()

entity entity_from_user_name

(

string

name

)

passage de name a NAME

determiner le nom avec le bon scope...

Parameters

name

ame

Definition at line 67 of file parser.c.

{
  entity e = entity_undefined;
  
  pips_debug(1, "begin\n");
 
  if(fortran_module_p(get_current_module_entity()))
    {
      /* passage de name a NAME */
      size_t i;
      for (i=0; i<strlen(name); i++)
        name[i]=toupper(name[i]);
 
      string full_name = strdup(concatenate(entity_user_name(get_current_module_entity()), MODULE_SEP_STRING, name, NULL));
      e = gen_find_tabulated(full_name, entity_domain);
      if (entity_undefined_p(e))
        pips_user_error("\nFortran entity \"%s\" not found\n", full_name);
      free(full_name);
    }
  else if (c_module_p(get_current_module_entity()))
    {
      /* determiner le nom avec le bon scope... */
      statement stmt_declaration = current_statement;
      pips_debug(4,"##### ENTITY DECL #####\n");
      while (entity_undefined_p(e) && stmt_declaration)
        {
          FOREACH(entity, ee, statement_declarations(stmt_declaration))
            {
              pips_debug(4, "entity decl : \"%s\"\n", entity_name(ee));
              if (strcmp(name, entity_user_name(ee)) == 0)
                {
                  e = ee;
                  break;
                }
            }
          stmt_declaration = (statement)gen_get_ancestor(statement_domain, stmt_declaration);
        }
 
      if (entity_undefined_p(e))
        {
          FOREACH(entity, ee, code_declarations(entity_code(get_current_module_entity())))
            {
              pips_debug(4, "entity decl : \"%s\"\n", entity_name(ee));
              if (strcmp(name, entity_user_name(ee)) == 0)
                {
                  e = ee;
                  break;
                }
            }
        }
      if (entity_undefined_p(e))
        {
          string cu = compilation_unit_of_module(get_current_module_name());
          string full_name = strdup(concatenate(cu, MODULE_SEP_STRING, name, NULL));
          e = gen_find_tabulated(full_name, entity_domain);
          free(full_name);
        }
     if (entity_undefined_p(e))
        {
          string full_name = strdup(concatenate(TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING, name, NULL));
          e = gen_find_tabulated(full_name, entity_domain);
          free(full_name);
        }
 
      if (entity_undefined_p(e))
        pips_user_error("\nC Entity \"%s\" not found\n", name);
    }
 
  pips_debug(1, "end\n");;
  return e;
}

References c_module_p(), code_declarations, compilation_unit_of_module(), concatenate(), current_statement, entity_code(), entity_domain, entity_name, entity_undefined, entity_undefined_p, entity_user_name(), FOREACH, fortran_module_p(), free(), full_name, gen_find_tabulated(), gen_get_ancestor(), get_current_module_entity(), get_current_module_name(), MODULE_SEP_STRING, pips_debug, pips_user_error, statement_declarations, statement_domain, strdup(), and TOP_LEVEL_MODULE_NAME.

Referenced by step_add_to_ident_list().

Here is the call graph for this function:

Here is the caller graph for this function:

free()

void free

(

void *

)

Referenced by step_bison_parse().

Here is the caller graph for this function:

malloc()

void* malloc

(

YYSIZE_T

)

remove_old_pragma()

void remove_old_pragma

(

void

)

Definition at line 139 of file parser.c.

{
  pips_assert("statement defined", !statement_undefined_p(current_statement));
  pips_assert("pragma defined", !pragma_undefined_p(current_pragma));
 
  extensions es = statement_extensions(current_statement);
 
  list el = extensions_extension(es);
 
  extensions_extension(es) = NIL;
  FOREACH(EXTENSION, e, el)
    {
      pragma p=extension_pragma(e);
      if (p != current_pragma)
        extensions_extension(es) = gen_extension_cons(e, extensions_extension(es));
    }
 
  extensions_extension(es) = gen_nreverse(extensions_extension(es));
}

References current_pragma, current_statement, EXTENSION, extension_pragma, extensions_extension, FOREACH, gen_extension_cons(), gen_nreverse(), NIL, pips_assert, pragma_undefined_p, statement_extensions, and statement_undefined_p.

Here is the call graph for this function:

set_current_transform()

void set_current_transform

(

int

transform

)

First part of user prologue.

First part of user prologue.

parser.c

Parameters

transform

ransform

Definition at line 41 of file parser.c.

{
  current_transform = transform;
}

References current_transform.

step_add_to_ident_list()

static cons * step_add_to_ident_list ( string  name, cons *  list  )

static

Definition at line 1869 of file step_bison_parser.c.

{
  pips_debug(2, "begin\n");
  entity e = entity_from_user_name(name);
  pips_assert("entity", !entity_undefined_p(e));
  pips_debug(2, "end\n");
  return CONS(ENTITY, e, list);
}

References CONS, ENTITY, entity_from_user_name(), entity_undefined_p, pips_assert, and pips_debug.

Here is the call graph for this function:

step_bison_parse()

void step_bison_parse	(	pragma	pgm,
		statement	stmt
	)

Parameters

pgm	gm
stmt	tmt

Definition at line 1901 of file step_bison_parser.c.

{
  string pragma_str = pragma_string(pgm);
 
  if(pragma_str[strlen(pragma_str)-1]!= '\n')
    pragma_str = strdup(concatenate(pragma_string(pgm),"\n",NULL));
  else
    pragma_str = strdup(pragma_string(pgm));
 
  pips_debug(1, "############### PARSER BEGIN ################\nwith :\n%s\non stmt : %p\n", pragma_str, stmt);
  ifdebug(4)
    yydebug=1;
  pragma_str_original = strdup(pragma_str);
  step_lexer_scan_string(pragma_str);
  step_lexerparse();
  free(pragma_str_original);
  pips_debug(1, "############### PARSER END ################\n");
 
  free(pragma_str);
}

References concatenate(), free(), ifdebug, pips_debug, pragma_str_original, pragma_string, step_lexerparse(), strdup(), and yydebug.

Referenced by step_pragma_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

step_handle_reduction_clause()

static step_clause step_handle_reduction_clause ( cons *  ident_liste, int  op  )

static

Definition at line 1878 of file step_bison_parser.c.

{
  pips_debug(2, "begin\n");
  map_entity_int reductions = make_map_entity_int();
  FOREACH(ENTITY, e, ident_liste)
    {
      pips_assert("first reduction", !bound_map_entity_int_p(reductions, e));
      pips_debug(2,"add reduction %d variable : %s)\n", op, entity_name(e));
      extend_map_entity_int(reductions, e, op);
    }
  gen_free_list(ident_liste);
  pips_debug(2, "end\n");
  return make_step_clause_reduction(reductions);
}

References bound_map_entity_int_p(), ENTITY, entity_name, extend_map_entity_int(), FOREACH, gen_free_list(), make_map_entity_int(), make_step_clause_reduction(), pips_assert, and pips_debug.

Here is the call graph for this function:

step_lexererror()

void step_lexererror

(

const char *

s

)

step_bison_parser.c

Definition at line 105 of file step_bison_parser.c.

{
  pips_user_error("\nParsing :\n%s\n%s at '%s'\n", pragma_str_original, s, step_lexertext);
}

References pips_user_error, pragma_str_original, and step_lexertext.

yy_reduce_print()

static void yy_reduce_print ( yy_state_t *  yyssp, YYSTYPE *  yyvsp, int  yyrule  )

static

--------------------------------------------—.

| Report that the YYRULE is going to be reduced. | `---------------------------------------------—

The symbols being reduced.

Definition at line 900 of file step_bison_parser.c.

{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
                       &yyvsp[(yyi + 1) - (yynrhs)]);
      YYFPRINTF (stderr, "\n");
    }
}

References YY_ACCESSING_SYMBOL, yy_symbol_print(), YYFPRINTF, yyr2, and yyrline.

Here is the call graph for this function:

yy_stack_print()

static void yy_stack_print ( yy_state_t *  yybottom, yy_state_t *  yytop  )

static

--------------------------------------------------------------—.

| yy_stack_print – Print the state stack from its BOTTOM up to its | | TOP (included). | `---------------------------------------------------------------—

Definition at line 877 of file step_bison_parser.c.

{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

References YYFPRINTF.

yy_symbol_print()

static void yy_symbol_print ( FILE *  yyo, yysymbol_kind_t  yykind, YYSTYPE const *const  yyvaluep  )

static

-----------------------—.

| Print this symbol on YYO. | `------------------------—

Definition at line 861 of file step_bison_parser.c.

{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
 
  yy_symbol_value_print (yyo, yykind, yyvaluep);
  YYFPRINTF (yyo, ")");
}

References yy_symbol_value_print(), YYFPRINTF, YYNTOKENS, and yysymbol_name().

Referenced by yy_reduce_print().

Here is the call graph for this function:

Here is the caller graph for this function:

yy_symbol_value_print()

static void yy_symbol_value_print ( FILE *  yyo, yysymbol_kind_t  yykind, YYSTYPE const *const  yyvaluep  )

static

-------------------------------—.

| Print this symbol's value on YYO. | `--------------------------------—

Definition at line 843 of file step_bison_parser.c.

{
  FILE *yyoutput = yyo;
  YY_USE (yyoutput);
  if (!yyvaluep)
    return;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YY_USE (yykind);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}

References YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN, YY_IGNORE_MAYBE_UNINITIALIZED_END, and YY_USE.

Referenced by yy_symbol_print().

Here is the caller graph for this function:

yydestruct()

static void yydestruct ( const char *  yymsg, yysymbol_kind_t  yykind, YYSTYPE *  yyvaluep  )

static

-------------------------------------------—.

| Release the memory associated to this symbol. | `--------------------------------------------—

Definition at line 962 of file step_bison_parser.c.

{
  YY_USE (yyvaluep);
  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
 
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YY_USE (yykind);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}

References YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN, YY_IGNORE_MAYBE_UNINITIALIZED_END, YY_SYMBOL_PRINT, and YY_USE.

yysymbol_name()

static const char * yysymbol_name ( yysymbol_kind_t  yysymbol )

static

The user-facing name of the symbol whose (internal) number is YYSYMBOL.

No bounds checking.

Definition at line 632 of file step_bison_parser.c.

{
  return yytname[yysymbol];
}

References yytname.

Referenced by yy_symbol_print().

Here is the caller graph for this function:

Variable Documentation

pragma_str_original

string pragma_str_original =NULL

static

Definition at line 103 of file step_bison_parser.c.

Referenced by step_bison_parse(), and step_lexererror().

yychar

int yychar

Lookahead token kind.

Definition at line 977 of file step_bison_parser.c.

yycheck

const yytype_int8 yycheck[]

static

Initial value:

=
{
      75,    76,    12,    13,    79,    80,    30,    30,    30,     6,
       6,     8,     8,     0,    38,    38,    38,    21,    22,    29,
      24,    25,    26,    27,    28,     3,   101,     3,    30,    15,
      10,     6,    10,     8,    10,    14,    15,    16,    17,    18,
      19,    20,     3,    15,    21,    22,     3,    24,    25,    26,
      27,    22,    23,    24,     5,     9,    27,    28,    22,    23,
      24,    14,    15,    27,    28,    18,    19,     6,     6,     8,
       8,     6,     6,     8,     8,     5,     5,     5,     5,     5,
       5,     5,    22,    38,    -1,     6,    38,     9,    11,     9,
       9,     7,     9,    38,    38
}

Definition at line 718 of file step_bison_parser.c.

yydebug

int yydebug

Nonzero means print parse trace.

It is left uninitialized so that multiple parsers can coexist.

Definition at line 927 of file step_bison_parser.c.

yydefact

const yytype_int8 yydefact[]

static

Initial value:

=
{
       0,     2,     3,     5,     0,     0,     0,     1,    10,    12,
       0,    18,    16,    17,    19,     8,     7,     0,    14,    26,
      33,    21,    33,    24,    25,    55,     9,     0,     6,    41,
      11,    13,    23,     0,    22,    20,     0,     4,    15,    49,
      51,    61,    64,    53,    57,    27,    28,    29,    30,    31,
      32,    38,    59,    34,    35,    37,    36,    38,     0,    42,
      43,    44,    45,    47,    46,    48,     0,     0,     0,     0,
       0,     0,     0,    68,     0,     0,     0,     0,     0,     0,
       0,     0,    56,     0,     0,     0,    62,     0,     0,     0,
      66,     0,    69,    50,    52,     0,    65,    54,    58,    60,
       0,     0,    67,     0,    63
}

YYDEFACT[STATE-NUM] – Default reduction number in state STATE-NUM.

Performed when YYTABLE does not specify something else to do. Zero means the default is an error.

Definition at line 668 of file step_bison_parser.c.

yydefgoto

const yytype_int8 yydefgoto[]

static

Initial value:

=
{
       0,     4,     5,     6,    17,    27,    15,    19,    20,    29,
      25,    30,    31,    34,    38,    45,    66,    53,    67,    47,
      70,    35,    36,    54,    71,    55,    72,    56,    68,    95,
      50,    69,    91,    74
}

YYDEFGOTO[NTERM-NUM].

Definition at line 693 of file step_bison_parser.c.

yylval

YYSTYPE yylval

The semantic value of the lookahead symbol.

Definition at line 980 of file step_bison_parser.c.

yynerrs

int yynerrs

Number of syntax errors so far.

Definition at line 982 of file step_bison_parser.c.

yypact

const yytype_int8 yypact[]

static

Initial value:

=
{
     -10,   -76,   -76,   -76,    13,    21,    -2,   -76,    14,   -76,
      47,   -76,   -76,   -76,   -76,    20,   -76,    39,   -76,   -76,
     -76,    28,    22,   -76,   -76,   -76,   -76,    43,   -76,   -76,
      23,    29,   -76,    36,   -76,   -76,    49,   -76,    -4,   -76,
     -76,   -76,   -76,   -76,   -76,   -76,   -76,   -76,   -76,   -76,
     -76,   -76,   -76,   -76,   -76,   -76,   -76,    24,    46,   -76,
     -76,   -76,   -76,   -76,   -76,   -76,    70,    71,    72,    73,
      74,    75,    76,   -76,     3,    46,    46,    77,    78,    46,
      46,    80,   -76,    81,     4,    25,   -76,    79,    61,    62,
     -76,    65,   -76,   -76,   -76,    84,   -76,   -76,   -76,   -76,
      83,    46,   -76,    66,   -76
}

YYPACT[STATE-NUM] – Index in YYTABLE of the portion describing STATE-NUM.

Definition at line 650 of file step_bison_parser.c.

yypgoto

const yytype_int8 yypgoto[]

static

Initial value:

=
{
     -76,   -76,   -76,   -76,   -76,   -76,   -76,   -76,   -76,   -76,
     -76,   -76,    60,   -76,   -76,    45,   -76,   -24,   -76,    48,
     -76,   -76,   -76,   -23,   -76,    55,   -76,   -22,   -76,   -76,
      56,   -76,   -76,   -75
}

YYPGOTO[NTERM-NUM].

Definition at line 684 of file step_bison_parser.c.

yyr1

const yytype_int8 yyr1[]

static

Initial value:

=
{
       0,    31,    32,    33,    32,    34,    32,    35,    36,    36,
      38,    37,    39,    37,    40,    37,    37,    37,    37,    41,
      37,    37,    37,    37,    37,    37,    42,    42,    42,    42,
      42,    42,    42,    43,    43,    43,    43,    43,    43,    44,
      44,    45,    45,    45,    45,    45,    45,    45,    45,    47,
      46,    49,    48,    51,    50,    53,    52,    55,    54,    57,
      56,    59,    60,    58,    62,    61,    63,    63,    64,    64
}

YYR1[RULE-NUM] – Symbol kind of the left-hand side of rule RULE-NUM.

Definition at line 750 of file step_bison_parser.c.

yyr2

const yytype_int8 yyr2[]

static

Initial value:

=
{
       0,     2,     1,     0,     5,     0,     4,     1,     0,     1,
       0,     3,     0,     3,     0,     4,     1,     1,     1,     0,
       3,     2,     3,     3,     2,     2,     0,     2,     2,     2,
       2,     2,     2,     0,     2,     2,     2,     2,     2,     0,
       2,     0,     2,     2,     2,     2,     2,     2,     2,     0,
       5,     0,     5,     0,     5,     0,     4,     0,     5,     0,
       5,     0,     0,     8,     0,     5,     1,     3,     1,     3
}

YYR2[RULE-NUM] – Number of symbols on the right-hand side of rule RULE-NUM.

Definition at line 762 of file step_bison_parser.c.

Referenced by yy_reduce_print().

yyrline

const yytype_int16 yyrline[]

static

Initial value:

=
{
       0,    72,    72,    75,    74,    80,    79,    86,    89,    90,
      95,    94,    99,    98,   103,   102,   106,   108,   110,   115,
     114,   119,   121,   123,   125,   127,   131,   132,   135,   138,
     141,   144,   147,   153,   154,   157,   160,   163,   166,   171,
     172,   176,   177,   180,   183,   186,   189,   192,   195,   200,
     200,   207,   206,   215,   214,   222,   222,   230,   229,   238,
     237,   246,   248,   245,   256,   255,   262,   266,   273,   277
}

YYRLINE[YYN] – Source line where rule number YYN was defined.

Definition at line 590 of file step_bison_parser.c.

Referenced by yy_reduce_print().

yystos

const yytype_int8 yystos[]

static

Initial value:

=
{
       0,    12,    13,    29,    32,    33,    34,     0,    14,    15,
      16,    17,    18,    19,    20,    37,    30,    35,    15,    38,
      39,    14,    15,    18,    19,    41,    10,    36,     3,    40,
      42,    43,    15,    43,    44,    52,    53,     3,    45,    21,
      22,    24,    25,    26,    27,    46,    48,    50,    54,    58,
      61,    23,    28,    48,    54,    56,    58,    23,     5,    46,
      48,    50,    54,    56,    58,    61,    47,    49,    59,    62,
      51,    55,    57,     9,    64,     5,     5,     5,     5,     5,
       5,     5,     6,     8,    64,    64,    11,     9,    64,    64,
       9,    63,     9,     6,     6,    60,     6,     6,     6,     6,
       8,     7,     9,    64,     6
}

YYSTOS[STATE-NUM] – The symbol kind of the accessing symbol of state STATE-NUM.

Definition at line 734 of file step_bison_parser.c.

yytable

const yytype_int8 yytable[]

static

Initial value:

=
{
      84,    85,     1,     2,    88,    89,    46,    48,    49,    82,
      93,    83,    83,     7,    60,    62,    64,    39,    40,     3,
      41,    42,    43,    44,    52,   -39,   103,   -40,    16,    18,
      26,    94,   -39,    83,   -40,     8,     9,    10,    11,    12,
      13,    14,    28,    32,    39,    40,    37,    41,    42,    43,
      44,    40,    51,    41,    58,    73,    44,    52,    40,    57,
      41,    21,    22,    44,    52,    23,    24,    97,    98,    83,
      83,    99,   104,   100,    83,    75,    76,    77,    78,    79,
      80,    81,    33,    59,     0,    96,    61,    87,    86,    90,
      92,   101,   102,    63,    65
}

YYTABLE[YYPACT[STATE-NUM]] – What to do in state STATE-NUM.

If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error.

Definition at line 704 of file step_bison_parser.c.

yytname

const char* const yytname[]

static

Initial value:

=
{
  "\"end of file\"", "error", "\"invalid token\"", "TK_EOL", "TK_ERROR",
  "TK_LPAREN", "TK_RPAREN", "TK_COLON", "TK_COMMA", "TK_IDENT",
  "TK_COMMENT", "TK_OPERATOR", "TK_RAW", "TK_OMP_PRAGMA",
  "TK_OMP_PARALLEL", "TK_OMP_LOOP", "TK_OMP_END", "TK_OMP_BARRIER",
  "TK_OMP_MASTER", "TK_OMP_SINGLE", "TK_OMP_THREADPRIVATE",
  "TK_OMP_SHARED", "TK_OMP_PRIVATE", "TK_OMP_NOWAIT", "TK_OMP_REDUCTION",
  "TK_OMP_DEFAULT", "TK_OMP_COPYIN", "TK_OMP_FIRSTPRIVATE",
  "TK_OMP_SCHEDULE", "TK_STEP_PRAGMA", "TK_STEP_TRANSFORMATION", "$accept",
  "pragma", "$@1", "$@2", "step_transformation", "omp_comment",
  "omp_directive", "@3", "@4", "@5", "@6", "omp_parallel_clauses",
  "omp_loop_clauses", "omp_end_loop_clauses", "omp_parallel_loop_clauses",
  "omp_shared", "$@7", "omp_private", "$@8", "omp_copyin", "$@9",
  "omp_threadprivate_listvar", "$@10", "omp_firstprivate", "$@11",
  "omp_schedule", "$@12", "omp_reduction", "$@13", "$@14", "omp_default",
  "$@15", "string_list", "ident_list", YY_NULLPTR
}

YYTNAME[SYMBOL-NUM] – String name of the symbol SYMBOL-NUM.

First, the terminals, then, starting at YYNTOKENS, nonterminals.

Definition at line 612 of file step_bison_parser.c.

Referenced by yysymbol_name().

yytranslate

const yytype_int8 yytranslate[]

static

YYTRANSLATE[TOKEN-NUM] – Symbol number corresponding to TOKEN-NUM as returned by yylex.

Definition at line 555 of file step_bison_parser.c.