PIPS
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
cyacc.tab.c File Reference
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "text-util.h"
#include "misc.h"
#include "properties.h"
#include "c_parser_private.h"
#include "c_syntax.h"
#include "cyacc.tab.h"
#include <limits.h>
+ Include dependency graph for cyacc.tab.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)   c_parse
 ------—. More...
 
#define yylex   c_lex
 
#define yyerror   c_error
 
#define yydebug   c_debug
 
#define yynerrs   c_nerrs
 
#define yylval   c_lval
 
#define yychar   c_char
 
#define C_ERROR_VERBOSE   1 /**much clearer error messages with bison */
 First part of user prologue. More...
 
#define YYMAXDEPTH   1000000
 Increase the parser stack to have SPEC2006/445.gobmk/owl_defendpat.c going through without a: More...
 
#define BREAKPOINT   ;
 
#define SCOPE_UNDEFINED   (-1)
 Each scope in the current unit has its own number. More...
 
#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   3204
 YYLAST – Last index in YYTABLE. More...
 
#define YYNTOKENS   119
 YYNTOKENS – Number of terminals. More...
 
#define YYNNTS   110
 YYNNTS – Number of nonterminals. More...
 
#define YYNRULES   324
 YYNRULES – Number of rules. More...
 
#define YYNSTATES   597
 YYNSTATES – Number of states. More...
 
#define YYMAXUTOK   373
 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   (-445)
 
#define yypact_value_is_default(Yyn)    ((Yyn) == YYPACT_NINF)
 
#define YYTABLE_NINF   (-299)
 
#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 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_int16 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

static void add_initialization_expression (int init_p)
 init_p = 0 => no initialization for a variable or no definition for a derived entity (struct, union, maybe enum) More...
 
static void PushFunction (entity f)
 The following structures must be stacks because all the related entities are in recursive structures. More...
 
static void PopFunction ()
 
entity GetFunction ()
 cproto workaround More...
 
void reset_expression_comment ()
 we don't want an expression comment with new lines, it is disgracefull More...
 
static statement flush_expression_comment (statement s)
 flushes all expression comments and add them to statement s More...
 
static void save_expression_comment_as_statement_comment ()
 
static statement flush_statement_comment (statement s)
 flushes all statement comments and add them to statement s More...
 
string pop_block_scope (string old_scope)
 The scope is moved up the scope tree and a NULL is return when there are no more scope to explore. More...
 
string scope_to_block_scope (string full_scope)
 Allocate a new string containing only block scope information. More...
 
c_parser_context CreateDefaultContext ()
 
void InitScope ()
 
static void EnterScope ()
 
int ScopeStackSize ()
 
string GetScope ()
 
string GetParentScope ()
 
void ExitScope ()
 
void PushContext (c_parser_context c)
 
void PopContext ()
 
c_parser_context GetContext ()
 
c_parser_context GetContextCopy ()
 
void reset_declaration_counter ()
 
int get_declaration_counter ()
 
void init_c_parser_scope_stack ()
 
void reset_c_parser_scope_stack ()
 
void force_reset_c_parser_scope_stack ()
 To be used by an error handler. More...
 
void push_new_c_parser_scope ()
 
void pop_c_parser_scope_stack ()
 
bool c_parser_scope_stack_empty_p ()
 
string get_c_parser_current_scope ()
 
string get_c_parser_nth_scope (int n)
 
int c_parser_number_of_scopes ()
 
static void RecordDerivedEntityDeclaration (entity de)
 
static list GetDerivedEntityDeclarations ()
 
static void ResetDerivedEntityDeclarations ()
 
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)
 YYMAXDEPTH – maximum size the stacks can grow to (effective only if the built-in stack extension method is used). More...
 

Variables

static int CurrentMode = 0
 to know the mode of the formal parameter: by value or by reference More...
 
static bool is_external = true
 to know if the variable is declared inside or outside a function, so its scope is the current function or the compilation unit or TOP-LEVEL More...
 
static int enum_counter = 0
 to compute the enumerator value: val(i) = val(i-1) + 1 More...
 
static int abstract_counter = 1
 to create temporary entities for abstract types More...
 
static list initialization_expressions = NIL
 to preserve information about the declarations for the prettyprinter, especially for the global variables, but also the derived types (struct, union, enum). More...
 
static c_parser_context ycontext = c_parser_context_undefined
 
static string expression_comment = string_undefined
 FI: these two variables are used in conjunction with comma expressions. More...
 
static int expression_line_number = STATEMENT_NUMBER_UNDEFINED
 
static list all_expression_comments_as_statement_comments = NIL
 after a while (crocodile) expression comments are pushed into a list that is purged upon call to add_expression_comment More...
 
static int C_scope_identifier = -2
 
static int declaration_counter = 0
 Declaration counter. More...
 
static int c_parser_scope_number = SCOPE_UNDEFINED
 
static stack c_parser_scope_stack = stack_undefined
 
static list internal_derived_entity_declarations = NIL
 When struct and union declarations are nested, the rules cannot return information about the internal declarations because they must return type information. More...
 
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_int16 yypact []
 YYPACT[STATE-NUM] – Index in YYTABLE of the portion describing STATE-NUM. More...
 
static const yytype_int16 yydefact []
 YYDEFACT[STATE-NUM] – Default reduction number in state STATE-NUM. More...
 
static const yytype_int16 yypgoto []
 YYPGOTO[NTERM-NUM]. More...
 
static const yytype_int16 yydefgoto []
 YYDEFGOTO[NTERM-NUM]. More...
 
static const yytype_int16 yytable []
 YYTABLE[YYPACT[STATE-NUM]] – What to do in state STATE-NUM. More...
 
static const yytype_int16 yycheck []
 
static const yytype_uint8 yystos []
 YYSTOS[STATE-NUM] – The symbol kind of the accessing symbol of state STATE-NUM. More...
 
static const yytype_uint8 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

◆ BREAKPOINT

#define BREAKPOINT   ;

Definition at line 112 of file cyacc.tab.c.

◆ C_ERROR_VERBOSE

#define C_ERROR_VERBOSE   1 /**much clearer error messages with bison */

First part of user prologue.


C declarations

Definition at line 100 of file cyacc.tab.c.

◆ SCOPE_UNDEFINED

#define SCOPE_UNDEFINED   (-1)

Each scope in the current unit has its own number.

The scope management in the C parser is the same as in the C preprocessor.

The scope numbers defined here are used by the C parser lexical analyzer to disambiguate between named types and variables, but different scopes are defined for the internal representation.

Definition at line 510 of file cyacc.tab.c.

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 1013 of file cyacc.tab.c.

◆ YY_ACCESSING_SYMBOL

#define YY_ACCESSING_SYMBOL (   State)    YY_CAST (yysymbol_kind_t, yystos[State])

Accessing symbol of state STATE.


Definition at line 1318 of file cyacc.tab.c.

◆ YY_ASSERT

#define YY_ASSERT (   E)    ((void) (0 && (E)))

Definition at line 1079 of file cyacc.tab.c.

◆ YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE

Definition at line 1022 of file cyacc.tab.c.

◆ YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED

Definition at line 1030 of file cyacc.tab.c.

◆ YY_CAST

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

Definition at line 634 of file cyacc.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 1059 of file cyacc.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 1060 of file cyacc.tab.c.

◆ YY_IGNORE_USELESS_CAST_BEGIN

#define YY_IGNORE_USELESS_CAST_BEGIN

Definition at line 1074 of file cyacc.tab.c.

◆ YY_IGNORE_USELESS_CAST_END

#define YY_IGNORE_USELESS_CAST_END

Definition at line 1075 of file cyacc.tab.c.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Suppress an incorrect diagnostic about yylval being uninitialized.


Definition at line 1056 of file cyacc.tab.c.

◆ YY_NULLPTR

#define YY_NULLPTR   ((void*)0)

Definition at line 646 of file cyacc.tab.c.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)
Value:
do { \
if (yydebug) \
yy_reduce_print (yyssp, yyvsp, Rule); \
} while (0)
yydebug
#define yydebug
Definition: cyacc.tab.c:71

Definition at line 2505 of file cyacc.tab.c.

◆ YY_REINTERPRET_CAST

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

Definition at line 635 of file cyacc.tab.c.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)
Value:
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)

Definition at line 2474 of file cyacc.tab.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)
Value
int Value
Definition: arithmetique-local.h:296

Definition at line 2412 of file cyacc.tab.c.

◆ YY_USE

#define YY_USE (   E)    ((void) (E))

Suppress unused-variable warnings by "using" E.


Definition at line 1036 of file cyacc.tab.c.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 2366 of file cyacc.tab.c.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 2365 of file cyacc.tab.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)
YY_
#define YY_(Msgid)
Definition: cyacc.tab.c:1013
yychar
#define yychar
Definition: cyacc.tab.c:74
YYEMPTY
#define YYEMPTY
Token kinds.
Definition: genread.h:84
if
if(!(yy_init))
Definition: genread_lex.c:1029

Definition at line 2373 of file cyacc.tab.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 cyacc.tab.c.

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.8.2"

Bison version string.


Definition at line 52 of file cyacc.tab.c.

◆ yychar

#define yychar   c_char

Definition at line 74 of file cyacc.tab.c.

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 2363 of file cyacc.tab.c.

◆ YYCOPY

#define YYCOPY (   Dst,
  Src,
  Count 
)
Value:
do \
{ \
YYPTRDIFF_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (0)
Count
static int Count
a set of variables shared by the functions of this package.
Definition: scc.c:74

Copy COUNT objects from SRC to DST.

The source and destination do not overlap.

Definition at line 1196 of file cyacc.tab.c.

◆ YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

Definition at line 1168 of file cyacc.tab.c.

◆ yydebug

#define yydebug   c_debug

Definition at line 71 of file cyacc.tab.c.

◆ YYDPRINTF

#define YYDPRINTF (   Args)
Value:
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)

Definition at line 2403 of file cyacc.tab.c.

◆ YYERRCODE

#define YYERRCODE   YYUNDEF

Backward compatibility with an undocumented macro.

Use YYerror or YYUNDEF.

Definition at line 2392 of file cyacc.tab.c.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 2362 of file cyacc.tab.c.

◆ yyerror

#define yyerror   c_error

Definition at line 70 of file cyacc.tab.c.

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 2367 of file cyacc.tab.c.

◆ YYFINAL

#define YYFINAL   7

!YYCOPY_NEEDED

YYFINAL – State number of the termination state.

Definition at line 1209 of file cyacc.tab.c.

◆ YYFPRINTF

#define YYFPRINTF   fprintf

Enable debugging if requested.


INFRINGES ON USER NAME SPACE

Definition at line 2400 of file cyacc.tab.c.

◆ YYFREE

#define YYFREE   free

INFRINGES ON USER NAME SPACE.

Definition at line 1140 of file cyacc.tab.c.

◆ YYINITDEPTH

#define YYINITDEPTH   200

!YYDEBUG

YYINITDEPTH – initial size of the parser's stacks.

Definition at line 2524 of file cyacc.tab.c.

◆ YYLAST

#define YYLAST   3204

YYLAST – Last index in YYTABLE.


Definition at line 1211 of file cyacc.tab.c.

◆ yylex

#define yylex (   void)    c_lex

Definition at line 69 of file cyacc.tab.c.

◆ yylval

#define yylval   c_lval

Definition at line 73 of file cyacc.tab.c.

◆ YYMALLOC

#define YYMALLOC   malloc

Definition at line 1134 of file cyacc.tab.c.

◆ YYMAXDEPTH

#define YYMAXDEPTH   1000000

Increase the parser stack to have SPEC2006/445.gobmk/owl_defendpat.c going through without a:

user warning in splitc_error: C memory exhausted near "0" at preprocessed line 13459 (user line 8732)

Definition at line 107 of file cyacc.tab.c.

◆ YYMAXUTOK

#define YYMAXUTOK   373

YYMAXUTOK – Last valid token kind.


Definition at line 1223 of file cyacc.tab.c.

◆ yynerrs

#define yynerrs   c_nerrs

Definition at line 72 of file cyacc.tab.c.

◆ YYNNTS

#define YYNNTS   110

YYNNTS – Number of nonterminals.


Definition at line 1216 of file cyacc.tab.c.

◆ YYNOMEM

#define YYNOMEM   goto yyexhaustedlab

Definition at line 2368 of file cyacc.tab.c.

◆ YYNRULES

#define YYNRULES   324

YYNRULES – Number of rules.


Definition at line 1218 of file cyacc.tab.c.

◆ YYNSTATES

#define YYNSTATES   597

YYNSTATES – Number of states.


Definition at line 1220 of file cyacc.tab.c.

◆ YYNTOKENS

#define YYNTOKENS   119

YYNTOKENS – Number of terminals.


Definition at line 1214 of file cyacc.tab.c.

◆ YYPACT_NINF

#define YYPACT_NINF   (-445)

Definition at line 1389 of file cyacc.tab.c.

◆ yypact_value_is_default

#define yypact_value_is_default (   Yyn)     ((Yyn) == YYPACT_NINF)

Definition at line 1391 of file cyacc.tab.c.

◆ yyparse

#define yyparse (   void)    c_parse

------—.

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.

interpret: file TK_EOF

file: globals

To handle special case: compilation unit module

dl != NIL

A C file with comments only is OK

globals: empty

$@1: empty

globals: $@1 global globals

PRAGMA

Each variable should be declared only once. Type and initial value conflict should have been detected earlier.

The order of declarations must be preserved: a structure is declared before it is used to declare a variable

Redeclarations are possible in C as long as they are compatible

It is assumed that compatibility is checked somewhere else...

Too late for line numbers, do not use c_parser_user_warning

globals: TK_SEMICOLON globals

location: empty

global: declaration

discard_C_comment();

fprintf(stderr, "declaration\n");

global: function_def

global: TK_ASM TK_LPAREN string_constant TK_RPAREN TK_SEMICOLON

global: TK_PRAGMA

$@2: empty

global: TK_IDENT TK_LPAREN $@2 old_parameter_list_ne TK_RPAREN old_pardef_list TK_SEMICOLON

global: TK_AT_TRANSFORM TK_LBRACE global TK_RBRACE TK_IDENT TK_LBRACE globals TK_RBRACE

global: TK_AT_TRANSFORMEXPR TK_LBRACE expression TK_RBRACE TK_IDENT TK_LBRACE expression TK_RBRACE

global: location error TK_SEMICOLON

id_or_typename: TK_IDENT

id_or_typename: TK_NAMED_TYPE

id_or_typename: TK_AT_NAME TK_LPAREN TK_IDENT TK_RPAREN

expression: constant

expression: TK_IDENT

Create the expression corresponding to this identifier

expression: TK_SIZEOF expression

expression: TK_SIZEOF TK_LPAREN type_name TK_RPAREN

expression: TK_ALIGNOF expression

expression: TK_ALIGNOF TK_LPAREN type_name TK_RPAREN

expression: TK_PLUS expression

expression: TK_MINUS expression

expression: TK_STAR expression

expression: TK_AND expression

expression: TK_EXCLAM expression

expression: TK_TILDE expression

expression: TK_PLUS_PLUS expression

expression: expression TK_PLUS_PLUS

expression: TK_MINUS_MINUS expression

expression: expression TK_MINUS_MINUS

expression: expression TK_ARROW id_or_typename

Find the struct/union type of the expression then the struct/union member entity and transform it to expression

expression: expression TK_DOT id_or_typename

expression: TK_LPAREN block TK_RPAREN

expression: paren_comma_expression

paren_comma_expression is a list of expressions, maybe reduced to one

expression: expression TK_LPAREN arguments TK_RPAREN

expression: TK_BUILTIN_VA_ARG TK_LPAREN expression TK_COMMA type_name TK_RPAREN

expression: expression bracket_comma_expression

expression: expression TK_QUEST opt_expression TK_COLON expression

expression: expression TK_PLUS expression

expression: expression TK_MINUS expression

expression: expression TK_STAR expression

expression: expression TK_SLASH expression

expression: expression TK_PERCENT expression

expression: expression TK_AND_AND expression

expression: expression TK_PIPE_PIPE expression

expression: expression TK_AND expression

expression: expression TK_PIPE expression

expression: expression TK_CIRC expression

expression: expression TK_EQ_EQ expression

expression: expression TK_EXCLAM_EQ expression

expression: expression TK_INF expression

expression: expression TK_SUP expression

expression: expression TK_INF_EQ expression

expression: expression TK_SUP_EQ expression

expression: expression TK_INF_INF expression

expression: expression TK_SUP_SUP expression

expression: expression TK_EQ expression

Check the left hand side expression

expression: expression TK_PLUS_EQ expression

expression: expression TK_MINUS_EQ expression

expression: expression TK_STAR_EQ expression

expression: expression TK_SLASH_EQ expression

expression: expression TK_PERCENT_EQ expression

expression: expression TK_AND_EQ expression

expression: expression TK_PIPE_EQ expression

expression: expression TK_CIRC_EQ expression

expression: expression TK_INF_INF_EQ expression

expression: expression TK_SUP_SUP_EQ expression

expression: TK_LPAREN type_name TK_RPAREN expression

expression: TK_LPAREN type_name TK_RPAREN TK_LBRACE initializer_list_opt TK_RBRACE

expression: TK_AND_AND TK_IDENT

expression: TK_AT_EXPR TK_LPAREN TK_IDENT TK_RPAREN

constant: TK_INTCON

constant: TK_FLOATCON

constant: TK_COMPLEXCON

some work left to accomodate imaginary constants

