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