btyacc_demo.tab.c revision 1.1.1.4
1 /* $NetBSD: btyacc_demo.tab.c,v 1.1.1.4 2017/02/11 19:30:04 christos Exp $ */ 2 3 /* original parser id follows */ 4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 6 7 #define YYBYACC 1 8 #define YYMAJOR 1 9 #define YYMINOR 9 10 #define YYCHECK "yyyymmdd" 11 12 #define YYEMPTY (-1) 13 #define yyclearin (yychar = YYEMPTY) 14 #define yyerrok (yyerrflag = 0) 15 #define YYRECOVERING() (yyerrflag != 0) 16 #define YYENOMEM (-2) 17 #define YYEOF 0 18 #undef YYBTYACC 19 #define YYBTYACC 1 20 #define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug") 21 22 #ifndef yyparse 23 #define yyparse demo_parse 24 #endif /* yyparse */ 25 26 #ifndef yylex 27 #define yylex demo_lex 28 #endif /* yylex */ 29 30 #ifndef yyerror 31 #define yyerror demo_error 32 #endif /* yyerror */ 33 34 #ifndef yychar 35 #define yychar demo_char 36 #endif /* yychar */ 37 38 #ifndef yyval 39 #define yyval demo_val 40 #endif /* yyval */ 41 42 #ifndef yylval 43 #define yylval demo_lval 44 #endif /* yylval */ 45 46 #ifndef yydebug 47 #define yydebug demo_debug 48 #endif /* yydebug */ 49 50 #ifndef yynerrs 51 #define yynerrs demo_nerrs 52 #endif /* yynerrs */ 53 54 #ifndef yyerrflag 55 #define yyerrflag demo_errflag 56 #endif /* yyerrflag */ 57 58 #ifndef yylhs 59 #define yylhs demo_lhs 60 #endif /* yylhs */ 61 62 #ifndef yylen 63 #define yylen demo_len 64 #endif /* yylen */ 65 66 #ifndef yydefred 67 #define yydefred demo_defred 68 #endif /* yydefred */ 69 70 #ifndef yystos 71 #define yystos demo_stos 72 #endif /* yystos */ 73 74 #ifndef yydgoto 75 #define yydgoto demo_dgoto 76 #endif /* yydgoto */ 77 78 #ifndef yysindex 79 #define yysindex demo_sindex 80 #endif /* yysindex */ 81 82 #ifndef yyrindex 83 #define yyrindex demo_rindex 84 #endif /* yyrindex */ 85 86 #ifndef yygindex 87 #define yygindex demo_gindex 88 #endif /* yygindex */ 89 90 #ifndef yytable 91 #define yytable demo_table 92 #endif /* yytable */ 93 94 #ifndef yycheck 95 #define yycheck demo_check 96 #endif /* yycheck */ 97 98 #ifndef yyname 99 #define yyname demo_name 100 #endif /* yyname */ 101 102 #ifndef yyrule 103 #define yyrule demo_rule 104 #endif /* yyrule */ 105 106 #ifndef yyloc 107 #define yyloc demo_loc 108 #endif /* yyloc */ 109 110 #ifndef yylloc 111 #define yylloc demo_lloc 112 #endif /* yylloc */ 113 114 #if YYBTYACC 115 116 #ifndef yycindex 117 #define yycindex demo_cindex 118 #endif /* yycindex */ 119 120 #ifndef yyctable 121 #define yyctable demo_ctable 122 #endif /* yyctable */ 123 124 #endif /* YYBTYACC */ 125 126 #define YYPREFIX "demo_" 127 128 #define YYPURE 0 129 130 #line 15 "btyacc_demo.y" 131 /* dummy types just for compile check */ 132 typedef int Code; 133 typedef int Decl_List; 134 typedef int Expr; 135 typedef int Expr_List; 136 typedef int Scope; 137 typedef int Type; 138 enum Operator { ADD, SUB, MUL, MOD, DIV, DEREF }; 139 140 typedef unsigned char bool; 141 typedef struct Decl { 142 Scope *scope; 143 Type *type; 144 bool (*istype)(void); 145 } Decl; 146 147 #include "btyacc_demo.tab.h" 148 #include <stdlib.h> 149 #include <stdio.h> 150 #ifdef YYSTYPE 151 #undef YYSTYPE_IS_DECLARED 152 #define YYSTYPE_IS_DECLARED 1 153 #endif 154 #ifndef YYSTYPE_IS_DECLARED 155 #define YYSTYPE_IS_DECLARED 1 156 #line 36 "btyacc_demo.y" 157 typedef union { 158 Scope *scope; 159 Expr *expr; 160 Expr_List *elist; 161 Type *type; 162 Decl *decl; 163 Decl_List *dlist; 164 Code *code; 165 char *id; 166 } YYSTYPE; 167 #endif /* !YYSTYPE_IS_DECLARED */ 168 #line 167 "btyacc_demo.tab.c" 169 170 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 171 /* Default: YYLTYPE is the text position type. */ 172 typedef struct YYLTYPE 173 { 174 int first_line; 175 int first_column; 176 int last_line; 177 int last_column; 178 unsigned source; 179 } YYLTYPE; 180 #define YYLTYPE_IS_DECLARED 1 181 #endif 182 #define YYRHSLOC(rhs, k) ((rhs)[k]) 183 184 /* compatibility with bison */ 185 #ifdef YYPARSE_PARAM 186 /* compatibility with FreeBSD */ 187 # ifdef YYPARSE_PARAM_TYPE 188 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 189 # else 190 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 191 # endif 192 #else 193 # define YYPARSE_DECL() yyparse(void) 194 #endif 195 196 /* Parameters sent to lex. */ 197 #ifdef YYLEX_PARAM 198 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 199 # define YYLEX yylex(YYLEX_PARAM) 200 #else 201 # define YYLEX_DECL() yylex(void) 202 # define YYLEX yylex() 203 #endif 204 205 /* Parameters sent to yyerror. */ 206 #ifndef YYERROR_DECL 207 #define YYERROR_DECL() yyerror(YYLTYPE *loc, const char *s) 208 #endif 209 #ifndef YYERROR_CALL 210 #define YYERROR_CALL(msg) yyerror(&yylloc, msg) 211 #endif 212 213 #ifndef YYDESTRUCT_DECL 214 #define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, YYLTYPE *loc) 215 #endif 216 #ifndef YYDESTRUCT_CALL 217 #define YYDESTRUCT_CALL(msg, psymb, val, loc) yydestruct(msg, psymb, val, loc) 218 #endif 219 220 extern int YYPARSE_DECL(); 221 222 #define PREFIX 257 223 #define POSTFIX 258 224 #define ID 259 225 #define CONSTANT 260 226 #define EXTERN 261 227 #define REGISTER 262 228 #define STATIC 263 229 #define CONST 264 230 #define VOLATILE 265 231 #define IF 266 232 #define THEN 267 233 #define ELSE 268 234 #define CLCL 269 235 #define YYERRCODE 256 236 typedef short YYINT; 237 static const YYINT demo_lhs[] = { -1, 238 15, 15, 15, 12, 18, 0, 4, 19, 4, 2, 239 20, 2, 10, 10, 13, 13, 11, 11, 11, 11, 240 11, 14, 14, 21, 22, 3, 3, 8, 8, 23, 241 24, 8, 8, 8, 8, 16, 16, 17, 17, 9, 242 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 243 25, 26, 5, 5, 27, 5, 6, 6, 7, 244 }; 245 static const YYINT demo_len[] = { 2, 246 0, 1, 3, 2, 0, 2, 0, 0, 3, 3, 247 0, 4, 1, 3, 0, 2, 1, 1, 1, 1, 248 1, 1, 1, 0, 0, 5, 1, 0, 1, 0, 249 0, 5, 5, 5, 6, 0, 1, 4, 1, 2, 250 4, 4, 4, 4, 4, 3, 1, 1, 1, 2, 251 0, 0, 11, 8, 0, 2, 0, 3, 4, 252 }; 253 static const YYINT demo_defred[] = { 5, 254 0, 7, 0, 0, 19, 20, 21, 22, 23, 2, 255 9, 0, 13, 18, 17, 0, 15, 30, 29, 0, 256 0, 0, 0, 0, 31, 10, 24, 24, 24, 0, 257 14, 3, 16, 25, 0, 25, 0, 0, 8, 12, 258 0, 0, 0, 39, 0, 0, 0, 8, 47, 48, 259 0, 57, 0, 32, 0, 0, 15, 30, 0, 30, 260 30, 30, 30, 30, 34, 0, 0, 0, 46, 0, 261 0, 0, 0, 0, 59, 0, 38, 0, 0, 43, 262 45, 44, 0, 0, 49, 58, 0, 30, 50, 56, 263 0, 0, 0, 51, 0, 0, 52, 0, 53, 264 }; 265 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 266 static const YYINT demo_stos[] = { 0, 267 271, 289, 275, 290, 261, 262, 263, 264, 265, 269, 268 273, 281, 282, 283, 285, 286, 42, 40, 259, 274, 269 279, 290, 259, 284, 294, 59, 44, 40, 91, 291, 270 282, 269, 285, 292, 295, 292, 292, 292, 123, 278, 271 293, 279, 293, 280, 281, 287, 288, 42, 259, 260, 272 272, 290, 279, 41, 279, 279, 41, 44, 290, 43, 273 45, 42, 47, 37, 93, 277, 284, 294, 272, 294, 274 294, 294, 294, 294, 125, 290, 280, 272, 272, 272, 275 272, 272, 266, 272, 273, 276, 298, 40, 59, 278, 276 294, 272, 41, 267, 296, 276, 268, 297, 276, 277 }; 278 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 279 static const YYINT demo_dgoto[] = { 1, 280 84, 85, 20, 3, 86, 66, 40, 21, 44, 12, 281 13, 14, 24, 15, 16, 46, 47, 2, 22, 30, 282 34, 41, 25, 35, 95, 98, 87, 283 }; 284 static const YYINT demo_sindex[] = { 0, 285 0, 0, 0, -103, 0, 0, 0, 0, 0, 0, 286 0, -31, 0, 0, 0, -238, 0, 0, 0, 4, 287 -36, -103, 0, -133, 0, 0, 0, 0, 0, -94, 288 0, 0, 0, 0, -40, 0, -103, -33, 0, 0, 289 -40, -25, -40, 0, -31, 8, 15, 0, 0, 0, 290 -2, 0, -36, 0, -36, -36, 0, 0, -33, 0, 291 0, 0, 0, 0, 0, -92, -133, -103, 0, -33, 292 -33, -33, -33, -33, 0, -8, 0, 23, 23, 0, 293 0, 0, 11, 75, 0, 0, -94, 0, 0, 0, 294 -33, 96, -194, 0, -8, 0, 0, -8, 0, 295 }; 296 static const YYINT demo_rindex[] = { 0, 297 0, 0, 1, -181, 0, 0, 0, 0, 0, 0, 298 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 299 -39, -181, 12, -34, 0, 0, 0, 0, 0, 0, 300 0, 0, 0, 0, -5, 0, -11, 0, 0, 0, 301 -17, 0, 28, 0, -41, 0, 47, 0, 0, 0, 302 0, 0, -13, 0, 18, 70, 0, 0, 0, 0, 303 0, 0, 0, 0, 0, -19, -27, -181, 0, 0, 304 0, 0, 0, 0, 0, -29, 0, 56, 64, 0, 305 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 306 0, 0, 0, 0, -29, -30, 0, -29, 0, 307 }; 308 #if YYBTYACC 309 static const YYINT demo_cindex[] = { 0, 310 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311 0, -22, 0, 0, 0, 0, 0, 0, 0, 0, 312 0, 0, -179, 0, 0, 0, 0, 0, 0, 0, 313 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 314 58, 0, 62, 0, -21, 0, 0, 0, 0, 0, 315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 317 0, 0, 0, 0, 0, -146, 0, 0, 0, 0, 318 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 319 0, 0, 0, 0, -143, -147, 0, -134, 0, 320 }; 321 #endif 322 static const YYINT demo_gindex[] = { 0, 323 9, 143, 0, 0, 50, 0, 63, 101, 83, 7, 324 130, 0, 98, 2, 0, 0, 0, 0, 19, 0, 325 10, 117, 66, 0, 0, 0, 0, 326 }; 327 #define YYTABLESIZE 286 328 static const YYINT demo_table[] = { 28, 329 6, 17, 28, 28, 27, 24, 24, 24, 48, 24, 330 17, 54, 35, 35, 28, 54, 35, 0, 0, 27, 331 23, 4, 8, 28, 24, 33, 28, 33, 39, 36, 332 33, 35, 75, 48, 64, 28, 36, 37, 38, 62, 333 60, 28, 61, 45, 63, 33, 51, 27, 57, 28, 334 88, 4, 4, 4, 29, 4, 24, 52, 58, 64, 335 28, 26, 26, 35, 62, 29, 59, 69, 33, 63, 336 4, 28, 94, 28, 45, 28, 26, 1, 78, 79, 337 80, 81, 82, 11, 76, 28, 28, 37, 24, 6, 338 65, 0, 54, 55, 54, 35, 41, 0, 41, 92, 339 41, 0, 4, 8, 42, 28, 42, 28, 42, 33, 340 40, 64, 9, 40, 41, 9, 62, 60, 28, 61, 341 12, 63, 42, 68, 9, 70, 71, 72, 73, 74, 342 8, 9, 64, 89, 4, 42, 93, 62, 60, 28, 343 61, 53, 63, 55, 96, 56, 11, 99, 41, 90, 344 77, 31, 43, 91, 67, 0, 42, 5, 6, 7, 345 8, 9, 0, 0, 0, 10, 0, 0, 0, 0, 346 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 347 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 348 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 349 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 350 0, 0, 0, 0, 0, 0, 0, 0, 19, 8, 351 8, 8, 8, 8, 24, 49, 50, 8, 54, 54, 352 54, 54, 54, 54, 54, 54, 3, 3, 54, 8, 353 8, 8, 8, 8, 8, 8, 8, 1, 0, 8, 354 0, 50, 5, 6, 7, 8, 9, 83, 0, 8, 355 10, 8, 8, 8, 8, 8, 0, 0, 0, 8, 356 4, 0, 4, 4, 4, 4, 4, 8, 8, 8, 357 8, 8, 0, 0, 0, 8, 358 }; 359 static const YYINT demo_check[] = { 41, 360 0, 42, 44, 40, 44, 40, 41, 42, 42, 44, 361 42, 42, 40, 41, 40, 41, 44, 40, 40, 59, 362 259, 3, 42, 41, 59, 24, 44, 41, 123, 41, 363 44, 59, 125, 42, 37, 41, 27, 28, 29, 42, 364 43, 59, 45, 37, 47, 59, 38, 44, 41, 91, 365 40, 40, 41, 42, 91, 44, 91, 39, 44, 37, 366 44, 44, 59, 91, 42, 91, 48, 59, 67, 47, 367 59, 44, 267, 91, 68, 59, 59, 259, 70, 71, 368 72, 73, 74, 123, 66, 91, 59, 41, 123, 269, 369 93, 40, 123, 123, 125, 123, 41, 40, 43, 91, 370 45, 40, 91, 123, 41, 123, 43, 91, 45, 123, 371 41, 37, 259, 44, 59, 259, 42, 43, 91, 45, 372 268, 47, 59, 58, 259, 60, 61, 62, 63, 64, 373 264, 265, 37, 59, 123, 35, 41, 42, 43, 123, 374 45, 41, 47, 43, 95, 45, 4, 98, 93, 87, 375 68, 22, 36, 88, 57, -1, 93, 261, 262, 263, 376 264, 265, -1, -1, -1, 269, -1, -1, -1, -1, 377 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 378 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 379 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 380 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 381 -1, -1, -1, -1, -1, -1, -1, -1, 259, 261, 382 262, 263, 264, 265, 259, 259, 260, 269, 259, 260, 383 261, 262, 263, 264, 265, 266, 259, 259, 269, 259, 384 260, 261, 262, 263, 264, 265, 266, 259, -1, 269, 385 -1, 260, 261, 262, 263, 264, 265, 266, -1, 259, 386 269, 261, 262, 263, 264, 265, -1, -1, -1, 269, 387 259, -1, 261, 262, 263, 264, 265, 261, 262, 263, 388 264, 265, -1, -1, -1, 269, 389 }; 390 #if YYBTYACC 391 static const YYINT demo_ctable[] = { 18, 392 28, -1, 19, 8, -1, 32, 4, -1, 49, 1, 393 -1, 97, 54, -1, -1, -1, -1, -1, -1, -1, 394 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 395 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 396 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 397 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 398 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 399 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 400 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 401 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 402 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 403 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 404 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 405 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 406 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 407 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 408 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 409 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 410 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 411 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 412 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 413 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 414 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 415 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 416 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 417 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 418 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 419 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 420 -1, -1, -1, -1, -1, 421 }; 422 #endif 423 #define YYFINAL 1 424 #ifndef YYDEBUG 425 #define YYDEBUG 0 426 #endif 427 #define YYMAXTOKEN 269 428 #define YYUNDFTOKEN 299 429 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 430 #if YYDEBUG 431 static const char *const demo_name[] = { 432 433 "$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 434 "'%'",0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,0,0,0,0,0,0,0,0,0, 435 "';'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'['",0, 436 "']'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0, 437 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 438 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 439 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 440 0,0,0,0,0,0,0,0,0,"error","PREFIX","POSTFIX","ID","CONSTANT","EXTERN", 441 "REGISTER","STATIC","CONST","VOLATILE","IF","THEN","ELSE","CLCL","$accept", 442 "input","expr","decl","declarator_list","decl_list","statement", 443 "statement_list","block_statement","declarator","formal_arg","decl_specs", 444 "decl_spec","typename","cv_quals","cv_qual","opt_scope","formal_arg_list", 445 "nonempty_formal_arg_list","$$1","$$2","$$3","$$4","$$5","$$6","$$7","$$8", 446 "$$9","$$10","illegal-symbol", 447 }; 448 static const char *const demo_rule[] = { 449 "$accept : input", 450 "opt_scope :", 451 "opt_scope : CLCL", 452 "opt_scope : opt_scope ID CLCL", 453 "typename : opt_scope ID", 454 "$$1 :", 455 "input : $$1 decl_list", 456 "decl_list :", 457 "$$2 :", 458 "decl_list : decl_list $$2 decl", 459 "decl : decl_specs declarator_list ';'", 460 "$$3 :", 461 "decl : decl_specs declarator $$3 block_statement", 462 "decl_specs : decl_spec", 463 "decl_specs : decl_specs $$2 decl_spec", 464 "cv_quals :", 465 "cv_quals : cv_quals cv_qual", 466 "decl_spec : cv_qual", 467 "decl_spec : typename", 468 "decl_spec : EXTERN", 469 "decl_spec : REGISTER", 470 "decl_spec : STATIC", 471 "cv_qual : CONST", 472 "cv_qual : VOLATILE", 473 "$$4 :", 474 "$$5 :", 475 "declarator_list : declarator_list ',' $$4 $$5 declarator", 476 "declarator_list : declarator", 477 "declarator :", 478 "declarator : ID", 479 "$$6 :", 480 "$$7 :", 481 "declarator : '(' $$6 $$7 declarator ')'", 482 "declarator : '*' cv_quals $$4 $$5 declarator", 483 "declarator : declarator '[' $$4 expr ']'", 484 "declarator : declarator '(' $$4 formal_arg_list ')' cv_quals", 485 "formal_arg_list :", 486 "formal_arg_list : nonempty_formal_arg_list", 487 "nonempty_formal_arg_list : nonempty_formal_arg_list ',' $$6 formal_arg", 488 "nonempty_formal_arg_list : formal_arg", 489 "formal_arg : decl_specs declarator", 490 "expr : expr '+' $$6 expr", 491 "expr : expr '-' $$6 expr", 492 "expr : expr '*' $$6 expr", 493 "expr : expr '%' $$6 expr", 494 "expr : expr '/' $$6 expr", 495 "expr : '*' $$2 expr", 496 "expr : ID", 497 "expr : CONSTANT", 498 "statement : decl", 499 "statement : expr ';'", 500 "$$8 :", 501 "$$9 :", 502 "statement : IF '(' $$6 expr ')' THEN $$8 statement ELSE $$9 statement", 503 "statement : IF '(' $$6 expr ')' THEN $$8 statement", 504 "$$10 :", 505 "statement : $$10 block_statement", 506 "statement_list :", 507 "statement_list : statement_list $$2 statement", 508 "block_statement : '{' $$2 statement_list '}'", 509 510 }; 511 #endif 512 513 int yydebug; 514 int yynerrs; 515 516 int yyerrflag; 517 int yychar; 518 YYSTYPE yyval; 519 YYSTYPE yylval; 520 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 521 YYLTYPE yyloc; /* position returned by actions */ 522 YYLTYPE yylloc; /* position from the lexer */ 523 #endif 524 525 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 526 #ifndef YYLLOC_DEFAULT 527 #define YYLLOC_DEFAULT(loc, rhs, n) \ 528 do \ 529 { \ 530 if (n == 0) \ 531 { \ 532 (loc).first_line = ((rhs)[-1]).last_line; \ 533 (loc).first_column = ((rhs)[-1]).last_column; \ 534 (loc).last_line = ((rhs)[-1]).last_line; \ 535 (loc).last_column = ((rhs)[-1]).last_column; \ 536 } \ 537 else \ 538 { \ 539 (loc).first_line = ((rhs)[ 0 ]).first_line; \ 540 (loc).first_column = ((rhs)[ 0 ]).first_column; \ 541 (loc).last_line = ((rhs)[n-1]).last_line; \ 542 (loc).last_column = ((rhs)[n-1]).last_column; \ 543 } \ 544 } while (0) 545 #endif /* YYLLOC_DEFAULT */ 546 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 547 #if YYBTYACC 548 549 #ifndef YYLVQUEUEGROWTH 550 #define YYLVQUEUEGROWTH 32 551 #endif 552 #endif /* YYBTYACC */ 553 554 /* define the initial stack-sizes */ 555 #ifdef YYSTACKSIZE 556 #undef YYMAXDEPTH 557 #define YYMAXDEPTH YYSTACKSIZE 558 #else 559 #ifdef YYMAXDEPTH 560 #define YYSTACKSIZE YYMAXDEPTH 561 #else 562 #define YYSTACKSIZE 10000 563 #define YYMAXDEPTH 10000 564 #endif 565 #endif 566 567 #ifndef YYINITSTACKSIZE 568 #define YYINITSTACKSIZE 200 569 #endif 570 571 typedef struct { 572 unsigned stacksize; 573 YYINT *s_base; 574 YYINT *s_mark; 575 YYINT *s_last; 576 YYSTYPE *l_base; 577 YYSTYPE *l_mark; 578 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 579 YYLTYPE *p_base; 580 YYLTYPE *p_mark; 581 #endif 582 } YYSTACKDATA; 583 #if YYBTYACC 584 585 struct YYParseState_s 586 { 587 struct YYParseState_s *save; /* Previously saved parser state */ 588 YYSTACKDATA yystack; /* saved parser stack */ 589 int state; /* saved parser state */ 590 int errflag; /* saved error recovery status */ 591 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 592 YYINT ctry; /* saved index in yyctable[] for this conflict */ 593 }; 594 typedef struct YYParseState_s YYParseState; 595 #endif /* YYBTYACC */ 596 /* variables for the parser stack */ 597 static YYSTACKDATA yystack; 598 #if YYBTYACC 599 600 /* Current parser state */ 601 static YYParseState *yyps = 0; 602 603 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 604 static YYParseState *yypath = 0; 605 606 /* Base of the lexical value queue */ 607 static YYSTYPE *yylvals = 0; 608 609 /* Current position at lexical value queue */ 610 static YYSTYPE *yylvp = 0; 611 612 /* End position of lexical value queue */ 613 static YYSTYPE *yylve = 0; 614 615 /* The last allocated position at the lexical value queue */ 616 static YYSTYPE *yylvlim = 0; 617 618 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 619 /* Base of the lexical position queue */ 620 static YYLTYPE *yylpsns = 0; 621 622 /* Current position at lexical position queue */ 623 static YYLTYPE *yylpp = 0; 624 625 /* End position of lexical position queue */ 626 static YYLTYPE *yylpe = 0; 627 628 /* The last allocated position at the lexical position queue */ 629 static YYLTYPE *yylplim = 0; 630 #endif 631 632 /* Current position at lexical token queue */ 633 static YYINT *yylexp = 0; 634 635 static YYINT *yylexemes = 0; 636 #endif /* YYBTYACC */ 637 #line 200 "btyacc_demo.y" 638 639 extern int YYLEX_DECL(); 640 extern void YYERROR_DECL(); 641 642 extern Scope *global_scope; 643 644 extern Decl * lookup(Scope *scope, char *id); 645 extern Scope * new_scope(Scope *outer_scope); 646 extern Scope * start_fn_def(Scope *scope, Decl *fn_decl); 647 extern void finish_fn_def(Decl *fn_decl, Code *block); 648 extern Type * type_combine(Type *specs, Type *spec); 649 extern Type * bare_extern(void); 650 extern Type * bare_register(void); 651 extern Type * bare_static(void); 652 extern Type * bare_const(void); 653 extern Type * bare_volatile(void); 654 extern Decl * declare(Scope *scope, char *id, Type *type); 655 extern Decl * make_pointer(Decl *decl, Type *type); 656 extern Decl * make_array(Type *type, Expr *expr); 657 extern Decl * build_function(Decl *decl, Decl_List *dlist, Type *type); 658 extern Decl_List * append_dlist(Decl_List *dlist, Decl *decl); 659 extern Decl_List * build_dlist(Decl *decl); 660 extern Expr * build_expr(Expr *left, enum Operator op, Expr *right); 661 extern Expr * var_expr(Scope *scope, char *id); 662 extern Code * build_expr_code(Expr *expr); 663 extern Code * build_if(Expr *cond_expr, Code *then_stmt, Code *else_stmt); 664 extern Code * code_append(Code *stmt_list, Code *stmt); 665 #line 664 "btyacc_demo.tab.c" 666 667 /* Release memory associated with symbol. */ 668 #if ! defined YYDESTRUCT_IS_DECLARED 669 static void 670 YYDESTRUCT_DECL() 671 { 672 switch (psymb) 673 { 674 case 43: 675 #line 83 "btyacc_demo.y" 676 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 677 msg, 678 (*loc).first_line, (*loc).first_column, 679 (*loc).last_line, (*loc).last_column); 680 /* in this example, we don't know what to do here */ } 681 break; 682 #line 681 "btyacc_demo.tab.c" 683 case 45: 684 #line 83 "btyacc_demo.y" 685 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 686 msg, 687 (*loc).first_line, (*loc).first_column, 688 (*loc).last_line, (*loc).last_column); 689 /* in this example, we don't know what to do here */ } 690 break; 691 #line 690 "btyacc_demo.tab.c" 692 case 42: 693 #line 83 "btyacc_demo.y" 694 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 695 msg, 696 (*loc).first_line, (*loc).first_column, 697 (*loc).last_line, (*loc).last_column); 698 /* in this example, we don't know what to do here */ } 699 break; 700 #line 699 "btyacc_demo.tab.c" 701 case 47: 702 #line 83 "btyacc_demo.y" 703 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 704 msg, 705 (*loc).first_line, (*loc).first_column, 706 (*loc).last_line, (*loc).last_column); 707 /* in this example, we don't know what to do here */ } 708 break; 709 #line 708 "btyacc_demo.tab.c" 710 case 37: 711 #line 83 "btyacc_demo.y" 712 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 713 msg, 714 (*loc).first_line, (*loc).first_column, 715 (*loc).last_line, (*loc).last_column); 716 /* in this example, we don't know what to do here */ } 717 break; 718 #line 717 "btyacc_demo.tab.c" 719 case 257: 720 #line 83 "btyacc_demo.y" 721 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 722 msg, 723 (*loc).first_line, (*loc).first_column, 724 (*loc).last_line, (*loc).last_column); 725 /* in this example, we don't know what to do here */ } 726 break; 727 #line 726 "btyacc_demo.tab.c" 728 case 258: 729 #line 83 "btyacc_demo.y" 730 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 731 msg, 732 (*loc).first_line, (*loc).first_column, 733 (*loc).last_line, (*loc).last_column); 734 /* in this example, we don't know what to do here */ } 735 break; 736 #line 735 "btyacc_demo.tab.c" 737 case 40: 738 #line 83 "btyacc_demo.y" 739 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 740 msg, 741 (*loc).first_line, (*loc).first_column, 742 (*loc).last_line, (*loc).last_column); 743 /* in this example, we don't know what to do here */ } 744 break; 745 #line 744 "btyacc_demo.tab.c" 746 case 91: 747 #line 83 "btyacc_demo.y" 748 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 749 msg, 750 (*loc).first_line, (*loc).first_column, 751 (*loc).last_line, (*loc).last_column); 752 /* in this example, we don't know what to do here */ } 753 break; 754 #line 753 "btyacc_demo.tab.c" 755 case 46: 756 #line 83 "btyacc_demo.y" 757 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 758 msg, 759 (*loc).first_line, (*loc).first_column, 760 (*loc).last_line, (*loc).last_column); 761 /* in this example, we don't know what to do here */ } 762 break; 763 #line 762 "btyacc_demo.tab.c" 764 case 259: 765 #line 78 "btyacc_demo.y" 766 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 767 msg, 768 (*loc).first_line, (*loc).first_column, 769 (*loc).last_line, (*loc).last_column); 770 free((*val).id); } 771 break; 772 #line 771 "btyacc_demo.tab.c" 773 case 260: 774 #line 78 "btyacc_demo.y" 775 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 776 msg, 777 (*loc).first_line, (*loc).first_column, 778 (*loc).last_line, (*loc).last_column); 779 free((*val).expr); } 780 break; 781 #line 780 "btyacc_demo.tab.c" 782 case 261: 783 #line 83 "btyacc_demo.y" 784 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 785 msg, 786 (*loc).first_line, (*loc).first_column, 787 (*loc).last_line, (*loc).last_column); 788 /* in this example, we don't know what to do here */ } 789 break; 790 #line 789 "btyacc_demo.tab.c" 791 case 262: 792 #line 83 "btyacc_demo.y" 793 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 794 msg, 795 (*loc).first_line, (*loc).first_column, 796 (*loc).last_line, (*loc).last_column); 797 /* in this example, we don't know what to do here */ } 798 break; 799 #line 798 "btyacc_demo.tab.c" 800 case 263: 801 #line 83 "btyacc_demo.y" 802 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 803 msg, 804 (*loc).first_line, (*loc).first_column, 805 (*loc).last_line, (*loc).last_column); 806 /* in this example, we don't know what to do here */ } 807 break; 808 #line 807 "btyacc_demo.tab.c" 809 case 264: 810 #line 83 "btyacc_demo.y" 811 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 812 msg, 813 (*loc).first_line, (*loc).first_column, 814 (*loc).last_line, (*loc).last_column); 815 /* in this example, we don't know what to do here */ } 816 break; 817 #line 816 "btyacc_demo.tab.c" 818 case 265: 819 #line 83 "btyacc_demo.y" 820 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 821 msg, 822 (*loc).first_line, (*loc).first_column, 823 (*loc).last_line, (*loc).last_column); 824 /* in this example, we don't know what to do here */ } 825 break; 826 #line 825 "btyacc_demo.tab.c" 827 case 266: 828 #line 83 "btyacc_demo.y" 829 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 830 msg, 831 (*loc).first_line, (*loc).first_column, 832 (*loc).last_line, (*loc).last_column); 833 /* in this example, we don't know what to do here */ } 834 break; 835 #line 834 "btyacc_demo.tab.c" 836 case 267: 837 #line 83 "btyacc_demo.y" 838 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 839 msg, 840 (*loc).first_line, (*loc).first_column, 841 (*loc).last_line, (*loc).last_column); 842 /* in this example, we don't know what to do here */ } 843 break; 844 #line 843 "btyacc_demo.tab.c" 845 case 268: 846 #line 83 "btyacc_demo.y" 847 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 848 msg, 849 (*loc).first_line, (*loc).first_column, 850 (*loc).last_line, (*loc).last_column); 851 /* in this example, we don't know what to do here */ } 852 break; 853 #line 852 "btyacc_demo.tab.c" 854 case 269: 855 #line 83 "btyacc_demo.y" 856 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 857 msg, 858 (*loc).first_line, (*loc).first_column, 859 (*loc).last_line, (*loc).last_column); 860 /* in this example, we don't know what to do here */ } 861 break; 862 #line 861 "btyacc_demo.tab.c" 863 case 59: 864 #line 83 "btyacc_demo.y" 865 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 866 msg, 867 (*loc).first_line, (*loc).first_column, 868 (*loc).last_line, (*loc).last_column); 869 /* in this example, we don't know what to do here */ } 870 break; 871 #line 870 "btyacc_demo.tab.c" 872 case 44: 873 #line 83 "btyacc_demo.y" 874 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 875 msg, 876 (*loc).first_line, (*loc).first_column, 877 (*loc).last_line, (*loc).last_column); 878 /* in this example, we don't know what to do here */ } 879 break; 880 #line 879 "btyacc_demo.tab.c" 881 case 41: 882 #line 83 "btyacc_demo.y" 883 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 884 msg, 885 (*loc).first_line, (*loc).first_column, 886 (*loc).last_line, (*loc).last_column); 887 /* in this example, we don't know what to do here */ } 888 break; 889 #line 888 "btyacc_demo.tab.c" 890 case 93: 891 #line 83 "btyacc_demo.y" 892 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 893 msg, 894 (*loc).first_line, (*loc).first_column, 895 (*loc).last_line, (*loc).last_column); 896 /* in this example, we don't know what to do here */ } 897 break; 898 #line 897 "btyacc_demo.tab.c" 899 case 123: 900 #line 83 "btyacc_demo.y" 901 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 902 msg, 903 (*loc).first_line, (*loc).first_column, 904 (*loc).last_line, (*loc).last_column); 905 /* in this example, we don't know what to do here */ } 906 break; 907 #line 906 "btyacc_demo.tab.c" 908 case 125: 909 #line 83 "btyacc_demo.y" 910 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 911 msg, 912 (*loc).first_line, (*loc).first_column, 913 (*loc).last_line, (*loc).last_column); 914 /* in this example, we don't know what to do here */ } 915 break; 916 #line 915 "btyacc_demo.tab.c" 917 case 270: 918 #line 83 "btyacc_demo.y" 919 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 920 msg, 921 (*loc).first_line, (*loc).first_column, 922 (*loc).last_line, (*loc).last_column); 923 /* in this example, we don't know what to do here */ } 924 break; 925 #line 924 "btyacc_demo.tab.c" 926 case 271: 927 #line 83 "btyacc_demo.y" 928 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 929 msg, 930 (*loc).first_line, (*loc).first_column, 931 (*loc).last_line, (*loc).last_column); 932 /* in this example, we don't know what to do here */ } 933 break; 934 #line 933 "btyacc_demo.tab.c" 935 case 272: 936 #line 78 "btyacc_demo.y" 937 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 938 msg, 939 (*loc).first_line, (*loc).first_column, 940 (*loc).last_line, (*loc).last_column); 941 free((*val).expr); } 942 break; 943 #line 942 "btyacc_demo.tab.c" 944 case 273: 945 #line 67 "btyacc_demo.y" 946 { /* 'msg' is a 'char *' indicating the context of destructor invocation*/ 947 printf("%s accessed by symbol \"decl\" (case s.b. 273) @ position[%d,%d..%d,%d]\n", 948 msg, 949 (*loc).first_line, (*loc).first_column, 950 (*loc).last_line, (*loc).last_column); 951 free((*val).decl->scope); free((*val).decl->type); } 952 break; 953 #line 952 "btyacc_demo.tab.c" 954 case 274: 955 #line 83 "btyacc_demo.y" 956 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 957 msg, 958 (*loc).first_line, (*loc).first_column, 959 (*loc).last_line, (*loc).last_column); 960 /* in this example, we don't know what to do here */ } 961 break; 962 #line 961 "btyacc_demo.tab.c" 963 case 275: 964 #line 83 "btyacc_demo.y" 965 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", 966 msg, 967 (*loc).first_line, (*loc).first_column, 968 (*loc).last_line, (*loc).last_column); 969 /* in this example, we don't know what to do here */ } 970 break; 971 #line 970 "btyacc_demo.tab.c" 972 case 276: 973 #line 78 "btyacc_demo.y" 974 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 975 msg, 976 (*loc).first_line, (*loc).first_column, 977 (*loc).last_line, (*loc).last_column); 978 free((*val).code); } 979 break; 980 #line 979 "btyacc_demo.tab.c" 981 case 277: 982 #line 78 "btyacc_demo.y" 983 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 984 msg, 985 (*loc).first_line, (*loc).first_column, 986 (*loc).last_line, (*loc).last_column); 987 free((*val).code); } 988 break; 989 #line 988 "btyacc_demo.tab.c" 990 case 278: 991 #line 78 "btyacc_demo.y" 992 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 993 msg, 994 (*loc).first_line, (*loc).first_column, 995 (*loc).last_line, (*loc).last_column); 996 free((*val).code); } 997 break; 998 #line 997 "btyacc_demo.tab.c" 999 case 279: 1000 #line 73 "btyacc_demo.y" 1001 { printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n", 1002 msg, 1003 (*loc).first_line, (*loc).first_column, 1004 (*loc).last_line, (*loc).last_column); 1005 free((*val).decl); } 1006 break; 1007 #line 1006 "btyacc_demo.tab.c" 1008 case 280: 1009 #line 73 "btyacc_demo.y" 1010 { printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n", 1011 msg, 1012 (*loc).first_line, (*loc).first_column, 1013 (*loc).last_line, (*loc).last_column); 1014 free((*val).decl); } 1015 break; 1016 #line 1015 "btyacc_demo.tab.c" 1017 case 281: 1018 #line 78 "btyacc_demo.y" 1019 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1020 msg, 1021 (*loc).first_line, (*loc).first_column, 1022 (*loc).last_line, (*loc).last_column); 1023 free((*val).type); } 1024 break; 1025 #line 1024 "btyacc_demo.tab.c" 1026 case 282: 1027 #line 78 "btyacc_demo.y" 1028 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1029 msg, 1030 (*loc).first_line, (*loc).first_column, 1031 (*loc).last_line, (*loc).last_column); 1032 free((*val).type); } 1033 break; 1034 #line 1033 "btyacc_demo.tab.c" 1035 case 283: 1036 #line 78 "btyacc_demo.y" 1037 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1038 msg, 1039 (*loc).first_line, (*loc).first_column, 1040 (*loc).last_line, (*loc).last_column); 1041 free((*val).type); } 1042 break; 1043 #line 1042 "btyacc_demo.tab.c" 1044 case 284: 1045 #line 78 "btyacc_demo.y" 1046 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1047 msg, 1048 (*loc).first_line, (*loc).first_column, 1049 (*loc).last_line, (*loc).last_column); 1050 free((*val).type); } 1051 break; 1052 #line 1051 "btyacc_demo.tab.c" 1053 case 285: 1054 #line 78 "btyacc_demo.y" 1055 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1056 msg, 1057 (*loc).first_line, (*loc).first_column, 1058 (*loc).last_line, (*loc).last_column); 1059 free((*val).type); } 1060 break; 1061 #line 1060 "btyacc_demo.tab.c" 1062 case 286: 1063 #line 78 "btyacc_demo.y" 1064 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1065 msg, 1066 (*loc).first_line, (*loc).first_column, 1067 (*loc).last_line, (*loc).last_column); 1068 free((*val).scope); } 1069 break; 1070 #line 1069 "btyacc_demo.tab.c" 1071 case 287: 1072 #line 78 "btyacc_demo.y" 1073 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1074 msg, 1075 (*loc).first_line, (*loc).first_column, 1076 (*loc).last_line, (*loc).last_column); 1077 free((*val).dlist); } 1078 break; 1079 #line 1078 "btyacc_demo.tab.c" 1080 case 288: 1081 #line 78 "btyacc_demo.y" 1082 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1083 msg, 1084 (*loc).first_line, (*loc).first_column, 1085 (*loc).last_line, (*loc).last_column); 1086 free((*val).dlist); } 1087 break; 1088 #line 1087 "btyacc_demo.tab.c" 1089 case 289: 1090 #line 78 "btyacc_demo.y" 1091 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1092 msg, 1093 (*loc).first_line, (*loc).first_column, 1094 (*loc).last_line, (*loc).last_column); 1095 free((*val).scope); } 1096 break; 1097 #line 1096 "btyacc_demo.tab.c" 1098 case 290: 1099 #line 78 "btyacc_demo.y" 1100 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1101 msg, 1102 (*loc).first_line, (*loc).first_column, 1103 (*loc).last_line, (*loc).last_column); 1104 free((*val).scope); } 1105 break; 1106 #line 1105 "btyacc_demo.tab.c" 1107 case 291: 1108 #line 78 "btyacc_demo.y" 1109 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1110 msg, 1111 (*loc).first_line, (*loc).first_column, 1112 (*loc).last_line, (*loc).last_column); 1113 free((*val).scope); } 1114 break; 1115 #line 1114 "btyacc_demo.tab.c" 1116 case 292: 1117 #line 78 "btyacc_demo.y" 1118 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1119 msg, 1120 (*loc).first_line, (*loc).first_column, 1121 (*loc).last_line, (*loc).last_column); 1122 free((*val).scope); } 1123 break; 1124 #line 1123 "btyacc_demo.tab.c" 1125 case 293: 1126 #line 78 "btyacc_demo.y" 1127 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1128 msg, 1129 (*loc).first_line, (*loc).first_column, 1130 (*loc).last_line, (*loc).last_column); 1131 free((*val).type); } 1132 break; 1133 #line 1132 "btyacc_demo.tab.c" 1134 case 294: 1135 #line 78 "btyacc_demo.y" 1136 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1137 msg, 1138 (*loc).first_line, (*loc).first_column, 1139 (*loc).last_line, (*loc).last_column); 1140 free((*val).scope); } 1141 break; 1142 #line 1141 "btyacc_demo.tab.c" 1143 case 295: 1144 #line 78 "btyacc_demo.y" 1145 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1146 msg, 1147 (*loc).first_line, (*loc).first_column, 1148 (*loc).last_line, (*loc).last_column); 1149 free((*val).type); } 1150 break; 1151 #line 1150 "btyacc_demo.tab.c" 1152 case 296: 1153 #line 78 "btyacc_demo.y" 1154 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1155 msg, 1156 (*loc).first_line, (*loc).first_column, 1157 (*loc).last_line, (*loc).last_column); 1158 free((*val).scope); } 1159 break; 1160 #line 1159 "btyacc_demo.tab.c" 1161 case 297: 1162 #line 78 "btyacc_demo.y" 1163 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1164 msg, 1165 (*loc).first_line, (*loc).first_column, 1166 (*loc).last_line, (*loc).last_column); 1167 free((*val).scope); } 1168 break; 1169 #line 1168 "btyacc_demo.tab.c" 1170 case 298: 1171 #line 78 "btyacc_demo.y" 1172 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", 1173 msg, 1174 (*loc).first_line, (*loc).first_column, 1175 (*loc).last_line, (*loc).last_column); 1176 free((*val).scope); } 1177 break; 1178 #line 1177 "btyacc_demo.tab.c" 1179 } 1180 } 1181 #define YYDESTRUCT_IS_DECLARED 1 1182 #endif 1183 1184 /* For use in generated program */ 1185 #define yydepth (int)(yystack.s_mark - yystack.s_base) 1186 #if YYBTYACC 1187 #define yytrial (yyps->save) 1188 #endif /* YYBTYACC */ 1189 1190 #if YYDEBUG 1191 #include <stdio.h> /* needed for printf */ 1192 #endif 1193 1194 #include <stdlib.h> /* needed for malloc, etc */ 1195 #include <string.h> /* needed for memset */ 1196 1197 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 1198 static int yygrowstack(YYSTACKDATA *data) 1199 { 1200 int i; 1201 unsigned newsize; 1202 YYINT *newss; 1203 YYSTYPE *newvs; 1204 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1205 YYLTYPE *newps; 1206 #endif 1207 1208 if ((newsize = data->stacksize) == 0) 1209 newsize = YYINITSTACKSIZE; 1210 else if (newsize >= YYMAXDEPTH) 1211 return YYENOMEM; 1212 else if ((newsize *= 2) > YYMAXDEPTH) 1213 newsize = YYMAXDEPTH; 1214 1215 i = (int) (data->s_mark - data->s_base); 1216 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 1217 if (newss == 0) 1218 return YYENOMEM; 1219 1220 data->s_base = newss; 1221 data->s_mark = newss + i; 1222 1223 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 1224 if (newvs == 0) 1225 return YYENOMEM; 1226 1227 data->l_base = newvs; 1228 data->l_mark = newvs + i; 1229 1230 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1231 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 1232 if (newps == 0) 1233 return YYENOMEM; 1234 1235 data->p_base = newps; 1236 data->p_mark = newps + i; 1237 #endif 1238 1239 data->stacksize = newsize; 1240 data->s_last = data->s_base + newsize - 1; 1241 1242 #if YYDEBUG 1243 if (yydebug) 1244 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 1245 #endif 1246 return 0; 1247 } 1248 1249 #if YYPURE || defined(YY_NO_LEAKS) 1250 static void yyfreestack(YYSTACKDATA *data) 1251 { 1252 free(data->s_base); 1253 free(data->l_base); 1254 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1255 free(data->p_base); 1256 #endif 1257 memset(data, 0, sizeof(*data)); 1258 } 1259 #else 1260 #define yyfreestack(data) /* nothing */ 1261 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 1262 #if YYBTYACC 1263 1264 static YYParseState * 1265 yyNewState(unsigned size) 1266 { 1267 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 1268 if (p == NULL) return NULL; 1269 1270 p->yystack.stacksize = size; 1271 if (size == 0) 1272 { 1273 p->yystack.s_base = NULL; 1274 p->yystack.l_base = NULL; 1275 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1276 p->yystack.p_base = NULL; 1277 #endif 1278 return p; 1279 } 1280 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 1281 if (p->yystack.s_base == NULL) return NULL; 1282 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 1283 if (p->yystack.l_base == NULL) return NULL; 1284 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 1285 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1286 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 1287 if (p->yystack.p_base == NULL) return NULL; 1288 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 1289 #endif 1290 1291 return p; 1292 } 1293 1294 static void 1295 yyFreeState(YYParseState *p) 1296 { 1297 yyfreestack(&p->yystack); 1298 free(p); 1299 } 1300 #endif /* YYBTYACC */ 1301 1302 #define YYABORT goto yyabort 1303 #define YYREJECT goto yyabort 1304 #define YYACCEPT goto yyaccept 1305 #define YYERROR goto yyerrlab 1306 #if YYBTYACC 1307 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 1308 #define YYVALID_NESTED do { if (yyps->save && \ 1309 yyps->save->save == 0) goto yyvalid; } while(0) 1310 #endif /* YYBTYACC */ 1311 1312 int 1313 YYPARSE_DECL() 1314 { 1315 int yym, yyn, yystate, yyresult; 1316 #if YYBTYACC 1317 int yynewerrflag; 1318 YYParseState *yyerrctx = NULL; 1319 #endif /* YYBTYACC */ 1320 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1321 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 1322 #endif 1323 #if YYDEBUG 1324 const char *yys; 1325 1326 if ((yys = getenv("YYDEBUG")) != 0) 1327 { 1328 yyn = *yys; 1329 if (yyn >= '0' && yyn <= '9') 1330 yydebug = yyn - '0'; 1331 } 1332 if (yydebug) 1333 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 1334 #endif 1335 1336 #if YYBTYACC 1337 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 1338 yyps->save = 0; 1339 #endif /* YYBTYACC */ 1340 yym = 0; 1341 yyn = 0; 1342 yynerrs = 0; 1343 yyerrflag = 0; 1344 yychar = YYEMPTY; 1345 yystate = 0; 1346 1347 #if YYPURE 1348 memset(&yystack, 0, sizeof(yystack)); 1349 #endif 1350 1351 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1352 yystack.s_mark = yystack.s_base; 1353 yystack.l_mark = yystack.l_base; 1354 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1355 yystack.p_mark = yystack.p_base; 1356 #endif 1357 yystate = 0; 1358 *yystack.s_mark = 0; 1359 1360 yyloop: 1361 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 1362 if (yychar < 0) 1363 { 1364 #if YYBTYACC 1365 do { 1366 if (yylvp < yylve) 1367 { 1368 /* we're currently re-reading tokens */ 1369 yylval = *yylvp++; 1370 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1371 yylloc = *yylpp++; 1372 #endif 1373 yychar = *yylexp++; 1374 break; 1375 } 1376 if (yyps->save) 1377 { 1378 /* in trial mode; save scanner results for future parse attempts */ 1379 if (yylvp == yylvlim) 1380 { /* Enlarge lexical value queue */ 1381 size_t p = (size_t) (yylvp - yylvals); 1382 size_t s = (size_t) (yylvlim - yylvals); 1383 1384 s += YYLVQUEUEGROWTH; 1385 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 1386 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 1387 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1388 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 1389 #endif 1390 yylvp = yylve = yylvals + p; 1391 yylvlim = yylvals + s; 1392 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1393 yylpp = yylpe = yylpsns + p; 1394 yylplim = yylpsns + s; 1395 #endif 1396 yylexp = yylexemes + p; 1397 } 1398 *yylexp = (YYINT) YYLEX; 1399 *yylvp++ = yylval; 1400 yylve++; 1401 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1402 *yylpp++ = yylloc; 1403 yylpe++; 1404 #endif 1405 yychar = *yylexp++; 1406 break; 1407 } 1408 /* normal operation, no conflict encountered */ 1409 #endif /* YYBTYACC */ 1410 yychar = YYLEX; 1411 #if YYBTYACC 1412 } while (0); 1413 #endif /* YYBTYACC */ 1414 if (yychar < 0) yychar = YYEOF; 1415 #if YYDEBUG 1416 if (yydebug) 1417 { 1418 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1419 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 1420 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1421 #ifdef YYSTYPE_TOSTRING 1422 #if YYBTYACC 1423 if (!yytrial) 1424 #endif /* YYBTYACC */ 1425 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 1426 #endif 1427 fputc('\n', stderr); 1428 } 1429 #endif 1430 } 1431 #if YYBTYACC 1432 1433 /* Do we have a conflict? */ 1434 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1435 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1436 { 1437 YYINT ctry; 1438 1439 if (yypath) 1440 { 1441 YYParseState *save; 1442 #if YYDEBUG 1443 if (yydebug) 1444 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 1445 YYDEBUGSTR, yydepth, yystate); 1446 #endif 1447 /* Switch to the next conflict context */ 1448 save = yypath; 1449 yypath = save->save; 1450 save->save = NULL; 1451 ctry = save->ctry; 1452 if (save->state != yystate) YYABORT; 1453 yyFreeState(save); 1454 1455 } 1456 else 1457 { 1458 1459 /* Unresolved conflict - start/continue trial parse */ 1460 YYParseState *save; 1461 #if YYDEBUG 1462 if (yydebug) 1463 { 1464 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 1465 if (yyps->save) 1466 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 1467 else 1468 fputs("Starting trial parse.\n", stderr); 1469 } 1470 #endif 1471 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1472 if (save == NULL) goto yyenomem; 1473 save->save = yyps->save; 1474 save->state = yystate; 1475 save->errflag = yyerrflag; 1476 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 1477 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1478 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 1479 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1480 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1481 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 1482 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1483 #endif 1484 ctry = yytable[yyn]; 1485 if (yyctable[ctry] == -1) 1486 { 1487 #if YYDEBUG 1488 if (yydebug && yychar >= YYEOF) 1489 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 1490 #endif 1491 ctry++; 1492 } 1493 save->ctry = ctry; 1494 if (yyps->save == NULL) 1495 { 1496 /* If this is a first conflict in the stack, start saving lexemes */ 1497 if (!yylexemes) 1498 { 1499 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 1500 if (yylexemes == NULL) goto yyenomem; 1501 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 1502 if (yylvals == NULL) goto yyenomem; 1503 yylvlim = yylvals + YYLVQUEUEGROWTH; 1504 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1505 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 1506 if (yylpsns == NULL) goto yyenomem; 1507 yylplim = yylpsns + YYLVQUEUEGROWTH; 1508 #endif 1509 } 1510 if (yylvp == yylve) 1511 { 1512 yylvp = yylve = yylvals; 1513 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1514 yylpp = yylpe = yylpsns; 1515 #endif 1516 yylexp = yylexemes; 1517 if (yychar >= YYEOF) 1518 { 1519 *yylve++ = yylval; 1520 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1521 *yylpe++ = yylloc; 1522 #endif 1523 *yylexp = (YYINT) yychar; 1524 yychar = YYEMPTY; 1525 } 1526 } 1527 } 1528 if (yychar >= YYEOF) 1529 { 1530 yylvp--; 1531 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1532 yylpp--; 1533 #endif 1534 yylexp--; 1535 yychar = YYEMPTY; 1536 } 1537 save->lexeme = (int) (yylvp - yylvals); 1538 yyps->save = save; 1539 } 1540 if (yytable[yyn] == ctry) 1541 { 1542 #if YYDEBUG 1543 if (yydebug) 1544 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1545 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 1546 #endif 1547 if (yychar < 0) 1548 { 1549 yylvp++; 1550 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1551 yylpp++; 1552 #endif 1553 yylexp++; 1554 } 1555 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 1556 goto yyoverflow; 1557 yystate = yyctable[ctry]; 1558 *++yystack.s_mark = (YYINT) yystate; 1559 *++yystack.l_mark = yylval; 1560 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1561 *++yystack.p_mark = yylloc; 1562 #endif 1563 yychar = YYEMPTY; 1564 if (yyerrflag > 0) --yyerrflag; 1565 goto yyloop; 1566 } 1567 else 1568 { 1569 yyn = yyctable[ctry]; 1570 goto yyreduce; 1571 } 1572 } /* End of code dealing with conflicts */ 1573 #endif /* YYBTYACC */ 1574 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1575 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1576 { 1577 #if YYDEBUG 1578 if (yydebug) 1579 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1580 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 1581 #endif 1582 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1583 yystate = yytable[yyn]; 1584 *++yystack.s_mark = yytable[yyn]; 1585 *++yystack.l_mark = yylval; 1586 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1587 *++yystack.p_mark = yylloc; 1588 #endif 1589 yychar = YYEMPTY; 1590 if (yyerrflag > 0) --yyerrflag; 1591 goto yyloop; 1592 } 1593 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1594 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1595 { 1596 yyn = yytable[yyn]; 1597 goto yyreduce; 1598 } 1599 if (yyerrflag != 0) goto yyinrecovery; 1600 #if YYBTYACC 1601 1602 yynewerrflag = 1; 1603 goto yyerrhandler; 1604 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1605 1606 yyerrlab: 1607 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 1608 * before looking for error recovery */ 1609 yystack.s_mark -= yym; 1610 yystate = *yystack.s_mark; 1611 yystack.l_mark -= yym; 1612 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1613 yystack.p_mark -= yym; 1614 #endif 1615 1616 yynewerrflag = 0; 1617 yyerrhandler: 1618 while (yyps->save) 1619 { 1620 int ctry; 1621 YYParseState *save = yyps->save; 1622 #if YYDEBUG 1623 if (yydebug) 1624 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 1625 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 1626 (int)(yylvp - yylvals - yyps->save->lexeme)); 1627 #endif 1628 /* Memorize most forward-looking error state in case it's really an error. */ 1629 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 1630 { 1631 /* Free old saved error context state */ 1632 if (yyerrctx) yyFreeState(yyerrctx); 1633 /* Create and fill out new saved error context state */ 1634 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1635 if (yyerrctx == NULL) goto yyenomem; 1636 yyerrctx->save = yyps->save; 1637 yyerrctx->state = yystate; 1638 yyerrctx->errflag = yyerrflag; 1639 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 1640 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1641 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 1642 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1643 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1644 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 1645 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1646 #endif 1647 yyerrctx->lexeme = (int) (yylvp - yylvals); 1648 } 1649 yylvp = yylvals + save->lexeme; 1650 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1651 yylpp = yylpsns + save->lexeme; 1652 #endif 1653 yylexp = yylexemes + save->lexeme; 1654 yychar = YYEMPTY; 1655 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1656 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1657 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1658 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1659 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1660 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1661 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1662 #endif 1663 ctry = ++save->ctry; 1664 yystate = save->state; 1665 /* We tried shift, try reduce now */ 1666 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1667 yyps->save = save->save; 1668 save->save = NULL; 1669 yyFreeState(save); 1670 1671 /* Nothing left on the stack -- error */ 1672 if (!yyps->save) 1673 { 1674 #if YYDEBUG 1675 if (yydebug) 1676 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1677 YYPREFIX, yydepth); 1678 #endif 1679 /* Restore state as it was in the most forward-advanced error */ 1680 yylvp = yylvals + yyerrctx->lexeme; 1681 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1682 yylpp = yylpsns + yyerrctx->lexeme; 1683 #endif 1684 yylexp = yylexemes + yyerrctx->lexeme; 1685 yychar = yylexp[-1]; 1686 yylval = yylvp[-1]; 1687 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1688 yylloc = yylpp[-1]; 1689 #endif 1690 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1691 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1692 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1693 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1694 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1695 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1696 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1697 #endif 1698 yystate = yyerrctx->state; 1699 yyFreeState(yyerrctx); 1700 yyerrctx = NULL; 1701 } 1702 yynewerrflag = 1; 1703 } 1704 if (yynewerrflag == 0) goto yyinrecovery; 1705 #endif /* YYBTYACC */ 1706 1707 YYERROR_CALL("syntax error"); 1708 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1709 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1710 #endif 1711 1712 #if !YYBTYACC 1713 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1714 yyerrlab: 1715 #endif 1716 ++yynerrs; 1717 1718 yyinrecovery: 1719 if (yyerrflag < 3) 1720 { 1721 yyerrflag = 3; 1722 for (;;) 1723 { 1724 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1725 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1726 { 1727 #if YYDEBUG 1728 if (yydebug) 1729 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1730 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1731 #endif 1732 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1733 yystate = yytable[yyn]; 1734 *++yystack.s_mark = yytable[yyn]; 1735 *++yystack.l_mark = yylval; 1736 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1737 /* lookahead position is error end position */ 1738 yyerror_loc_range[1] = yylloc; 1739 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1740 *++yystack.p_mark = yyloc; 1741 #endif 1742 goto yyloop; 1743 } 1744 else 1745 { 1746 #if YYDEBUG 1747 if (yydebug) 1748 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1749 YYDEBUGSTR, yydepth, *yystack.s_mark); 1750 #endif 1751 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1752 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1753 /* the current TOS position is the error start position */ 1754 yyerror_loc_range[0] = *yystack.p_mark; 1755 #endif 1756 #if defined(YYDESTRUCT_CALL) 1757 #if YYBTYACC 1758 if (!yytrial) 1759 #endif /* YYBTYACC */ 1760 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1761 YYDESTRUCT_CALL("error: discarding state", 1762 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1763 #else 1764 YYDESTRUCT_CALL("error: discarding state", 1765 yystos[*yystack.s_mark], yystack.l_mark); 1766 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1767 #endif /* defined(YYDESTRUCT_CALL) */ 1768 --yystack.s_mark; 1769 --yystack.l_mark; 1770 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1771 --yystack.p_mark; 1772 #endif 1773 } 1774 } 1775 } 1776 else 1777 { 1778 if (yychar == YYEOF) goto yyabort; 1779 #if YYDEBUG 1780 if (yydebug) 1781 { 1782 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1783 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1784 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1785 } 1786 #endif 1787 #if defined(YYDESTRUCT_CALL) 1788 #if YYBTYACC 1789 if (!yytrial) 1790 #endif /* YYBTYACC */ 1791 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1792 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1793 #else 1794 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1795 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1796 #endif /* defined(YYDESTRUCT_CALL) */ 1797 yychar = YYEMPTY; 1798 goto yyloop; 1799 } 1800 1801 yyreduce: 1802 yym = yylen[yyn]; 1803 #if YYDEBUG 1804 if (yydebug) 1805 { 1806 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1807 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1808 #ifdef YYSTYPE_TOSTRING 1809 #if YYBTYACC 1810 if (!yytrial) 1811 #endif /* YYBTYACC */ 1812 if (yym > 0) 1813 { 1814 int i; 1815 fputc('<', stderr); 1816 for (i = yym; i > 0; i--) 1817 { 1818 if (i != yym) fputs(", ", stderr); 1819 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1820 yystack.l_mark[1-i]), stderr); 1821 } 1822 fputc('>', stderr); 1823 } 1824 #endif 1825 fputc('\n', stderr); 1826 } 1827 #endif 1828 if (yym > 0) 1829 yyval = yystack.l_mark[1-yym]; 1830 else 1831 memset(&yyval, 0, sizeof yyval); 1832 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1833 1834 /* Perform position reduction */ 1835 memset(&yyloc, 0, sizeof(yyloc)); 1836 #if YYBTYACC 1837 if (!yytrial) 1838 #endif /* YYBTYACC */ 1839 { 1840 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1841 /* just in case YYERROR is invoked within the action, save 1842 the start of the rhs as the error start position */ 1843 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1844 } 1845 #endif 1846 1847 switch (yyn) 1848 { 1849 case 1: 1850 #line 93 "btyacc_demo.y" 1851 { yyval.scope = yystack.l_mark[0].scope; } 1852 break; 1853 case 2: 1854 #line 94 "btyacc_demo.y" 1855 { yyval.scope = global_scope; } 1856 break; 1857 case 3: 1858 #line 95 "btyacc_demo.y" 1859 { Decl *d = lookup(yystack.l_mark[-2].scope, yystack.l_mark[-1].id); 1860 if (!d || !d->scope) YYERROR; 1861 yyval.scope = d->scope; } 1862 break; 1863 case 4: 1864 #line 101 "btyacc_demo.y" 1865 { Decl *d = lookup(yystack.l_mark[-1].scope, yystack.l_mark[0].id); 1866 if (d == NULL || d->istype() == 0) YYERROR; 1867 yyval.type = d->type; } 1868 break; 1869 case 5: 1870 #line 106 "btyacc_demo.y" 1871 yyval.scope = global_scope = new_scope(0); 1872 break; 1873 case 8: 1874 #line 107 "btyacc_demo.y" 1875 yyval.scope = yystack.l_mark[-1].scope; 1876 break; 1877 case 10: 1878 #line 109 "btyacc_demo.y" 1879 {YYVALID;} 1880 break; 1881 case 11: 1882 #line 110 "btyacc_demo.y" 1883 yyval.scope = start_fn_def(yystack.l_mark[-2].scope, yystack.l_mark[0].decl); 1884 break; 1885 case 12: 1886 if (!yytrial) 1887 #line 111 "btyacc_demo.y" 1888 { /* demonstrate use of @$ & @N, although this is just the 1889 default computation and so is not necessary */ 1890 yyloc.first_line = yystack.p_mark[-3].first_line; 1891 yyloc.first_column = yystack.p_mark[-3].first_column; 1892 yyloc.last_line = yystack.p_mark[0].last_line; 1893 yyloc.last_column = yystack.p_mark[0].last_column; 1894 finish_fn_def(yystack.l_mark[-2].decl, yystack.l_mark[0].code); } 1895 break; 1896 case 13: 1897 #line 121 "btyacc_demo.y" 1898 { yyval.type = yystack.l_mark[0].type; } 1899 break; 1900 case 14: 1901 #line 122 "btyacc_demo.y" 1902 { yyval.type = type_combine(yystack.l_mark[-2].type, yystack.l_mark[0].type); } 1903 break; 1904 case 15: 1905 #line 125 "btyacc_demo.y" 1906 { yyval.type = 0; } 1907 break; 1908 case 16: 1909 #line 126 "btyacc_demo.y" 1910 { yyval.type = type_combine(yystack.l_mark[-1].type, yystack.l_mark[0].type); } 1911 break; 1912 case 17: 1913 #line 130 "btyacc_demo.y" 1914 { yyval.type = yystack.l_mark[0].type; } 1915 break; 1916 case 18: 1917 #line 131 "btyacc_demo.y" 1918 { yyval.type = yystack.l_mark[0].type; } 1919 break; 1920 case 19: 1921 #line 132 "btyacc_demo.y" 1922 { yyval.type = bare_extern(); } 1923 break; 1924 case 20: 1925 #line 133 "btyacc_demo.y" 1926 { yyval.type = bare_register(); } 1927 break; 1928 case 21: 1929 #line 134 "btyacc_demo.y" 1930 { yyval.type = bare_static(); } 1931 break; 1932 case 22: 1933 #line 138 "btyacc_demo.y" 1934 { yyval.type = bare_const(); } 1935 break; 1936 case 23: 1937 #line 139 "btyacc_demo.y" 1938 { yyval.type = bare_volatile(); } 1939 break; 1940 case 24: 1941 #line 143 "btyacc_demo.y" 1942 yyval.scope = yystack.l_mark[-3].scope; 1943 break; 1944 case 25: 1945 #line 143 "btyacc_demo.y" 1946 yyval.type = yystack.l_mark[-3].type; 1947 break; 1948 case 28: 1949 #line 148 "btyacc_demo.y" 1950 { if (!yystack.l_mark[0].type) YYERROR; } if (!yytrial) 1951 #line 149 "btyacc_demo.y" 1952 { yyval.decl = declare(yystack.l_mark[-1].scope, 0, yystack.l_mark[0].type); } 1953 break; 1954 case 29: 1955 if (!yytrial) 1956 #line 150 "btyacc_demo.y" 1957 { yyval.decl = declare(yystack.l_mark[-2].scope, yystack.l_mark[0].id, yystack.l_mark[-1].type); } 1958 break; 1959 case 30: 1960 #line 151 "btyacc_demo.y" 1961 yyval.scope = yystack.l_mark[-2].scope; 1962 break; 1963 case 31: 1964 #line 151 "btyacc_demo.y" 1965 yyval.type = yystack.l_mark[-2].type; 1966 break; 1967 case 32: 1968 if (!yytrial) 1969 #line 151 "btyacc_demo.y" 1970 { yyval.decl = yystack.l_mark[-1].decl; } 1971 break; 1972 case 33: 1973 if (!yytrial) 1974 #line 153 "btyacc_demo.y" 1975 { yyval.decl = make_pointer(yystack.l_mark[0].decl, yystack.l_mark[-3].type); } 1976 break; 1977 case 34: 1978 if (!yytrial) 1979 #line 155 "btyacc_demo.y" 1980 { yyval.decl = make_array(yystack.l_mark[-4].decl->type, yystack.l_mark[-1].expr); } 1981 break; 1982 case 35: 1983 if (!yytrial) 1984 #line 157 "btyacc_demo.y" 1985 { yyval.decl = build_function(yystack.l_mark[-5].decl, yystack.l_mark[-2].dlist, yystack.l_mark[0].type); } 1986 break; 1987 case 36: 1988 if (!yytrial) 1989 #line 160 "btyacc_demo.y" 1990 { yyval.dlist = 0; } 1991 break; 1992 case 37: 1993 if (!yytrial) 1994 #line 161 "btyacc_demo.y" 1995 { yyval.dlist = yystack.l_mark[0].dlist; } 1996 break; 1997 case 38: 1998 if (!yytrial) 1999 #line 164 "btyacc_demo.y" 2000 { yyval.dlist = append_dlist(yystack.l_mark[-3].dlist, yystack.l_mark[0].decl); } 2001 break; 2002 case 39: 2003 if (!yytrial) 2004 #line 165 "btyacc_demo.y" 2005 { yyval.dlist = build_dlist(yystack.l_mark[0].decl); } 2006 break; 2007 case 40: 2008 if (!yytrial) 2009 #line 168 "btyacc_demo.y" 2010 { yyval.decl = yystack.l_mark[0].decl; } 2011 break; 2012 case 41: 2013 if (!yytrial) 2014 #line 172 "btyacc_demo.y" 2015 { yyval.expr = build_expr(yystack.l_mark[-3].expr, ADD, yystack.l_mark[0].expr); } 2016 break; 2017 case 42: 2018 if (!yytrial) 2019 #line 173 "btyacc_demo.y" 2020 { yyval.expr = build_expr(yystack.l_mark[-3].expr, SUB, yystack.l_mark[0].expr); } 2021 break; 2022 case 43: 2023 if (!yytrial) 2024 #line 174 "btyacc_demo.y" 2025 { yyval.expr = build_expr(yystack.l_mark[-3].expr, MUL, yystack.l_mark[0].expr); } 2026 break; 2027 case 44: 2028 if (!yytrial) 2029 #line 175 "btyacc_demo.y" 2030 { yyval.expr = build_expr(yystack.l_mark[-3].expr, MOD, yystack.l_mark[0].expr); } 2031 break; 2032 case 45: 2033 if (!yytrial) 2034 #line 176 "btyacc_demo.y" 2035 { yyval.expr = build_expr(yystack.l_mark[-3].expr, DIV, yystack.l_mark[0].expr); } 2036 break; 2037 case 46: 2038 if (!yytrial) 2039 #line 177 "btyacc_demo.y" 2040 { yyval.expr = build_expr(0, DEREF, yystack.l_mark[0].expr); } 2041 break; 2042 case 47: 2043 if (!yytrial) 2044 #line 178 "btyacc_demo.y" 2045 { yyval.expr = var_expr(yystack.l_mark[-1].scope, yystack.l_mark[0].id); } 2046 break; 2047 case 48: 2048 if (!yytrial) 2049 #line 179 "btyacc_demo.y" 2050 { yyval.expr = yystack.l_mark[0].expr; } 2051 break; 2052 case 49: 2053 if (!yytrial) 2054 #line 183 "btyacc_demo.y" 2055 { yyval.code = 0; } 2056 break; 2057 case 50: 2058 #line 184 "btyacc_demo.y" 2059 {YYVALID;} if (!yytrial) 2060 #line 184 "btyacc_demo.y" 2061 { yyval.code = build_expr_code(yystack.l_mark[-1].expr); } 2062 break; 2063 case 51: 2064 #line 185 "btyacc_demo.y" 2065 yyval.scope = yystack.l_mark[-6].scope; 2066 break; 2067 case 52: 2068 #line 185 "btyacc_demo.y" 2069 yyval.scope = yystack.l_mark[-9].scope; 2070 break; 2071 case 53: 2072 #line 185 "btyacc_demo.y" 2073 {YYVALID;} if (!yytrial) 2074 #line 186 "btyacc_demo.y" 2075 { yyval.code = build_if(yystack.l_mark[-7].expr, yystack.l_mark[-3].code, yystack.l_mark[0].code); } 2076 break; 2077 case 54: 2078 #line 187 "btyacc_demo.y" 2079 {YYVALID;} if (!yytrial) 2080 #line 188 "btyacc_demo.y" 2081 { yyval.code = build_if(yystack.l_mark[-4].expr, yystack.l_mark[0].code, 0); } 2082 break; 2083 case 55: 2084 #line 189 "btyacc_demo.y" 2085 yyval.scope = new_scope(yystack.l_mark[0].scope); 2086 break; 2087 case 56: 2088 #line 189 "btyacc_demo.y" 2089 {YYVALID;} if (!yytrial) 2090 #line 189 "btyacc_demo.y" 2091 { yyval.code = yystack.l_mark[0].code; } 2092 break; 2093 case 57: 2094 if (!yytrial) 2095 #line 192 "btyacc_demo.y" 2096 { yyval.code = 0; } 2097 break; 2098 case 58: 2099 if (!yytrial) 2100 #line 193 "btyacc_demo.y" 2101 { yyval.code = code_append(yystack.l_mark[-2].code, yystack.l_mark[0].code); } 2102 break; 2103 case 59: 2104 if (!yytrial) 2105 #line 197 "btyacc_demo.y" 2106 { yyval.code = yystack.l_mark[-1].code; } 2107 break; 2108 #line 2107 "btyacc_demo.tab.c" 2109 default: 2110 break; 2111 } 2112 yystack.s_mark -= yym; 2113 yystate = *yystack.s_mark; 2114 yystack.l_mark -= yym; 2115 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2116 yystack.p_mark -= yym; 2117 #endif 2118 yym = yylhs[yyn]; 2119 if (yystate == 0 && yym == 0) 2120 { 2121 #if YYDEBUG 2122 if (yydebug) 2123 { 2124 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 2125 #ifdef YYSTYPE_TOSTRING 2126 #if YYBTYACC 2127 if (!yytrial) 2128 #endif /* YYBTYACC */ 2129 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 2130 #endif 2131 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 2132 } 2133 #endif 2134 yystate = YYFINAL; 2135 *++yystack.s_mark = YYFINAL; 2136 *++yystack.l_mark = yyval; 2137 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2138 *++yystack.p_mark = yyloc; 2139 #endif 2140 if (yychar < 0) 2141 { 2142 #if YYBTYACC 2143 do { 2144 if (yylvp < yylve) 2145 { 2146 /* we're currently re-reading tokens */ 2147 yylval = *yylvp++; 2148 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2149 yylloc = *yylpp++; 2150 #endif 2151 yychar = *yylexp++; 2152 break; 2153 } 2154 if (yyps->save) 2155 { 2156 /* in trial mode; save scanner results for future parse attempts */ 2157 if (yylvp == yylvlim) 2158 { /* Enlarge lexical value queue */ 2159 size_t p = (size_t) (yylvp - yylvals); 2160 size_t s = (size_t) (yylvlim - yylvals); 2161 2162 s += YYLVQUEUEGROWTH; 2163 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) 2164 goto yyenomem; 2165 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 2166 goto yyenomem; 2167 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2168 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 2169 goto yyenomem; 2170 #endif 2171 yylvp = yylve = yylvals + p; 2172 yylvlim = yylvals + s; 2173 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2174 yylpp = yylpe = yylpsns + p; 2175 yylplim = yylpsns + s; 2176 #endif 2177 yylexp = yylexemes + p; 2178 } 2179 *yylexp = (YYINT) YYLEX; 2180 *yylvp++ = yylval; 2181 yylve++; 2182 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2183 *yylpp++ = yylloc; 2184 yylpe++; 2185 #endif 2186 yychar = *yylexp++; 2187 break; 2188 } 2189 /* normal operation, no conflict encountered */ 2190 #endif /* YYBTYACC */ 2191 yychar = YYLEX; 2192 #if YYBTYACC 2193 } while (0); 2194 #endif /* YYBTYACC */ 2195 if (yychar < 0) yychar = YYEOF; 2196 #if YYDEBUG 2197 if (yydebug) 2198 { 2199 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 2200 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 2201 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 2202 } 2203 #endif 2204 } 2205 if (yychar == YYEOF) goto yyaccept; 2206 goto yyloop; 2207 } 2208 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 2209 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 2210 yystate = yytable[yyn]; 2211 else 2212 yystate = yydgoto[yym]; 2213 #if YYDEBUG 2214 if (yydebug) 2215 { 2216 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 2217 #ifdef YYSTYPE_TOSTRING 2218 #if YYBTYACC 2219 if (!yytrial) 2220 #endif /* YYBTYACC */ 2221 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 2222 #endif 2223 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 2224 } 2225 #endif 2226 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 2227 *++yystack.s_mark = (YYINT) yystate; 2228 *++yystack.l_mark = yyval; 2229 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2230 *++yystack.p_mark = yyloc; 2231 #endif 2232 goto yyloop; 2233 #if YYBTYACC 2234 2235 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 2236 yyvalid: 2237 if (yypath) YYABORT; 2238 while (yyps->save) 2239 { 2240 YYParseState *save = yyps->save; 2241 yyps->save = save->save; 2242 save->save = yypath; 2243 yypath = save; 2244 } 2245 #if YYDEBUG 2246 if (yydebug) 2247 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 2248 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 2249 #endif 2250 if (yyerrctx) 2251 { 2252 yyFreeState(yyerrctx); 2253 yyerrctx = NULL; 2254 } 2255 yylvp = yylvals + yypath->lexeme; 2256 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2257 yylpp = yylpsns + yypath->lexeme; 2258 #endif 2259 yylexp = yylexemes + yypath->lexeme; 2260 yychar = YYEMPTY; 2261 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 2262 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 2263 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 2264 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 2265 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2266 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 2267 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 2268 #endif 2269 yystate = yypath->state; 2270 goto yyloop; 2271 #endif /* YYBTYACC */ 2272 2273 yyoverflow: 2274 YYERROR_CALL("yacc stack overflow"); 2275 #if YYBTYACC 2276 goto yyabort_nomem; 2277 yyenomem: 2278 YYERROR_CALL("memory exhausted"); 2279 yyabort_nomem: 2280 #endif /* YYBTYACC */ 2281 yyresult = 2; 2282 goto yyreturn; 2283 2284 yyabort: 2285 yyresult = 1; 2286 goto yyreturn; 2287 2288 yyaccept: 2289 #if YYBTYACC 2290 if (yyps->save) goto yyvalid; 2291 #endif /* YYBTYACC */ 2292 yyresult = 0; 2293 2294 yyreturn: 2295 #if defined(YYDESTRUCT_CALL) 2296 if (yychar != YYEOF && yychar != YYEMPTY) 2297 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2298 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 2299 #else 2300 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 2301 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2302 2303 { 2304 YYSTYPE *pv; 2305 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2306 YYLTYPE *pp; 2307 2308 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 2309 YYDESTRUCT_CALL("cleanup: discarding state", 2310 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 2311 #else 2312 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 2313 YYDESTRUCT_CALL("cleanup: discarding state", 2314 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 2315 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2316 } 2317 #endif /* defined(YYDESTRUCT_CALL) */ 2318 2319 #if YYBTYACC 2320 if (yyerrctx) 2321 { 2322 yyFreeState(yyerrctx); 2323 yyerrctx = NULL; 2324 } 2325 while (yyps) 2326 { 2327 YYParseState *save = yyps; 2328 yyps = save->save; 2329 save->save = NULL; 2330 yyFreeState(save); 2331 } 2332 while (yypath) 2333 { 2334 YYParseState *save = yypath; 2335 yypath = save->save; 2336 save->save = NULL; 2337 yyFreeState(save); 2338 } 2339 #endif /* YYBTYACC */ 2340 yyfreestack(&yystack); 2341 return (yyresult); 2342 } 2343
Indexes created Sat Apr 11 00:22:22 UTC 2026