constant: TK_CHARCON

constant: string_constant

The size will be fixed later, hence 0 here.

constant: wstring_list

string_constant: string_list

Hmmm... Looks like a memory leak on all the strings...

one_string_constant: TK_STRINGCON

string_list: one_string

string_list: string_list one_string

wstring_list: TK_WSTRINGCON

wstring_list: wstring_list one_string

wstring_list: wstring_list TK_WSTRINGCON

one_string: TK_STRINGCON

one_string: TK_FUNCTION__

one_string: TK_PRETTY_FUNCTION__

init_expression: expression

ifdebug(8) {

fprintf(stderr, "Initialization expression: ");

print_expression(ie);

fprintf(stderr, "\n");

}

init_expression: TK_LBRACE initializer_list_opt TK_RBRACE

Deduce the size of an array by its initialization ?

initializer_list: initializer

initializer_list: initializer TK_COMMA initializer_list_opt

initializer_list_opt: empty

initializer_list_opt: initializer_list

initializer: init_designators eq_opt init_expression

initializer: gcc_init_designators init_expression

initializer: init_expression

eq_opt: TK_EQ

eq_opt: empty

init_designators: TK_DOT id_or_typename init_designators_opt

init_designators: TK_LBRACKET expression TK_RBRACKET init_designators_opt

init_designators: TK_LBRACKET expression TK_ELLIPSIS expression TK_RBRACKET

init_designators_opt: empty

init_designators_opt: init_designators

gcc_init_designators: id_or_typename TK_COLON

arguments: empty

arguments: comma_expression

opt_expression: empty

opt_expression: comma_expression

comma_expression: expression

comma_expression: expression TK_COMMA comma_expression

comma_expression: error TK_COMMA comma_expression

comma_expression_opt: empty

comma_expression_opt: comma_expression

statement_paren_comma_expression: TK_LPAREN comma_expression TK_RPAREN

statement_paren_comma_expression: TK_LPAREN error TK_RPAREN

paren_comma_expression: TK_LPAREN comma_expression TK_RPAREN

paren_comma_expression: TK_LPAREN error TK_RPAREN

bracket_comma_expression: TK_LBRACKET comma_expression TK_RBRACKET

bracket_comma_expression: TK_LBRACKET error TK_RBRACKET

$@3: empty

To avoid some parasitic line skipping after the block opening brace. May be it should be cleaner to keep this eventual line-break as a comment in the statement, for subtler user source layout representation?

statements_inside_block: TK_LBRACE $@3 local_labels block_attrs statement_list

block: statements_inside_block TK_RBRACE

block: error location TK_RBRACE

block_attrs: empty

statement_list: empty

statement_list: pragmas

statement_list: statement statement_list

statement_list: label

local_labels: empty

local_labels: TK_LABEL__ local_label_names TK_SEMICOLON local_labels

local_label_names: TK_IDENT

local_label_names: TK_IDENT TK_COMMA local_label_names

label: TK_IDENT TK_COLON

pragma: TK__Pragma TK_LPAREN string_constant TK_RPAREN

Well, indeed this has not been tested at the time of writing since the _Pragma("...") is replaced by a pragma ... in the C preprocessor, at least in gcc 4.4.

The pragma string has been strdup()ed in the lexer...

pragma: TK_PRAGMA

pragmas: pragma

Only one pragma... The common case, return it in a list

pragmas: pragma pragmas

Concatenate the pragma to the list of pragmas

statement: pragmas statement_without_pragma

Do not reallocate the strings

Reduce the CO2 impact of this code, even there is huge memory leaks everywhere around in this file:

statement: statement_without_pragma

statement_without_pragma: TK_SEMICOLON

Null statement in C is represented as continue statement in Fortran

FI: the comments should be handled at another level, so as not to repeat the same code over and over again?

statement_without_pragma: comma_expression TK_SEMICOLON

This uses the current comment and current line number.

FI: I do not know how expression_comment is supposed to work for real comma expressions

statement_without_pragma: block

statement_without_pragma: declaration

In C99 we can have a declaration anywhere!

Declaration returns a statement list. Maybe it could be changed to return only a statement? Well sometimes NIL is returned here so deeper work is required for this...

print_statements(sl);

Extract the statement from the list and free the list container:

statement_without_pragma: TK_IF statement_paren_comma_expression statement

statement_without_pragma: TK_IF statement_paren_comma_expression statement TK_ELSE statement

$@4: empty

push_current_C_comment();

$@5: empty

statement_without_pragma: TK_SWITCH $@4 statement_paren_comma_expression $@5 statement

$@6: empty

push_current_C_comment();

statement_without_pragma: TK_WHILE $@6 statement_paren_comma_expression statement

$@7: empty

push_current_C_comment();

statement_without_pragma: TK_DO $@7 statement TK_WHILE statement_paren_comma_expression TK_SEMICOLON

The line number and comment are related to paren_comma_expression and not to TK_DO

$@8: empty

Save the comments agregated in the for close up to now:

statement_without_pragma: for_clause opt_expression TK_SEMICOLON opt_expression TK_SEMICOLON opt_expression $@8 TK_RPAREN statement

$@9: empty

We need a new variable scope to avoid conflict names between the loop index and some previous upper declarations:

$@10: empty

Save the comments agregated in the for close up to now:

statement_without_pragma: for_clause $@9 declaration opt_expression TK_SEMICOLON opt_expression TK_RPAREN $@10 statement

statement_without_pragma: label statement

Create the statement with label comment in front of it:

ifdebug(8) {

pips_debug(8,"Adding label '%s' to statement:\n", $1);

print_statement($$);

}

statement_without_pragma: TK_CASE expression TK_COLON

statement_without_pragma: TK_CASE expression TK_ELLIPSIS expression TK_COLON

statement_without_pragma: TK_DEFAULT TK_COLON

statement_without_pragma: TK_RETURN TK_SEMICOLON

$$ = call_to_statement(make_call(CreateIntrinsic(C_RETURN_FUNCTION_NAME),NIL));

statement_without_pragma: TK_RETURN comma_expression TK_SEMICOLON

$$ = call_to_statement(make_call(CreateIntrinsic(C_RETURN_FUNCTION_NAME),$2));

pointers to functions, hence functions can be returned in C

FI: relationship with undeclared?

statement_without_pragma: TK_BREAK TK_SEMICOLON

statement_without_pragma: TK_CONTINUE TK_SEMICOLON

statement_without_pragma: TK_GOTO TK_IDENT TK_SEMICOLON

statement_without_pragma: TK_GOTO TK_STAR comma_expression TK_SEMICOLON

statement_without_pragma: TK_ASM asmattr TK_LPAREN string_constant asmoutputs TK_RPAREN TK_SEMICOLON

statement_without_pragma: TK_MSASM

statement_without_pragma: error location TK_SEMICOLON

$@11: empty

Number the loops in prefix depth-first:

Record the line number of thw "for" keyword:

Try to save a max of comments. The issue is that opt_expression's afterwards can reset the comments if there is a comma_expression in them. So at least preserve the commemts before the for.

Issue trigered by several examples such as validation/Semantics-New/do01.tpips

But I think now (RK, 2011/02/05 :-) ) that in a source-to-source compiler comments should appear explicitly in the parser syntax and not be dealt by some side effects in the lexer as now in PIPS with some stacks and so on.

declaration: decl_spec_list init_declarator_list TK_SEMICOLON

declaration: decl_spec_list TK_SEMICOLON

init_declarator_list: init_declarator

init_declarator_list: init_declarator TK_COMMA init_declarator_list

init_declarator: declarator

The default initial value is often zero, but not so for formal parameters or functions

init_declarator: declarator TK_EQ init_expression

Do nothing, leave the initial field of entity as it is.

Put init_expression in the initial value of entity declarator

$@12: empty

Copy may be excessive as only the scope needs to be preserved...

FI: You do not want to propagate qualifiers

How can these two problems occur since ycontext is only a copy of the ContextStack's head? Are we in the middle of a stack_push() /stack_pop()? The previous policy was to always allocate a new ycontext, regardless of the stack state

FI: a bit afraid of freeing the past type if any

A new context is entered: no longer typedef as in "typedef int f(int a)" when we hit "int a"

FI: sometimes, the scope is erased and lost

Finally, to avoid problems!

Only block scope information is inherited

FI: too primitive; we need to push and pop contexts more than to update them.

Problem with "extern f(x), g(y);". f anf g are definitvely top-level, but x and y must be searched in the current scope first.

decl_spec_list: $@12 my_decl_spec_list

my_decl_spec_list: TK_TYPEDEF decl_spec_list_opt

Add TYPEDEF_PREFIX to entity name prefix and make it a rom storage

my_decl_spec_list: TK_EXTERN decl_spec_list_opt

This can be a variable or a function, whose storage is ram or return

What is the scope in cyacc.y of this scope modification? Too much because the TOP_LEVEL scope is going to be used for argument types as well...

FI: because of C laxity about redeclarations in compilation unit, the EXTERN information should be carried by the declaration statement to be able to regenerate precise source-to-source.

my_decl_spec_list: TK_STATIC decl_spec_list_opt

my_decl_spec_list: TK_THREAD decl_spec_list_opt

Add to type variable qualifiers

my_decl_spec_list: TK_AUTO decl_spec_list_opt

Make dynamic storage for current entity

my_decl_spec_list: TK_REGISTER decl_spec_list_opt

Add to type variable qualifiers

my_decl_spec_list: type_spec decl_spec_list_opt_no_named

statement s =

make_continue_statement(entity_empty_label());

statement_declarations(s) = el;

my_decl_spec_list: TK_INLINE decl_spec_list_opt

my_decl_spec_list: attribute decl_spec_list_opt

my_decl_spec_list: TK_AT_SPECIFIER TK_LPAREN TK_IDENT TK_RPAREN

decl_spec_list_opt: empty

decl_spec_list_opt: my_decl_spec_list

decl_spec_list_opt_no_named: empty

decl_spec_list_opt_no_named: my_decl_spec_list

type_spec: TK_VOID

type_spec: TK_CHAR

type_spec: TK_SHORT

type_spec: TK_INT

type_spec: TK_INT128

type_spec: TK_UINT128

type_spec: TK_COMPLEX

Can be qualified by float, double and long double

type_spec: TK_LONG

type_spec: TK_FLOAT

type_spec: TK_DOUBLE

This secondary test is probably useless. See the case of TK_COMPLEX.

FI: we should probably have a user or internal error here since we ignore the beginning of the type declaration

type_spec: TK_SIGNED

see the IR document or ri-util.h for explanation

type_spec: TK_UNSIGNED

type_spec: TK_STRUCT id_or_typename

Find the entity associated to the struct, current scope can be [file%][module:][block]

Specify the type of the variable that follows this declaration specifier

To handle mesa.c (SPEC 2000 benchmark) We have struct HashTable in a file, but do not know its structure and scope, because it is declared in other file

Declaration statement "struct s;" disappears with $$ = NIL... See for instance decl68.c. A place holder variable is added, just in case.

This may be useless, but will be fixed by make_declarations_statement()

$@13: empty

type_spec: TK_STRUCT id_or_typename TK_LBRACE $@13 struct_decl_list TK_RBRACE

field list, which may also contain nested derived entities

Create the struct entity

Record the declaration of the struct entity

Specify the type of the variable that follows this declaration specifier

Take from $5 the struct/union entities

Fields do not need to appear in the declaration list, but they are used later to decide which derived entities are defined and which ones are used.

$@14: empty

type_spec: TK_STRUCT TK_LBRACE $@14 struct_decl_list TK_RBRACE

Create the struct entity with unique name s

Take from el the struct/union entities

type_spec: TK_UNION id_or_typename

Find the entity associated to the union, current scope can be [file%][module:][block]

Specify the type of the variable that follows this declaration specifier

This may be useless, but will be fixed by make_declarations_statement()

$@15: empty

type_spec: TK_UNION id_or_typename TK_LBRACE $@15 struct_decl_list TK_RBRACE

Take from $5 the indirectly declared struct/union entities as in "struct {struct ... ".

$@16: empty

type_spec: TK_UNION TK_LBRACE $@16 struct_decl_list TK_RBRACE

Create the union entity with unique name

Take from $4 the struct/union entities

type_spec: TK_ENUM id_or_typename

Find the entity associated to the enum

Specify the type of the variable that follows this declaration specifier

FI: What should the initial value be?

This happens with the old style function declaration at least

Oops, we have to assume that the enum is also defined in the compilation unit... else it would be useless.

This may be useless, but will be fixed by make_declarations_statement()

type_spec: TK_ENUM id_or_typename TK_LBRACE enum_list maybecomma TK_RBRACE

Create the enum entity

type_spec: TK_ENUM TK_LBRACE enum_list maybecomma TK_RBRACE

Create the enum entity with unique name

type_spec: TK_NAMED_TYPE

Specify the type of the variable that follows this declaration specifier

typedef T1 T2 => the type of T2 will be that of T1

T1 var => the type of var is basic typedef

type_spec: TK_TYPEOF TK_LPAREN expression TK_RPAREN

type_spec: TK_TYPEOF TK_LPAREN type_name TK_RPAREN

struct_decl_list: empty

struct_decl_list: decl_spec_list TK_SEMICOLON struct_decl_list

Create the struct member entity with unique name, the name of the struct/union is added to the member name prefix

Temporally put the list of struct/union entities defined in $1 to initial value of ent. FI: where is it retrieved? in TakeDerivedEntities()?

$@17: empty

Add struct/union name and MEMBER_SEP_STRING to entity name

struct_decl_list: decl_spec_list $@17 field_decl_list TK_SEMICOLON struct_decl_list

Update the entity in field_decl_list with final type, storage, initial value

Create the list of member entities

This code is not good ... I have problem with the global variable ycontext and recursion: ycontext is crushed when this decl_spec_list in struct_decl_list is entered, so the scope and storage of the new context are given to the old context, before it is pushed in the stack.

For the moment, I reset the changed values of the context, by hoping that in C, before a STRUCT/UNION declaration, there is no extern, ...

struct_decl_list: error TK_SEMICOLON struct_decl_list

field_decl_list: field_decl

field_decl_list: field_decl TK_COMMA field_decl_list

field_decl: declarator

For debugging...

It's probably the last place where you can use the qualifier from the context to update the type of e when e is a pointer.

FI: Well, this piece of code may be fully useless because t or pt is always undefined.

FI: because of the above assert, the next statement could be simplified

field_decl: declarator TK_COLON expression

ips_assert("Width of bit-field must be a positive constant integer", integer_constant_expression_p($3));

Ignore for this moment if the bit is signed or unsigned

field_decl: TK_COLON expression

Unnamed bit-field : special and unique name

pips_assert("Width of bit-field must be a positive constant integer", integer_constant_expression_p($2));

enum_list: enumerator

initial_value = 0 or $3

enum_list: enum_list TK_COMMA enumerator

Attention to the reverse recursive definition

enum_list: enum_list TK_COMMA error

enumerator: TK_IDENT

Create an entity of is_basic_int, storage rom initial_value = 0 if it is the first member initial_value = intial_value(precedessor) + 1

No need to add current struct/union/enum name to the name's scope of the member entity for ENUM, as in the case of STRUCT and UNION

The information is not yet available, but I need to recognize this entity as symbolic for next rule

entity_initial(ent) = MakeEnumeratorInitialValue(enum_list,enum_counter);

enumerator: TK_IDENT TK_EQ expression

Create an entity of is_basic_int, storage rom, initial_value = $3

No, enum member must be functional entity, just like Fortran's parameters

Error or reference to a previous member of the same enum (enum04.c)

FI: it might be easier to delay systematically the evaluation

Let's try to delay evaluation anyway (enum05.c)

declarator: pointer_opt direct_decl attributes_with_asm

Update the type of the direct_decl entity with pointer_opt and attributes

direct_decl: id_or_typename

FI: A variable cannot be redeclared within the same scope, but this is not checked yet.

Initialize the type stack and push the type of found/created entity to the stack. It can be undefined if the entity has not been parsed, or a given type which is used later to check if the declarations are the same for one entity. This stack is put temporarily in the storage of the entity, not a global variable for each declarator to avoid being erased by recursion (FI: this last sentence seems to be wrong)

e has already been defined since a type stack is associated to it. At least, if the mapping from entity to type stack is well managed. Since entities are sometimes destroyed, a new entity might end up with the same memory address and hence the same type stack.

A function can be redeclared inside itself. see C_syntax/extern.c

Dummy parameters can also be redeclared as long as their types are equal

entity_name(e)

entity_name(e)

entity_name(e)

direct_decl: TK_LPAREN attributes declarator TK_RPAREN

Add attributes such as const, restrict, ... to variable's qualifiers

direct_decl: direct_decl TK_LBRACKET attributes comma_expression_opt TK_RBRACKET

This is the last dimension of an array (i.e a[1][2][3] => [3]). Questions:

  • What can be attributes ?
  • Why comma_expression, it can be a list of expressions ?
  • When the comma_expression is empty (corresponding to the first dimension), the array is of unknown size => can be determined by the intialization ? TO BE DONE

direct_decl: direct_decl TK_LBRACKET attributes error TK_RBRACKET

$@18: empty

Well, here it can be a function or a pointer to a function

If it is a pointer, its value is going to be "unknown" or "expression"; if it is a function, its value is going to be "code". If the value cannot stay undefined, it should be made unknown...

direct_decl: direct_decl parameter_list_startscope $@18 rest_par_list TK_RPAREN

