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