Intrinsic functions in C such as printf, fprintf, ... are considered as entities with functional type ??? if (!intrinsic_entity_p(e))

e can be a function or a pointer to a function. The information is available somewhere in the stacks...

No need to declare C user functions extern in a compilation unit; they are global or local.

Too early: pointers to functions are still seen as functions here. Let's delay

parameter_list_startscope: TK_LPAREN

rest_par_list: empty

rest_par_list: parameter_decl rest_par_list1

rest_par_list1: empty

$@19: empty

rest_par_list1: TK_COMMA $@19 TK_ELLIPSIS

$ = CONS(PARAMETER,make_parameter(make_type_varargs(type_undefined), make_mode(CurrentMode,UU), make_dummy_unknown()),NIL);

$@20: empty

rest_par_list1: TK_COMMA $@20 parameter_decl rest_par_list1

parameter_decl: decl_spec_list declarator

Set CurentMode where ????

parameter_decl: decl_spec_list abstract_decl

parameter_decl: decl_spec_list

function prototype

parameter_decl: TK_LPAREN parameter_decl TK_RPAREN

old_proto_decl: pointer_opt direct_old_proto_decl

$@21: empty

direct_old_proto_decl: direct_decl TK_LPAREN $@21 old_parameter_list_ne TK_RPAREN old_pardef_list

old_parameter_list_ne: TK_IDENT

old_parameter_list_ne: TK_IDENT TK_COMMA old_parameter_list_ne

old_pardef_list: empty

old_pardef_list: decl_spec_list old_pardef TK_SEMICOLON TK_ELLIPSIS

Can we have struct/union definition in $1 ?

$ = gen_nconc($1,$2);

old_pardef_list: decl_spec_list old_pardef TK_SEMICOLON old_pardef_list

Rule used for C_syntax/activate.c, decl33.c and adi.c. CreateReturnEntity() only useful for activate.c

Can we have struct/union definition in $1 ?

$ = gen_nconc($1,gen_nconc(el,$4));

old_pardef: declarator

old_pardef: declarator TK_COMMA old_pardef

old_pardef: error

pointer: TK_STAR attributes pointer_opt

decl24.c, decl50.c, decl51.c, decl52.c, decl53.c : const attribute lost or misplaced for pointers

pointer_opt: empty

pointer_opt: pointer

type_name: decl_spec_list abstract_decl

type_name: decl_spec_list

abstract_decl: pointer_opt abs_direct_decl attributes

Update the type of the direct_decl entity with pointer_opt and attributes

abstract_decl: pointer

Initialize the type stack and push the type of found/created entity to the stack. It can be undefined if the entity has not been parsed, or a given type which is used later to check if the declarations are the same for one entity. This stack is put temporarily in the storage of the entity, not a global variable for each declarator to avoid being erased by recursion

ntity_type($$) = type_undefined;

abs_direct_decl: TK_LPAREN attributes abstract_decl TK_RPAREN

abs_direct_decl: TK_LPAREN error TK_RPAREN

abs_direct_decl: abs_direct_decl_opt TK_LBRACKET comma_expression_opt TK_RBRACKET

$@22: empty

abs_direct_decl: abs_direct_decl_opt parameter_list_startscope $@22 rest_par_list TK_RPAREN

abs_direct_decl_opt: abs_direct_decl

abs_direct_decl_opt: empty

$@23: empty

function_def: function_def_start $@23 block

Make value_code for current module here

Let's delay this? ResetCurrentModule();

function_def_start: decl_spec_list declarator

function_def_start: decl_spec_list old_proto_decl

$@24: empty

function_def_start: TK_IDENT parameter_list_startscope $@24 rest_par_list TK_RPAREN

Functional type is unknown or int (by default) or void ?

$@25: empty

function_def_start: TK_IDENT TK_LPAREN old_parameter_list_ne $@25 TK_RPAREN old_pardef_list

attributes: empty

attributes: attribute attributes

attributes_with_asm: empty

attributes_with_asm: attribute attributes_with_asm

attributes_with_asm: TK_ASM TK_LPAREN string_constant TK_RPAREN attributes

attribute: TK_MSATTR

attribute: TK_CONST

attribute: TK_RESTRICT

attribute: TK_VOLATILE

attribute: TK_STATIC_DIMENSION

asmattr: empty

asmattr: TK_VOLATILE asmattr

asmattr: TK_CONST asmattr

asmoutputs: empty

asmoutputs: TK_COLON asmoperands asminputs

asmoperands: empty

asmoperands: asmoperandsne

asmoperandsne: asmoperand

asmoperandsne: asmoperandsne TK_COMMA asmoperand

asmoperand: string_constant TK_LPAREN expression TK_RPAREN

asmoperand: string_constant TK_LPAREN error TK_RPAREN

asminputs: empty

asminputs: TK_COLON asmoperands asmclobber

asmclobber: empty

asmclobber: TK_COLON asmcloberlst_ne

asmcloberlst_ne: one_string_constant

asmcloberlst_ne: one_string_constant TK_COMMA asmcloberlst_ne

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 cyacc.tab.c.

◆ YYPOPSTACK

#define YYPOPSTACK (   N)    (yyvsp -= (N), yyssp -= (N))

◆ YYPTRDIFF_MAXIMUM

#define YYPTRDIFF_MAXIMUM   LONG_MAX

Definition at line 973 of file cyacc.tab.c.

◆ YYPTRDIFF_T

#define YYPTRDIFF_T   long

Definition at line 972 of file cyacc.tab.c.

◆ YYPULL

#define YYPULL   1

Pull parsers.


Definition at line 64 of file cyacc.tab.c.

◆ YYPURE

#define YYPURE   0

Pure parsers.


Definition at line 58 of file cyacc.tab.c.

◆ YYPUSH

#define YYPUSH   0

Push parsers.


Definition at line 61 of file cyacc.tab.c.

◆ YYRECOVERING

#define YYRECOVERING ( )    (!!yyerrstatus)

Definition at line 2371 of file cyacc.tab.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)))
YYPTRDIFF_MAXIMUM
#define YYPTRDIFF_MAXIMUM
Definition: cyacc.tab.c:973
YY_CAST
#define YY_CAST(Type, Val)
Definition: cyacc.tab.c:634
YYSIZE_T
#define YYSIZE_T
Definition: cyacc.tab.c:986
YYPTRDIFF_T
#define YYPTRDIFF_T
Definition: cyacc.tab.c:972

Definition at line 990 of file cyacc.tab.c.

◆ YYSIZE_T

#define YYSIZE_T   unsigned

Definition at line 986 of file cyacc.tab.c.

◆ YYSIZEOF

#define YYSIZEOF (   X)    YY_CAST (YYPTRDIFF_T, sizeof (X))

Definition at line 996 of file cyacc.tab.c.

◆ YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

Skeleton name.


Definition at line 55 of file cyacc.tab.c.

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

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


Definition at line 1120 of file cyacc.tab.c.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 1123 of file cyacc.tab.c.

◆ YYSTACK_BYTES

#define YYSTACK_BYTES (   N)
Value:
((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM)
YYSIZEOF
#define YYSIZEOF(X)
Definition: cyacc.tab.c:996
YYSTACK_GAP_MAXIMUM
#define YYSTACK_GAP_MAXIMUM
The size of the maximum gap between one aligned stack and the next.
Definition: cyacc.tab.c:1160
yy_state_t
yytype_int8 yy_state_t
Stored state numbers (used for stacks).
Definition: genread_yacc.c:454
YYSTYPE
Value type.
Definition: genread.h:115

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


Definition at line 1164 of file cyacc.tab.c.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 1121 of file cyacc.tab.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 1160 of file cyacc.tab.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)
Stack
static vertex * Stack
Definition: scc.c:75

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 1175 of file cyacc.tab.c.

◆ YYTABLE_NINF

#define YYTABLE_NINF   (-299)

Definition at line 1394 of file cyacc.tab.c.

◆ yytable_value_is_error

#define yytable_value_is_error (   Yyn)     0

Definition at line 1396 of file cyacc.tab.c.

◆ YYTRANSLATE

#define YYTRANSLATE (   YYX)
Value:
(0 <= (YYX) && (YYX) <= YYMAXUTOK \
? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
: YYSYMBOL_YYUNDEF)
yytranslate
static const yytype_int8 yytranslate[]
YYTRANSLATE[TOKEN-NUM] – Symbol number corresponding to TOKEN-NUM as returned by yylex.
Definition: cyacc.tab.c:1235
YYSYMBOL_YYUNDEF
@ YYSYMBOL_YYUNDEF
error
Definition: cyacc.tab.c:657
YYMAXUTOK
#define YYMAXUTOK
YYMAXUTOK – Last valid token kind.
Definition: cyacc.tab.c:1223
yysymbol_kind_t
yysymbol_kind_t
!YY_GENREAD_Y_TAB_H_INCLUDED
Definition: genread_yacc.c:294

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


Definition at line 1228 of file cyacc.tab.c.

Typedef Documentation

◆ yy_state_fast_t

typedef int yy_state_fast_t

State numbers in computations.


Definition at line 1003 of file cyacc.tab.c.

◆ yy_state_t

typedef yytype_int16 yy_state_t

Stored state numbers (used for stacks).

Definition at line 1000 of file cyacc.tab.c.

◆ yysymbol_kind_t

typedef enum yysymbol_kind_t yysymbol_kind_t

Definition at line 619 of file cyacc.tab.c.

◆ yytype_int16

typedef short yytype_int16

Definition at line 924 of file cyacc.tab.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 916 of file cyacc.tab.c.

◆ yytype_uint16

typedef unsigned short yytype_uint16

Definition at line 956 of file cyacc.tab.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 945 of file cyacc.tab.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
YYENOMEM 

Definition at line 2360 of file cyacc.tab.c.

2360 { YYENOMEM = -2 };
YYENOMEM
@ YYENOMEM
Definition: cyacc.tab.c:2360

◆ 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 652 of file cyacc.tab.c.

653 {
654  YYSYMBOL_YYEMPTY = -2,
655  YYSYMBOL_YYEOF = 0, /* "end of file" */
656  YYSYMBOL_YYerror = 1, /* error */
657  YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
658  YYSYMBOL_TK_IDENT = 3, /* TK_IDENT */
659  YYSYMBOL_TK_CHARCON = 4, /* TK_CHARCON */
660  YYSYMBOL_TK_INTCON = 5, /* TK_INTCON */
661  YYSYMBOL_TK_FLOATCON = 6, /* TK_FLOATCON */
662  YYSYMBOL_TK_NAMED_TYPE = 7, /* TK_NAMED_TYPE */
663  YYSYMBOL_TK_STRINGCON = 8, /* TK_STRINGCON */
664  YYSYMBOL_TK_WSTRINGCON = 9, /* TK_WSTRINGCON */
665  YYSYMBOL_TK_EOF = 10, /* TK_EOF */
666  YYSYMBOL_TK_CHAR = 11, /* TK_CHAR */
667  YYSYMBOL_TK_INT = 12, /* TK_INT */
668  YYSYMBOL_TK_INT128 = 13, /* TK_INT128 */
669  YYSYMBOL_TK_UINT128 = 14, /* TK_UINT128 */
670  YYSYMBOL_TK_DOUBLE = 15, /* TK_DOUBLE */
671  YYSYMBOL_TK_FLOAT = 16, /* TK_FLOAT */
672  YYSYMBOL_TK_VOID = 17, /* TK_VOID */
673  YYSYMBOL_TK_COMPLEX = 18, /* TK_COMPLEX */
674  YYSYMBOL_TK_ENUM = 19, /* TK_ENUM */
675  YYSYMBOL_TK_STRUCT = 20, /* TK_STRUCT */
676  YYSYMBOL_TK_TYPEDEF = 21, /* TK_TYPEDEF */
677  YYSYMBOL_TK_UNION = 22, /* TK_UNION */
678  YYSYMBOL_TK_SIGNED = 23, /* TK_SIGNED */
679  YYSYMBOL_TK_UNSIGNED = 24, /* TK_UNSIGNED */
680  YYSYMBOL_TK_LONG = 25, /* TK_LONG */
681  YYSYMBOL_TK_SHORT = 26, /* TK_SHORT */
682  YYSYMBOL_TK_VOLATILE = 27, /* TK_VOLATILE */
683  YYSYMBOL_TK_EXTERN = 28, /* TK_EXTERN */
684  YYSYMBOL_TK_STATIC = 29, /* TK_STATIC */
685  YYSYMBOL_TK_STATIC_DIMENSION = 30, /* TK_STATIC_DIMENSION */
686  YYSYMBOL_TK_CONST = 31, /* TK_CONST */
687  YYSYMBOL_TK_RESTRICT = 32, /* TK_RESTRICT */
688  YYSYMBOL_TK_AUTO = 33, /* TK_AUTO */
689  YYSYMBOL_TK_REGISTER = 34, /* TK_REGISTER */
690  YYSYMBOL_TK_THREAD = 35, /* TK_THREAD */
691  YYSYMBOL_TK_SIZEOF = 36, /* TK_SIZEOF */
692  YYSYMBOL_TK_ALIGNOF = 37, /* TK_ALIGNOF */
693  YYSYMBOL_TK_EQ = 38, /* TK_EQ */
694  YYSYMBOL_TK_PLUS_EQ = 39, /* TK_PLUS_EQ */
695  YYSYMBOL_TK_MINUS_EQ = 40, /* TK_MINUS_EQ */
696  YYSYMBOL_TK_STAR_EQ = 41, /* TK_STAR_EQ */
697  YYSYMBOL_TK_SLASH_EQ = 42, /* TK_SLASH_EQ */
698  YYSYMBOL_TK_PERCENT_EQ = 43, /* TK_PERCENT_EQ */
699  YYSYMBOL_TK_AND_EQ = 44, /* TK_AND_EQ */
700  YYSYMBOL_TK_PIPE_EQ = 45, /* TK_PIPE_EQ */
701  YYSYMBOL_TK_CIRC_EQ = 46, /* TK_CIRC_EQ */
702  YYSYMBOL_TK_INF_INF_EQ = 47, /* TK_INF_INF_EQ */
703  YYSYMBOL_TK_SUP_SUP_EQ = 48, /* TK_SUP_SUP_EQ */
704  YYSYMBOL_TK_ARROW = 49, /* TK_ARROW */
705  YYSYMBOL_TK_DOT = 50, /* TK_DOT */
706  YYSYMBOL_TK_EQ_EQ = 51, /* TK_EQ_EQ */
707  YYSYMBOL_TK_EXCLAM_EQ = 52, /* TK_EXCLAM_EQ */
708  YYSYMBOL_TK_INF = 53, /* TK_INF */
709  YYSYMBOL_TK_SUP = 54, /* TK_SUP */
710  YYSYMBOL_TK_INF_EQ = 55, /* TK_INF_EQ */
711  YYSYMBOL_TK_SUP_EQ = 56, /* TK_SUP_EQ */
712  YYSYMBOL_TK_PLUS = 57, /* TK_PLUS */
713  YYSYMBOL_TK_MINUS = 58, /* TK_MINUS */
714  YYSYMBOL_TK_STAR = 59, /* TK_STAR */
715  YYSYMBOL_TK_SLASH = 60, /* TK_SLASH */
716  YYSYMBOL_TK_PERCENT = 61, /* TK_PERCENT */
717  YYSYMBOL_TK_TILDE = 62, /* TK_TILDE */
718  YYSYMBOL_TK_AND = 63, /* TK_AND */
719  YYSYMBOL_TK_PIPE = 64, /* TK_PIPE */
720  YYSYMBOL_TK_CIRC = 65, /* TK_CIRC */
721  YYSYMBOL_TK_EXCLAM = 66, /* TK_EXCLAM */
722  YYSYMBOL_TK_AND_AND = 67, /* TK_AND_AND */
723  YYSYMBOL_TK_PIPE_PIPE = 68, /* TK_PIPE_PIPE */
724  YYSYMBOL_TK_INF_INF = 69, /* TK_INF_INF */
725  YYSYMBOL_TK_SUP_SUP = 70, /* TK_SUP_SUP */
726  YYSYMBOL_TK_PLUS_PLUS = 71, /* TK_PLUS_PLUS */
727  YYSYMBOL_TK_MINUS_MINUS = 72, /* TK_MINUS_MINUS */
728  YYSYMBOL_TK_RPAREN = 73, /* TK_RPAREN */
729  YYSYMBOL_TK_LPAREN = 74, /* TK_LPAREN */
730  YYSYMBOL_TK_RBRACE = 75, /* TK_RBRACE */
731  YYSYMBOL_TK_LBRACE = 76, /* TK_LBRACE */
732  YYSYMBOL_TK_LBRACKET = 77, /* TK_LBRACKET */
733  YYSYMBOL_TK_RBRACKET = 78, /* TK_RBRACKET */
734  YYSYMBOL_TK_COLON = 79, /* TK_COLON */
735  YYSYMBOL_TK_SEMICOLON = 80, /* TK_SEMICOLON */
736  YYSYMBOL_TK_COMMA = 81, /* TK_COMMA */
737  YYSYMBOL_TK_ELLIPSIS = 82, /* TK_ELLIPSIS */
738  YYSYMBOL_TK_QUEST = 83, /* TK_QUEST */
739  YYSYMBOL_TK_BREAK = 84, /* TK_BREAK */
740  YYSYMBOL_TK_CONTINUE = 85, /* TK_CONTINUE */
741  YYSYMBOL_TK_GOTO = 86, /* TK_GOTO */
742  YYSYMBOL_TK_RETURN = 87, /* TK_RETURN */
743  YYSYMBOL_TK_SWITCH = 88, /* TK_SWITCH */
744  YYSYMBOL_TK_CASE = 89, /* TK_CASE */
745  YYSYMBOL_TK_DEFAULT = 90, /* TK_DEFAULT */
746  YYSYMBOL_TK_WHILE = 91, /* TK_WHILE */
747  YYSYMBOL_TK_DO = 92, /* TK_DO */
748  YYSYMBOL_TK_FOR = 93, /* TK_FOR */
749  YYSYMBOL_TK_IF = 94, /* TK_IF */
750  YYSYMBOL_TK_ELSE = 95, /* TK_ELSE */
751  YYSYMBOL_TK_ATTRIBUTE = 96, /* TK_ATTRIBUTE */
752  YYSYMBOL_TK_INLINE = 97, /* TK_INLINE */
753  YYSYMBOL_TK_ASM = 98, /* TK_ASM */
754  YYSYMBOL_TK_TYPEOF = 99, /* TK_TYPEOF */
755  YYSYMBOL_TK_FUNCTION__ = 100, /* TK_FUNCTION__ */
756  YYSYMBOL_TK_PRETTY_FUNCTION__ = 101, /* TK_PRETTY_FUNCTION__ */
757  YYSYMBOL_TK_LABEL__ = 102, /* TK_LABEL__ */
758  YYSYMBOL_TK_BUILTIN_VA_ARG = 103, /* TK_BUILTIN_VA_ARG */
759  YYSYMBOL_TK_BUILTIN_VA_LIST = 104, /* TK_BUILTIN_VA_LIST */
760  YYSYMBOL_TK_BLOCKATTRIBUTE = 105, /* TK_BLOCKATTRIBUTE */
761  YYSYMBOL_TK_DECLSPEC = 106, /* TK_DECLSPEC */
762  YYSYMBOL_TK_MSASM = 107, /* TK_MSASM */
763  YYSYMBOL_TK_MSATTR = 108, /* TK_MSATTR */
764  YYSYMBOL_TK_PRAGMA = 109, /* TK_PRAGMA */
765  YYSYMBOL_TK__Pragma = 110, /* TK__Pragma */
766  YYSYMBOL_TK_AT_TRANSFORM = 111, /* TK_AT_TRANSFORM */
767  YYSYMBOL_TK_AT_TRANSFORMEXPR = 112, /* TK_AT_TRANSFORMEXPR */
768  YYSYMBOL_TK_AT_SPECIFIER = 113, /* TK_AT_SPECIFIER */
769  YYSYMBOL_TK_AT_EXPR = 114, /* TK_AT_EXPR */
770  YYSYMBOL_TK_AT_NAME = 115, /* TK_AT_NAME */
771  YYSYMBOL_TK_COMPLEXCON = 116, /* TK_COMPLEXCON */
772  YYSYMBOL_TK_CAST = 117, /* TK_CAST */
773  YYSYMBOL_TK_ADDROF = 118, /* TK_ADDROF */
774  YYSYMBOL_YYACCEPT = 119, /* $accept */
775  YYSYMBOL_interpret = 120, /* interpret */
776  YYSYMBOL_file = 121, /* file */
777  YYSYMBOL_globals = 122, /* globals */
778  YYSYMBOL_123_1 = 123, /* $@1 */
779  YYSYMBOL_location = 124, /* location */
780  YYSYMBOL_global = 125, /* global */
781  YYSYMBOL_126_2 = 126, /* $@2 */
782  YYSYMBOL_id_or_typename = 127, /* id_or_typename */
783  YYSYMBOL_maybecomma = 128, /* maybecomma */
784  YYSYMBOL_expression = 129, /* expression */
785  YYSYMBOL_constant = 130, /* constant */
786  YYSYMBOL_string_constant = 131, /* string_constant */
787  YYSYMBOL_one_string_constant = 132, /* one_string_constant */
788  YYSYMBOL_string_list = 133, /* string_list */
789  YYSYMBOL_wstring_list = 134, /* wstring_list */
790  YYSYMBOL_one_string = 135, /* one_string */
791  YYSYMBOL_init_expression = 136, /* init_expression */
792  YYSYMBOL_initializer_list = 137, /* initializer_list */
793  YYSYMBOL_initializer_list_opt = 138, /* initializer_list_opt */
794  YYSYMBOL_initializer = 139, /* initializer */
795  YYSYMBOL_eq_opt = 140, /* eq_opt */
796  YYSYMBOL_init_designators = 141, /* init_designators */
797  YYSYMBOL_init_designators_opt = 142, /* init_designators_opt */
798  YYSYMBOL_gcc_init_designators = 143, /* gcc_init_designators */
799  YYSYMBOL_arguments = 144, /* arguments */
800  YYSYMBOL_opt_expression = 145, /* opt_expression */
801  YYSYMBOL_comma_expression = 146, /* comma_expression */
802  YYSYMBOL_comma_expression_opt = 147, /* comma_expression_opt */
803  YYSYMBOL_statement_paren_comma_expression = 148, /* statement_paren_comma_expression */
804  YYSYMBOL_paren_comma_expression = 149, /* paren_comma_expression */
805  YYSYMBOL_bracket_comma_expression = 150, /* bracket_comma_expression */
806  YYSYMBOL_statements_inside_block = 151, /* statements_inside_block */
807  YYSYMBOL_152_3 = 152, /* $@3 */
808  YYSYMBOL_block = 153, /* block */
809  YYSYMBOL_block_attrs = 154, /* block_attrs */
810  YYSYMBOL_statement_list = 155, /* statement_list */
811  YYSYMBOL_local_labels = 156, /* local_labels */
812  YYSYMBOL_local_label_names = 157, /* local_label_names */
813  YYSYMBOL_label = 158, /* label */
814  YYSYMBOL_pragma = 159, /* pragma */
815  YYSYMBOL_pragmas = 160, /* pragmas */
816  YYSYMBOL_statement = 161, /* statement */
817  YYSYMBOL_statement_without_pragma = 162, /* statement_without_pragma */
818  YYSYMBOL_163_4 = 163, /* $@4 */
819  YYSYMBOL_164_5 = 164, /* $@5 */
820  YYSYMBOL_165_6 = 165, /* $@6 */
821  YYSYMBOL_166_7 = 166, /* $@7 */
822  YYSYMBOL_167_8 = 167, /* $@8 */
823  YYSYMBOL_168_9 = 168, /* $@9 */
824  YYSYMBOL_169_10 = 169, /* $@10 */
825  YYSYMBOL_for_clause = 170, /* for_clause */
826  YYSYMBOL_171_11 = 171, /* $@11 */
827  YYSYMBOL_declaration = 172, /* declaration */
828  YYSYMBOL_init_declarator_list = 173, /* init_declarator_list */
829  YYSYMBOL_init_declarator = 174, /* init_declarator */
830  YYSYMBOL_decl_spec_list = 175, /* decl_spec_list */
831  YYSYMBOL_176_12 = 176, /* $@12 */
832  YYSYMBOL_my_decl_spec_list = 177, /* my_decl_spec_list */
833  YYSYMBOL_decl_spec_list_opt = 178, /* decl_spec_list_opt */
834  YYSYMBOL_decl_spec_list_opt_no_named = 179, /* decl_spec_list_opt_no_named */
835  YYSYMBOL_type_spec = 180, /* type_spec */
836  YYSYMBOL_181_13 = 181, /* $@13 */
837  YYSYMBOL_182_14 = 182, /* $@14 */
838  YYSYMBOL_183_15 = 183, /* $@15 */
839  YYSYMBOL_184_16 = 184, /* $@16 */
840  YYSYMBOL_struct_decl_list = 185, /* struct_decl_list */
841  YYSYMBOL_186_17 = 186, /* $@17 */
842  YYSYMBOL_field_decl_list = 187, /* field_decl_list */
843  YYSYMBOL_field_decl = 188, /* field_decl */
844  YYSYMBOL_enum_list = 189, /* enum_list */
845  YYSYMBOL_enumerator = 190, /* enumerator */
846  YYSYMBOL_declarator = 191, /* declarator */
847  YYSYMBOL_direct_decl = 192, /* direct_decl */
848  YYSYMBOL_193_18 = 193, /* $@18 */
849  YYSYMBOL_parameter_list_startscope = 194, /* parameter_list_startscope */
850  YYSYMBOL_rest_par_list = 195, /* rest_par_list */
851  YYSYMBOL_rest_par_list1 = 196, /* rest_par_list1 */
852  YYSYMBOL_197_19 = 197, /* $@19 */
853  YYSYMBOL_198_20 = 198, /* $@20 */
854  YYSYMBOL_parameter_decl = 199, /* parameter_decl */
855  YYSYMBOL_old_proto_decl = 200, /* old_proto_decl */
856  YYSYMBOL_direct_old_proto_decl = 201, /* direct_old_proto_decl */
857  YYSYMBOL_202_21 = 202, /* $@21 */
858  YYSYMBOL_old_parameter_list_ne = 203, /* old_parameter_list_ne */
859  YYSYMBOL_old_pardef_list = 204, /* old_pardef_list */
860  YYSYMBOL_old_pardef = 205, /* old_pardef */
861  YYSYMBOL_pointer = 206, /* pointer */
862  YYSYMBOL_pointer_opt = 207, /* pointer_opt */
863  YYSYMBOL_type_name = 208, /* type_name */
864  YYSYMBOL_abstract_decl = 209, /* abstract_decl */
865  YYSYMBOL_abs_direct_decl = 210, /* abs_direct_decl */
866  YYSYMBOL_211_22 = 211, /* $@22 */
867  YYSYMBOL_abs_direct_decl_opt = 212, /* abs_direct_decl_opt */
868  YYSYMBOL_function_def = 213, /* function_def */
869  YYSYMBOL_214_23 = 214, /* $@23 */
870  YYSYMBOL_function_def_start = 215, /* function_def_start */
871  YYSYMBOL_216_24 = 216, /* $@24 */
872  YYSYMBOL_217_25 = 217, /* $@25 */
873  YYSYMBOL_attributes = 218, /* attributes */
874  YYSYMBOL_attributes_with_asm = 219, /* attributes_with_asm */
875  YYSYMBOL_attribute = 220, /* attribute */
876  YYSYMBOL_asmattr = 221, /* asmattr */
877  YYSYMBOL_asmoutputs = 222, /* asmoutputs */
878  YYSYMBOL_asmoperands = 223, /* asmoperands */
879  YYSYMBOL_asmoperandsne = 224, /* asmoperandsne */
880  YYSYMBOL_asmoperand = 225, /* asmoperand */
881  YYSYMBOL_asminputs = 226, /* asminputs */
882  YYSYMBOL_asmclobber = 227, /* asmclobber */
883  YYSYMBOL_asmcloberlst_ne = 228 /* asmcloberlst_ne */
884 };
YYSYMBOL_statement_list
@ YYSYMBOL_statement_list
block_attrs
Definition: cyacc.tab.c:810
YYSYMBOL_TK_ALIGNOF
@ YYSYMBOL_TK_ALIGNOF
TK_SIZEOF
Definition: cyacc.tab.c:692
YYSYMBOL_wstring_list
@ YYSYMBOL_wstring_list
string_list
Definition: cyacc.tab.c:789
YYSYMBOL_TK_TYPEOF
@ YYSYMBOL_TK_TYPEOF
TK_ASM
Definition: cyacc.tab.c:754
YYSYMBOL_decl_spec_list
@ YYSYMBOL_decl_spec_list
init_declarator
Definition: cyacc.tab.c:830
YYSYMBOL_TK_SHORT
@ YYSYMBOL_TK_SHORT
TK_LONG
Definition: cyacc.tab.c:681
YYSYMBOL_TK_LBRACKET
@ YYSYMBOL_TK_LBRACKET
TK_LBRACE
Definition: cyacc.tab.c:732
YYSYMBOL_asmattr
@ YYSYMBOL_asmattr
attribute
Definition: cyacc.tab.c:876
YYSYMBOL_TK_MINUS_EQ
@ YYSYMBOL_TK_MINUS_EQ
TK_PLUS_EQ
Definition: cyacc.tab.c:695
YYSYMBOL_local_label_names
@ YYSYMBOL_local_label_names
local_labels
Definition: cyacc.tab.c:812
YYSYMBOL_for_clause
@ YYSYMBOL_for_clause
$@10
Definition: cyacc.tab.c:825
YYSYMBOL_attribute
@ YYSYMBOL_attribute
attributes_with_asm
Definition: cyacc.tab.c:875
YYSYMBOL_maybecomma
@ YYSYMBOL_maybecomma
id_or_typename
Definition: cyacc.tab.c:783
YYSYMBOL_TK_UNION
@ YYSYMBOL_TK_UNION
TK_TYPEDEF
Definition: cyacc.tab.c:677
YYSYMBOL_block_attrs
@ YYSYMBOL_block_attrs
block
Definition: cyacc.tab.c:809
YYSYMBOL_TK_ASM
@ YYSYMBOL_TK_ASM
TK_INLINE
Definition: cyacc.tab.c:753
YYSYMBOL_TK_RBRACKET
@ YYSYMBOL_TK_RBRACKET
TK_LBRACKET
Definition: cyacc.tab.c:733
YYSYMBOL_TK_MSATTR
@ YYSYMBOL_TK_MSATTR
TK_MSASM
Definition: cyacc.tab.c:763
YYSYMBOL_comma_expression_opt
@ YYSYMBOL_comma_expression_opt
comma_expression
Definition: cyacc.tab.c:802
YYSYMBOL_TK_MINUS
@ YYSYMBOL_TK_MINUS
TK_PLUS
Definition: cyacc.tab.c:713
YYSYMBOL_asmclobber
@ YYSYMBOL_asmclobber
asminputs
Definition: cyacc.tab.c:882
YYSYMBOL_168_9
@ YYSYMBOL_168_9
$@8
Definition: cyacc.tab.c:823
YYSYMBOL_rest_par_list1
@ YYSYMBOL_rest_par_list1
rest_par_list
Definition: cyacc.tab.c:851
YYSYMBOL_TK_CASE
@ YYSYMBOL_TK_CASE
TK_SWITCH
Definition: cyacc.tab.c:744
YYSYMBOL_TK_NAMED_TYPE
@ YYSYMBOL_TK_NAMED_TYPE
TK_FLOATCON
Definition: cyacc.tab.c:662
YYSYMBOL_TK_SLASH_EQ
@ YYSYMBOL_TK_SLASH_EQ
TK_STAR_EQ
Definition: cyacc.tab.c:697
YYSYMBOL_pointer_opt
@ YYSYMBOL_pointer_opt
pointer
Definition: cyacc.tab.c:862
YYSYMBOL_TK_BUILTIN_VA_ARG
@ YYSYMBOL_TK_BUILTIN_VA_ARG
TK_LABEL__
Definition: cyacc.tab.c:758
YYSYMBOL_TK_TYPEDEF
@ YYSYMBOL_TK_TYPEDEF
TK_STRUCT
Definition: cyacc.tab.c:676
YYSYMBOL_TK_GOTO
@ YYSYMBOL_TK_GOTO
TK_CONTINUE
Definition: cyacc.tab.c:741
YYSYMBOL_TK_CONTINUE
@ YYSYMBOL_TK_CONTINUE
TK_BREAK
Definition: cyacc.tab.c:740
YYSYMBOL_TK_BREAK
@ YYSYMBOL_TK_BREAK
TK_QUEST
Definition: cyacc.tab.c:739
YYSYMBOL_TK_ARROW
@ YYSYMBOL_TK_ARROW
TK_SUP_SUP_EQ
Definition: cyacc.tab.c:704
YYSYMBOL_enumerator
@ YYSYMBOL_enumerator
enum_list
Definition: cyacc.tab.c:845
YYSYMBOL_TK_BUILTIN_VA_LIST
@ YYSYMBOL_TK_BUILTIN_VA_LIST
TK_BUILTIN_VA_ARG
Definition: cyacc.tab.c:759
YYSYMBOL_id_or_typename
@ YYSYMBOL_id_or_typename
$@2
Definition: cyacc.tab.c:782
YYSYMBOL_TK_PERCENT
@ YYSYMBOL_TK_PERCENT
TK_SLASH
Definition: cyacc.tab.c:716
YYSYMBOL_initializer
@ YYSYMBOL_initializer
initializer_list_opt
Definition: cyacc.tab.c:794
YYSYMBOL_TK_AUTO
@ YYSYMBOL_TK_AUTO
TK_RESTRICT
Definition: cyacc.tab.c:688
YYSYMBOL_TK_INT
@ YYSYMBOL_TK_INT
TK_CHAR
Definition: cyacc.tab.c:667
YYSYMBOL_asmoperand
@ YYSYMBOL_asmoperand
asmoperandsne
Definition: cyacc.tab.c:880
YYSYMBOL_TK_COLON
@ YYSYMBOL_TK_COLON
TK_RBRACKET
Definition: cyacc.tab.c:734
YYSYMBOL_TK_SUP_EQ
@ YYSYMBOL_TK_SUP_EQ
TK_INF_EQ
Definition: cyacc.tab.c:711
YYSYMBOL_init_expression
@ YYSYMBOL_init_expression
one_string
Definition: cyacc.tab.c:791
YYSYMBOL_file
@ YYSYMBOL_file
interpret
Definition: cyacc.tab.c:776
YYSYMBOL_TK_EXCLAM
@ YYSYMBOL_TK_EXCLAM
TK_CIRC
Definition: cyacc.tab.c:721
YYSYMBOL_TK_SIZEOF
@ YYSYMBOL_TK_SIZEOF
TK_THREAD
Definition: cyacc.tab.c:691
YYSYMBOL_YYerror
@ YYSYMBOL_YYerror
"end of file"
Definition: cyacc.tab.c:656
YYSYMBOL_TK_SUP_SUP
@ YYSYMBOL_TK_SUP_SUP
TK_INF_INF
Definition: cyacc.tab.c:725
YYSYMBOL_TK_CONST
@ YYSYMBOL_TK_CONST
TK_STATIC_DIMENSION
Definition: cyacc.tab.c:686
YYSYMBOL_constant
@ YYSYMBOL_constant
expression
Definition: cyacc.tab.c:785
YYSYMBOL_TK_AT_NAME
@ YYSYMBOL_TK_AT_NAME
TK_AT_EXPR
Definition: cyacc.tab.c:770
YYSYMBOL_216_24
@ YYSYMBOL_216_24
function_def_start
Definition: cyacc.tab.c:871
YYSYMBOL_TK_RPAREN
@ YYSYMBOL_TK_RPAREN
TK_MINUS_MINUS
Definition: cyacc.tab.c:728
YYSYMBOL_TK_UINT128
@ YYSYMBOL_TK_UINT128
TK_INT128
Definition: cyacc.tab.c:669
YYSYMBOL_198_20
@ YYSYMBOL_198_20
$@19
Definition: cyacc.tab.c:853
YYSYMBOL_126_2
@ YYSYMBOL_126_2
global
Definition: cyacc.tab.c:781
YYSYMBOL_type_spec
@ YYSYMBOL_type_spec
decl_spec_list_opt_no_named
Definition: cyacc.tab.c:835
YYSYMBOL_214_23
@ YYSYMBOL_214_23
function_def
Definition: cyacc.tab.c:869
YYSYMBOL_TK_EOF
@ YYSYMBOL_TK_EOF
TK_WSTRINGCON
Definition: cyacc.tab.c:665
YYSYMBOL_TK_SUP_SUP_EQ
@ YYSYMBOL_TK_SUP_SUP_EQ
TK_INF_INF_EQ
Definition: cyacc.tab.c:703
YYSYMBOL_166_7
@ YYSYMBOL_166_7
$@6
Definition: cyacc.tab.c:821
YYSYMBOL_old_pardef_list
@ YYSYMBOL_old_pardef_list
old_parameter_list_ne
Definition: cyacc.tab.c:859
YYSYMBOL_TK_VOLATILE
@ YYSYMBOL_TK_VOLATILE
TK_SHORT
Definition: cyacc.tab.c:682
YYSYMBOL_local_labels
@ YYSYMBOL_local_labels
statement_list
Definition: cyacc.tab.c:811
YYSYMBOL_string_list
@ YYSYMBOL_string_list
one_string_constant
Definition: cyacc.tab.c:788
YYSYMBOL_abs_direct_decl_opt
@ YYSYMBOL_abs_direct_decl_opt
$@22
Definition: cyacc.tab.c:867
YYSYMBOL_202_21
@ YYSYMBOL_202_21
direct_old_proto_decl
Definition: cyacc.tab.c:857
YYSYMBOL_TK_INF
@ YYSYMBOL_TK_INF
TK_EXCLAM_EQ
Definition: cyacc.tab.c:708
YYSYMBOL_TK_INLINE
@ YYSYMBOL_TK_INLINE
TK_ATTRIBUTE
Definition: cyacc.tab.c:752
YYSYMBOL_struct_decl_list
@ YYSYMBOL_struct_decl_list
$@16
Definition: cyacc.tab.c:840
YYSYMBOL_TK_EQ_EQ
@ YYSYMBOL_TK_EQ_EQ
TK_DOT
Definition: cyacc.tab.c:706
YYSYMBOL_abs_direct_decl
@ YYSYMBOL_abs_direct_decl
abstract_decl
Definition: cyacc.tab.c:865
YYSYMBOL_TK_PRAGMA
@ YYSYMBOL_TK_PRAGMA
TK_MSATTR
Definition: cyacc.tab.c:764
YYSYMBOL_164_5
@ YYSYMBOL_164_5
$@4
Definition: cyacc.tab.c:819
YYSYMBOL_enum_list
@ YYSYMBOL_enum_list
field_decl
Definition: cyacc.tab.c:844
YYSYMBOL_182_14
@ YYSYMBOL_182_14
$@13
Definition: cyacc.tab.c:837
YYSYMBOL_TK_INT128
@ YYSYMBOL_TK_INT128
TK_INT
Definition: cyacc.tab.c:668
YYSYMBOL_TK_AT_EXPR
@ YYSYMBOL_TK_AT_EXPR
TK_AT_SPECIFIER
Definition: cyacc.tab.c:769
YYSYMBOL_field_decl_list
@ YYSYMBOL_field_decl_list
$@17
Definition: cyacc.tab.c:842
YYSYMBOL_parameter_list_startscope
@ YYSYMBOL_parameter_list_startscope
$@18
Definition: cyacc.tab.c:849
YYSYMBOL_declarator
@ YYSYMBOL_declarator
enumerator
Definition: cyacc.tab.c:846
YYSYMBOL_TK_PIPE_PIPE
@ YYSYMBOL_TK_PIPE_PIPE
TK_AND_AND
Definition: cyacc.tab.c:723
YYSYMBOL_init_declarator
@ YYSYMBOL_init_declarator
init_declarator_list
Definition: cyacc.tab.c:829
YYSYMBOL_TK__Pragma
@ YYSYMBOL_TK__Pragma
TK_PRAGMA
Definition: cyacc.tab.c:765
YYSYMBOL_expression
@ YYSYMBOL_expression
maybecomma
Definition: cyacc.tab.c:784
YYSYMBOL_location
@ YYSYMBOL_location
$@1
Definition: cyacc.tab.c:779
YYSYMBOL_TK_IF
@ YYSYMBOL_TK_IF
TK_FOR
Definition: cyacc.tab.c:749
YYSYMBOL_TK_PIPE
@ YYSYMBOL_TK_PIPE
TK_AND
Definition: cyacc.tab.c:719
YYSYMBOL_186_17
@ YYSYMBOL_186_17
struct_decl_list
Definition: cyacc.tab.c:841
YYSYMBOL_asminputs
@ YYSYMBOL_asminputs
asmoperand
Definition: cyacc.tab.c:881
YYSYMBOL_label
@ YYSYMBOL_label
local_label_names
Definition: cyacc.tab.c:813
YYSYMBOL_TK_AT_SPECIFIER
@ YYSYMBOL_TK_AT_SPECIFIER
TK_AT_TRANSFORMEXPR
Definition: cyacc.tab.c:768
YYSYMBOL_TK_AND
@ YYSYMBOL_TK_AND
TK_TILDE
Definition: cyacc.tab.c:718
YYSYMBOL_184_16
@ YYSYMBOL_184_16
$@15
Definition: cyacc.tab.c:839
YYSYMBOL_TK_LBRACE
@ YYSYMBOL_TK_LBRACE
TK_RBRACE
Definition: cyacc.tab.c:731
YYSYMBOL_176_12
@ YYSYMBOL_176_12
decl_spec_list
Definition: cyacc.tab.c:831
YYSYMBOL_TK_PERCENT_EQ
@ YYSYMBOL_TK_PERCENT_EQ
TK_SLASH_EQ
Definition: cyacc.tab.c:698
YYSYMBOL_TK_MINUS_MINUS
@ YYSYMBOL_TK_MINUS_MINUS
TK_PLUS_PLUS
Definition: cyacc.tab.c:727
YYSYMBOL_comma_expression
@ YYSYMBOL_comma_expression
opt_expression
Definition: cyacc.tab.c:801
YYSYMBOL_TK_FLOATCON
@ YYSYMBOL_TK_FLOATCON
TK_INTCON
Definition: cyacc.tab.c:661
YYSYMBOL_TK_DOT
@ YYSYMBOL_TK_DOT
TK_ARROW
Definition: cyacc.tab.c:705
YYSYMBOL_TK_INF_EQ
@ YYSYMBOL_TK_INF_EQ
TK_SUP
Definition: cyacc.tab.c:710
YYSYMBOL_old_proto_decl
@ YYSYMBOL_old_proto_decl
parameter_decl
Definition: cyacc.tab.c:855
YYSYMBOL_TK_CIRC_EQ
@ YYSYMBOL_TK_CIRC_EQ
TK_PIPE_EQ
Definition: cyacc.tab.c:701
YYSYMBOL_TK_QUEST
@ YYSYMBOL_TK_QUEST
TK_ELLIPSIS
Definition: cyacc.tab.c:738
YYSYMBOL_arguments
@ YYSYMBOL_arguments
gcc_init_designators
Definition: cyacc.tab.c:799
YYSYMBOL_old_parameter_list_ne
@ YYSYMBOL_old_parameter_list_ne
$@21
Definition: cyacc.tab.c:858
YYSYMBOL_opt_expression
@ YYSYMBOL_opt_expression
arguments
Definition: cyacc.tab.c:800
YYSYMBOL_old_pardef
@ YYSYMBOL_old_pardef
old_pardef_list
Definition: cyacc.tab.c:860
YYSYMBOL_197_19
@ YYSYMBOL_197_19
rest_par_list1
Definition: cyacc.tab.c:852
YYSYMBOL_bracket_comma_expression
@ YYSYMBOL_bracket_comma_expression
paren_comma_expression
Definition: cyacc.tab.c:805
YYSYMBOL_TK_STATIC
@ YYSYMBOL_TK_STATIC
TK_EXTERN
Definition: cyacc.tab.c:684
YYSYMBOL_my_decl_spec_list
@ YYSYMBOL_my_decl_spec_list
$@12
Definition: cyacc.tab.c:832
YYSYMBOL_TK_DECLSPEC
@ YYSYMBOL_TK_DECLSPEC
TK_BLOCKATTRIBUTE
Definition: cyacc.tab.c:761
YYSYMBOL_TK_SWITCH
@ YYSYMBOL_TK_SWITCH
TK_RETURN
Definition: cyacc.tab.c:743
YYSYMBOL_init_declarator_list
@ YYSYMBOL_init_declarator_list
declaration
Definition: cyacc.tab.c:828
YYSYMBOL_169_10
@ YYSYMBOL_169_10
$@9
Definition: cyacc.tab.c:824
YYSYMBOL_TK_AND_EQ
@ YYSYMBOL_TK_AND_EQ
TK_PERCENT_EQ
Definition: cyacc.tab.c:699
YYSYMBOL_TK_INF_INF
@ YYSYMBOL_TK_INF_INF
TK_PIPE_PIPE
Definition: cyacc.tab.c:724
YYSYMBOL_init_designators
@ YYSYMBOL_init_designators
eq_opt
Definition: cyacc.tab.c:796
YYSYMBOL_TK_STRUCT
@ YYSYMBOL_TK_STRUCT
TK_ENUM
Definition: cyacc.tab.c:675
YYSYMBOL_152_3
@ YYSYMBOL_152_3
statements_inside_block
Definition: cyacc.tab.c:807
YYSYMBOL_TK_PLUS_EQ
@ YYSYMBOL_TK_PLUS_EQ
TK_EQ
Definition: cyacc.tab.c:694
YYSYMBOL_asmoutputs
@ YYSYMBOL_asmoutputs
asmattr
Definition: cyacc.tab.c:877
YYSYMBOL_211_22
@ YYSYMBOL_211_22
abs_direct_decl
Definition: cyacc.tab.c:866
YYSYMBOL_TK_LONG
@ YYSYMBOL_TK_LONG
TK_UNSIGNED
Definition: cyacc.tab.c:680
YYSYMBOL_TK_AND_AND
@ YYSYMBOL_TK_AND_AND
TK_EXCLAM
Definition: cyacc.tab.c:722
YYSYMBOL_statement_paren_comma_expression
@ YYSYMBOL_statement_paren_comma_expression
comma_expression_opt
Definition: cyacc.tab.c:803
YYSYMBOL_statement_without_pragma
@ YYSYMBOL_statement_without_pragma
statement
Definition: cyacc.tab.c:817
YYSYMBOL_TK_DO
@ YYSYMBOL_TK_DO
TK_WHILE
Definition: cyacc.tab.c:747
YYSYMBOL_initializer_list_opt
@ YYSYMBOL_initializer_list_opt
initializer_list
Definition: cyacc.tab.c:793
YYSYMBOL_asmoperandsne
@ YYSYMBOL_asmoperandsne
asmoperands
Definition: cyacc.tab.c:879
YYSYMBOL_declaration
@ YYSYMBOL_declaration
$@11
Definition: cyacc.tab.c:827
YYSYMBOL_TK_WSTRINGCON
@ YYSYMBOL_TK_WSTRINGCON
TK_STRINGCON
Definition: cyacc.tab.c:664
YYSYMBOL_statements_inside_block
@ YYSYMBOL_statements_inside_block
bracket_comma_expression
Definition: cyacc.tab.c:806
YYSYMBOL_block
@ YYSYMBOL_block
$@3
Definition: cyacc.tab.c:808
YYSYMBOL_abstract_decl
@ YYSYMBOL_abstract_decl
type_name
Definition: cyacc.tab.c:864
YYSYMBOL_TK_WHILE
@ YYSYMBOL_TK_WHILE
TK_DEFAULT
Definition: cyacc.tab.c:746
YYSYMBOL_TK_STAR_EQ
@ YYSYMBOL_TK_STAR_EQ
TK_MINUS_EQ
Definition: cyacc.tab.c:696
YYSYMBOL_TK_INF_INF_EQ
@ YYSYMBOL_TK_INF_INF_EQ
TK_CIRC_EQ
Definition: cyacc.tab.c:702
YYSYMBOL_TK_RBRACE
@ YYSYMBOL_TK_RBRACE
TK_LPAREN
Definition: cyacc.tab.c:730
YYSYMBOL_TK_CHAR
@ YYSYMBOL_TK_CHAR
TK_EOF
Definition: cyacc.tab.c:666
YYSYMBOL_YYACCEPT
@ YYSYMBOL_YYACCEPT
TK_ADDROF
Definition: cyacc.tab.c:774
YYSYMBOL_TK_SIGNED
@ YYSYMBOL_TK_SIGNED
TK_UNION
Definition: cyacc.tab.c:678
YYSYMBOL_statement
@ YYSYMBOL_statement
pragmas
Definition: cyacc.tab.c:816
YYSYMBOL_165_6
@ YYSYMBOL_165_6
$@5
Definition: cyacc.tab.c:820
YYSYMBOL_181_13
@ YYSYMBOL_181_13
type_spec
Definition: cyacc.tab.c:836
YYSYMBOL_TK_CIRC
@ YYSYMBOL_TK_CIRC
TK_PIPE
Definition: cyacc.tab.c:720
YYSYMBOL_TK_PLUS_PLUS
@ YYSYMBOL_TK_PLUS_PLUS
TK_SUP_SUP
Definition: cyacc.tab.c:726
YYSYMBOL_167_8
@ YYSYMBOL_167_8
$@7
Definition: cyacc.tab.c:822
YYSYMBOL_interpret
@ YYSYMBOL_interpret
$accept
Definition: cyacc.tab.c:775
YYSYMBOL_TK_TILDE
@ YYSYMBOL_TK_TILDE
TK_PERCENT
Definition: cyacc.tab.c:717
YYSYMBOL_217_25
@ YYSYMBOL_217_25
$@24
Definition: cyacc.tab.c:872
YYSYMBOL_TK_REGISTER
@ YYSYMBOL_TK_REGISTER
TK_AUTO
Definition: cyacc.tab.c:689
YYSYMBOL_function_def
@ YYSYMBOL_function_def
abs_direct_decl_opt
Definition: cyacc.tab.c:868
YYSYMBOL_pointer
@ YYSYMBOL_pointer
old_pardef
Definition: cyacc.tab.c:861
YYSYMBOL_TK_FLOAT
@ YYSYMBOL_TK_FLOAT
TK_DOUBLE
Definition: cyacc.tab.c:671
YYSYMBOL_rest_par_list
@ YYSYMBOL_rest_par_list
parameter_list_startscope
Definition: cyacc.tab.c:850
YYSYMBOL_TK_COMPLEX
@ YYSYMBOL_TK_COMPLEX
TK_VOID
Definition: cyacc.tab.c:673
YYSYMBOL_TK_SLASH
@ YYSYMBOL_TK_SLASH
TK_STAR
Definition: cyacc.tab.c:715
YYSYMBOL_YYEOF
@ YYSYMBOL_YYEOF
Definition: cyacc.tab.c:655
YYSYMBOL_pragma
@ YYSYMBOL_pragma
label
Definition: cyacc.tab.c:814
YYSYMBOL_pragmas
@ YYSYMBOL_pragmas
pragma
Definition: cyacc.tab.c:815
YYSYMBOL_paren_comma_expression
@ YYSYMBOL_paren_comma_expression
statement_paren_comma_expression
Definition: cyacc.tab.c:804
YYSYMBOL_TK_ADDROF
@ YYSYMBOL_TK_ADDROF
TK_CAST
Definition: cyacc.tab.c:773
YYSYMBOL_TK_ATTRIBUTE
@ YYSYMBOL_TK_ATTRIBUTE
TK_ELSE
Definition: cyacc.tab.c:751
YYSYMBOL_direct_decl
@ YYSYMBOL_direct_decl
declarator
Definition: cyacc.tab.c:847
YYSYMBOL_183_15
@ YYSYMBOL_183_15
$@14
Definition: cyacc.tab.c:838
YYSYMBOL_TK_VOID
@ YYSYMBOL_TK_VOID
TK_FLOAT
Definition: cyacc.tab.c:672
YYSYMBOL_TK_FOR
@ YYSYMBOL_TK_FOR
TK_DO
Definition: cyacc.tab.c:748
YYSYMBOL_TK_COMMA
@ YYSYMBOL_TK_COMMA
TK_SEMICOLON
Definition: cyacc.tab.c:736
YYSYMBOL_TK_FUNCTION__
@ YYSYMBOL_TK_FUNCTION__
TK_TYPEOF
Definition: cyacc.tab.c:755
YYSYMBOL_TK_MSASM
@ YYSYMBOL_TK_MSASM
TK_DECLSPEC
Definition: cyacc.tab.c:762
YYSYMBOL_TK_DOUBLE
@ YYSYMBOL_TK_DOUBLE
TK_UINT128
Definition: cyacc.tab.c:670
YYSYMBOL_171_11
@ YYSYMBOL_171_11
for_clause
Definition: cyacc.tab.c:826
YYSYMBOL_TK_LABEL__
@ YYSYMBOL_TK_LABEL__
TK_PRETTY_FUNCTION__
Definition: cyacc.tab.c:757
YYSYMBOL_TK_PRETTY_FUNCTION__
@ YYSYMBOL_TK_PRETTY_FUNCTION__
TK_FUNCTION__
Definition: cyacc.tab.c:756
YYSYMBOL_193_18
@ YYSYMBOL_193_18
direct_decl
Definition: cyacc.tab.c:848
YYSYMBOL_eq_opt
@ YYSYMBOL_eq_opt
initializer
Definition: cyacc.tab.c:795
YYSYMBOL_TK_PLUS
@ YYSYMBOL_TK_PLUS
TK_SUP_EQ
Definition: cyacc.tab.c:712
YYSYMBOL_TK_THREAD
@ YYSYMBOL_TK_THREAD
TK_REGISTER
Definition: cyacc.tab.c:690
YYSYMBOL_type_name
@ YYSYMBOL_type_name
pointer_opt
Definition: cyacc.tab.c:863
YYSYMBOL_TK_EXTERN
@ YYSYMBOL_TK_EXTERN
TK_VOLATILE
Definition: cyacc.tab.c:683
YYSYMBOL_TK_ELSE
@ YYSYMBOL_TK_ELSE
TK_IF
Definition: cyacc.tab.c:750
YYSYMBOL_TK_ELLIPSIS
@ YYSYMBOL_TK_ELLIPSIS
TK_COMMA
Definition: cyacc.tab.c:737
YYSYMBOL_TK_DEFAULT
@ YYSYMBOL_TK_DEFAULT
TK_CASE
Definition: cyacc.tab.c:745
YYSYMBOL_initializer_list
@ YYSYMBOL_initializer_list
init_expression
Definition: cyacc.tab.c:792
YYSYMBOL_TK_AT_TRANSFORMEXPR
@ YYSYMBOL_TK_AT_TRANSFORMEXPR
TK_AT_TRANSFORM
Definition: cyacc.tab.c:767
YYSYMBOL_string_constant
@ YYSYMBOL_string_constant
constant
Definition: cyacc.tab.c:786
YYSYMBOL_attributes
@ YYSYMBOL_attributes
$@25
Definition: cyacc.tab.c:873
YYSYMBOL_TK_STAR
@ YYSYMBOL_TK_STAR
TK_MINUS
Definition: cyacc.tab.c:714
YYSYMBOL_field_decl
@ YYSYMBOL_field_decl
field_decl_list
Definition: cyacc.tab.c:843
YYSYMBOL_YYEMPTY
@ YYSYMBOL_YYEMPTY
Definition: cyacc.tab.c:654
YYSYMBOL_global
@ YYSYMBOL_global
location
Definition: cyacc.tab.c:780
YYSYMBOL_globals
@ YYSYMBOL_globals
file
Definition: cyacc.tab.c:777
YYSYMBOL_function_def_start
@ YYSYMBOL_function_def_start
$@23
Definition: cyacc.tab.c:870
YYSYMBOL_TK_LPAREN
@ YYSYMBOL_TK_LPAREN
TK_RPAREN
Definition: cyacc.tab.c:729
YYSYMBOL_asmcloberlst_ne
@ YYSYMBOL_asmcloberlst_ne
asmclobber
Definition: cyacc.tab.c:883
YYSYMBOL_TK_AT_TRANSFORM
@ YYSYMBOL_TK_AT_TRANSFORM
TK__Pragma
Definition: cyacc.tab.c:766
YYSYMBOL_one_string
@ YYSYMBOL_one_string
wstring_list
Definition: cyacc.tab.c:790
YYSYMBOL_asmoperands
@ YYSYMBOL_asmoperands
asmoutputs
Definition: cyacc.tab.c:878
YYSYMBOL_init_designators_opt
@ YYSYMBOL_init_designators_opt
init_designators
Definition: cyacc.tab.c:797
YYSYMBOL_TK_COMPLEXCON
@ YYSYMBOL_TK_COMPLEXCON
TK_AT_NAME
Definition: cyacc.tab.c:771
YYSYMBOL_TK_EQ
@ YYSYMBOL_TK_EQ
TK_ALIGNOF
Definition: cyacc.tab.c:693
YYSYMBOL_TK_CHARCON
@ YYSYMBOL_TK_CHARCON
TK_IDENT
Definition: cyacc.tab.c:659
YYSYMBOL_123_1
@ YYSYMBOL_123_1
globals
Definition: cyacc.tab.c:778
YYSYMBOL_TK_UNSIGNED
@ YYSYMBOL_TK_UNSIGNED
TK_SIGNED
Definition: cyacc.tab.c:679
YYSYMBOL_TK_INTCON
@ YYSYMBOL_TK_INTCON
TK_CHARCON
Definition: cyacc.tab.c:660
YYSYMBOL_TK_RETURN
@ YYSYMBOL_TK_RETURN
TK_GOTO
Definition: cyacc.tab.c:742
YYSYMBOL_TK_IDENT
@ YYSYMBOL_TK_IDENT
"invalid token"
Definition: cyacc.tab.c:658
YYSYMBOL_attributes_with_asm
@ YYSYMBOL_attributes_with_asm
attributes
Definition: cyacc.tab.c:874
YYSYMBOL_TK_RESTRICT
@ YYSYMBOL_TK_RESTRICT
TK_CONST
Definition: cyacc.tab.c:687
YYSYMBOL_gcc_init_designators
@ YYSYMBOL_gcc_init_designators
init_designators_opt
Definition: cyacc.tab.c:798
YYSYMBOL_TK_SUP
@ YYSYMBOL_TK_SUP
TK_INF
Definition: cyacc.tab.c:709
YYSYMBOL_TK_ENUM
@ YYSYMBOL_TK_ENUM
TK_COMPLEX
Definition: cyacc.tab.c:674
YYSYMBOL_TK_BLOCKATTRIBUTE
@ YYSYMBOL_TK_BLOCKATTRIBUTE
TK_BUILTIN_VA_LIST
Definition: cyacc.tab.c:760
YYSYMBOL_decl_spec_list_opt_no_named
@ YYSYMBOL_decl_spec_list_opt_no_named
decl_spec_list_opt
Definition: cyacc.tab.c:834
YYSYMBOL_one_string_constant
@ YYSYMBOL_one_string_constant
string_constant
Definition: cyacc.tab.c:787
YYSYMBOL_TK_STRINGCON
@ YYSYMBOL_TK_STRINGCON
TK_NAMED_TYPE
Definition: cyacc.tab.c:663
YYSYMBOL_decl_spec_list_opt
@ YYSYMBOL_decl_spec_list_opt
my_decl_spec_list
Definition: cyacc.tab.c:833
YYSYMBOL_TK_EXCLAM_EQ
@ YYSYMBOL_TK_EXCLAM_EQ
TK_EQ_EQ
Definition: cyacc.tab.c:707
YYSYMBOL_TK_SEMICOLON
@ YYSYMBOL_TK_SEMICOLON
TK_COLON
Definition: cyacc.tab.c:735
YYSYMBOL_163_4
@ YYSYMBOL_163_4
statement_without_pragma
Definition: cyacc.tab.c:818
YYSYMBOL_parameter_decl
@ YYSYMBOL_parameter_decl
$@20
Definition: cyacc.tab.c:854
YYSYMBOL_TK_STATIC_DIMENSION
@ YYSYMBOL_TK_STATIC_DIMENSION
TK_STATIC
Definition: cyacc.tab.c:685
YYSYMBOL_TK_CAST
@ YYSYMBOL_TK_CAST
TK_COMPLEXCON
Definition: cyacc.tab.c:772
YYSYMBOL_direct_old_proto_decl
@ YYSYMBOL_direct_old_proto_decl
old_proto_decl
Definition: cyacc.tab.c:856
YYSYMBOL_TK_PIPE_EQ
@ YYSYMBOL_TK_PIPE_EQ
TK_AND_EQ
Definition: cyacc.tab.c:700

Function Documentation

◆ add_initialization_expression()

static void add_initialization_expression ( int  init_p)
static

init_p = 0 => no initialization for a variable or no definition for a derived entity (struct, union, maybe enum)

Definition at line 124 of file cyacc.tab.c.

125 {
126  initialization_expressions
127  = CONS(EXPRESSION, int_to_expression(init_p), initialization_expressions);
128 }
initialization_expressions
static list initialization_expressions
to preserve information about the declarations for the prettyprinter, especially for the global varia...
Definition: cyacc.tab.c:120
CONS
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
Definition: newgen_list.h:150
int_to_expression
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
Definition: expression.c:1188
EXPRESSION
#define EXPRESSION(x)
EXPRESSION.
Definition: ri.h:1217

References CONS, EXPRESSION, initialization_expressions, and int_to_expression().

+ Here is the call graph for this function:

◆ c_parser_number_of_scopes()

int c_parser_number_of_scopes ( void  )

Definition at line 587 of file cyacc.tab.c.

588  {
589  int n = stack_size(c_parser_scope_stack);
590  return n;
591  }
c_parser_scope_stack
static stack c_parser_scope_stack
Definition: cyacc.tab.c:512
stack_size
int stack_size(const stack)
observers

References c_parser_scope_stack, and stack_size().

Referenced by is_c_parser_keyword_typedef().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ c_parser_scope_stack_empty_p()

bool c_parser_scope_stack_empty_p ( void  )

Definition at line 564 of file cyacc.tab.c.

565 {
566  return stack_empty_p(c_parser_scope_stack);
567 }
stack_empty_p
bool stack_empty_p(const stack)

References c_parser_scope_stack, and stack_empty_p().

Referenced by get_c_parser_current_scope().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ CreateDefaultContext()

c_parser_context CreateDefaultContext ( void  )

Definition at line 292 of file cyacc.tab.c.

293 {
294  c_parser_context c = make_c_parser_context(empty_scope(),
295  type_undefined,
296  storage_undefined,
297  NIL,
298  false,
299  false);
300  pips_debug(8, "New default context %p\n", c);
301  return c;
302 }
make_c_parser_context
c_parser_context make_c_parser_context(string a1, type a2, storage a3, list a4, bool a5, bool a6)
Definition: c_parser_private.c:52
NIL
#define NIL
The empty list (nil in Lisp)
Definition: newgen_list.h:47
pips_debug
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
Definition: misc-local.h:145
empty_scope
string empty_scope()
Functions used to manage the block scoping in conjunction with ContextStack and yco ntext.
Definition: entity.c:498
type_undefined
#define type_undefined
Definition: ri.h:2883
storage_undefined
#define storage_undefined
Definition: ri.h:2476
_newgen_struct_c_parser_context_
Definition: c_parser_private.h:70

References empty_scope(), make_c_parser_context(), NIL, pips_debug, storage_undefined, and type_undefined.

Referenced by EnterScope().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ EnterScope()

static void EnterScope ( )
static

Definition at line 311 of file cyacc.tab.c.

312 {
313  c_parser_context nc = CreateDefaultContext();
314  string cs = string_undefined;
315 
316  push_new_c_parser_scope(); // For the lexical analyzer
317 
318  pips_assert("C_scope_identifier has been initialized", C_scope_identifier>-2);
319 
320  if(!stack_empty_p(ContextStack)) {
321  c_parser_context c = (c_parser_context) stack_head(ContextStack);
322  pips_assert("The current context is defined", !c_parser_context_undefined_p(c));
323  pips_assert("The current context scope is defined",
324  !string_undefined_p(c_parser_context_scope(c))
325  && c_parser_context_scope(c)!=NULL);
326  pips_assert("The current context only contains scope information",
327  //type_undefined_p(c_parser_context_type(c)) &&
328  storage_undefined_p(c_parser_context_storage(c))
329  && ENDP(c_parser_context_qualifiers(c))
330  //&& !c_parser_context_typedef(c)
331  //&& !c_parser_context_static(c)
332  );
333  cs = c_parser_context_scope(c);
334  pips_assert("scope contains only block scope information", string_block_scope_p(cs));
335  }
336  else
337  cs = "";
338 
339  // Add scope information if any
340  C_scope_identifier++;
341  // A scope is needed right away to distinguish between formal
342  // parameters and local variables. See
343  // Validation/C_syntax/block_scope01.c, identifier x in function foo
344  if(C_scope_identifier>=0) {
345  string ns = int2a(C_scope_identifier);
346 
347  char * stf = c_parser_context_scope(nc);
348  c_parser_context_scope(nc) = strdup(concatenate(cs, ns, BLOCK_SEP_STRING, NULL));
349  free(stf);
350  free(ns);
351  }
352  else {
353  char * stf = c_parser_context_scope(nc);
354  c_parser_context_scope(nc) = strdup(cs);
355  free(stf);
356  }
357 
358  stack_push((char *) nc, ContextStack);
359  //ycontext = nc;
360  //pips_assert("ycontext is consistant with stack_head(ContextStack)",
361  // ycontext==stack_head(ContextStack));
362  pips_debug(8, "New block scope string: \"%s\" for context %p\n",
363  c_parser_context_scope(nc), nc);
364 }
ContextStack
stack ContextStack
Definition: c_parser.c:117
c_parser_context_undefined_p
#define c_parser_context_undefined_p(x)
Definition: c_parser_private.h:55
c_parser_context_storage
#define c_parser_context_storage(x)
Definition: c_parser_private.h:86
c_parser_context_qualifiers
#define c_parser_context_qualifiers(x)
Definition: c_parser_private.h:88
c_parser_context
struct _newgen_struct_c_parser_context_ * c_parser_context
Definition: c_parser_private.h:43
c_parser_context_scope
#define c_parser_context_scope(x)
Definition: c_parser_private.h:82
push_new_c_parser_scope
void push_new_c_parser_scope()
Definition: cyacc.tab.c:549
CreateDefaultContext
c_parser_context CreateDefaultContext()
Definition: cyacc.tab.c:292
free
void free(void *)
C_scope_identifier
static int C_scope_identifier
Definition: cyacc.tab.c:304
ENDP
#define ENDP(l)
Test if a list is empty.
Definition: newgen_list.h:66
pips_assert
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
Definition: misc-local.h:172
BLOCK_SEP_STRING
#define BLOCK_SEP_STRING
Scope separator.
Definition: naming-local.h:50
concatenate
string concatenate(const char *,...)
Return the concatenation of the given strings.
Definition: string.c:183
stack_head
void * stack_head(const stack)
returns the item on top of stack s
Definition: stack.c:420
stack_push
void stack_push(void *, stack)
stack use
Definition: stack.c:373
string_undefined
#define string_undefined
Definition: newgen_types.h:40
string_undefined_p
#define string_undefined_p(s)
Definition: newgen_types.h:41
string_block_scope_p
bool string_block_scope_p(string s)
Definition: entity.c:511
storage_undefined_p
#define storage_undefined_p(x)
Definition: ri.h:2477
strdup
char * strdup()
int2a
char * int2a(int)
util.c
Definition: util.c:42
stf
bool stf(const string)
standardize_structure.c

References BLOCK_SEP_STRING, c_parser_context_qualifiers, c_parser_context_scope, c_parser_context_storage, c_parser_context_undefined_p, C_scope_identifier, concatenate(), ContextStack, CreateDefaultContext(), ENDP, free(), int2a(), pips_assert, pips_debug, push_new_c_parser_scope(), stack_empty_p(), stack_head(), stack_push(), stf(), storage_undefined_p, strdup(), string_block_scope_p(), string_undefined, and string_undefined_p.

+ Here is the call graph for this function:

◆ ExitScope()

void ExitScope ( void  )

Definition at line 400 of file cyacc.tab.c.

401 {
402  c_parser_context c = (c_parser_context) stack_head(ContextStack);
403 
404  pop_c_parser_scope_stack();
405 
406  pips_assert("The current context is defined", !c_parser_context_undefined_p(c));
407  pips_assert("The current context scope is defined",
408  !string_undefined_p(c_parser_context_scope(c))
409  && c_parser_context_scope(c)!=NULL);
410  pips_assert("The current context only contains scope information",
411  //type_undefined_p(c_parser_context_type(c)) &&
412  storage_undefined_p(c_parser_context_storage(c))
413  && ENDP(c_parser_context_qualifiers(c))
414  //&& !c_parser_context_typedef(c)
415  //&& !c_parser_context_static(c)
416  );
417  pips_debug(8, "Exiting context scope \"\%s\" in context %p\n",
418  c_parser_context_scope(c), c);
419  free_c_parser_context(c);
420  (void) stack_pop(ContextStack);
421  if(!stack_empty_p(ContextStack)) {
422  c_parser_context oc = (c_parser_context) stack_head(ContextStack);
423  //pips_assert("ycontext is consistant with stack_head(ContextStack)",
424  // ycontext==stack_head(ContextStack));
425  pips_debug(8, "Back to context scope \"\%s\" in context %p\n",
426  c_parser_context_scope(oc), oc);
427  }
428  else {
429  // ycontext = c_parser_context_undefined;
430  pips_debug(8, "Back to undefined context scope\n");
431  }
432 }
free_c_parser_context
void free_c_parser_context(c_parser_context p)
Definition: c_parser_private.c:19
pop_c_parser_scope_stack
void pop_c_parser_scope_stack()
Definition: cyacc.tab.c:558
stack_pop
void * stack_pop(stack)
POPs one item from stack s.
Definition: stack.c:399

References c_parser_context_qualifiers, c_parser_context_scope, c_parser_context_storage, c_parser_context_undefined_p, ContextStack, ENDP, free_c_parser_context(), pips_assert, pips_debug, pop_c_parser_scope_stack(), stack_empty_p(), stack_head(), stack_pop(), storage_undefined_p, and string_undefined_p.

+ Here is the call graph for this function:

◆ flush_expression_comment()

static statement flush_expression_comment ( statement  s)
static

flushes all expression comments and add them to statement s

Definition at line 182 of file cyacc.tab.c.

182  {
183  if(!empty_comments_p(expression_comment)) {
184  if(!empty_comments_p(statement_comments(s))) {
185  char *tmp = statement_comments(s);
186  asprintf(&statement_comments(s),"%s%s",statement_comments(s),expression_comment);
187  free(tmp);
188  free(expression_comment);
189  }
190  else
191  statement_comments(s) = expression_comment;
192  statement_number(s) = expression_line_number;
193  expression_line_number = STATEMENT_NUMBER_UNDEFINED;
194  expression_comment=string_undefined;
195  }
196  return s;
197 }
expression_line_number
static int expression_line_number
Definition: cyacc.tab.c:166
expression_comment
static string expression_comment
FI: these two variables are used in conjunction with comma expressions.
Definition: cyacc.tab.c:165
empty_comments_p
bool empty_comments_p(const char *)
Definition: statement.c:107
asprintf
#define asprintf
Definition: misc-local.h:225
STATEMENT_NUMBER_UNDEFINED
#define STATEMENT_NUMBER_UNDEFINED
default values
Definition: ri-util-local.h:1720
statement_comments
#define statement_comments(x)
Definition: ri.h:2456
statement_number
#define statement_number(x)
Definition: ri.h:2452

References asprintf, empty_comments_p(), expression_comment, expression_line_number, free(), statement_comments, statement_number, STATEMENT_NUMBER_UNDEFINED, and string_undefined.

Referenced by flush_statement_comment().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ flush_statement_comment()

static statement flush_statement_comment ( statement  s)
static

flushes all statement comments and add them to statement s

Definition at line 211 of file cyacc.tab.c.

211  {
212  s=flush_expression_comment(s); // should not be necessary
213  if(!ENDP(all_expression_comments_as_statement_comments)) {
214  pips_assert("not on a block",!statement_block_p(s));
215  all_expression_comments_as_statement_comments = gen_nreverse(all_expression_comments_as_statement_comments);
216  char * comments = list_to_string(all_expression_comments_as_statement_comments);
217  if(!empty_comments_p(statement_comments(s))) {
218  char *tmp = statement_comments(s);
219  asprintf(&statement_comments(s),"%s%s",statement_comments(s), comments);
220  free(tmp);
221  free(comments);
222  }
223  else
224  statement_comments(s) = comments;
225  FOREACH(STRING,s,all_expression_comments_as_statement_comments) free(s);
226  gen_free_list(all_expression_comments_as_statement_comments);
227  all_expression_comments_as_statement_comments=NIL;
228  }
229  return s;
230 }
list_to_string
string list_to_string(list l)
Return the malloc()ed version of the concatenation of all the strings in the list.
Definition: args.c:74
all_expression_comments_as_statement_comments
static list all_expression_comments_as_statement_comments
after a while (crocodile) expression comments are pushed into a list that is purged upon call to add_...
Definition: cyacc.tab.c:202
flush_expression_comment
static statement flush_expression_comment(statement s)
flushes all expression comments and add them to statement s
Definition: cyacc.tab.c:182
STRING
#define STRING(x)
Definition: genC.h:87
gen_nreverse
list gen_nreverse(list cp)
reverse a list in place
Definition: list.c:304
gen_free_list
void gen_free_list(list l)
free the spine of the list
Definition: list.c:327
FOREACH
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
Definition: newgen_list.h:179
statement_block_p
#define statement_block_p(stat)
Definition: ri-util-local.h:1778

References all_expression_comments_as_statement_comments, asprintf, empty_comments_p(), ENDP, flush_expression_comment(), FOREACH, free(), gen_free_list(), gen_nreverse(), list_to_string(), NIL, pips_assert, statement_block_p, statement_comments, and STRING.

+ Here is the call graph for this function:

◆ force_reset_c_parser_scope_stack()

void force_reset_c_parser_scope_stack ( void  )

To be used by an error handler.

Definition at line 539 of file cyacc.tab.c.

540  {
541  if(c_parser_scope_stack != stack_undefined) {
542  stack_free(&c_parser_scope_stack);
543  c_parser_scope_stack = stack_undefined;
544  }
545  c_parser_scope_number = SCOPE_UNDEFINED;
546  return;
547  }
SCOPE_UNDEFINED
#define SCOPE_UNDEFINED
Each scope in the current unit has its own number.
Definition: cyacc.tab.c:510
c_parser_scope_number
static int c_parser_scope_number
Definition: cyacc.tab.c:511
stack_undefined
#define stack_undefined
Definition: newgen_stack.h:55
stack_free
void stack_free(stack *)
type, bucket_size, policy
Definition: stack.c:292

References c_parser_scope_number, c_parser_scope_stack, SCOPE_UNDEFINED, stack_free(), and stack_undefined.

Referenced by c_parser_error().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ free()

void free ( void *  )

Referenced by EnterScope(), flush_expression_comment(), flush_statement_comment(), and reset_expression_comment().

+ Here is the caller graph for this function:

◆ get_c_parser_current_scope()

string get_c_parser_current_scope ( void  )

Definition at line 569 of file cyacc.tab.c.

570  {
571  string sn = string_undefined;
572  if(c_parser_scope_stack_empty_p()) {
573  // We are at the global level: no scope has been entered yet
574  sn = "";
575  }
576  else
577  sn = (string) stack_head(c_parser_scope_stack);
578  return sn;
579  }
c_parser_scope_stack_empty_p
bool c_parser_scope_stack_empty_p()
Definition: cyacc.tab.c:564
string
char * string
STRING.
Definition: newgen_types.h:39

References c_parser_scope_stack, c_parser_scope_stack_empty_p(), stack_head(), and string_undefined.

Referenced by c_parser_put_new_typedef(), and is_c_parser_keyword_typedef().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_c_parser_nth_scope()

string get_c_parser_nth_scope ( int  n)

Definition at line 581 of file cyacc.tab.c.

582  {
583  string sn = (string) stack_nth(c_parser_scope_stack, n);
584  return sn;
585  }
stack_nth
void * stack_nth(const stack, int)
returns the nth item starting from the head and counting from 1, when possible, or NULL,...
Definition: stack.c:436

References c_parser_scope_stack, and stack_nth().

Referenced by is_c_parser_keyword_typedef().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_declaration_counter()

int get_declaration_counter ( void  )

Definition at line 497 of file cyacc.tab.c.

498  {
499  return declaration_counter;
500  }
declaration_counter
static int declaration_counter
Declaration counter.
Definition: cyacc.tab.c:490

References declaration_counter.

Referenced by set_current_dummy_parameter_number().

+ Here is the caller graph for this function:

◆ GetContext()

c_parser_context GetContext ( void  )

Definition at line 458 of file cyacc.tab.c.

459 {
460 
461  c_parser_context c = c_parser_context_undefined;
462 
463  if(!stack_empty_p(ContextStack))
464  c = (c_parser_context) stack_head(ContextStack);
465  else
466  // Should we return a default context?
467  // Not really compatible with a clean memory allocation policy
468  pips_internal_error("No current context");
469 
470  pips_debug(8, "Context %p is obtained from stack position %d\n",
471  c, stack_size(ContextStack));
472 
473  return c;
474 }
c_parser_context_undefined
#define c_parser_context_undefined
Definition: c_parser_private.h:54
pips_internal_error
#define pips_internal_error
Definition: misc-local.h:149

References c_parser_context_undefined, ContextStack, pips_debug, pips_internal_error, stack_empty_p(), stack_head(), and stack_size().

Referenced by FindOrCreateCurrentEntity().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ GetContextCopy()

c_parser_context GetContextCopy ( void  )

Definition at line 476 of file cyacc.tab.c.

477 {
478  c_parser_context c = (c_parser_context) stack_head(ContextStack);
479  c_parser_context cc = copy_c_parser_context(c);
480  pips_debug(8, "Context copy %p with scope \"%s\" is obtained from context %p with scope \"%s\" at stack position %d\n",
481  cc, c_parser_context_scope(cc),
482  c, c_parser_context_scope(c),
483  stack_size(ContextStack));
484  return cc;
485 }
copy_c_parser_context
c_parser_context copy_c_parser_context(c_parser_context p)
C_PARSER_CONTEXT.
Definition: c_parser_private.c:16

References c_parser_context_scope, ContextStack, copy_c_parser_context(), pips_debug, stack_head(), and stack_size().

+ Here is the call graph for this function:

◆ GetDerivedEntityDeclarations()

static list GetDerivedEntityDeclarations ( )
static

The list spine is going to be reused by the caller. No need to free.

Definition at line 610 of file cyacc.tab.c.

611 {
612  list l = internal_derived_entity_declarations;
613  /* The list spine is going to be reused by the caller. No need to
614  free. */
615  internal_derived_entity_declarations = NIL;
616  return l;
617 }
internal_derived_entity_declarations
static list internal_derived_entity_declarations
When struct and union declarations are nested, the rules cannot return information about the internal...
Definition: cyacc.tab.c:601
cons
The structure used to build lists in NewGen.
Definition: newgen_list.h:41

References internal_derived_entity_declarations, and NIL.

◆ GetFunction()

entity GetFunction ( void  )

cproto workaround

cyacc.tab.c

from "cyacc.y"

Definition at line 146 of file cyacc.tab.c.

147 {
148  entity f = stack_head(FunctionStack);
149  return f;
150 }
FunctionStack
stack FunctionStack
Definition: c_parser.c:118
f
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
Definition: offsets.c:15
_newgen_struct_entity_
Definition: ri.h:2778

References f(), FunctionStack, and stack_head().

+ Here is the call graph for this function:

◆ GetParentScope()

string GetParentScope ( void  )

Definition at line 387 of file cyacc.tab.c.

388 {
389  string s = "";
390 
391  if(!stack_empty_p(ContextStack) && stack_size(ContextStack)>=2) {
392  c_parser_context c = (c_parser_context) stack_nth(ContextStack,2);
393 
394  s = c_parser_context_scope(c);
395  }
396 
397  return s;
398 }

References c_parser_context_scope, ContextStack, stack_empty_p(), stack_nth(), and stack_size().

Referenced by FindEntityFromLocalNameAndPrefix().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ GetScope()

string GetScope ( void  )

FI: I do not know if it wouldn't be better to initialize the ContextStack with a default context before calling the C parser

Definition at line 371 of file cyacc.tab.c.

372 {
373  string s = "";
374 
375  /* FI: I do not know if it wouldn't be better to initialize the
376  ContextStack with a default context before calling the C
377  parser */
378  if(!stack_empty_p(ContextStack)) {
379  c_parser_context c = (c_parser_context) stack_head(ContextStack);
380 
381  s = c_parser_context_scope(c);
382  }
383 
384  return s;
385 }

References c_parser_context_scope, ContextStack, stack_empty_p(), and stack_head().

Referenced by CreateEntityFromLocalNameAndPrefix(), CreateMemberScope(), and FindEntityFromLocalNameAndPrefix().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ init_c_parser_scope_stack()

void init_c_parser_scope_stack ( void  )

Definition at line 514 of file cyacc.tab.c.

515  {
516  c_parser_scope_number = 0;
517  pips_assert("The stack is undefined",
518  stack_undefined_p(c_parser_scope_stack));
519  c_parser_scope_stack = stack_make(string_domain, 0, 0);
520  }
string_domain
@ string_domain
Definition: genC.h:170
stack_make
stack stack_make(int, int, int)
allocation
Definition: stack.c:246
stack_undefined_p
#define stack_undefined_p(s)
Definition: newgen_stack.h:56

References c_parser_scope_number, c_parser_scope_stack, pips_assert, stack_make(), stack_undefined_p, and string_domain.

Referenced by actual_c_parser().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ InitScope()

void InitScope ( void  )

Definition at line 306 of file cyacc.tab.c.

307 {
308  C_scope_identifier = -1;
309 }

References C_scope_identifier.

Referenced by actual_c_parser().

+ Here is the caller graph for this function:

◆ malloc()

void* malloc ( YYSIZE_T  )

◆ pop_block_scope()

string pop_block_scope ( string  old_scope)

The scope is moved up the scope tree and a NULL is return when there are no more scope to explore.

get rid of last block separator

Parameters
old_scopeld_scope

Definition at line 235 of file cyacc.tab.c.

236 {
237  string new_scope = old_scope;
238  string last_scope = string_undefined;
239 
240  pips_debug(8, "old_scope = \"%s\"\n", old_scope);
241  pips_assert("old_scope is a scope", string_block_scope_p(old_scope));
242 
243  if(strlen(old_scope)>0) {
244  /* get rid of last block separator */
245  new_scope[strlen(new_scope)-1] = '\0';
246  last_scope = strrchr(new_scope, BLOCK_SEP_CHAR);
247 
248  if(last_scope==NULL)
249  *new_scope = '\0';
250  else
251  *(last_scope+1) = '\0';
252  }
253  else
254  new_scope = NULL;
255 
256  if(new_scope!=NULL) {
257  pips_debug(8, "new_scope = \"%s\"\n", new_scope);
258  pips_assert("new_scope is a scope", string_block_scope_p(new_scope));
259  }
260  else {
261  pips_debug(8, "new_scope = NULL\n");
262  }
263 
264  return new_scope;
265 }
BLOCK_SEP_CHAR
#define BLOCK_SEP_CHAR
Definition: naming-local.h:51

References BLOCK_SEP_CHAR, pips_assert, pips_debug, string_block_scope_p(), and string_undefined.

Referenced by FindEntityFromLocalNameAndPrefixAndScope(), and FindOrCreateEntityFromLocalNameAndPrefixAndScope().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_c_parser_scope_stack()

void pop_c_parser_scope_stack ( void  )

Definition at line 558 of file cyacc.tab.c.

559  {
560  stack_pop(c_parser_scope_stack);
561  return;
562  }

References c_parser_scope_stack, and stack_pop().

Referenced by ExitScope().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PopContext()

void PopContext ( void  )

Definition at line 441 of file cyacc.tab.c.

442 {
443  c_parser_context fc = (c_parser_context) stack_head(ContextStack);
444 
445  pips_debug(8, "Context %p with scope \"%s\" is popped from stack position %d\n",
446  fc, c_parser_context_scope(fc), stack_size(ContextStack));
447  (void)stack_pop(ContextStack);
448  if(stack_empty_p(ContextStack)) {
449  pips_debug(8, "context stack is now empty\n");
450  }
451  else {
452  c_parser_context h = (c_parser_context) stack_head(ContextStack);
453  pips_debug(8, "Context %p with scope \"%s\" is top of stack at position %d\n",
454  h, c_parser_context_scope(h), stack_size(ContextStack));
455  }
456 }

References c_parser_context_scope, ContextStack, pips_debug, stack_empty_p(), stack_head(), stack_pop(), and stack_size().

+ Here is the call graph for this function:

◆ PopFunction()

static void PopFunction ( )
static

Definition at line 141 of file cyacc.tab.c.

142 {
143  stack_pop(FunctionStack);
144  }

References FunctionStack, and stack_pop().

+ Here is the call graph for this function:

◆ push_new_c_parser_scope()

void push_new_c_parser_scope ( void  )

Definition at line 549 of file cyacc.tab.c.

550  {
551  c_parser_scope_number++;
552  string sn = string_undefined;
553  (void) asprintf(&sn, "%d", c_parser_scope_number);
554  stack_push((void *) sn, c_parser_scope_stack);
555  return;
556  }

References asprintf, c_parser_scope_number, c_parser_scope_stack, stack_push(), and string_undefined.

Referenced by EnterScope().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PushContext()

void PushContext ( c_parser_context  c)

Definition at line 434 of file cyacc.tab.c.

435 {
436  stack_push((char *) c, ContextStack);
437  pips_debug(8, "Context %p with scope \"%s\" is put in stack position %d\n",
438  c, c_parser_context_scope(c), stack_size(ContextStack));
439 }

References c_parser_context_scope, ContextStack, pips_debug, stack_push(), and stack_size().

+ Here is the call graph for this function:

◆ PushFunction()

static void PushFunction ( entity  f)
static

The following structures must be stacks because all the related entities are in recursive structures.

Since there are not stacks with basic types such as integer or logical domain, I used basic_domain to avoid creating special stacks for FormalStack, OffsetStack, ...

Definition at line 136 of file cyacc.tab.c.

137 {
138  stack_push((char *) f, FunctionStack);
139 }

References f(), FunctionStack, and stack_push().

+ Here is the call graph for this function:

◆ RecordDerivedEntityDeclaration()

static void RecordDerivedEntityDeclaration ( entity  de)
static

Definition at line 603 of file cyacc.tab.c.

604 {
605  internal_derived_entity_declarations
606  = gen_nconc(internal_derived_entity_declarations,
607  CONS(ENTITY, de, NIL));
608 }
gen_nconc
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
Definition: list.c:344
ENTITY
#define ENTITY(x)
ENTITY.
Definition: ri.h:2755

References CONS, ENTITY, gen_nconc(), internal_derived_entity_declarations, and NIL.

+ Here is the call graph for this function:

◆ reset_c_parser_scope_stack()

void reset_c_parser_scope_stack ( void  )

Definition at line 522 of file cyacc.tab.c.

523  {
524  if(c_parser_scope_stack != stack_undefined) {
525  if(stack_empty_p(c_parser_scope_stack)) {
526  stack_free(&c_parser_scope_stack);
527  c_parser_scope_stack = stack_undefined;
528  }
529  else {
530  // pips_internal_error? Could be a bad input C file...
531  pips_user_warning("Parser scope stack is not empty.\n");
532  }
533  }
534  c_parser_scope_number = SCOPE_UNDEFINED;
535  return;
536  }
pips_user_warning
#define pips_user_warning
Definition: misc-local.h:146

References c_parser_scope_number, c_parser_scope_stack, pips_user_warning, SCOPE_UNDEFINED, stack_empty_p(), stack_free(), and stack_undefined.

Referenced by actual_c_parser().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ reset_declaration_counter()

void reset_declaration_counter ( void  )

Definition at line 492 of file cyacc.tab.c.

493  {
494  declaration_counter = 0;
495  }

References declaration_counter.

Referenced by actual_c_parser(), and c_parser_error().

+ Here is the caller graph for this function:

◆ reset_expression_comment()

void reset_expression_comment ( void  )

we don't want an expression comment with new lines, it is disgracefull

Too bad. This should not happen, but it happens with comma expressions in header files

Definition at line 169 of file cyacc.tab.c.

170 {
171  if(!string_undefined_p(expression_comment)) {
172  /* Too bad. This should not happen, but it happens with comma
173  expressions in header files */
174  free(expression_comment);
175  expression_comment = string_undefined;
176  }
177 
178  expression_line_number = STATEMENT_NUMBER_UNDEFINED;
179 }

References expression_comment, expression_line_number, free(), STATEMENT_NUMBER_UNDEFINED, string_undefined, and string_undefined_p.

Referenced by actual_c_parser(), and c_parser_error().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ResetDerivedEntityDeclarations()

static void ResetDerivedEntityDeclarations ( )
static

Definition at line 619 of file cyacc.tab.c.

620 {
621  if(!ENDP(internal_derived_entity_declarations)) {
622  gen_free_list(internal_derived_entity_declarations);
623  internal_derived_entity_declarations = NIL;
624  }
625 }

References ENDP, gen_free_list(), internal_derived_entity_declarations, and NIL.

+ Here is the call graph for this function:

◆ save_expression_comment_as_statement_comment()

static void save_expression_comment_as_statement_comment ( )
static

Definition at line 203 of file cyacc.tab.c.

203  {
204  if(!string_undefined_p(expression_comment)) {
205  all_expression_comments_as_statement_comments =
206  CONS(STRING,expression_comment, all_expression_comments_as_statement_comments);
207  }
208  expression_comment=string_undefined;
209 }

References all_expression_comments_as_statement_comments, CONS, expression_comment, STRING, string_undefined, and string_undefined_p.

◆ scope_to_block_scope()

string scope_to_block_scope ( string  full_scope)

Allocate a new string containing only block scope information.

Parameters
full_scopeull_scope

Definition at line 268 of file cyacc.tab.c.

269 {
270  string l_scope = strrchr(full_scope, BLOCK_SEP_CHAR);
271  string f_scope = strchr(full_scope, MODULE_SEP);
272  string block_scope = string_undefined;
273 
274  pips_debug(8, "full_scope = \"%s\"\n", full_scope);
275 
276  if(f_scope==NULL)
277  f_scope = full_scope;
278  else
279  f_scope++;
280 
281  if(l_scope==NULL)
282  block_scope = strdup("");
283  else
284  block_scope = gen_strndup0(f_scope, (unsigned) (l_scope-f_scope+1));
285 
286  pips_debug(8, "f_scope = \"%s\", l_scope = \"%s\"\n", f_scope, l_scope);
287  pips_assert("block_scope is a scope", string_block_scope_p(block_scope));
288 
289  return block_scope;
290 }
MODULE_SEP
#define MODULE_SEP
special characters to build entity names of various kinds
Definition: naming-local.h:27
gen_strndup0
string gen_strndup0(string, size_t)
Like strdup() but copy at most n characters.
Definition: string.c:83

References BLOCK_SEP_CHAR, gen_strndup0(), MODULE_SEP, pips_assert, pips_debug, strdup(), string_block_scope_p(), and string_undefined.

Referenced by constant_memory_access_path_to_location_name(), CreateEntityFromLocalNameAndPrefix(), CreateMemberScope(), FindEntityFromLocalNameAndPrefix(), and FindOrCreateCurrentEntity().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ScopeStackSize()

int ScopeStackSize ( void  )

Definition at line 366 of file cyacc.tab.c.

367 {
368  return stack_size(ContextStack);
369 }

References ContextStack, and stack_size().

Referenced by FindEntityFromLocalNameAndPrefix().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ 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 2486 of file cyacc.tab.c.

2488 {
2489  int yylno = yyrline[yyrule];
2490  int yynrhs = yyr2[yyrule];
2491  int yyi;
2492  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
2493  yyrule - 1, yylno);
2494  /* The symbols being reduced. */
2495  for (yyi = 0; yyi < yynrhs; yyi++)
2496  {
2497  YYFPRINTF (stderr, " $%d = ", yyi + 1);
2498  yy_symbol_print (stderr,
2499  YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
2500  &yyvsp[(yyi + 1) - (yynrhs)]);
2501  YYFPRINTF (stderr, "\n");
2502  }
2503 }
yy_symbol_print
static void yy_symbol_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
-----------------------—.
Definition: cyacc.tab.c:2447
yyrline
static const yytype_int16 yyrline[]
YYRLINE[YYN] – Source line where rule number YYN was defined.
Definition: cyacc.tab.c:1279
YY_ACCESSING_SYMBOL
#define YY_ACCESSING_SYMBOL(State)
Accessing symbol of state STATE.
Definition: cyacc.tab.c:1318
yyr2
static const yytype_int8 yyr2[]
YYR2[RULE-NUM] – Number of symbols on the right-hand side of rule RULE-NUM.
Definition: cyacc.tab.c:2322
YYFPRINTF
#define YYFPRINTF
Enable debugging if requested.
Definition: cyacc.tab.c:2400

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 2463 of file cyacc.tab.c.

2464 {
2465  YYFPRINTF (stderr, "Stack now");
2466  for (; yybottom <= yytop; yybottom++)
2467  {
2468  int yybot = *yybottom;
2469  YYFPRINTF (stderr, " %d", yybot);
2470  }
2471  YYFPRINTF (stderr, "\n");
2472 }

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 2447 of file cyacc.tab.c.

2449 {
2450  YYFPRINTF (yyo, "%s %s (",
2451  yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
2452 
2453  yy_symbol_value_print (yyo, yykind, yyvaluep);
2454  YYFPRINTF (yyo, ")");
2455 }
yysymbol_name
static const char * yysymbol_name(yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED
The user-facing name of the symbol whose (internal) number is YYSYMBOL.
Definition: cyacc.tab.c:1383
YYNTOKENS
#define YYNTOKENS
YYNTOKENS – Number of terminals.
Definition: cyacc.tab.c:1214
yy_symbol_value_print
static void yy_symbol_value_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
-------------------------------—.
Definition: cyacc.tab.c:2429

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 2429 of file cyacc.tab.c.

2431 {
2432  FILE *yyoutput = yyo;
2433  YY_USE (yyoutput);
2434  if (!yyvaluep)
2435  return;
2436  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2437  YY_USE (yykind);
2438  YY_IGNORE_MAYBE_UNINITIALIZED_END
2439 }
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: cyacc.tab.c:1059
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: cyacc.tab.c:1060
YY_USE
#define YY_USE(E)
Suppress unused-variable warnings by "using" E.
Definition: cyacc.tab.c:1036

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

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.
-------------------------------------------—. | Release the memory associated to this symbol. | `--------------------------------------------—

Definition at line 2548 of file cyacc.tab.c.

2550 {
2551  YY_USE (yyvaluep);
2552  if (!yymsg)
2553  yymsg = "Deleting";
2554  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
2555 
2556  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2557  YY_USE (yykind);
2558  YY_IGNORE_MAYBE_UNINITIALIZED_END
2559 }
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Definition: cyacc.tab.c:2412

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 1383 of file cyacc.tab.c.

1384 {
1385  return yytname[yysymbol];
1386 }
yytname
static const char *const yytname[]
YYTNAME[SYMBOL-NUM] – String name of the symbol SYMBOL-NUM.
Definition: cyacc.tab.c:1327

References yytname.

Referenced by yy_symbol_print().

+ Here is the caller graph for this function:

Variable Documentation

◆ abstract_counter

int abstract_counter = 1
static

to create temporary entities for abstract types

Definition at line 118 of file cyacc.tab.c.

◆ all_expression_comments_as_statement_comments

list all_expression_comments_as_statement_comments = NIL
static

after a while (crocodile) expression comments are pushed into a list that is purged upon call to add_expression_comment

Definition at line 202 of file cyacc.tab.c.

Referenced by flush_statement_comment(), and save_expression_comment_as_statement_comment().

◆ c_parser_scope_number

int c_parser_scope_number = SCOPE_UNDEFINED
static

Definition at line 511 of file cyacc.tab.c.

Referenced by force_reset_c_parser_scope_stack(), init_c_parser_scope_stack(), push_new_c_parser_scope(), and reset_c_parser_scope_stack().

◆ c_parser_scope_stack

stack c_parser_scope_stack = stack_undefined
static

Definition at line 512 of file cyacc.tab.c.

Referenced by c_parser_number_of_scopes(), c_parser_scope_stack_empty_p(), force_reset_c_parser_scope_stack(), get_c_parser_current_scope(), get_c_parser_nth_scope(), init_c_parser_scope_stack(), pop_c_parser_scope_stack(), push_new_c_parser_scope(), and reset_c_parser_scope_stack().

◆ C_scope_identifier

int C_scope_identifier = -2
static

Definition at line 304 of file cyacc.tab.c.

Referenced by EnterScope(), and InitScope().

◆ CurrentMode

int CurrentMode = 0
static

to know the mode of the formal parameter: by value or by reference

Definition at line 114 of file cyacc.tab.c.

◆ declaration_counter

int declaration_counter = 0
static

Declaration counter.

It is used to declare the formal parameters in function declarations.

Definition at line 490 of file cyacc.tab.c.

Referenced by get_declaration_counter(), and reset_declaration_counter().

◆ enum_counter

int enum_counter = 0
static

to compute the enumerator value: val(i) = val(i-1) + 1

Definition at line 117 of file cyacc.tab.c.

◆ expression_comment

string expression_comment = string_undefined
static

FI: these two variables are used in conjunction with comma expressions.

I do not remember why they are needed. They sometimes stay set although they have become useless. The parser used not to reset them systematically, which caused problems with io_intrinsics*.c

Definition at line 165 of file cyacc.tab.c.

Referenced by flush_expression_comment(), reset_expression_comment(), and save_expression_comment_as_statement_comment().

◆ expression_line_number

int expression_line_number = STATEMENT_NUMBER_UNDEFINED
static

Definition at line 166 of file cyacc.tab.c.

Referenced by flush_expression_comment(), and reset_expression_comment().

◆ initialization_expressions

list initialization_expressions = NIL
static

to preserve information about the declarations for the prettyprinter, especially for the global variables, but also the derived types (struct, union, enum).

Definition at line 120 of file cyacc.tab.c.

Referenced by add_initialization_expression(), and add_prettyprint_control_list_to_declaration_statement().

◆ internal_derived_entity_declarations

list internal_derived_entity_declarations = NIL
static

When struct and union declarations are nested, the rules cannot return information about the internal declarations because they must return type information.

Hence internal declarations must be recorded and re-used when the final continue/declaration statement is generated. In order not to confuse the prettyprinter, they must appear first in the declaration list, that is in the innermost to outermost order.

Definition at line 601 of file cyacc.tab.c.

Referenced by GetDerivedEntityDeclarations(), RecordDerivedEntityDeclaration(), and ResetDerivedEntityDeclarations().

◆ is_external

bool is_external = true
static

to know if the variable is declared inside or outside a function, so its scope is the current function or the compilation unit or TOP-LEVEL

Definition at line 115 of file cyacc.tab.c.

Referenced by CreateEntityFromLocalNameAndPrefix(), CreateMemberScope(), FindOrCreateCurrentEntity(), FindOrCreateEntityFromLocalNameAndPrefix(), FindOrCreateEntityFromLocalNameAndPrefixAndScope(), MakeDerivedEntity(), MakeStorageRam(), UpdateEntities(), and UpdateEntity().

◆ ycontext

c_parser_context ycontext = c_parser_context_undefined
static

Definition at line 157 of file cyacc.tab.c.

◆ yychar

int yychar

Lookahead token kind.


Definition at line 2563 of file cyacc.tab.c.

◆ yycheck

const yytype_int16 yycheck[]
static

Definition at line 1892 of file cyacc.tab.c.

◆ yydebug

int yydebug

Nonzero means print parse trace.

It is left uninitialized so that multiple parsers can coexist.

Definition at line 2513 of file cyacc.tab.c.

◆ yydefact

const yytype_int16 yydefact[]
static

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 1468 of file cyacc.tab.c.

◆ yydefgoto

const yytype_int16 yydefgoto[]
static
Initial value:
=
{
0, 2, 3, 4, 5, 14, 15, 71, 116, 327,
166, 102, 103, 593, 78, 104, 79, 312, 313, 314,
315, 372, 316, 415, 317, 300, 305, 454, 379, 501,
105, 210, 140, 241, 455, 396, 456, 340, 395, 507,
458, 508, 460, 461, 494, 546, 497, 498, 578, 514,
585, 462, 499, 463, 30, 31, 464, 18, 123, 124,
136, 67, 332, 233, 334, 235, 331, 389, 429, 430,
230, 231, 216, 307, 323, 226, 147, 253, 348, 349,
148, 33, 118, 320, 72, 342, 399, 34, 217, 170,
468, 346, 470, 347, 19, 69, 20, 73, 144, 107,
227, 68, 504, 562, 567, 568, 569, 575, 589, 594
}

YYDEFGOTO[NTERM-NUM].


Definition at line 1549 of file cyacc.tab.c.

◆ yylval

YYSTYPE yylval

The semantic value of the lookahead symbol.


Definition at line 2566 of file cyacc.tab.c.

◆ yynerrs

int yynerrs

Number of syntax errors so far.


Definition at line 2568 of file cyacc.tab.c.

◆ yypact

const yytype_int16 yypact[]
static

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


Definition at line 1401 of file cyacc.tab.c.

◆ yypgoto

const yytype_int16 yypgoto[]
static
Initial value:
=
{
-445, -445, -445, 2, -445, -134, 512, -445, -1, 211,
-24, -445, -23, -445, -445, -445, -29, -98, -445, -144,
-445, -445, -342, 128, -445, -445, -435, -74, 136, -444,
-445, -445, -445, -445, -39, -445, 81, 111, 113, -364,
-445, -358, -223, -424, -445, -445, -445, -445, -445, -445,
-445, -445, -445, -3, 438, -445, 109, -445, 19, 505,
-445, -445, -445, -445, -445, -445, -192, -445, 68, -445,
322, 229, -10, 526, -445, -4, -283, 156, -445, -445,
-129, -445, -445, -445, -60, -231, 103, -136, -8, -118,
-30, -445, -445, -445, -445, -445, -445, -445, -445, -102,
341, -20, -226, -445, -2, -445, -6, -445, -445, -19
}

YYPGOTO[NTERM-NUM].


Definition at line 1533 of file cyacc.tab.c.

◆ yyr1

const yytype_uint8 yyr1[]
static

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


Definition at line 2284 of file cyacc.tab.c.

◆ yyr2

const yytype_int8 yyr2[]
static

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


Definition at line 2322 of file cyacc.tab.c.

Referenced by yy_reduce_print().

◆ yyrline

const yytype_int16 yyrline[]
static

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


Definition at line 1279 of file cyacc.tab.c.

Referenced by yy_reduce_print().

◆ yystos

const yytype_uint8 yystos[]
static

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


Definition at line 2219 of file cyacc.tab.c.

◆ yytable

const yytype_int16 yytable[]
static

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 1567 of file cyacc.tab.c.

◆ yytname

const char* const yytname[]
static

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

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

Definition at line 1327 of file cyacc.tab.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 1235 of file cyacc.tab.c.