|
GDB (API)
|
|
GDB (API)
|
00001 /* A Bison parser, made by GNU Bison 2.5. */ 00002 00003 /* Bison implementation for Yacc-like parsers in C 00004 00005 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 00006 00007 This program is free software: you can redistribute it and/or modify 00008 it under the terms of the GNU General Public License as published by 00009 the Free Software Foundation, either version 3 of the License, or 00010 (at your option) any later version. 00011 00012 This program is distributed in the hope that it will be useful, 00013 but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00015 GNU General Public License for more details. 00016 00017 You should have received a copy of the GNU General Public License 00018 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 00019 00020 /* As a special exception, you may create a larger work that contains 00021 part or all of the Bison parser skeleton and distribute that work 00022 under terms of your choice, so long as that work isn't itself a 00023 parser generator using the skeleton or a modified version thereof 00024 as a parser skeleton. Alternatively, if you modify or redistribute 00025 the parser skeleton itself, you may (at your option) remove this 00026 special exception, which will cause the skeleton and the resulting 00027 Bison output files to be licensed under the GNU General Public 00028 License without this special exception. 00029 00030 This special exception was added by the Free Software Foundation in 00031 version 2.2 of Bison. */ 00032 00033 /* C LALR(1) parser skeleton written by Richard Stallman, by 00034 simplifying the original so-called "semantic" parser. */ 00035 00036 /* All symbols defined below should begin with yy or YY, to avoid 00037 infringing on user name space. This should be done even for local 00038 variables, as they might otherwise be expanded by user macros. 00039 There are some unavoidable exceptions within include files to 00040 define necessary library symbols; they are noted "INFRINGES ON 00041 USER NAME SPACE" below. */ 00042 00043 /* Identify Bison output. */ 00044 #define YYBISON 1 00045 00046 /* Bison version. */ 00047 #define YYBISON_VERSION "2.5" 00048 00049 /* Skeleton name. */ 00050 #define YYSKELETON_NAME "yacc.c" 00051 00052 /* Pure parsers. */ 00053 #define YYPURE 0 00054 00055 /* Push parsers. */ 00056 #define YYPUSH 0 00057 00058 /* Pull parsers. */ 00059 #define YYPULL 1 00060 00061 /* Using locations. */ 00062 #define YYLSP_NEEDED 0 00063 00064 00065 00066 /* Copy the first part of user declarations. */ 00067 00068 /* Line 268 of yacc.c */ 00069 #line 36 "../../src/gdb/c-exp.y" 00070 00071 00072 #include "defs.h" 00073 #include "gdb_string.h" 00074 #include <ctype.h> 00075 #include "expression.h" 00076 #include "value.h" 00077 #include "parser-defs.h" 00078 #include "language.h" 00079 #include "c-lang.h" 00080 #include "bfd.h" /* Required by objfiles.h. */ 00081 #include "symfile.h" /* Required by objfiles.h. */ 00082 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 00083 #include "charset.h" 00084 #include "block.h" 00085 #include "cp-support.h" 00086 #include "dfp.h" 00087 #include "gdb_assert.h" 00088 #include "macroscope.h" 00089 #include "objc-lang.h" 00090 #include "typeprint.h" 00091 #include "cp-abi.h" 00092 00093 #define parse_type builtin_type (parse_gdbarch) 00094 00095 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 00096 as well as gratuitiously global symbol names, so we can have multiple 00097 yacc generated parsers in gdb. Note that these are only the variables 00098 produced by yacc. If other parser generators (bison, byacc, etc) produce 00099 additional global names that conflict at link time, then those parser 00100 generators need to be fixed instead of adding those names to this list. */ 00101 00102 #define yymaxdepth c_maxdepth 00103 #define yyparse c_parse_internal 00104 #define yylex c_lex 00105 #define yyerror c_error 00106 #define yylval c_lval 00107 #define yychar c_char 00108 #define yydebug c_debug 00109 #define yypact c_pact 00110 #define yyr1 c_r1 00111 #define yyr2 c_r2 00112 #define yydef c_def 00113 #define yychk c_chk 00114 #define yypgo c_pgo 00115 #define yyact c_act 00116 #define yyexca c_exca 00117 #define yyerrflag c_errflag 00118 #define yynerrs c_nerrs 00119 #define yyps c_ps 00120 #define yypv c_pv 00121 #define yys c_s 00122 #define yy_yys c_yys 00123 #define yystate c_state 00124 #define yytmp c_tmp 00125 #define yyv c_v 00126 #define yy_yyv c_yyv 00127 #define yyval c_val 00128 #define yylloc c_lloc 00129 #define yyreds c_reds /* With YYDEBUG defined */ 00130 #define yytoks c_toks /* With YYDEBUG defined */ 00131 #define yyname c_name /* With YYDEBUG defined */ 00132 #define yyrule c_rule /* With YYDEBUG defined */ 00133 #define yylhs c_yylhs 00134 #define yylen c_yylen 00135 #define yydefred c_yydefred 00136 #define yydgoto c_yydgoto 00137 #define yysindex c_yysindex 00138 #define yyrindex c_yyrindex 00139 #define yygindex c_yygindex 00140 #define yytable c_yytable 00141 #define yycheck c_yycheck 00142 #define yyss c_yyss 00143 #define yysslim c_yysslim 00144 #define yyssp c_yyssp 00145 #define yystacksize c_yystacksize 00146 #define yyvs c_yyvs 00147 #define yyvsp c_yyvsp 00148 00149 #ifndef YYDEBUG 00150 #define YYDEBUG 1 /* Default to yydebug support */ 00151 #endif 00152 00153 #define YYFPRINTF parser_fprintf 00154 00155 int yyparse (void); 00156 00157 static int yylex (void); 00158 00159 void yyerror (char *); 00160 00161 00162 00163 /* Line 268 of yacc.c */ 00164 #line 165 "c-exp.c" 00165 00166 /* Enabling traces. */ 00167 #ifndef YYDEBUG 00168 # define YYDEBUG 0 00169 #endif 00170 00171 /* Enabling verbose error messages. */ 00172 #ifdef YYERROR_VERBOSE 00173 # undef YYERROR_VERBOSE 00174 # define YYERROR_VERBOSE 1 00175 #else 00176 # define YYERROR_VERBOSE 0 00177 #endif 00178 00179 /* Enabling the token table. */ 00180 #ifndef YYTOKEN_TABLE 00181 # define YYTOKEN_TABLE 0 00182 #endif 00183 00184 00185 /* Tokens. */ 00186 #ifndef YYTOKENTYPE 00187 # define YYTOKENTYPE 00188 /* Put the tokens into the symbol table, so that GDB and other debuggers 00189 know about them. */ 00190 enum yytokentype { 00191 INT = 258, 00192 FLOAT = 259, 00193 DECFLOAT = 260, 00194 STRING = 261, 00195 NSSTRING = 262, 00196 SELECTOR = 263, 00197 CHAR = 264, 00198 NAME = 265, 00199 UNKNOWN_CPP_NAME = 266, 00200 COMPLETE = 267, 00201 TYPENAME = 268, 00202 CLASSNAME = 269, 00203 OBJC_LBRAC = 270, 00204 NAME_OR_INT = 271, 00205 OPERATOR = 272, 00206 STRUCT = 273, 00207 CLASS = 274, 00208 UNION = 275, 00209 ENUM = 276, 00210 SIZEOF = 277, 00211 UNSIGNED = 278, 00212 COLONCOLON = 279, 00213 TEMPLATE = 280, 00214 ERROR = 281, 00215 NEW = 282, 00216 DELETE = 283, 00217 REINTERPRET_CAST = 284, 00218 DYNAMIC_CAST = 285, 00219 STATIC_CAST = 286, 00220 CONST_CAST = 287, 00221 ENTRY = 288, 00222 TYPEOF = 289, 00223 DECLTYPE = 290, 00224 TYPEID = 291, 00225 SIGNED_KEYWORD = 292, 00226 LONG = 293, 00227 SHORT = 294, 00228 INT_KEYWORD = 295, 00229 CONST_KEYWORD = 296, 00230 VOLATILE_KEYWORD = 297, 00231 DOUBLE_KEYWORD = 298, 00232 VARIABLE = 299, 00233 ASSIGN_MODIFY = 300, 00234 TRUEKEYWORD = 301, 00235 FALSEKEYWORD = 302, 00236 ABOVE_COMMA = 303, 00237 OROR = 304, 00238 ANDAND = 305, 00239 NOTEQUAL = 306, 00240 EQUAL = 307, 00241 GEQ = 308, 00242 LEQ = 309, 00243 RSH = 310, 00244 LSH = 311, 00245 DECREMENT = 312, 00246 INCREMENT = 313, 00247 UNARY = 314, 00248 DOT_STAR = 315, 00249 ARROW_STAR = 316, 00250 ARROW = 317, 00251 BLOCKNAME = 318, 00252 FILENAME = 319, 00253 DOTDOTDOT = 320 00254 }; 00255 #endif 00256 /* Tokens. */ 00257 #define INT 258 00258 #define FLOAT 259 00259 #define DECFLOAT 260 00260 #define STRING 261 00261 #define NSSTRING 262 00262 #define SELECTOR 263 00263 #define CHAR 264 00264 #define NAME 265 00265 #define UNKNOWN_CPP_NAME 266 00266 #define COMPLETE 267 00267 #define TYPENAME 268 00268 #define CLASSNAME 269 00269 #define OBJC_LBRAC 270 00270 #define NAME_OR_INT 271 00271 #define OPERATOR 272 00272 #define STRUCT 273 00273 #define CLASS 274 00274 #define UNION 275 00275 #define ENUM 276 00276 #define SIZEOF 277 00277 #define UNSIGNED 278 00278 #define COLONCOLON 279 00279 #define TEMPLATE 280 00280 #define ERROR 281 00281 #define NEW 282 00282 #define DELETE 283 00283 #define REINTERPRET_CAST 284 00284 #define DYNAMIC_CAST 285 00285 #define STATIC_CAST 286 00286 #define CONST_CAST 287 00287 #define ENTRY 288 00288 #define TYPEOF 289 00289 #define DECLTYPE 290 00290 #define TYPEID 291 00291 #define SIGNED_KEYWORD 292 00292 #define LONG 293 00293 #define SHORT 294 00294 #define INT_KEYWORD 295 00295 #define CONST_KEYWORD 296 00296 #define VOLATILE_KEYWORD 297 00297 #define DOUBLE_KEYWORD 298 00298 #define VARIABLE 299 00299 #define ASSIGN_MODIFY 300 00300 #define TRUEKEYWORD 301 00301 #define FALSEKEYWORD 302 00302 #define ABOVE_COMMA 303 00303 #define OROR 304 00304 #define ANDAND 305 00305 #define NOTEQUAL 306 00306 #define EQUAL 307 00307 #define GEQ 308 00308 #define LEQ 309 00309 #define RSH 310 00310 #define LSH 311 00311 #define DECREMENT 312 00312 #define INCREMENT 313 00313 #define UNARY 314 00314 #define DOT_STAR 315 00315 #define ARROW_STAR 316 00316 #define ARROW 317 00317 #define BLOCKNAME 318 00318 #define FILENAME 319 00319 #define DOTDOTDOT 320 00320 00321 00322 00323 00324 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 00325 typedef union YYSTYPE 00326 { 00327 00328 /* Line 293 of yacc.c */ 00329 #line 134 "../../src/gdb/c-exp.y" 00330 00331 LONGEST lval; 00332 struct { 00333 LONGEST val; 00334 struct type *type; 00335 } typed_val_int; 00336 struct { 00337 DOUBLEST dval; 00338 struct type *type; 00339 } typed_val_float; 00340 struct { 00341 gdb_byte val[16]; 00342 struct type *type; 00343 } typed_val_decfloat; 00344 struct type *tval; 00345 struct stoken sval; 00346 struct typed_stoken tsval; 00347 struct ttype tsym; 00348 struct symtoken ssym; 00349 int voidval; 00350 struct block *bval; 00351 enum exp_opcode opcode; 00352 00353 struct stoken_vector svec; 00354 VEC (type_ptr) *tvec; 00355 00356 struct type_stack *type_stack; 00357 00358 struct objc_class_str class; 00359 00360 00361 00362 /* Line 293 of yacc.c */ 00363 #line 364 "c-exp.c" 00364 } YYSTYPE; 00365 # define YYSTYPE_IS_TRIVIAL 1 00366 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 00367 # define YYSTYPE_IS_DECLARED 1 00368 #endif 00369 00370 00371 /* Copy the second part of user declarations. */ 00372 00373 /* Line 343 of yacc.c */ 00374 #line 165 "../../src/gdb/c-exp.y" 00375 00376 /* YYSTYPE gets defined by %union */ 00377 static int parse_number (const char *, int, int, YYSTYPE *); 00378 static struct stoken operator_stoken (const char *); 00379 static void check_parameter_typelist (VEC (type_ptr) *); 00380 static void write_destructor_name (struct stoken); 00381 00382 static void c_print_token (FILE *file, int type, YYSTYPE value); 00383 #define YYPRINT(FILE, TYPE, VALUE) c_print_token (FILE, TYPE, VALUE) 00384 00385 00386 /* Line 343 of yacc.c */ 00387 #line 388 "c-exp.c" 00388 00389 #ifdef short 00390 # undef short 00391 #endif 00392 00393 #ifdef YYTYPE_UINT8 00394 typedef YYTYPE_UINT8 yytype_uint8; 00395 #else 00396 typedef unsigned char yytype_uint8; 00397 #endif 00398 00399 #ifdef YYTYPE_INT8 00400 typedef YYTYPE_INT8 yytype_int8; 00401 #elif (defined __STDC__ || defined __C99__FUNC__ \ 00402 || defined __cplusplus || defined _MSC_VER) 00403 typedef signed char yytype_int8; 00404 #else 00405 typedef short int yytype_int8; 00406 #endif 00407 00408 #ifdef YYTYPE_UINT16 00409 typedef YYTYPE_UINT16 yytype_uint16; 00410 #else 00411 typedef unsigned short int yytype_uint16; 00412 #endif 00413 00414 #ifdef YYTYPE_INT16 00415 typedef YYTYPE_INT16 yytype_int16; 00416 #else 00417 typedef short int yytype_int16; 00418 #endif 00419 00420 #ifndef YYSIZE_T 00421 # ifdef __SIZE_TYPE__ 00422 # define YYSIZE_T __SIZE_TYPE__ 00423 # elif defined size_t 00424 # define YYSIZE_T size_t 00425 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 00426 || defined __cplusplus || defined _MSC_VER) 00427 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 00428 # define YYSIZE_T size_t 00429 # else 00430 # define YYSIZE_T unsigned int 00431 # endif 00432 #endif 00433 00434 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 00435 00436 #ifndef YY_ 00437 # if defined YYENABLE_NLS && YYENABLE_NLS 00438 # if ENABLE_NLS 00439 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 00440 # define YY_(msgid) dgettext ("bison-runtime", msgid) 00441 # endif 00442 # endif 00443 # ifndef YY_ 00444 # define YY_(msgid) msgid 00445 # endif 00446 #endif 00447 00448 /* Suppress unused-variable warnings by "using" E. */ 00449 #if ! defined lint || defined __GNUC__ 00450 # define YYUSE(e) ((void) (e)) 00451 #else 00452 # define YYUSE(e) /* empty */ 00453 #endif 00454 00455 /* Identity function, used to suppress warnings about constant conditions. */ 00456 #ifndef lint 00457 # define YYID(n) (n) 00458 #else 00459 #if (defined __STDC__ || defined __C99__FUNC__ \ 00460 || defined __cplusplus || defined _MSC_VER) 00461 static int 00462 YYID (int yyi) 00463 #else 00464 static int 00465 YYID (yyi) 00466 int yyi; 00467 #endif 00468 { 00469 return yyi; 00470 } 00471 #endif 00472 00473 #if ! defined yyoverflow || YYERROR_VERBOSE 00474 00475 /* The parser invokes alloca or xmalloc; define the necessary symbols. */ 00476 00477 # ifdef YYSTACK_USE_ALLOCA 00478 # if YYSTACK_USE_ALLOCA 00479 # ifdef __GNUC__ 00480 # define YYSTACK_ALLOC __builtin_alloca 00481 # elif defined __BUILTIN_VA_ARG_INCR 00482 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 00483 # elif defined _AIX 00484 # define YYSTACK_ALLOC __alloca 00485 # elif defined _MSC_VER 00486 # define alloca _alloca 00487 # else 00488 # define YYSTACK_ALLOC alloca 00489 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 00490 || defined __cplusplus || defined _MSC_VER) 00491 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00492 # ifndef EXIT_SUCCESS 00493 # define EXIT_SUCCESS 0 00494 # endif 00495 # endif 00496 # endif 00497 # endif 00498 # endif 00499 00500 # ifdef YYSTACK_ALLOC 00501 /* Pacify GCC's `empty if-body' warning. */ 00502 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 00503 # ifndef YYSTACK_ALLOC_MAXIMUM 00504 /* The OS might guarantee only one guard page at the bottom of the stack, 00505 and a page size can be as small as 4096 bytes. So we cannot safely 00506 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 00507 to allow for a few compiler-allocated temporary stack slots. */ 00508 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 00509 # endif 00510 # else 00511 # define YYSTACK_ALLOC YYMALLOC 00512 # define YYSTACK_FREE YYFREE 00513 # ifndef YYSTACK_ALLOC_MAXIMUM 00514 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 00515 # endif 00516 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 00517 && ! ((defined YYMALLOC || defined xmalloc) \ 00518 && (defined YYFREE || defined xfree))) 00519 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00520 # ifndef EXIT_SUCCESS 00521 # define EXIT_SUCCESS 0 00522 # endif 00523 # endif 00524 # ifndef YYMALLOC 00525 # define YYMALLOC xmalloc 00526 # if ! defined xmalloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 00527 || defined __cplusplus || defined _MSC_VER) 00528 void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 00529 # endif 00530 # endif 00531 # ifndef YYFREE 00532 # define YYFREE xfree 00533 # if ! defined xfree && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 00534 || defined __cplusplus || defined _MSC_VER) 00535 void xfree (void *); /* INFRINGES ON USER NAME SPACE */ 00536 # endif 00537 # endif 00538 # endif 00539 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 00540 00541 00542 #if (! defined yyoverflow \ 00543 && (! defined __cplusplus \ 00544 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 00545 00546 /* A type that is properly aligned for any stack member. */ 00547 union yyalloc 00548 { 00549 yytype_int16 yyss_alloc; 00550 YYSTYPE yyvs_alloc; 00551 }; 00552 00553 /* The size of the maximum gap between one aligned stack and the next. */ 00554 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 00555 00556 /* The size of an array large to enough to hold all stacks, each with 00557 N elements. */ 00558 # define YYSTACK_BYTES(N) \ 00559 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 00560 + YYSTACK_GAP_MAXIMUM) 00561 00562 # define YYCOPY_NEEDED 1 00563 00564 /* Relocate STACK from its old location to the new one. The 00565 local variables YYSIZE and YYSTACKSIZE give the old and new number of 00566 elements in the stack, and YYPTR gives the new location of the 00567 stack. Advance YYPTR to a properly aligned location for the next 00568 stack. */ 00569 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 00570 do \ 00571 { \ 00572 YYSIZE_T yynewbytes; \ 00573 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 00574 Stack = &yyptr->Stack_alloc; \ 00575 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 00576 yyptr += yynewbytes / sizeof (*yyptr); \ 00577 } \ 00578 while (YYID (0)) 00579 00580 #endif 00581 00582 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 00583 /* Copy COUNT objects from FROM to TO. The source and destination do 00584 not overlap. */ 00585 # ifndef YYCOPY 00586 # if defined __GNUC__ && 1 < __GNUC__ 00587 # define YYCOPY(To, From, Count) \ 00588 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 00589 # else 00590 # define YYCOPY(To, From, Count) \ 00591 do \ 00592 { \ 00593 YYSIZE_T yyi; \ 00594 for (yyi = 0; yyi < (Count); yyi++) \ 00595 (To)[yyi] = (From)[yyi]; \ 00596 } \ 00597 while (YYID (0)) 00598 # endif 00599 # endif 00600 #endif /* !YYCOPY_NEEDED */ 00601 00602 /* YYFINAL -- State number of the termination state. */ 00603 #define YYFINAL 167 00604 /* YYLAST -- Last index in YYTABLE. */ 00605 #define YYLAST 1734 00606 00607 /* YYNTOKENS -- Number of terminals. */ 00608 #define YYNTOKENS 90 00609 /* YYNNTS -- Number of nonterminals. */ 00610 #define YYNNTS 46 00611 /* YYNRULES -- Number of rules. */ 00612 #define YYNRULES 260 00613 /* YYNRULES -- Number of states. */ 00614 #define YYNSTATES 413 00615 00616 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 00617 #define YYUNDEFTOK 2 00618 #define YYMAXUTOK 320 00619 00620 #define YYTRANSLATE(YYX) \ 00621 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 00622 00623 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 00624 static const yytype_uint8 yytranslate[] = 00625 { 00626 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00627 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00628 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00629 2, 2, 2, 84, 2, 2, 2, 70, 56, 2, 00630 76, 83, 68, 66, 48, 67, 74, 69, 2, 2, 00631 2, 2, 2, 2, 2, 2, 2, 2, 87, 2, 00632 59, 50, 60, 51, 65, 2, 2, 2, 2, 2, 00633 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00634 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00635 2, 75, 2, 86, 55, 2, 2, 2, 2, 2, 00636 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00637 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00638 2, 2, 2, 88, 54, 89, 85, 2, 2, 2, 00639 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00640 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00641 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00642 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00643 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00644 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00645 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00646 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00647 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00648 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00649 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00650 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00651 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 00652 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 00653 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 00654 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 00655 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 00656 45, 46, 47, 49, 52, 53, 57, 58, 61, 62, 00657 63, 64, 71, 72, 73, 77, 78, 79, 80, 81, 00658 82 00659 }; 00660 00661 #if YYDEBUG 00662 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 00663 YYRHS. */ 00664 static const yytype_uint16 yyprhs[] = 00665 { 00666 0, 0, 3, 5, 7, 9, 14, 19, 24, 26, 00667 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 00668 60, 65, 70, 73, 77, 82, 86, 91, 97, 101, 00669 105, 109, 114, 118, 123, 129, 133, 137, 142, 147, 00670 148, 154, 155, 161, 162, 168, 170, 172, 174, 177, 00671 181, 184, 187, 188, 194, 195, 201, 203, 204, 206, 00672 210, 216, 218, 222, 227, 232, 236, 240, 244, 248, 00673 252, 256, 260, 264, 268, 272, 276, 280, 284, 288, 00674 292, 296, 300, 304, 308, 312, 318, 322, 326, 328, 00675 330, 332, 334, 336, 338, 340, 345, 350, 358, 366, 00676 374, 382, 384, 387, 389, 391, 393, 395, 397, 399, 00677 403, 406, 410, 414, 419, 425, 427, 430, 432, 435, 00678 437, 438, 442, 444, 446, 448, 449, 450, 455, 456, 00679 460, 462, 465, 467, 470, 472, 474, 478, 481, 483, 00680 486, 488, 491, 494, 498, 502, 505, 509, 511, 513, 00681 515, 517, 519, 522, 526, 529, 533, 537, 541, 544, 00682 547, 551, 556, 560, 564, 569, 573, 578, 582, 587, 00683 590, 594, 597, 601, 604, 608, 610, 613, 616, 619, 00684 623, 626, 629, 633, 636, 639, 643, 646, 649, 653, 00685 656, 658, 661, 663, 669, 672, 675, 677, 679, 681, 00686 683, 685, 689, 691, 695, 697, 700, 703, 704, 707, 00687 710, 713, 715, 717, 719, 722, 725, 730, 735, 740, 00688 745, 748, 751, 754, 757, 760, 763, 766, 769, 772, 00689 775, 778, 781, 784, 787, 790, 793, 796, 799, 802, 00690 805, 808, 811, 814, 817, 820, 823, 826, 830, 834, 00691 838, 841, 843, 845, 847, 849, 851, 853, 855, 857, 00692 859 00693 }; 00694 00695 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 00696 static const yytype_int16 yyrhs[] = 00697 { 00698 91, 0, -1, 93, -1, 92, -1, 123, -1, 34, 00699 76, 94, 83, -1, 34, 76, 123, 83, -1, 35, 00700 76, 94, 83, -1, 94, -1, 93, 48, 94, -1, 00701 68, 94, -1, 56, 94, -1, 67, 94, -1, 66, 00702 94, -1, 84, 94, -1, 85, 94, -1, 72, 94, 00703 -1, 71, 94, -1, 94, 72, -1, 94, 71, -1, 00704 36, 76, 94, 83, -1, 36, 76, 92, 83, -1, 00705 22, 94, -1, 94, 79, 134, -1, 94, 79, 134, 00706 12, -1, 94, 79, 12, -1, 94, 79, 85, 134, 00707 -1, 94, 79, 85, 134, 12, -1, 94, 79, 109, 00708 -1, 94, 78, 94, -1, 94, 74, 134, -1, 94, 00709 74, 134, 12, -1, 94, 74, 12, -1, 94, 74, 00710 85, 134, -1, 94, 74, 85, 134, 12, -1, 94, 00711 74, 109, -1, 94, 77, 94, -1, 94, 75, 93, 00712 86, -1, 94, 15, 93, 86, -1, -1, 15, 13, 00713 95, 98, 86, -1, -1, 15, 14, 96, 98, 86, 00714 -1, -1, 15, 94, 97, 98, 86, -1, 134, -1, 00715 99, -1, 100, -1, 99, 100, -1, 134, 87, 94, 00716 -1, 87, 94, -1, 48, 94, -1, -1, 94, 76, 00717 101, 104, 83, -1, -1, 11, 76, 102, 104, 83, 00718 -1, 88, -1, -1, 94, -1, 104, 48, 94, -1, 00719 94, 76, 126, 83, 111, -1, 89, -1, 103, 104, 00720 105, -1, 103, 92, 105, 94, -1, 76, 92, 83, 00721 94, -1, 76, 93, 83, -1, 94, 65, 94, -1, 00722 94, 68, 94, -1, 94, 69, 94, -1, 94, 70, 00723 94, -1, 94, 66, 94, -1, 94, 67, 94, -1, 00724 94, 64, 94, -1, 94, 63, 94, -1, 94, 58, 00725 94, -1, 94, 57, 94, -1, 94, 62, 94, -1, 00726 94, 61, 94, -1, 94, 59, 94, -1, 94, 60, 00727 94, -1, 94, 56, 94, -1, 94, 55, 94, -1, 00728 94, 54, 94, -1, 94, 53, 94, -1, 94, 52, 00729 94, -1, 94, 51, 94, 87, 94, -1, 94, 50, 00730 94, -1, 94, 45, 94, -1, 3, -1, 9, -1, 00731 16, -1, 4, -1, 5, -1, 108, -1, 44, -1, 00732 8, 76, 134, 83, -1, 22, 76, 123, 83, -1, 00733 29, 59, 92, 60, 76, 94, 83, -1, 31, 59, 00734 92, 60, 76, 94, 83, -1, 30, 59, 92, 60, 00735 76, 94, 83, -1, 32, 59, 92, 60, 76, 94, 00736 83, -1, 6, -1, 106, 6, -1, 106, -1, 7, 00737 -1, 46, -1, 47, -1, 80, -1, 81, -1, 107, 00738 24, 134, -1, 135, 33, -1, 107, 24, 134, -1, 00739 13, 24, 134, -1, 13, 24, 85, 134, -1, 13, 00740 24, 134, 24, 134, -1, 109, -1, 24, 135, -1, 00741 135, -1, 65, 10, -1, 132, -1, -1, 111, 110, 00742 111, -1, 112, -1, 132, -1, 113, -1, -1, -1, 00743 115, 68, 116, 114, -1, -1, 68, 117, 114, -1, 00744 56, -1, 56, 115, -1, 115, -1, 118, 120, -1, 00745 118, -1, 120, -1, 76, 119, 83, -1, 120, 121, 00746 -1, 121, -1, 120, 122, -1, 122, -1, 75, 86, 00747 -1, 15, 86, -1, 75, 3, 86, -1, 15, 3, 00748 86, -1, 76, 83, -1, 76, 126, 83, -1, 128, 00749 -1, 13, -1, 40, -1, 38, -1, 39, -1, 38, 00750 40, -1, 38, 37, 40, -1, 38, 37, -1, 37, 00751 38, 40, -1, 23, 38, 40, -1, 38, 23, 40, 00752 -1, 38, 23, -1, 38, 38, -1, 38, 38, 40, 00753 -1, 38, 38, 37, 40, -1, 38, 38, 37, -1, 00754 37, 38, 38, -1, 37, 38, 38, 40, -1, 23, 00755 38, 38, -1, 23, 38, 38, 40, -1, 38, 38, 00756 23, -1, 38, 38, 23, 40, -1, 39, 40, -1, 00757 39, 37, 40, -1, 39, 37, -1, 23, 39, 40, 00758 -1, 39, 23, -1, 39, 23, 40, -1, 43, -1, 00759 38, 43, -1, 18, 134, -1, 18, 12, -1, 18, 00760 134, 12, -1, 19, 134, -1, 19, 12, -1, 19, 00761 134, 12, -1, 20, 134, -1, 20, 12, -1, 20, 00762 134, 12, -1, 21, 134, -1, 21, 12, -1, 21, 00763 134, 12, -1, 23, 125, -1, 23, -1, 37, 125, 00764 -1, 37, -1, 25, 134, 59, 123, 60, -1, 113, 00765 124, -1, 124, 113, -1, 13, -1, 40, -1, 38, 00766 -1, 39, -1, 127, -1, 127, 48, 82, -1, 123, 00767 -1, 127, 48, 123, -1, 124, -1, 128, 119, -1, 00768 124, 130, -1, -1, 115, 130, -1, 41, 42, -1, 00769 42, 41, -1, 131, -1, 41, -1, 42, -1, 17, 00770 27, -1, 17, 28, -1, 17, 27, 75, 86, -1, 00771 17, 28, 75, 86, -1, 17, 27, 15, 86, -1, 00772 17, 28, 15, 86, -1, 17, 66, -1, 17, 67, 00773 -1, 17, 68, -1, 17, 69, -1, 17, 70, -1, 00774 17, 55, -1, 17, 56, -1, 17, 54, -1, 17, 00775 85, -1, 17, 84, -1, 17, 50, -1, 17, 59, 00776 -1, 17, 60, -1, 17, 45, -1, 17, 64, -1, 00777 17, 63, -1, 17, 58, -1, 17, 57, -1, 17, 00778 62, -1, 17, 61, -1, 17, 53, -1, 17, 52, 00779 -1, 17, 72, -1, 17, 71, -1, 17, 48, -1, 00780 17, 78, -1, 17, 79, -1, 17, 76, 83, -1, 00781 17, 75, 86, -1, 17, 15, 86, -1, 17, 129, 00782 -1, 10, -1, 80, -1, 13, -1, 16, -1, 11, 00783 -1, 133, -1, 10, -1, 80, -1, 133, -1, 11, 00784 -1 00785 }; 00786 00787 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 00788 static const yytype_uint16 yyrline[] = 00789 { 00790 0, 279, 279, 280, 283, 287, 291, 297, 304, 305, 00791 310, 314, 318, 322, 326, 330, 334, 338, 342, 346, 00792 350, 354, 358, 362, 368, 375, 385, 391, 398, 406, 00793 410, 416, 423, 433, 439, 446, 454, 458, 462, 472, 00794 471, 494, 493, 509, 508, 517, 519, 522, 523, 526, 00795 528, 530, 537, 534, 545, 544, 567, 571, 574, 578, 00796 582, 600, 603, 610, 614, 618, 624, 628, 632, 636, 00797 640, 644, 648, 652, 656, 660, 664, 668, 672, 676, 00798 680, 684, 688, 692, 696, 700, 704, 708, 714, 721, 00799 730, 741, 748, 755, 758, 764, 771, 781, 785, 789, 00800 793, 800, 817, 835, 868, 877, 884, 893, 901, 907, 00801 917, 932, 954, 969, 995, 1004, 1005, 1033, 1087, 1091, 00802 1092, 1095, 1098, 1099, 1103, 1104, 1109, 1108, 1112, 1111, 00803 1114, 1116, 1120, 1129, 1131, 1132, 1135, 1137, 1144, 1151, 00804 1157, 1164, 1166, 1168, 1170, 1174, 1176, 1188, 1192, 1194, 00805 1198, 1202, 1206, 1210, 1214, 1218, 1222, 1226, 1230, 1234, 00806 1238, 1242, 1246, 1250, 1254, 1258, 1262, 1266, 1270, 1274, 00807 1278, 1282, 1286, 1290, 1294, 1298, 1302, 1306, 1309, 1314, 00808 1320, 1323, 1328, 1334, 1337, 1342, 1348, 1351, 1356, 1362, 00809 1366, 1370, 1374, 1381, 1385, 1387, 1391, 1392, 1400, 1408, 00810 1419, 1421, 1430, 1436, 1443, 1444, 1451, 1455, 1456, 1459, 00811 1460, 1463, 1467, 1469, 1473, 1475, 1477, 1479, 1481, 1483, 00812 1485, 1487, 1489, 1491, 1493, 1495, 1497, 1499, 1501, 1503, 00813 1505, 1507, 1509, 1511, 1551, 1553, 1555, 1557, 1559, 1561, 00814 1563, 1565, 1567, 1569, 1571, 1573, 1575, 1577, 1579, 1581, 00815 1583, 1599, 1600, 1601, 1602, 1603, 1604, 1607, 1608, 1616, 00816 1628 00817 }; 00818 #endif 00819 00820 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 00821 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 00822 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 00823 static const char *const yytname[] = 00824 { 00825 "$end", "error", "$undefined", "INT", "FLOAT", "DECFLOAT", "STRING", 00826 "NSSTRING", "SELECTOR", "CHAR", "NAME", "UNKNOWN_CPP_NAME", "COMPLETE", 00827 "TYPENAME", "CLASSNAME", "OBJC_LBRAC", "NAME_OR_INT", "OPERATOR", 00828 "STRUCT", "CLASS", "UNION", "ENUM", "SIZEOF", "UNSIGNED", "COLONCOLON", 00829 "TEMPLATE", "ERROR", "NEW", "DELETE", "REINTERPRET_CAST", "DYNAMIC_CAST", 00830 "STATIC_CAST", "CONST_CAST", "ENTRY", "TYPEOF", "DECLTYPE", "TYPEID", 00831 "SIGNED_KEYWORD", "LONG", "SHORT", "INT_KEYWORD", "CONST_KEYWORD", 00832 "VOLATILE_KEYWORD", "DOUBLE_KEYWORD", "VARIABLE", "ASSIGN_MODIFY", 00833 "TRUEKEYWORD", "FALSEKEYWORD", "','", "ABOVE_COMMA", "'='", "'?'", 00834 "OROR", "ANDAND", "'|'", "'^'", "'&'", "NOTEQUAL", "EQUAL", "'<'", "'>'", 00835 "GEQ", "LEQ", "RSH", "LSH", "'@'", "'+'", "'-'", "'*'", "'/'", "'%'", 00836 "DECREMENT", "INCREMENT", "UNARY", "'.'", "'['", "'('", "DOT_STAR", 00837 "ARROW_STAR", "ARROW", "BLOCKNAME", "FILENAME", "DOTDOTDOT", "')'", 00838 "'!'", "'~'", "']'", "':'", "'{'", "'}'", "$accept", "start", "type_exp", 00839 "exp1", "exp", "$@1", "$@2", "$@3", "msglist", "msgarglist", "msgarg", 00840 "$@4", "$@5", "lcurly", "arglist", "rcurly", "string_exp", "block", 00841 "variable", "qualified_name", "space_identifier", "const_or_volatile", 00842 "cv_with_space_id", "const_or_volatile_or_space_identifier_noopt", 00843 "const_or_volatile_or_space_identifier", "ptr_operator", "$@6", "$@7", 00844 "ptr_operator_ts", "abs_decl", "direct_abs_decl", "array_mod", 00845 "func_mod", "type", "typebase", "typename", "parameter_typelist", 00846 "nonempty_typelist", "ptype", "conversion_type_id", 00847 "conversion_declarator", "const_and_volatile", "const_or_volatile_noopt", 00848 "operator", "name", "name_not_typename", 0 00849 }; 00850 #endif 00851 00852 # ifdef YYPRINT 00853 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 00854 token YYLEX-NUM. */ 00855 static const yytype_uint16 yytoknum[] = 00856 { 00857 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 00858 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 00859 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 00860 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 00861 295, 296, 297, 298, 299, 300, 301, 302, 44, 303, 00862 61, 63, 304, 305, 124, 94, 38, 306, 307, 60, 00863 62, 308, 309, 310, 311, 64, 43, 45, 42, 47, 00864 37, 312, 313, 314, 46, 91, 40, 315, 316, 317, 00865 318, 319, 320, 41, 33, 126, 93, 58, 123, 125 00866 }; 00867 # endif 00868 00869 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 00870 static const yytype_uint8 yyr1[] = 00871 { 00872 0, 90, 91, 91, 92, 92, 92, 92, 93, 93, 00873 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 00874 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 00875 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 00876 94, 96, 94, 97, 94, 98, 98, 99, 99, 100, 00877 100, 100, 101, 94, 102, 94, 103, 104, 104, 104, 00878 94, 105, 94, 94, 94, 94, 94, 94, 94, 94, 00879 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 00880 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 00881 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 00882 94, 106, 106, 94, 94, 94, 94, 107, 107, 107, 00883 108, 108, 109, 109, 109, 108, 108, 108, 110, 111, 00884 111, 112, 113, 113, 114, 114, 116, 115, 117, 115, 00885 115, 115, 118, 119, 119, 119, 120, 120, 120, 120, 00886 120, 121, 121, 121, 121, 122, 122, 123, 124, 124, 00887 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 00888 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 00889 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 00890 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 00891 124, 124, 124, 124, 124, 124, 125, 125, 125, 125, 00892 126, 126, 127, 127, 128, 128, 129, 130, 130, 131, 00893 131, 132, 132, 132, 133, 133, 133, 133, 133, 133, 00894 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 00895 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 00896 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 00897 133, 134, 134, 134, 134, 134, 134, 135, 135, 135, 00898 135 00899 }; 00900 00901 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 00902 static const yytype_uint8 yyr2[] = 00903 { 00904 0, 2, 1, 1, 1, 4, 4, 4, 1, 3, 00905 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00906 4, 4, 2, 3, 4, 3, 4, 5, 3, 3, 00907 3, 4, 3, 4, 5, 3, 3, 4, 4, 0, 00908 5, 0, 5, 0, 5, 1, 1, 1, 2, 3, 00909 2, 2, 0, 5, 0, 5, 1, 0, 1, 3, 00910 5, 1, 3, 4, 4, 3, 3, 3, 3, 3, 00911 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00912 3, 3, 3, 3, 3, 5, 3, 3, 1, 1, 00913 1, 1, 1, 1, 1, 4, 4, 7, 7, 7, 00914 7, 1, 2, 1, 1, 1, 1, 1, 1, 3, 00915 2, 3, 3, 4, 5, 1, 2, 1, 2, 1, 00916 0, 3, 1, 1, 1, 0, 0, 4, 0, 3, 00917 1, 2, 1, 2, 1, 1, 3, 2, 1, 2, 00918 1, 2, 2, 3, 3, 2, 3, 1, 1, 1, 00919 1, 1, 2, 3, 2, 3, 3, 3, 2, 2, 00920 3, 4, 3, 3, 4, 3, 4, 3, 4, 2, 00921 3, 2, 3, 2, 3, 1, 2, 2, 2, 3, 00922 2, 2, 3, 2, 2, 3, 2, 2, 3, 2, 00923 1, 2, 1, 5, 2, 2, 1, 1, 1, 1, 00924 1, 3, 1, 3, 1, 2, 2, 0, 2, 2, 00925 2, 1, 1, 1, 2, 2, 4, 4, 4, 4, 00926 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00927 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00928 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 00929 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00930 1 00931 }; 00932 00933 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 00934 Performed when YYTABLE doesn't specify something else to do. Zero 00935 means the default is an error. */ 00936 static const yytype_uint16 yydefact[] = 00937 { 00938 120, 88, 91, 92, 101, 104, 0, 89, 257, 260, 00939 148, 0, 90, 120, 0, 0, 0, 0, 0, 190, 00940 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 00941 150, 151, 149, 212, 213, 175, 94, 105, 106, 0, 00942 0, 0, 0, 0, 0, 120, 258, 108, 0, 0, 00943 56, 0, 3, 2, 8, 57, 103, 0, 93, 115, 00944 0, 122, 120, 4, 204, 147, 211, 123, 259, 117, 00945 0, 54, 0, 39, 41, 43, 148, 0, 214, 215, 00946 233, 244, 230, 241, 240, 227, 225, 226, 237, 236, 00947 231, 232, 239, 238, 235, 234, 220, 221, 222, 223, 00948 224, 243, 242, 0, 0, 245, 246, 229, 228, 207, 00949 250, 251, 255, 178, 253, 254, 252, 256, 177, 181, 00950 180, 184, 183, 187, 186, 0, 120, 22, 196, 198, 00951 199, 197, 189, 260, 258, 116, 0, 120, 120, 120, 00952 120, 120, 0, 120, 198, 199, 191, 158, 154, 159, 00953 152, 176, 173, 171, 169, 209, 210, 11, 13, 12, 00954 10, 17, 16, 0, 0, 14, 15, 1, 0, 0, 00955 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00956 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00957 0, 0, 19, 18, 0, 0, 52, 0, 0, 0, 00958 0, 58, 0, 102, 0, 0, 120, 194, 195, 0, 00959 130, 128, 0, 120, 132, 134, 205, 135, 138, 140, 00960 110, 0, 57, 0, 112, 0, 0, 0, 249, 0, 00961 0, 0, 0, 248, 247, 207, 206, 179, 182, 185, 00962 188, 0, 165, 156, 172, 120, 0, 0, 0, 0, 00963 0, 0, 0, 0, 0, 163, 155, 157, 153, 167, 00964 162, 160, 174, 170, 0, 65, 9, 0, 87, 86, 00965 0, 84, 83, 82, 81, 80, 75, 74, 78, 79, 00966 77, 76, 73, 72, 66, 70, 71, 67, 68, 69, 00967 32, 253, 0, 35, 30, 0, 57, 202, 0, 200, 00968 36, 29, 25, 0, 28, 23, 61, 0, 0, 62, 00969 111, 118, 121, 119, 0, 142, 131, 125, 0, 141, 00970 145, 0, 0, 126, 133, 120, 137, 139, 95, 0, 00971 113, 0, 0, 0, 0, 46, 47, 45, 0, 0, 00972 218, 216, 219, 217, 126, 208, 96, 166, 0, 0, 00973 0, 0, 0, 5, 6, 7, 21, 20, 164, 168, 00974 161, 64, 38, 0, 33, 31, 37, 0, 120, 120, 00975 26, 24, 63, 59, 144, 124, 129, 143, 136, 146, 00976 125, 55, 114, 51, 50, 40, 48, 0, 0, 42, 00977 44, 193, 0, 0, 0, 0, 85, 34, 53, 60, 00978 201, 203, 27, 127, 49, 0, 0, 0, 0, 97, 00979 99, 98, 100 00980 }; 00981 00982 /* YYDEFGOTO[NTERM-NUM]. */ 00983 static const yytype_int16 yydefgoto[] = 00984 { 00985 -1, 51, 163, 164, 54, 225, 226, 227, 334, 335, 00986 336, 296, 222, 55, 202, 307, 56, 57, 58, 59, 00987 206, 60, 61, 62, 376, 214, 380, 317, 215, 216, 00988 217, 218, 219, 63, 64, 132, 322, 299, 65, 110, 00989 236, 66, 67, 68, 337, 69 00990 }; 00991 00992 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 00993 STATE-NUM. */ 00994 #define YYPACT_NINF -214 00995 static const yytype_int16 yypact[] = 00996 { 00997 468, -214, -214, -214, -214, -214, -24, -214, -214, -2, 00998 58, 640, -214, 886, 265, 292, 330, 347, 726, 110, 00999 25, 193, 33, 48, 63, 84, 50, 80, 82, 185, 01000 328, 22, -214, 139, 149, -214, -214, -214, -214, 812, 01001 812, 812, 812, 812, 812, 468, 167, -214, 812, 812, 01002 -214, 192, -214, 145, 1399, 382, 189, 172, -214, -214, 01003 135, -214, 746, -214, 86, 215, -214, 136, -214, 186, 01004 193, -214, 53, 58, -214, 1399, -214, 141, 19, 43, 01005 -214, -214, -214, -214, -214, -214, -214, -214, -214, -214, 01006 -214, -214, -214, -214, -214, -214, -214, -214, -214, -214, 01007 -214, -214, -214, 142, 146, -214, -214, -214, -214, 271, 01008 -214, -214, -214, -214, -214, -214, -214, -214, 220, -214, 01009 222, -214, 223, -214, 230, 58, 468, 24, -214, 96, 01010 204, -214, -214, -214, -214, -214, 203, 660, 660, 660, 01011 660, 554, 812, 468, 97, -214, -214, 211, 232, 288, 01012 -214, -214, 239, 240, -214, -214, -214, 24, 24, 24, 01013 24, 24, 24, 180, -23, 24, 24, -214, 812, 812, 01014 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, 01015 812, 812, 812, 812, 812, 812, 812, 812, 812, 812, 01016 812, 812, -214, -214, 67, 812, 1669, 812, 812, 103, 01017 195, 1399, -8, -214, 193, 278, 30, 86, -214, 5, 01018 221, -214, 11, 218, 224, 12, -214, 34, -214, -214, 01019 -214, 216, 812, 193, 276, 37, 37, 37, -214, 228, 01020 229, 233, 234, -214, -214, -13, -214, -214, -214, -214, 01021 -214, 235, 267, -214, -214, 746, 256, 263, 264, 269, 01022 993, 248, 1051, 249, 1109, 293, -214, -214, -214, 295, 01023 297, -214, -214, -214, 812, -214, 1399, 20, 1399, 1399, 01024 922, 1457, 1486, 1515, 1544, 1573, 1602, 1602, 1072, 1072, 01025 1072, 1072, 365, 365, 1130, 1188, 1188, 24, 24, 24, 01026 -214, 58, 193, -214, 332, 60, 812, -214, 266, 300, 01027 138, 138, -214, 193, -214, 338, -214, 812, 812, -214, 01028 329, -214, -214, -214, 268, -214, 224, 86, 270, -214, 01029 -214, 272, 279, -214, 34, 227, -214, -214, -214, -22, 01030 -214, 193, 812, 812, 275, 37, -214, 280, 283, 284, 01031 -214, -214, -214, -214, -214, -214, -214, -214, 313, 298, 01032 299, 302, 303, -214, -214, -214, -214, -214, -214, -214, 01033 -214, 24, -214, 812, 364, -214, -214, 38, 30, 992, 01034 384, -214, 24, 1399, -214, -214, -214, -214, -214, -214, 01035 86, -214, -214, 1399, 1399, -214, -214, 280, 812, -214, 01036 -214, -214, 812, 812, 812, 812, 1428, -214, -214, -214, 01037 -214, -214, -214, -214, 1399, 1167, 1225, 1283, 1341, -214, 01038 -214, -214, -214 01039 }; 01040 01041 /* YYPGOTO[NTERM-NUM]. */ 01042 static const yytype_int16 yypgoto[] = 01043 { 01044 -214, -214, 2, 13, -11, -214, -214, -214, -72, -214, 01045 59, -214, -214, -214, -207, 206, -214, -214, -214, -143, 01046 -214, -184, -214, -63, 29, -106, -214, -214, -214, 202, 01047 231, -213, -212, -120, 28, 416, 255, -214, -214, -214, 01048 217, -214, -183, -5, 3, 435 01049 }; 01050 01051 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 01052 positive, shift that token. If negative, reduce the rule which 01053 number is the opposite. If YYTABLE_NINF, syntax error. */ 01054 #define YYTABLE_NINF -121 01055 static const yytype_int16 yytable[] = 01056 { 01057 75, 208, 52, 235, 326, 327, 241, 127, 314, 117, 01058 117, 117, 117, 53, 318, 329, 117, 118, 120, 122, 01059 124, 251, 312, 313, 136, 168, 308, 209, 157, 158, 01060 159, 160, 161, 162, 229, 8, 133, 165, 166, 169, 01061 308, 109, 13, 210, 201, 152, 208, 111, 112, 209, 01062 114, 293, 70, 115, 13, 344, 304, 200, 231, 153, 01063 265, 381, 154, 111, 112, 117, 114, 117, 168, 115, 01064 13, 33, 34, 221, 71, 224, 297, 111, 112, 290, 01065 291, 306, 72, 115, 13, 332, 308, 212, 213, 367, 01066 207, 315, 137, 297, 230, 192, 193, 319, 194, 195, 01067 196, 197, 198, 199, 316, 134, 362, 138, 168, 212, 01068 325, 326, 327, 111, 112, 302, 291, 116, 232, 115, 01069 13, 398, 139, 128, 333, 348, 141, 33, 34, 235, 01070 250, 252, 254, 116, 242, 255, 243, 256, 223, 246, 01071 247, 248, 249, 140, 208, 253, 366, 116, 129, 130, 01072 131, -120, 292, 169, 338, 339, 142, 266, 143, 268, 01073 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 01074 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 01075 289, 155, 267, 116, 399, 313, 300, 301, 303, 117, 01076 156, -107, 167, 168, 117, 203, 204, 294, 128, 117, 01077 205, -119, 305, 111, 112, 297, 114, 310, 295, 115, 01078 13, 201, 194, 195, 196, 197, 198, 199, 117, 220, 01079 117, 117, 117, 144, 145, 131, 330, 228, 233, 234, 01080 209, 76, 237, 209, 238, 239, 14, 15, 16, 17, 01081 76, 19, 240, 21, 244, 14, 15, 16, 17, 401, 01082 19, 257, 21, 361, 375, 29, 30, 31, 32, 33, 01083 34, 35, 245, 264, 29, 30, 31, 32, 33, 34, 01084 35, 210, 258, 116, 210, 111, 112, 113, 114, 262, 01085 263, 115, 13, 211, 306, 201, 211, 117, 311, 211, 01086 212, 213, 323, 212, 213, 364, 372, 373, 117, 328, 01087 331, 320, 111, 112, 119, 114, 370, 347, 115, 13, 01088 320, 259, 33, 34, 340, 341, 349, 375, 346, 342, 01089 343, 383, 384, 350, 351, 260, 117, 210, 261, 352, 01090 117, 354, 356, 358, 382, 359, -120, 360, 387, 211, 01091 111, 112, 121, 114, 365, 116, 115, 13, 369, 368, 01092 371, 147, 396, -109, 374, 378, 377, 111, 112, 123, 01093 114, 385, 379, 115, 13, 148, 149, 388, 150, 389, 01094 390, 151, 116, 391, 392, 393, 397, 404, 394, 395, 01095 169, 405, 406, 407, 408, 1, 2, 3, 4, 5, 01096 6, 7, 8, 9, 386, 10, 402, 11, 12, 13, 01097 14, 15, 16, 17, 18, 19, 20, 21, 309, 403, 01098 116, 22, 23, 24, 25, 321, 26, 27, 28, 29, 01099 30, 31, 32, 33, 34, 35, 36, 116, 37, 38, 01100 186, 187, 188, 189, 190, 191, 192, 193, 39, 194, 01101 195, 196, 197, 198, 199, 146, 324, -120, 40, 41, 01102 42, 298, 345, 43, 44, 135, 0, 0, 45, 0, 01103 0, 0, 46, 47, 0, 0, 48, 49, 0, 0, 01104 50, 1, 2, 3, 4, 5, 6, 7, 8, 9, 01105 0, 10, 0, 11, 12, 13, 14, 15, 16, 17, 01106 18, 19, 20, 21, 0, 0, 0, 22, 23, 24, 01107 25, 0, 26, 27, 28, 29, 30, 31, 32, 33, 01108 34, 35, 36, 0, 37, 38, 0, 0, 0, 0, 01109 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 01110 0, 0, 0, 0, 40, 41, 42, 0, 0, 43, 01111 44, 0, 0, 0, 45, 0, 0, 0, 46, 47, 01112 0, 0, 48, 49, 0, 0, 50, 1, 2, 3, 01113 4, 5, 6, 7, 8, 9, 0, 10, 0, 11, 01114 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 01115 0, 0, 0, 22, 23, 24, 25, 0, 0, 0, 01116 28, 29, 30, 31, 32, 33, 34, 35, 36, 0, 01117 37, 38, 0, 0, 0, 0, 0, 0, 0, 0, 01118 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01119 40, 41, 42, 0, 0, 43, 44, 0, 0, 0, 01120 45, 0, 0, 0, 46, 47, 0, 0, 48, 49, 01121 0, 0, 50, 1, 2, 3, 4, 5, 6, 7, 01122 8, 9, 0, 73, 74, 11, 12, 13, 0, 0, 01123 0, 0, 18, 0, 20, 0, 0, 0, 0, 22, 01124 23, 24, 25, 76, 0, 0, 28, 0, 14, 15, 01125 16, 17, 0, 19, 36, 21, 37, 38, 0, 0, 01126 0, 0, 0, 0, 26, 27, 39, 29, 30, 31, 01127 32, 33, 34, 35, 0, 0, 40, 41, 42, 0, 01128 0, 43, 44, 0, 0, 0, 45, 0, 0, 0, 01129 46, 47, 0, 0, 48, 49, 0, 0, 50, 1, 01130 2, 3, 4, 5, 6, 7, 8, 9, 0, 125, 01131 0, 11, 12, 13, 0, 0, 0, 0, 18, 0, 01132 20, 0, 0, 0, 0, 22, 23, 24, 25, 76, 01133 0, 0, 28, 0, 14, 15, 16, 17, 0, 19, 01134 36, 21, 37, 38, 0, 0, 0, 0, 0, 0, 01135 0, 0, 39, 29, 30, 31, 32, 33, 34, 35, 01136 0, 0, 40, 41, 42, 0, 0, 43, 44, 0, 01137 0, 0, 126, 0, 0, 0, 46, 47, 0, 0, 01138 48, 49, 0, 0, 50, 1, 2, 3, 4, 5, 01139 6, 7, 8, 9, 0, 125, 0, 11, 12, 13, 01140 0, 0, 0, 0, 18, 0, 20, 0, 0, 0, 01141 0, 22, 23, 24, 25, 0, 0, 0, 28, 0, 01142 0, 0, 0, 0, 0, 0, 36, 0, 37, 38, 01143 0, 0, 0, 0, 0, 0, 0, 0, 39, 0, 01144 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 01145 42, 0, 0, 43, 44, 0, 0, 0, 45, 0, 01146 0, 0, 46, 47, 0, 0, 48, 49, 0, 76, 01147 50, 77, 0, 0, 14, 15, 16, 17, 0, 19, 01148 0, 21, 0, 78, 79, 0, 0, 0, 0, 0, 01149 0, 0, 0, 29, 30, 31, 32, 33, 34, 35, 01150 0, 80, 0, 0, 81, 0, 82, 169, 83, 84, 01151 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 01152 95, 0, 96, 97, 98, 99, 100, 101, 102, 0, 01153 0, 103, 104, 0, 105, 106, 0, 170, 0, 0, 01154 107, 108, 171, 172, 173, 174, 175, 176, 177, 178, 01155 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 01156 189, 190, 191, 192, 193, 0, 194, 195, 196, 197, 01157 198, 199, 0, 0, 0, 76, 0, 0, 169, 363, 01158 14, 15, 16, 17, 0, 19, 0, 21, 0, 0, 01159 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 01160 30, 31, 32, 33, 34, 35, 0, 0, 170, 0, 01161 0, 0, 0, 171, 172, 173, 174, 175, 176, 177, 01162 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 01163 188, 189, 190, 191, 192, 193, 169, 194, 195, 196, 01164 197, 198, 199, 0, 400, 0, 353, 0, 0, 0, 01165 0, 0, 0, 0, 0, 0, 0, 169, 0, 0, 01166 0, 0, 0, 0, 0, 0, 170, 0, 0, 0, 01167 0, 171, 172, 173, 174, 175, 176, 177, 178, 179, 01168 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 01169 190, 191, 192, 193, 169, 194, 195, 196, 197, 198, 01170 199, 0, 0, 0, 355, 184, 185, 186, 187, 188, 01171 189, 190, 191, 192, 193, 169, 194, 195, 196, 197, 01172 198, 199, 0, 0, 170, 0, 0, 0, 0, 171, 01173 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 01174 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 01175 192, 193, 169, 194, 195, 196, 197, 198, 199, 0, 01176 0, 0, 357, 0, 0, 0, 187, 188, 189, 190, 01177 191, 192, 193, 169, 194, 195, 196, 197, 198, 199, 01178 0, 0, 170, 0, 0, 0, 0, 171, 172, 173, 01179 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 01180 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 01181 169, 194, 195, 196, 197, 198, 199, 0, 0, 0, 01182 409, 0, 0, 0, 0, 0, 189, 190, 191, 192, 01183 193, 0, 194, 195, 196, 197, 198, 199, 0, 0, 01184 170, 0, 0, 0, 0, 171, 172, 173, 174, 175, 01185 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 01186 186, 187, 188, 189, 190, 191, 192, 193, 169, 194, 01187 195, 196, 197, 198, 199, 0, 0, 0, 410, 0, 01188 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01189 0, 0, 0, 0, 0, 0, 0, 0, 170, 0, 01190 0, 0, 0, 171, 172, 173, 174, 175, 176, 177, 01191 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 01192 188, 189, 190, 191, 192, 193, 169, 194, 195, 196, 01193 197, 198, 199, 0, 0, 0, 411, 0, 0, 0, 01194 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01195 0, 0, 0, 0, 0, 0, 170, 0, 0, 0, 01196 0, 171, 172, 173, 174, 175, 176, 177, 178, 179, 01197 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 01198 190, 191, 192, 193, 169, 194, 195, 196, 197, 198, 01199 199, 0, 0, 0, 412, 0, 0, 0, 0, 0, 01200 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01201 0, 0, 0, 169, 170, 0, 0, 0, 0, 171, 01202 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 01203 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 01204 192, 193, 169, 194, 195, 196, 197, 198, 199, 172, 01205 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 01206 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 01207 193, 169, 194, 195, 196, 197, 198, 199, 0, 0, 01208 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 01209 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 01210 169, 194, 195, 196, 197, 198, 199, 0, 0, 0, 01211 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 01212 185, 186, 187, 188, 189, 190, 191, 192, 193, 169, 01213 194, 195, 196, 197, 198, 199, 0, 0, 0, 0, 01214 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 01215 186, 187, 188, 189, 190, 191, 192, 193, 169, 194, 01216 195, 196, 197, 198, 199, 0, 0, 0, 0, 0, 01217 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 01218 187, 188, 189, 190, 191, 192, 193, 169, 194, 195, 01219 196, 197, 198, 199, 0, 0, 0, 0, 0, 0, 01220 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 01221 188, 189, 190, 191, 192, 193, 0, 194, 195, 196, 01222 197, 198, 199, 0, 0, 0, 0, 0, 0, 0, 01223 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 01224 189, 190, 191, 192, 193, 0, 194, 195, 196, 197, 01225 198, 199, 76, 0, 0, 0, 0, 14, 15, 16, 01226 17, 0, 19, 0, 21, 0, 0, 0, 0, 0, 01227 0, 0, 0, 0, 0, 0, 29, 30, 31, 32, 01228 33, 34, 35, 0, 0, 0, 0, 0, 0, 0, 01229 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01230 0, 0, 0, 0, -120 01231 }; 01232 01233 #define yypact_value_is_default(yystate) \ 01234 ((yystate) == (-214)) 01235 01236 #define yytable_value_is_error(yytable_value) \ 01237 YYID (0) 01238 01239 static const yytype_int16 yycheck[] = 01240 { 01241 11, 64, 0, 109, 217, 217, 126, 18, 3, 14, 01242 15, 16, 17, 0, 3, 222, 21, 14, 15, 16, 01243 17, 141, 206, 206, 21, 48, 48, 15, 39, 40, 01244 41, 42, 43, 44, 15, 10, 11, 48, 49, 15, 01245 48, 13, 17, 56, 55, 23, 109, 10, 11, 15, 01246 13, 194, 76, 16, 17, 68, 199, 55, 15, 37, 01247 83, 83, 40, 10, 11, 70, 13, 72, 48, 16, 01248 17, 41, 42, 70, 76, 72, 196, 10, 11, 12, 01249 13, 89, 24, 16, 17, 48, 48, 75, 76, 296, 01250 62, 86, 59, 213, 75, 71, 72, 86, 74, 75, 01251 76, 77, 78, 79, 210, 80, 86, 59, 48, 75, 01252 76, 324, 324, 10, 11, 12, 13, 80, 75, 16, 01253 17, 83, 59, 13, 87, 245, 76, 41, 42, 235, 01254 141, 142, 143, 80, 38, 38, 40, 40, 85, 137, 01255 138, 139, 140, 59, 207, 143, 86, 80, 38, 39, 01256 40, 65, 85, 15, 226, 227, 76, 168, 76, 170, 01257 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 01258 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 01259 191, 42, 169, 80, 368, 368, 197, 198, 85, 194, 01260 41, 24, 0, 48, 199, 6, 24, 194, 13, 204, 01261 65, 65, 199, 10, 11, 325, 13, 204, 195, 16, 01262 17, 222, 74, 75, 76, 77, 78, 79, 223, 33, 01263 225, 226, 227, 38, 39, 40, 223, 86, 86, 83, 01264 15, 13, 12, 15, 12, 12, 18, 19, 20, 21, 01265 13, 23, 12, 25, 40, 18, 19, 20, 21, 369, 01266 23, 40, 25, 264, 317, 37, 38, 39, 40, 41, 01267 42, 43, 59, 83, 37, 38, 39, 40, 41, 42, 01268 43, 56, 40, 80, 56, 10, 11, 12, 13, 40, 01269 40, 16, 17, 68, 89, 296, 68, 292, 10, 68, 01270 75, 76, 68, 75, 76, 292, 307, 308, 303, 83, 01271 24, 83, 10, 11, 12, 13, 303, 40, 16, 17, 01272 83, 23, 41, 42, 86, 86, 60, 380, 83, 86, 01273 86, 332, 333, 60, 60, 37, 331, 56, 40, 60, 01274 335, 83, 83, 40, 331, 40, 65, 40, 335, 68, 01275 10, 11, 12, 13, 12, 80, 16, 17, 48, 83, 01276 12, 23, 363, 24, 86, 83, 86, 10, 11, 12, 01277 13, 86, 83, 16, 17, 37, 38, 87, 40, 86, 01278 86, 43, 80, 60, 76, 76, 12, 388, 76, 76, 01279 15, 392, 393, 394, 395, 3, 4, 5, 6, 7, 01280 8, 9, 10, 11, 335, 13, 12, 15, 16, 17, 01281 18, 19, 20, 21, 22, 23, 24, 25, 202, 380, 01282 80, 29, 30, 31, 32, 213, 34, 35, 36, 37, 01283 38, 39, 40, 41, 42, 43, 44, 80, 46, 47, 01284 65, 66, 67, 68, 69, 70, 71, 72, 56, 74, 01285 75, 76, 77, 78, 79, 29, 215, 65, 66, 67, 01286 68, 196, 235, 71, 72, 20, -1, -1, 76, -1, 01287 -1, -1, 80, 81, -1, -1, 84, 85, -1, -1, 01288 88, 3, 4, 5, 6, 7, 8, 9, 10, 11, 01289 -1, 13, -1, 15, 16, 17, 18, 19, 20, 21, 01290 22, 23, 24, 25, -1, -1, -1, 29, 30, 31, 01291 32, -1, 34, 35, 36, 37, 38, 39, 40, 41, 01292 42, 43, 44, -1, 46, 47, -1, -1, -1, -1, 01293 -1, -1, -1, -1, 56, -1, -1, -1, -1, -1, 01294 -1, -1, -1, -1, 66, 67, 68, -1, -1, 71, 01295 72, -1, -1, -1, 76, -1, -1, -1, 80, 81, 01296 -1, -1, 84, 85, -1, -1, 88, 3, 4, 5, 01297 6, 7, 8, 9, 10, 11, -1, 13, -1, 15, 01298 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 01299 -1, -1, -1, 29, 30, 31, 32, -1, -1, -1, 01300 36, 37, 38, 39, 40, 41, 42, 43, 44, -1, 01301 46, 47, -1, -1, -1, -1, -1, -1, -1, -1, 01302 56, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01303 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, 01304 76, -1, -1, -1, 80, 81, -1, -1, 84, 85, 01305 -1, -1, 88, 3, 4, 5, 6, 7, 8, 9, 01306 10, 11, -1, 13, 14, 15, 16, 17, -1, -1, 01307 -1, -1, 22, -1, 24, -1, -1, -1, -1, 29, 01308 30, 31, 32, 13, -1, -1, 36, -1, 18, 19, 01309 20, 21, -1, 23, 44, 25, 46, 47, -1, -1, 01310 -1, -1, -1, -1, 34, 35, 56, 37, 38, 39, 01311 40, 41, 42, 43, -1, -1, 66, 67, 68, -1, 01312 -1, 71, 72, -1, -1, -1, 76, -1, -1, -1, 01313 80, 81, -1, -1, 84, 85, -1, -1, 88, 3, 01314 4, 5, 6, 7, 8, 9, 10, 11, -1, 13, 01315 -1, 15, 16, 17, -1, -1, -1, -1, 22, -1, 01316 24, -1, -1, -1, -1, 29, 30, 31, 32, 13, 01317 -1, -1, 36, -1, 18, 19, 20, 21, -1, 23, 01318 44, 25, 46, 47, -1, -1, -1, -1, -1, -1, 01319 -1, -1, 56, 37, 38, 39, 40, 41, 42, 43, 01320 -1, -1, 66, 67, 68, -1, -1, 71, 72, -1, 01321 -1, -1, 76, -1, -1, -1, 80, 81, -1, -1, 01322 84, 85, -1, -1, 88, 3, 4, 5, 6, 7, 01323 8, 9, 10, 11, -1, 13, -1, 15, 16, 17, 01324 -1, -1, -1, -1, 22, -1, 24, -1, -1, -1, 01325 -1, 29, 30, 31, 32, -1, -1, -1, 36, -1, 01326 -1, -1, -1, -1, -1, -1, 44, -1, 46, 47, 01327 -1, -1, -1, -1, -1, -1, -1, -1, 56, -1, 01328 -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, 01329 68, -1, -1, 71, 72, -1, -1, -1, 76, -1, 01330 -1, -1, 80, 81, -1, -1, 84, 85, -1, 13, 01331 88, 15, -1, -1, 18, 19, 20, 21, -1, 23, 01332 -1, 25, -1, 27, 28, -1, -1, -1, -1, -1, 01333 -1, -1, -1, 37, 38, 39, 40, 41, 42, 43, 01334 -1, 45, -1, -1, 48, -1, 50, 15, 52, 53, 01335 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 01336 64, -1, 66, 67, 68, 69, 70, 71, 72, -1, 01337 -1, 75, 76, -1, 78, 79, -1, 45, -1, -1, 01338 84, 85, 50, 51, 52, 53, 54, 55, 56, 57, 01339 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 01340 68, 69, 70, 71, 72, -1, 74, 75, 76, 77, 01341 78, 79, -1, -1, -1, 13, -1, -1, 15, 87, 01342 18, 19, 20, 21, -1, 23, -1, 25, -1, -1, 01343 -1, -1, -1, -1, -1, -1, -1, -1, -1, 37, 01344 38, 39, 40, 41, 42, 43, -1, -1, 45, -1, 01345 -1, -1, -1, 50, 51, 52, 53, 54, 55, 56, 01346 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 01347 67, 68, 69, 70, 71, 72, 15, 74, 75, 76, 01348 77, 78, 79, -1, 82, -1, 83, -1, -1, -1, 01349 -1, -1, -1, -1, -1, -1, -1, 15, -1, -1, 01350 -1, -1, -1, -1, -1, -1, 45, -1, -1, -1, 01351 -1, 50, 51, 52, 53, 54, 55, 56, 57, 58, 01352 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 01353 69, 70, 71, 72, 15, 74, 75, 76, 77, 78, 01354 79, -1, -1, -1, 83, 63, 64, 65, 66, 67, 01355 68, 69, 70, 71, 72, 15, 74, 75, 76, 77, 01356 78, 79, -1, -1, 45, -1, -1, -1, -1, 50, 01357 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 01358 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 01359 71, 72, 15, 74, 75, 76, 77, 78, 79, -1, 01360 -1, -1, 83, -1, -1, -1, 66, 67, 68, 69, 01361 70, 71, 72, 15, 74, 75, 76, 77, 78, 79, 01362 -1, -1, 45, -1, -1, -1, -1, 50, 51, 52, 01363 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 01364 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 01365 15, 74, 75, 76, 77, 78, 79, -1, -1, -1, 01366 83, -1, -1, -1, -1, -1, 68, 69, 70, 71, 01367 72, -1, 74, 75, 76, 77, 78, 79, -1, -1, 01368 45, -1, -1, -1, -1, 50, 51, 52, 53, 54, 01369 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 01370 65, 66, 67, 68, 69, 70, 71, 72, 15, 74, 01371 75, 76, 77, 78, 79, -1, -1, -1, 83, -1, 01372 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01373 -1, -1, -1, -1, -1, -1, -1, -1, 45, -1, 01374 -1, -1, -1, 50, 51, 52, 53, 54, 55, 56, 01375 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 01376 67, 68, 69, 70, 71, 72, 15, 74, 75, 76, 01377 77, 78, 79, -1, -1, -1, 83, -1, -1, -1, 01378 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01379 -1, -1, -1, -1, -1, -1, 45, -1, -1, -1, 01380 -1, 50, 51, 52, 53, 54, 55, 56, 57, 58, 01381 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 01382 69, 70, 71, 72, 15, 74, 75, 76, 77, 78, 01383 79, -1, -1, -1, 83, -1, -1, -1, -1, -1, 01384 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01385 -1, -1, -1, 15, 45, -1, -1, -1, -1, 50, 01386 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 01387 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 01388 71, 72, 15, 74, 75, 76, 77, 78, 79, 51, 01389 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 01390 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 01391 72, 15, 74, 75, 76, 77, 78, 79, -1, -1, 01392 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 01393 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 01394 15, 74, 75, 76, 77, 78, 79, -1, -1, -1, 01395 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 01396 64, 65, 66, 67, 68, 69, 70, 71, 72, 15, 01397 74, 75, 76, 77, 78, 79, -1, -1, -1, -1, 01398 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 01399 65, 66, 67, 68, 69, 70, 71, 72, 15, 74, 01400 75, 76, 77, 78, 79, -1, -1, -1, -1, -1, 01401 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 01402 66, 67, 68, 69, 70, 71, 72, 15, 74, 75, 01403 76, 77, 78, 79, -1, -1, -1, -1, -1, -1, 01404 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 01405 67, 68, 69, 70, 71, 72, -1, 74, 75, 76, 01406 77, 78, 79, -1, -1, -1, -1, -1, -1, -1, 01407 -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, 01408 68, 69, 70, 71, 72, -1, 74, 75, 76, 77, 01409 78, 79, 13, -1, -1, -1, -1, 18, 19, 20, 01410 21, -1, 23, -1, 25, -1, -1, -1, -1, -1, 01411 -1, -1, -1, -1, -1, -1, 37, 38, 39, 40, 01412 41, 42, 43, -1, -1, -1, -1, -1, -1, -1, 01413 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01414 -1, -1, -1, -1, 65 01415 }; 01416 01417 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 01418 symbol of state STATE-NUM. */ 01419 static const yytype_uint8 yystos[] = 01420 { 01421 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 01422 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01423 24, 25, 29, 30, 31, 32, 34, 35, 36, 37, 01424 38, 39, 40, 41, 42, 43, 44, 46, 47, 56, 01425 66, 67, 68, 71, 72, 76, 80, 81, 84, 85, 01426 88, 91, 92, 93, 94, 103, 106, 107, 108, 109, 01427 111, 112, 113, 123, 124, 128, 131, 132, 133, 135, 01428 76, 76, 24, 13, 14, 94, 13, 15, 27, 28, 01429 45, 48, 50, 52, 53, 54, 55, 56, 57, 58, 01430 59, 60, 61, 62, 63, 64, 66, 67, 68, 69, 01431 70, 71, 72, 75, 76, 78, 79, 84, 85, 124, 01432 129, 10, 11, 12, 13, 16, 80, 133, 134, 12, 01433 134, 12, 134, 12, 134, 13, 76, 94, 13, 38, 01434 39, 40, 125, 11, 80, 135, 134, 59, 59, 59, 01435 59, 76, 76, 76, 38, 39, 125, 23, 37, 38, 01436 40, 43, 23, 37, 40, 42, 41, 94, 94, 94, 01437 94, 94, 94, 92, 93, 94, 94, 0, 48, 15, 01438 45, 50, 51, 52, 53, 54, 55, 56, 57, 58, 01439 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 01440 69, 70, 71, 72, 74, 75, 76, 77, 78, 79, 01441 92, 94, 104, 6, 24, 65, 110, 124, 113, 15, 01442 56, 68, 75, 76, 115, 118, 119, 120, 121, 122, 01443 33, 134, 102, 85, 134, 95, 96, 97, 86, 15, 01444 75, 15, 75, 86, 83, 115, 130, 12, 12, 12, 01445 12, 123, 38, 40, 40, 59, 92, 92, 92, 92, 01446 94, 123, 94, 92, 94, 38, 40, 40, 40, 23, 01447 37, 40, 40, 40, 83, 83, 94, 93, 94, 94, 01448 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 01449 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 01450 12, 13, 85, 109, 134, 93, 101, 123, 126, 127, 01451 94, 94, 12, 85, 109, 134, 89, 105, 48, 105, 01452 134, 10, 111, 132, 3, 86, 115, 117, 3, 86, 01453 83, 119, 126, 68, 120, 76, 121, 122, 83, 104, 01454 134, 24, 48, 87, 98, 99, 100, 134, 98, 98, 01455 86, 86, 86, 86, 68, 130, 83, 40, 123, 60, 01456 60, 60, 60, 83, 83, 83, 83, 83, 40, 40, 01457 40, 94, 86, 87, 134, 12, 86, 104, 83, 48, 01458 134, 12, 94, 94, 86, 113, 114, 86, 83, 83, 01459 116, 83, 134, 94, 94, 86, 100, 134, 87, 86, 01460 86, 60, 76, 76, 76, 76, 94, 12, 83, 111, 01461 82, 123, 12, 114, 94, 94, 94, 94, 94, 83, 01462 83, 83, 83 01463 }; 01464 01465 #define yyerrok (yyerrstatus = 0) 01466 #define yyclearin (yychar = YYEMPTY) 01467 #define YYEMPTY (-2) 01468 #define YYEOF 0 01469 01470 #define YYACCEPT goto yyacceptlab 01471 #define YYABORT goto yyabortlab 01472 #define YYERROR goto yyerrorlab 01473 01474 01475 /* Like YYERROR except do call yyerror. This remains here temporarily 01476 to ease the transition to the new meaning of YYERROR, for GCC. 01477 Once GCC version 2 has supplanted version 1, this can go. However, 01478 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 01479 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 01480 discussed. */ 01481 01482 #define YYFAIL goto yyerrlab 01483 #if defined YYFAIL 01484 /* This is here to suppress warnings from the GCC cpp's 01485 -Wunused-macros. Normally we don't worry about that warning, but 01486 some users do, and we want to make it easy for users to remove 01487 YYFAIL uses, which will produce warnings from Bison 2.5. */ 01488 #endif 01489 01490 #define YYRECOVERING() (!!yyerrstatus) 01491 01492 #define YYBACKUP(Token, Value) \ 01493 do \ 01494 if (yychar == YYEMPTY && yylen == 1) \ 01495 { \ 01496 yychar = (Token); \ 01497 yylval = (Value); \ 01498 YYPOPSTACK (1); \ 01499 goto yybackup; \ 01500 } \ 01501 else \ 01502 { \ 01503 yyerror (YY_("syntax error: cannot back up")); \ 01504 YYERROR; \ 01505 } \ 01506 while (YYID (0)) 01507 01508 01509 #define YYTERROR 1 01510 #define YYERRCODE 256 01511 01512 01513 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 01514 If N is 0, then set CURRENT to the empty location which ends 01515 the previous symbol: RHS[0] (always defined). */ 01516 01517 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 01518 #ifndef YYLLOC_DEFAULT 01519 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 01520 do \ 01521 if (YYID (N)) \ 01522 { \ 01523 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 01524 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 01525 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 01526 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 01527 } \ 01528 else \ 01529 { \ 01530 (Current).first_line = (Current).last_line = \ 01531 YYRHSLOC (Rhs, 0).last_line; \ 01532 (Current).first_column = (Current).last_column = \ 01533 YYRHSLOC (Rhs, 0).last_column; \ 01534 } \ 01535 while (YYID (0)) 01536 #endif 01537 01538 01539 /* This macro is provided for backward compatibility. */ 01540 01541 #ifndef YY_LOCATION_PRINT 01542 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 01543 #endif 01544 01545 01546 /* YYLEX -- calling `yylex' with the right arguments. */ 01547 01548 #ifdef YYLEX_PARAM 01549 # define YYLEX yylex (YYLEX_PARAM) 01550 #else 01551 # define YYLEX yylex () 01552 #endif 01553 01554 /* Enable debugging if requested. */ 01555 #if YYDEBUG 01556 01557 # ifndef YYFPRINTF 01558 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 01559 # define YYFPRINTF fprintf 01560 # endif 01561 01562 # define YYDPRINTF(Args) \ 01563 do { \ 01564 if (yydebug) \ 01565 YYFPRINTF Args; \ 01566 } while (YYID (0)) 01567 01568 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 01569 do { \ 01570 if (yydebug) \ 01571 { \ 01572 YYFPRINTF (stderr, "%s ", Title); \ 01573 yy_symbol_print (stderr, \ 01574 Type, Value); \ 01575 YYFPRINTF (stderr, "\n"); \ 01576 } \ 01577 } while (YYID (0)) 01578 01579 01580 /*--------------------------------. 01581 | Print this symbol on YYOUTPUT. | 01582 `--------------------------------*/ 01583 01584 /*ARGSUSED*/ 01585 #if (defined __STDC__ || defined __C99__FUNC__ \ 01586 || defined __cplusplus || defined _MSC_VER) 01587 static void 01588 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01589 #else 01590 static void 01591 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 01592 FILE *yyoutput; 01593 int yytype; 01594 YYSTYPE const * const yyvaluep; 01595 #endif 01596 { 01597 if (!yyvaluep) 01598 return; 01599 # ifdef YYPRINT 01600 if (yytype < YYNTOKENS) 01601 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 01602 # else 01603 YYUSE (yyoutput); 01604 # endif 01605 switch (yytype) 01606 { 01607 default: 01608 break; 01609 } 01610 } 01611 01612 01613 /*--------------------------------. 01614 | Print this symbol on YYOUTPUT. | 01615 `--------------------------------*/ 01616 01617 #if (defined __STDC__ || defined __C99__FUNC__ \ 01618 || defined __cplusplus || defined _MSC_VER) 01619 static void 01620 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01621 #else 01622 static void 01623 yy_symbol_print (yyoutput, yytype, yyvaluep) 01624 FILE *yyoutput; 01625 int yytype; 01626 YYSTYPE const * const yyvaluep; 01627 #endif 01628 { 01629 if (yytype < YYNTOKENS) 01630 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 01631 else 01632 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 01633 01634 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 01635 YYFPRINTF (yyoutput, ")"); 01636 } 01637 01638 /*------------------------------------------------------------------. 01639 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 01640 | TOP (included). | 01641 `------------------------------------------------------------------*/ 01642 01643 #if (defined __STDC__ || defined __C99__FUNC__ \ 01644 || defined __cplusplus || defined _MSC_VER) 01645 static void 01646 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 01647 #else 01648 static void 01649 yy_stack_print (yybottom, yytop) 01650 yytype_int16 *yybottom; 01651 yytype_int16 *yytop; 01652 #endif 01653 { 01654 YYFPRINTF (stderr, "Stack now"); 01655 for (; yybottom <= yytop; yybottom++) 01656 { 01657 int yybot = *yybottom; 01658 YYFPRINTF (stderr, " %d", yybot); 01659 } 01660 YYFPRINTF (stderr, "\n"); 01661 } 01662 01663 # define YY_STACK_PRINT(Bottom, Top) \ 01664 do { \ 01665 if (yydebug) \ 01666 yy_stack_print ((Bottom), (Top)); \ 01667 } while (YYID (0)) 01668 01669 01670 /*------------------------------------------------. 01671 | Report that the YYRULE is going to be reduced. | 01672 `------------------------------------------------*/ 01673 01674 #if (defined __STDC__ || defined __C99__FUNC__ \ 01675 || defined __cplusplus || defined _MSC_VER) 01676 static void 01677 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 01678 #else 01679 static void 01680 yy_reduce_print (yyvsp, yyrule) 01681 YYSTYPE *yyvsp; 01682 int yyrule; 01683 #endif 01684 { 01685 int yynrhs = yyr2[yyrule]; 01686 int yyi; 01687 unsigned long int yylno = yyrline[yyrule]; 01688 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 01689 yyrule - 1, yylno); 01690 /* The symbols being reduced. */ 01691 for (yyi = 0; yyi < yynrhs; yyi++) 01692 { 01693 YYFPRINTF (stderr, " $%d = ", yyi + 1); 01694 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 01695 &(yyvsp[(yyi + 1) - (yynrhs)]) 01696 ); 01697 YYFPRINTF (stderr, "\n"); 01698 } 01699 } 01700 01701 # define YY_REDUCE_PRINT(Rule) \ 01702 do { \ 01703 if (yydebug) \ 01704 yy_reduce_print (yyvsp, Rule); \ 01705 } while (YYID (0)) 01706 01707 /* Nonzero means print parse trace. It is left uninitialized so that 01708 multiple parsers can coexist. */ 01709 int yydebug; 01710 #else /* !YYDEBUG */ 01711 # define YYDPRINTF(Args) 01712 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 01713 # define YY_STACK_PRINT(Bottom, Top) 01714 # define YY_REDUCE_PRINT(Rule) 01715 #endif /* !YYDEBUG */ 01716 01717 01718 /* YYINITDEPTH -- initial size of the parser's stacks. */ 01719 #ifndef YYINITDEPTH 01720 # define YYINITDEPTH 200 01721 #endif 01722 01723 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 01724 if the built-in stack extension method is used). 01725 01726 Do not make this value too large; the results are undefined if 01727 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 01728 evaluated with infinite-precision integer arithmetic. */ 01729 01730 #ifndef YYMAXDEPTH 01731 # define YYMAXDEPTH 10000 01732 #endif 01733 01734 01735 #if YYERROR_VERBOSE 01736 01737 # ifndef yystrlen 01738 # if defined __GLIBC__ && defined _STRING_H 01739 # define yystrlen strlen 01740 # else 01741 /* Return the length of YYSTR. */ 01742 #if (defined __STDC__ || defined __C99__FUNC__ \ 01743 || defined __cplusplus || defined _MSC_VER) 01744 static YYSIZE_T 01745 yystrlen (const char *yystr) 01746 #else 01747 static YYSIZE_T 01748 yystrlen (yystr) 01749 const char *yystr; 01750 #endif 01751 { 01752 YYSIZE_T yylen; 01753 for (yylen = 0; yystr[yylen]; yylen++) 01754 continue; 01755 return yylen; 01756 } 01757 # endif 01758 # endif 01759 01760 # ifndef yystpcpy 01761 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 01762 # define yystpcpy stpcpy 01763 # else 01764 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 01765 YYDEST. */ 01766 #if (defined __STDC__ || defined __C99__FUNC__ \ 01767 || defined __cplusplus || defined _MSC_VER) 01768 static char * 01769 yystpcpy (char *yydest, const char *yysrc) 01770 #else 01771 static char * 01772 yystpcpy (yydest, yysrc) 01773 char *yydest; 01774 const char *yysrc; 01775 #endif 01776 { 01777 char *yyd = yydest; 01778 const char *yys = yysrc; 01779 01780 while ((*yyd++ = *yys++) != '\0') 01781 continue; 01782 01783 return yyd - 1; 01784 } 01785 # endif 01786 # endif 01787 01788 # ifndef yytnamerr 01789 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 01790 quotes and backslashes, so that it's suitable for yyerror. The 01791 heuristic is that double-quoting is unnecessary unless the string 01792 contains an apostrophe, a comma, or backslash (other than 01793 backslash-backslash). YYSTR is taken from yytname. If YYRES is 01794 null, do not copy; instead, return the length of what the result 01795 would have been. */ 01796 static YYSIZE_T 01797 yytnamerr (char *yyres, const char *yystr) 01798 { 01799 if (*yystr == '"') 01800 { 01801 YYSIZE_T yyn = 0; 01802 char const *yyp = yystr; 01803 01804 for (;;) 01805 switch (*++yyp) 01806 { 01807 case '\'': 01808 case ',': 01809 goto do_not_strip_quotes; 01810 01811 case '\\': 01812 if (*++yyp != '\\') 01813 goto do_not_strip_quotes; 01814 /* Fall through. */ 01815 default: 01816 if (yyres) 01817 yyres[yyn] = *yyp; 01818 yyn++; 01819 break; 01820 01821 case '"': 01822 if (yyres) 01823 yyres[yyn] = '\0'; 01824 return yyn; 01825 } 01826 do_not_strip_quotes: ; 01827 } 01828 01829 if (! yyres) 01830 return yystrlen (yystr); 01831 01832 return yystpcpy (yyres, yystr) - yyres; 01833 } 01834 # endif 01835 01836 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 01837 about the unexpected token YYTOKEN for the state stack whose top is 01838 YYSSP. 01839 01840 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 01841 not large enough to hold the message. In that case, also set 01842 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 01843 required number of bytes is too large to store. */ 01844 static int 01845 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 01846 yytype_int16 *yyssp, int yytoken) 01847 { 01848 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 01849 YYSIZE_T yysize = yysize0; 01850 YYSIZE_T yysize1; 01851 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 01852 /* Internationalized format string. */ 01853 const char *yyformat = 0; 01854 /* Arguments of yyformat. */ 01855 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 01856 /* Number of reported tokens (one for the "unexpected", one per 01857 "expected"). */ 01858 int yycount = 0; 01859 01860 /* There are many possibilities here to consider: 01861 - Assume YYFAIL is not used. It's too flawed to consider. See 01862 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 01863 for details. YYERROR is fine as it does not invoke this 01864 function. 01865 - If this state is a consistent state with a default action, then 01866 the only way this function was invoked is if the default action 01867 is an error action. In that case, don't check for expected 01868 tokens because there are none. 01869 - The only way there can be no lookahead present (in yychar) is if 01870 this state is a consistent state with a default action. Thus, 01871 detecting the absence of a lookahead is sufficient to determine 01872 that there is no unexpected or expected token to report. In that 01873 case, just report a simple "syntax error". 01874 - Don't assume there isn't a lookahead just because this state is a 01875 consistent state with a default action. There might have been a 01876 previous inconsistent state, consistent state with a non-default 01877 action, or user semantic action that manipulated yychar. 01878 - Of course, the expected token list depends on states to have 01879 correct lookahead information, and it depends on the parser not 01880 to perform extra reductions after fetching a lookahead from the 01881 scanner and before detecting a syntax error. Thus, state merging 01882 (from LALR or IELR) and default reductions corrupt the expected 01883 token list. However, the list is correct for canonical LR with 01884 one exception: it will still contain any token that will not be 01885 accepted due to an error action in a later state. 01886 */ 01887 if (yytoken != YYEMPTY) 01888 { 01889 int yyn = yypact[*yyssp]; 01890 yyarg[yycount++] = yytname[yytoken]; 01891 if (!yypact_value_is_default (yyn)) 01892 { 01893 /* Start YYX at -YYN if negative to avoid negative indexes in 01894 YYCHECK. In other words, skip the first -YYN actions for 01895 this state because they are default actions. */ 01896 int yyxbegin = yyn < 0 ? -yyn : 0; 01897 /* Stay within bounds of both yycheck and yytname. */ 01898 int yychecklim = YYLAST - yyn + 1; 01899 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 01900 int yyx; 01901 01902 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 01903 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 01904 && !yytable_value_is_error (yytable[yyx + yyn])) 01905 { 01906 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 01907 { 01908 yycount = 1; 01909 yysize = yysize0; 01910 break; 01911 } 01912 yyarg[yycount++] = yytname[yyx]; 01913 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 01914 if (! (yysize <= yysize1 01915 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 01916 return 2; 01917 yysize = yysize1; 01918 } 01919 } 01920 } 01921 01922 switch (yycount) 01923 { 01924 # define YYCASE_(N, S) \ 01925 case N: \ 01926 yyformat = S; \ 01927 break 01928 YYCASE_(0, YY_("syntax error")); 01929 YYCASE_(1, YY_("syntax error, unexpected %s")); 01930 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 01931 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 01932 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 01933 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 01934 # undef YYCASE_ 01935 } 01936 01937 yysize1 = yysize + yystrlen (yyformat); 01938 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 01939 return 2; 01940 yysize = yysize1; 01941 01942 if (*yymsg_alloc < yysize) 01943 { 01944 *yymsg_alloc = 2 * yysize; 01945 if (! (yysize <= *yymsg_alloc 01946 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 01947 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 01948 return 1; 01949 } 01950 01951 /* Avoid sprintf, as that infringes on the user's name space. 01952 Don't have undefined behavior even if the translation 01953 produced a string with the wrong number of "%s"s. */ 01954 { 01955 char *yyp = *yymsg; 01956 int yyi = 0; 01957 while ((*yyp = *yyformat) != '\0') 01958 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 01959 { 01960 yyp += yytnamerr (yyp, yyarg[yyi++]); 01961 yyformat += 2; 01962 } 01963 else 01964 { 01965 yyp++; 01966 yyformat++; 01967 } 01968 } 01969 return 0; 01970 } 01971 #endif /* YYERROR_VERBOSE */ 01972 01973 /*-----------------------------------------------. 01974 | Release the memory associated to this symbol. | 01975 `-----------------------------------------------*/ 01976 01977 /*ARGSUSED*/ 01978 #if (defined __STDC__ || defined __C99__FUNC__ \ 01979 || defined __cplusplus || defined _MSC_VER) 01980 static void 01981 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 01982 #else 01983 static void 01984 yydestruct (yymsg, yytype, yyvaluep) 01985 const char *yymsg; 01986 int yytype; 01987 YYSTYPE *yyvaluep; 01988 #endif 01989 { 01990 YYUSE (yyvaluep); 01991 01992 if (!yymsg) 01993 yymsg = "Deleting"; 01994 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 01995 01996 switch (yytype) 01997 { 01998 01999 default: 02000 break; 02001 } 02002 } 02003 02004 02005 /* Prevent warnings from -Wmissing-prototypes. */ 02006 #ifdef YYPARSE_PARAM 02007 #if defined __STDC__ || defined __cplusplus 02008 int yyparse (void *YYPARSE_PARAM); 02009 #else 02010 int yyparse (); 02011 #endif 02012 #else /* ! YYPARSE_PARAM */ 02013 #if defined __STDC__ || defined __cplusplus 02014 int yyparse (void); 02015 #else 02016 int yyparse (); 02017 #endif 02018 #endif /* ! YYPARSE_PARAM */ 02019 02020 02021 /* The lookahead symbol. */ 02022 int yychar; 02023 02024 /* The semantic value of the lookahead symbol. */ 02025 YYSTYPE yylval; 02026 02027 /* Number of syntax errors so far. */ 02028 int yynerrs; 02029 02030 02031 /*----------. 02032 | yyparse. | 02033 `----------*/ 02034 02035 #ifdef YYPARSE_PARAM 02036 #if (defined __STDC__ || defined __C99__FUNC__ \ 02037 || defined __cplusplus || defined _MSC_VER) 02038 int 02039 yyparse (void *YYPARSE_PARAM) 02040 #else 02041 int 02042 yyparse (YYPARSE_PARAM) 02043 void *YYPARSE_PARAM; 02044 #endif 02045 #else /* ! YYPARSE_PARAM */ 02046 #if (defined __STDC__ || defined __C99__FUNC__ \ 02047 || defined __cplusplus || defined _MSC_VER) 02048 int 02049 yyparse (void) 02050 #else 02051 int 02052 yyparse () 02053 02054 #endif 02055 #endif 02056 { 02057 int yystate; 02058 /* Number of tokens to shift before error messages enabled. */ 02059 int yyerrstatus; 02060 02061 /* The stacks and their tools: 02062 `yyss': related to states. 02063 `yyvs': related to semantic values. 02064 02065 Refer to the stacks thru separate pointers, to allow yyoverflow 02066 to xreallocate them elsewhere. */ 02067 02068 /* The state stack. */ 02069 yytype_int16 yyssa[YYINITDEPTH]; 02070 yytype_int16 *yyss; 02071 yytype_int16 *yyssp; 02072 02073 /* The semantic value stack. */ 02074 YYSTYPE yyvsa[YYINITDEPTH]; 02075 YYSTYPE *yyvs; 02076 YYSTYPE *yyvsp; 02077 02078 YYSIZE_T yystacksize; 02079 02080 int yyn; 02081 int yyresult; 02082 /* Lookahead token as an internal (translated) token number. */ 02083 int yytoken; 02084 /* The variables used to return semantic value and location from the 02085 action routines. */ 02086 YYSTYPE yyval; 02087 02088 #if YYERROR_VERBOSE 02089 /* Buffer for error messages, and its allocated size. */ 02090 char yymsgbuf[128]; 02091 char *yymsg = yymsgbuf; 02092 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 02093 #endif 02094 02095 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 02096 02097 /* The number of symbols on the RHS of the reduced rule. 02098 Keep to zero when no symbol should be popped. */ 02099 int yylen = 0; 02100 02101 yytoken = 0; 02102 yyss = yyssa; 02103 yyvs = yyvsa; 02104 yystacksize = YYINITDEPTH; 02105 02106 YYDPRINTF ((stderr, "Starting parse\n")); 02107 02108 yystate = 0; 02109 yyerrstatus = 0; 02110 yynerrs = 0; 02111 yychar = YYEMPTY; /* Cause a token to be read. */ 02112 02113 /* Initialize stack pointers. 02114 Waste one element of value and location stack 02115 so that they stay on the same level as the state stack. 02116 The wasted elements are never initialized. */ 02117 yyssp = yyss; 02118 yyvsp = yyvs; 02119 02120 goto yysetstate; 02121 02122 /*------------------------------------------------------------. 02123 | yynewstate -- Push a new state, which is found in yystate. | 02124 `------------------------------------------------------------*/ 02125 yynewstate: 02126 /* In all cases, when you get here, the value and location stacks 02127 have just been pushed. So pushing a state here evens the stacks. */ 02128 yyssp++; 02129 02130 yysetstate: 02131 *yyssp = yystate; 02132 02133 if (yyss + yystacksize - 1 <= yyssp) 02134 { 02135 /* Get the current used size of the three stacks, in elements. */ 02136 YYSIZE_T yysize = yyssp - yyss + 1; 02137 02138 #ifdef yyoverflow 02139 { 02140 /* Give user a chance to xreallocate the stack. Use copies of 02141 these so that the &'s don't force the real ones into 02142 memory. */ 02143 YYSTYPE *yyvs1 = yyvs; 02144 yytype_int16 *yyss1 = yyss; 02145 02146 /* Each stack pointer address is followed by the size of the 02147 data in use in that stack, in bytes. This used to be a 02148 conditional around just the two extra args, but that might 02149 be undefined if yyoverflow is a macro. */ 02150 yyoverflow (YY_("memory exhausted"), 02151 &yyss1, yysize * sizeof (*yyssp), 02152 &yyvs1, yysize * sizeof (*yyvsp), 02153 &yystacksize); 02154 02155 yyss = yyss1; 02156 yyvs = yyvs1; 02157 } 02158 #else /* no yyoverflow */ 02159 # ifndef YYSTACK_RELOCATE 02160 goto yyexhaustedlab; 02161 # else 02162 /* Extend the stack our own way. */ 02163 if (YYMAXDEPTH <= yystacksize) 02164 goto yyexhaustedlab; 02165 yystacksize *= 2; 02166 if (YYMAXDEPTH < yystacksize) 02167 yystacksize = YYMAXDEPTH; 02168 02169 { 02170 yytype_int16 *yyss1 = yyss; 02171 union yyalloc *yyptr = 02172 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 02173 if (! yyptr) 02174 goto yyexhaustedlab; 02175 YYSTACK_RELOCATE (yyss_alloc, yyss); 02176 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 02177 # undef YYSTACK_RELOCATE 02178 if (yyss1 != yyssa) 02179 YYSTACK_FREE (yyss1); 02180 } 02181 # endif 02182 #endif /* no yyoverflow */ 02183 02184 yyssp = yyss + yysize - 1; 02185 yyvsp = yyvs + yysize - 1; 02186 02187 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 02188 (unsigned long int) yystacksize)); 02189 02190 if (yyss + yystacksize - 1 <= yyssp) 02191 YYABORT; 02192 } 02193 02194 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 02195 02196 if (yystate == YYFINAL) 02197 YYACCEPT; 02198 02199 goto yybackup; 02200 02201 /*-----------. 02202 | yybackup. | 02203 `-----------*/ 02204 yybackup: 02205 02206 /* Do appropriate processing given the current state. Read a 02207 lookahead token if we need one and don't already have one. */ 02208 02209 /* First try to decide what to do without reference to lookahead token. */ 02210 yyn = yypact[yystate]; 02211 if (yypact_value_is_default (yyn)) 02212 goto yydefault; 02213 02214 /* Not known => get a lookahead token if don't already have one. */ 02215 02216 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 02217 if (yychar == YYEMPTY) 02218 { 02219 YYDPRINTF ((stderr, "Reading a token: ")); 02220 yychar = YYLEX; 02221 } 02222 02223 if (yychar <= YYEOF) 02224 { 02225 yychar = yytoken = YYEOF; 02226 YYDPRINTF ((stderr, "Now at end of input.\n")); 02227 } 02228 else 02229 { 02230 yytoken = YYTRANSLATE (yychar); 02231 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 02232 } 02233 02234 /* If the proper action on seeing token YYTOKEN is to reduce or to 02235 detect an error, take that action. */ 02236 yyn += yytoken; 02237 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 02238 goto yydefault; 02239 yyn = yytable[yyn]; 02240 if (yyn <= 0) 02241 { 02242 if (yytable_value_is_error (yyn)) 02243 goto yyerrlab; 02244 yyn = -yyn; 02245 goto yyreduce; 02246 } 02247 02248 /* Count tokens shifted since error; after three, turn off error 02249 status. */ 02250 if (yyerrstatus) 02251 yyerrstatus--; 02252 02253 /* Shift the lookahead token. */ 02254 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 02255 02256 /* Discard the shifted token. */ 02257 yychar = YYEMPTY; 02258 02259 yystate = yyn; 02260 *++yyvsp = yylval; 02261 02262 goto yynewstate; 02263 02264 02265 /*-----------------------------------------------------------. 02266 | yydefault -- do the default action for the current state. | 02267 `-----------------------------------------------------------*/ 02268 yydefault: 02269 yyn = yydefact[yystate]; 02270 if (yyn == 0) 02271 goto yyerrlab; 02272 goto yyreduce; 02273 02274 02275 /*-----------------------------. 02276 | yyreduce -- Do a reduction. | 02277 `-----------------------------*/ 02278 yyreduce: 02279 /* yyn is the number of a rule to reduce with. */ 02280 yylen = yyr2[yyn]; 02281 02282 /* If YYLEN is nonzero, implement the default value of the action: 02283 `$$ = $1'. 02284 02285 Otherwise, the following line sets YYVAL to garbage. 02286 This behavior is undocumented and Bison 02287 users should not rely upon it. Assigning to YYVAL 02288 unconditionally makes the parser a bit smaller, and it avoids a 02289 GCC warning that YYVAL may be used uninitialized. */ 02290 yyval = yyvsp[1-yylen]; 02291 02292 02293 YY_REDUCE_PRINT (yyn); 02294 switch (yyn) 02295 { 02296 case 4: 02297 02298 /* Line 1806 of yacc.c */ 02299 #line 284 "../../src/gdb/c-exp.y" 02300 { write_exp_elt_opcode(OP_TYPE); 02301 write_exp_elt_type((yyvsp[(1) - (1)].tval)); 02302 write_exp_elt_opcode(OP_TYPE);} 02303 break; 02304 02305 case 5: 02306 02307 /* Line 1806 of yacc.c */ 02308 #line 288 "../../src/gdb/c-exp.y" 02309 { 02310 write_exp_elt_opcode (OP_TYPEOF); 02311 } 02312 break; 02313 02314 case 6: 02315 02316 /* Line 1806 of yacc.c */ 02317 #line 292 "../../src/gdb/c-exp.y" 02318 { 02319 write_exp_elt_opcode (OP_TYPE); 02320 write_exp_elt_type ((yyvsp[(3) - (4)].tval)); 02321 write_exp_elt_opcode (OP_TYPE); 02322 } 02323 break; 02324 02325 case 7: 02326 02327 /* Line 1806 of yacc.c */ 02328 #line 298 "../../src/gdb/c-exp.y" 02329 { 02330 write_exp_elt_opcode (OP_DECLTYPE); 02331 } 02332 break; 02333 02334 case 9: 02335 02336 /* Line 1806 of yacc.c */ 02337 #line 306 "../../src/gdb/c-exp.y" 02338 { write_exp_elt_opcode (BINOP_COMMA); } 02339 break; 02340 02341 case 10: 02342 02343 /* Line 1806 of yacc.c */ 02344 #line 311 "../../src/gdb/c-exp.y" 02345 { write_exp_elt_opcode (UNOP_IND); } 02346 break; 02347 02348 case 11: 02349 02350 /* Line 1806 of yacc.c */ 02351 #line 315 "../../src/gdb/c-exp.y" 02352 { write_exp_elt_opcode (UNOP_ADDR); } 02353 break; 02354 02355 case 12: 02356 02357 /* Line 1806 of yacc.c */ 02358 #line 319 "../../src/gdb/c-exp.y" 02359 { write_exp_elt_opcode (UNOP_NEG); } 02360 break; 02361 02362 case 13: 02363 02364 /* Line 1806 of yacc.c */ 02365 #line 323 "../../src/gdb/c-exp.y" 02366 { write_exp_elt_opcode (UNOP_PLUS); } 02367 break; 02368 02369 case 14: 02370 02371 /* Line 1806 of yacc.c */ 02372 #line 327 "../../src/gdb/c-exp.y" 02373 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 02374 break; 02375 02376 case 15: 02377 02378 /* Line 1806 of yacc.c */ 02379 #line 331 "../../src/gdb/c-exp.y" 02380 { write_exp_elt_opcode (UNOP_COMPLEMENT); } 02381 break; 02382 02383 case 16: 02384 02385 /* Line 1806 of yacc.c */ 02386 #line 335 "../../src/gdb/c-exp.y" 02387 { write_exp_elt_opcode (UNOP_PREINCREMENT); } 02388 break; 02389 02390 case 17: 02391 02392 /* Line 1806 of yacc.c */ 02393 #line 339 "../../src/gdb/c-exp.y" 02394 { write_exp_elt_opcode (UNOP_PREDECREMENT); } 02395 break; 02396 02397 case 18: 02398 02399 /* Line 1806 of yacc.c */ 02400 #line 343 "../../src/gdb/c-exp.y" 02401 { write_exp_elt_opcode (UNOP_POSTINCREMENT); } 02402 break; 02403 02404 case 19: 02405 02406 /* Line 1806 of yacc.c */ 02407 #line 347 "../../src/gdb/c-exp.y" 02408 { write_exp_elt_opcode (UNOP_POSTDECREMENT); } 02409 break; 02410 02411 case 20: 02412 02413 /* Line 1806 of yacc.c */ 02414 #line 351 "../../src/gdb/c-exp.y" 02415 { write_exp_elt_opcode (OP_TYPEID); } 02416 break; 02417 02418 case 21: 02419 02420 /* Line 1806 of yacc.c */ 02421 #line 355 "../../src/gdb/c-exp.y" 02422 { write_exp_elt_opcode (OP_TYPEID); } 02423 break; 02424 02425 case 22: 02426 02427 /* Line 1806 of yacc.c */ 02428 #line 359 "../../src/gdb/c-exp.y" 02429 { write_exp_elt_opcode (UNOP_SIZEOF); } 02430 break; 02431 02432 case 23: 02433 02434 /* Line 1806 of yacc.c */ 02435 #line 363 "../../src/gdb/c-exp.y" 02436 { write_exp_elt_opcode (STRUCTOP_PTR); 02437 write_exp_string ((yyvsp[(3) - (3)].sval)); 02438 write_exp_elt_opcode (STRUCTOP_PTR); } 02439 break; 02440 02441 case 24: 02442 02443 /* Line 1806 of yacc.c */ 02444 #line 369 "../../src/gdb/c-exp.y" 02445 { mark_struct_expression (); 02446 write_exp_elt_opcode (STRUCTOP_PTR); 02447 write_exp_string ((yyvsp[(3) - (4)].sval)); 02448 write_exp_elt_opcode (STRUCTOP_PTR); } 02449 break; 02450 02451 case 25: 02452 02453 /* Line 1806 of yacc.c */ 02454 #line 376 "../../src/gdb/c-exp.y" 02455 { struct stoken s; 02456 mark_struct_expression (); 02457 write_exp_elt_opcode (STRUCTOP_PTR); 02458 s.ptr = ""; 02459 s.length = 0; 02460 write_exp_string (s); 02461 write_exp_elt_opcode (STRUCTOP_PTR); } 02462 break; 02463 02464 case 26: 02465 02466 /* Line 1806 of yacc.c */ 02467 #line 386 "../../src/gdb/c-exp.y" 02468 { write_exp_elt_opcode (STRUCTOP_PTR); 02469 write_destructor_name ((yyvsp[(4) - (4)].sval)); 02470 write_exp_elt_opcode (STRUCTOP_PTR); } 02471 break; 02472 02473 case 27: 02474 02475 /* Line 1806 of yacc.c */ 02476 #line 392 "../../src/gdb/c-exp.y" 02477 { mark_struct_expression (); 02478 write_exp_elt_opcode (STRUCTOP_PTR); 02479 write_destructor_name ((yyvsp[(4) - (5)].sval)); 02480 write_exp_elt_opcode (STRUCTOP_PTR); } 02481 break; 02482 02483 case 28: 02484 02485 /* Line 1806 of yacc.c */ 02486 #line 399 "../../src/gdb/c-exp.y" 02487 { /* exp->type::name becomes exp->*(&type::name) */ 02488 /* Note: this doesn't work if name is a 02489 static member! FIXME */ 02490 write_exp_elt_opcode (UNOP_ADDR); 02491 write_exp_elt_opcode (STRUCTOP_MPTR); } 02492 break; 02493 02494 case 29: 02495 02496 /* Line 1806 of yacc.c */ 02497 #line 407 "../../src/gdb/c-exp.y" 02498 { write_exp_elt_opcode (STRUCTOP_MPTR); } 02499 break; 02500 02501 case 30: 02502 02503 /* Line 1806 of yacc.c */ 02504 #line 411 "../../src/gdb/c-exp.y" 02505 { write_exp_elt_opcode (STRUCTOP_STRUCT); 02506 write_exp_string ((yyvsp[(3) - (3)].sval)); 02507 write_exp_elt_opcode (STRUCTOP_STRUCT); } 02508 break; 02509 02510 case 31: 02511 02512 /* Line 1806 of yacc.c */ 02513 #line 417 "../../src/gdb/c-exp.y" 02514 { mark_struct_expression (); 02515 write_exp_elt_opcode (STRUCTOP_STRUCT); 02516 write_exp_string ((yyvsp[(3) - (4)].sval)); 02517 write_exp_elt_opcode (STRUCTOP_STRUCT); } 02518 break; 02519 02520 case 32: 02521 02522 /* Line 1806 of yacc.c */ 02523 #line 424 "../../src/gdb/c-exp.y" 02524 { struct stoken s; 02525 mark_struct_expression (); 02526 write_exp_elt_opcode (STRUCTOP_STRUCT); 02527 s.ptr = ""; 02528 s.length = 0; 02529 write_exp_string (s); 02530 write_exp_elt_opcode (STRUCTOP_STRUCT); } 02531 break; 02532 02533 case 33: 02534 02535 /* Line 1806 of yacc.c */ 02536 #line 434 "../../src/gdb/c-exp.y" 02537 { write_exp_elt_opcode (STRUCTOP_STRUCT); 02538 write_destructor_name ((yyvsp[(4) - (4)].sval)); 02539 write_exp_elt_opcode (STRUCTOP_STRUCT); } 02540 break; 02541 02542 case 34: 02543 02544 /* Line 1806 of yacc.c */ 02545 #line 440 "../../src/gdb/c-exp.y" 02546 { mark_struct_expression (); 02547 write_exp_elt_opcode (STRUCTOP_STRUCT); 02548 write_destructor_name ((yyvsp[(4) - (5)].sval)); 02549 write_exp_elt_opcode (STRUCTOP_STRUCT); } 02550 break; 02551 02552 case 35: 02553 02554 /* Line 1806 of yacc.c */ 02555 #line 447 "../../src/gdb/c-exp.y" 02556 { /* exp.type::name becomes exp.*(&type::name) */ 02557 /* Note: this doesn't work if name is a 02558 static member! FIXME */ 02559 write_exp_elt_opcode (UNOP_ADDR); 02560 write_exp_elt_opcode (STRUCTOP_MEMBER); } 02561 break; 02562 02563 case 36: 02564 02565 /* Line 1806 of yacc.c */ 02566 #line 455 "../../src/gdb/c-exp.y" 02567 { write_exp_elt_opcode (STRUCTOP_MEMBER); } 02568 break; 02569 02570 case 37: 02571 02572 /* Line 1806 of yacc.c */ 02573 #line 459 "../../src/gdb/c-exp.y" 02574 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 02575 break; 02576 02577 case 38: 02578 02579 /* Line 1806 of yacc.c */ 02580 #line 463 "../../src/gdb/c-exp.y" 02581 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 02582 break; 02583 02584 case 39: 02585 02586 /* Line 1806 of yacc.c */ 02587 #line 472 "../../src/gdb/c-exp.y" 02588 { 02589 CORE_ADDR class; 02590 02591 class = lookup_objc_class (parse_gdbarch, 02592 copy_name ((yyvsp[(2) - (2)].tsym).stoken)); 02593 if (class == 0) 02594 error (_("%s is not an ObjC Class"), 02595 copy_name ((yyvsp[(2) - (2)].tsym).stoken)); 02596 write_exp_elt_opcode (OP_LONG); 02597 write_exp_elt_type (parse_type->builtin_int); 02598 write_exp_elt_longcst ((LONGEST) class); 02599 write_exp_elt_opcode (OP_LONG); 02600 start_msglist(); 02601 } 02602 break; 02603 02604 case 40: 02605 02606 /* Line 1806 of yacc.c */ 02607 #line 487 "../../src/gdb/c-exp.y" 02608 { write_exp_elt_opcode (OP_OBJC_MSGCALL); 02609 end_msglist(); 02610 write_exp_elt_opcode (OP_OBJC_MSGCALL); 02611 } 02612 break; 02613 02614 case 41: 02615 02616 /* Line 1806 of yacc.c */ 02617 #line 494 "../../src/gdb/c-exp.y" 02618 { 02619 write_exp_elt_opcode (OP_LONG); 02620 write_exp_elt_type (parse_type->builtin_int); 02621 write_exp_elt_longcst ((LONGEST) (yyvsp[(2) - (2)].class).class); 02622 write_exp_elt_opcode (OP_LONG); 02623 start_msglist(); 02624 } 02625 break; 02626 02627 case 42: 02628 02629 /* Line 1806 of yacc.c */ 02630 #line 502 "../../src/gdb/c-exp.y" 02631 { write_exp_elt_opcode (OP_OBJC_MSGCALL); 02632 end_msglist(); 02633 write_exp_elt_opcode (OP_OBJC_MSGCALL); 02634 } 02635 break; 02636 02637 case 43: 02638 02639 /* Line 1806 of yacc.c */ 02640 #line 509 "../../src/gdb/c-exp.y" 02641 { start_msglist(); } 02642 break; 02643 02644 case 44: 02645 02646 /* Line 1806 of yacc.c */ 02647 #line 511 "../../src/gdb/c-exp.y" 02648 { write_exp_elt_opcode (OP_OBJC_MSGCALL); 02649 end_msglist(); 02650 write_exp_elt_opcode (OP_OBJC_MSGCALL); 02651 } 02652 break; 02653 02654 case 45: 02655 02656 /* Line 1806 of yacc.c */ 02657 #line 518 "../../src/gdb/c-exp.y" 02658 { add_msglist(&(yyvsp[(1) - (1)].sval), 0); } 02659 break; 02660 02661 case 49: 02662 02663 /* Line 1806 of yacc.c */ 02664 #line 527 "../../src/gdb/c-exp.y" 02665 { add_msglist(&(yyvsp[(1) - (3)].sval), 1); } 02666 break; 02667 02668 case 50: 02669 02670 /* Line 1806 of yacc.c */ 02671 #line 529 "../../src/gdb/c-exp.y" 02672 { add_msglist(0, 1); } 02673 break; 02674 02675 case 51: 02676 02677 /* Line 1806 of yacc.c */ 02678 #line 531 "../../src/gdb/c-exp.y" 02679 { add_msglist(0, 0); } 02680 break; 02681 02682 case 52: 02683 02684 /* Line 1806 of yacc.c */ 02685 #line 537 "../../src/gdb/c-exp.y" 02686 { start_arglist (); } 02687 break; 02688 02689 case 53: 02690 02691 /* Line 1806 of yacc.c */ 02692 #line 539 "../../src/gdb/c-exp.y" 02693 { write_exp_elt_opcode (OP_FUNCALL); 02694 write_exp_elt_longcst ((LONGEST) end_arglist ()); 02695 write_exp_elt_opcode (OP_FUNCALL); } 02696 break; 02697 02698 case 54: 02699 02700 /* Line 1806 of yacc.c */ 02701 #line 545 "../../src/gdb/c-exp.y" 02702 { 02703 /* This could potentially be a an argument defined 02704 lookup function (Koenig). */ 02705 write_exp_elt_opcode (OP_ADL_FUNC); 02706 write_exp_elt_block (expression_context_block); 02707 write_exp_elt_sym (NULL); /* Placeholder. */ 02708 write_exp_string ((yyvsp[(1) - (2)].ssym).stoken); 02709 write_exp_elt_opcode (OP_ADL_FUNC); 02710 02711 /* This is to save the value of arglist_len 02712 being accumulated by an outer function call. */ 02713 02714 start_arglist (); 02715 } 02716 break; 02717 02718 case 55: 02719 02720 /* Line 1806 of yacc.c */ 02721 #line 560 "../../src/gdb/c-exp.y" 02722 { 02723 write_exp_elt_opcode (OP_FUNCALL); 02724 write_exp_elt_longcst ((LONGEST) end_arglist ()); 02725 write_exp_elt_opcode (OP_FUNCALL); 02726 } 02727 break; 02728 02729 case 56: 02730 02731 /* Line 1806 of yacc.c */ 02732 #line 568 "../../src/gdb/c-exp.y" 02733 { start_arglist (); } 02734 break; 02735 02736 case 58: 02737 02738 /* Line 1806 of yacc.c */ 02739 #line 575 "../../src/gdb/c-exp.y" 02740 { arglist_len = 1; } 02741 break; 02742 02743 case 59: 02744 02745 /* Line 1806 of yacc.c */ 02746 #line 579 "../../src/gdb/c-exp.y" 02747 { arglist_len++; } 02748 break; 02749 02750 case 60: 02751 02752 /* Line 1806 of yacc.c */ 02753 #line 583 "../../src/gdb/c-exp.y" 02754 { int i; 02755 VEC (type_ptr) *type_list = (yyvsp[(3) - (5)].tvec); 02756 struct type *type_elt; 02757 LONGEST len = VEC_length (type_ptr, type_list); 02758 02759 write_exp_elt_opcode (TYPE_INSTANCE); 02760 write_exp_elt_longcst (len); 02761 for (i = 0; 02762 VEC_iterate (type_ptr, type_list, i, type_elt); 02763 ++i) 02764 write_exp_elt_type (type_elt); 02765 write_exp_elt_longcst(len); 02766 write_exp_elt_opcode (TYPE_INSTANCE); 02767 VEC_free (type_ptr, type_list); 02768 } 02769 break; 02770 02771 case 61: 02772 02773 /* Line 1806 of yacc.c */ 02774 #line 601 "../../src/gdb/c-exp.y" 02775 { (yyval.lval) = end_arglist () - 1; } 02776 break; 02777 02778 case 62: 02779 02780 /* Line 1806 of yacc.c */ 02781 #line 604 "../../src/gdb/c-exp.y" 02782 { write_exp_elt_opcode (OP_ARRAY); 02783 write_exp_elt_longcst ((LONGEST) 0); 02784 write_exp_elt_longcst ((LONGEST) (yyvsp[(3) - (3)].lval)); 02785 write_exp_elt_opcode (OP_ARRAY); } 02786 break; 02787 02788 case 63: 02789 02790 /* Line 1806 of yacc.c */ 02791 #line 611 "../../src/gdb/c-exp.y" 02792 { write_exp_elt_opcode (UNOP_MEMVAL_TYPE); } 02793 break; 02794 02795 case 64: 02796 02797 /* Line 1806 of yacc.c */ 02798 #line 615 "../../src/gdb/c-exp.y" 02799 { write_exp_elt_opcode (UNOP_CAST_TYPE); } 02800 break; 02801 02802 case 65: 02803 02804 /* Line 1806 of yacc.c */ 02805 #line 619 "../../src/gdb/c-exp.y" 02806 { } 02807 break; 02808 02809 case 66: 02810 02811 /* Line 1806 of yacc.c */ 02812 #line 625 "../../src/gdb/c-exp.y" 02813 { write_exp_elt_opcode (BINOP_REPEAT); } 02814 break; 02815 02816 case 67: 02817 02818 /* Line 1806 of yacc.c */ 02819 #line 629 "../../src/gdb/c-exp.y" 02820 { write_exp_elt_opcode (BINOP_MUL); } 02821 break; 02822 02823 case 68: 02824 02825 /* Line 1806 of yacc.c */ 02826 #line 633 "../../src/gdb/c-exp.y" 02827 { write_exp_elt_opcode (BINOP_DIV); } 02828 break; 02829 02830 case 69: 02831 02832 /* Line 1806 of yacc.c */ 02833 #line 637 "../../src/gdb/c-exp.y" 02834 { write_exp_elt_opcode (BINOP_REM); } 02835 break; 02836 02837 case 70: 02838 02839 /* Line 1806 of yacc.c */ 02840 #line 641 "../../src/gdb/c-exp.y" 02841 { write_exp_elt_opcode (BINOP_ADD); } 02842 break; 02843 02844 case 71: 02845 02846 /* Line 1806 of yacc.c */ 02847 #line 645 "../../src/gdb/c-exp.y" 02848 { write_exp_elt_opcode (BINOP_SUB); } 02849 break; 02850 02851 case 72: 02852 02853 /* Line 1806 of yacc.c */ 02854 #line 649 "../../src/gdb/c-exp.y" 02855 { write_exp_elt_opcode (BINOP_LSH); } 02856 break; 02857 02858 case 73: 02859 02860 /* Line 1806 of yacc.c */ 02861 #line 653 "../../src/gdb/c-exp.y" 02862 { write_exp_elt_opcode (BINOP_RSH); } 02863 break; 02864 02865 case 74: 02866 02867 /* Line 1806 of yacc.c */ 02868 #line 657 "../../src/gdb/c-exp.y" 02869 { write_exp_elt_opcode (BINOP_EQUAL); } 02870 break; 02871 02872 case 75: 02873 02874 /* Line 1806 of yacc.c */ 02875 #line 661 "../../src/gdb/c-exp.y" 02876 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 02877 break; 02878 02879 case 76: 02880 02881 /* Line 1806 of yacc.c */ 02882 #line 665 "../../src/gdb/c-exp.y" 02883 { write_exp_elt_opcode (BINOP_LEQ); } 02884 break; 02885 02886 case 77: 02887 02888 /* Line 1806 of yacc.c */ 02889 #line 669 "../../src/gdb/c-exp.y" 02890 { write_exp_elt_opcode (BINOP_GEQ); } 02891 break; 02892 02893 case 78: 02894 02895 /* Line 1806 of yacc.c */ 02896 #line 673 "../../src/gdb/c-exp.y" 02897 { write_exp_elt_opcode (BINOP_LESS); } 02898 break; 02899 02900 case 79: 02901 02902 /* Line 1806 of yacc.c */ 02903 #line 677 "../../src/gdb/c-exp.y" 02904 { write_exp_elt_opcode (BINOP_GTR); } 02905 break; 02906 02907 case 80: 02908 02909 /* Line 1806 of yacc.c */ 02910 #line 681 "../../src/gdb/c-exp.y" 02911 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 02912 break; 02913 02914 case 81: 02915 02916 /* Line 1806 of yacc.c */ 02917 #line 685 "../../src/gdb/c-exp.y" 02918 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 02919 break; 02920 02921 case 82: 02922 02923 /* Line 1806 of yacc.c */ 02924 #line 689 "../../src/gdb/c-exp.y" 02925 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 02926 break; 02927 02928 case 83: 02929 02930 /* Line 1806 of yacc.c */ 02931 #line 693 "../../src/gdb/c-exp.y" 02932 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 02933 break; 02934 02935 case 84: 02936 02937 /* Line 1806 of yacc.c */ 02938 #line 697 "../../src/gdb/c-exp.y" 02939 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 02940 break; 02941 02942 case 85: 02943 02944 /* Line 1806 of yacc.c */ 02945 #line 701 "../../src/gdb/c-exp.y" 02946 { write_exp_elt_opcode (TERNOP_COND); } 02947 break; 02948 02949 case 86: 02950 02951 /* Line 1806 of yacc.c */ 02952 #line 705 "../../src/gdb/c-exp.y" 02953 { write_exp_elt_opcode (BINOP_ASSIGN); } 02954 break; 02955 02956 case 87: 02957 02958 /* Line 1806 of yacc.c */ 02959 #line 709 "../../src/gdb/c-exp.y" 02960 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); 02961 write_exp_elt_opcode ((yyvsp[(2) - (3)].opcode)); 02962 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } 02963 break; 02964 02965 case 88: 02966 02967 /* Line 1806 of yacc.c */ 02968 #line 715 "../../src/gdb/c-exp.y" 02969 { write_exp_elt_opcode (OP_LONG); 02970 write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_int).type); 02971 write_exp_elt_longcst ((LONGEST)((yyvsp[(1) - (1)].typed_val_int).val)); 02972 write_exp_elt_opcode (OP_LONG); } 02973 break; 02974 02975 case 89: 02976 02977 /* Line 1806 of yacc.c */ 02978 #line 722 "../../src/gdb/c-exp.y" 02979 { 02980 struct stoken_vector vec; 02981 vec.len = 1; 02982 vec.tokens = &(yyvsp[(1) - (1)].tsval); 02983 write_exp_string_vector ((yyvsp[(1) - (1)].tsval).type, &vec); 02984 } 02985 break; 02986 02987 case 90: 02988 02989 /* Line 1806 of yacc.c */ 02990 #line 731 "../../src/gdb/c-exp.y" 02991 { YYSTYPE val; 02992 parse_number ((yyvsp[(1) - (1)].ssym).stoken.ptr, (yyvsp[(1) - (1)].ssym).stoken.length, 0, &val); 02993 write_exp_elt_opcode (OP_LONG); 02994 write_exp_elt_type (val.typed_val_int.type); 02995 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val); 02996 write_exp_elt_opcode (OP_LONG); 02997 } 02998 break; 02999 03000 case 91: 03001 03002 /* Line 1806 of yacc.c */ 03003 #line 742 "../../src/gdb/c-exp.y" 03004 { write_exp_elt_opcode (OP_DOUBLE); 03005 write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_float).type); 03006 write_exp_elt_dblcst ((yyvsp[(1) - (1)].typed_val_float).dval); 03007 write_exp_elt_opcode (OP_DOUBLE); } 03008 break; 03009 03010 case 92: 03011 03012 /* Line 1806 of yacc.c */ 03013 #line 749 "../../src/gdb/c-exp.y" 03014 { write_exp_elt_opcode (OP_DECFLOAT); 03015 write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_decfloat).type); 03016 write_exp_elt_decfloatcst ((yyvsp[(1) - (1)].typed_val_decfloat).val); 03017 write_exp_elt_opcode (OP_DECFLOAT); } 03018 break; 03019 03020 case 94: 03021 03022 /* Line 1806 of yacc.c */ 03023 #line 759 "../../src/gdb/c-exp.y" 03024 { 03025 write_dollar_variable ((yyvsp[(1) - (1)].sval)); 03026 } 03027 break; 03028 03029 case 95: 03030 03031 /* Line 1806 of yacc.c */ 03032 #line 765 "../../src/gdb/c-exp.y" 03033 { 03034 write_exp_elt_opcode (OP_OBJC_SELECTOR); 03035 write_exp_string ((yyvsp[(3) - (4)].sval)); 03036 write_exp_elt_opcode (OP_OBJC_SELECTOR); } 03037 break; 03038 03039 case 96: 03040 03041 /* Line 1806 of yacc.c */ 03042 #line 772 "../../src/gdb/c-exp.y" 03043 { write_exp_elt_opcode (OP_LONG); 03044 write_exp_elt_type (lookup_signed_typename 03045 (parse_language, parse_gdbarch, 03046 "int")); 03047 CHECK_TYPEDEF ((yyvsp[(3) - (4)].tval)); 03048 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ((yyvsp[(3) - (4)].tval))); 03049 write_exp_elt_opcode (OP_LONG); } 03050 break; 03051 03052 case 97: 03053 03054 /* Line 1806 of yacc.c */ 03055 #line 782 "../../src/gdb/c-exp.y" 03056 { write_exp_elt_opcode (UNOP_REINTERPRET_CAST); } 03057 break; 03058 03059 case 98: 03060 03061 /* Line 1806 of yacc.c */ 03062 #line 786 "../../src/gdb/c-exp.y" 03063 { write_exp_elt_opcode (UNOP_CAST_TYPE); } 03064 break; 03065 03066 case 99: 03067 03068 /* Line 1806 of yacc.c */ 03069 #line 790 "../../src/gdb/c-exp.y" 03070 { write_exp_elt_opcode (UNOP_DYNAMIC_CAST); } 03071 break; 03072 03073 case 100: 03074 03075 /* Line 1806 of yacc.c */ 03076 #line 794 "../../src/gdb/c-exp.y" 03077 { /* We could do more error checking here, but 03078 it doesn't seem worthwhile. */ 03079 write_exp_elt_opcode (UNOP_CAST_TYPE); } 03080 break; 03081 03082 case 101: 03083 03084 /* Line 1806 of yacc.c */ 03085 #line 801 "../../src/gdb/c-exp.y" 03086 { 03087 /* We copy the string here, and not in the 03088 lexer, to guarantee that we do not leak a 03089 string. Note that we follow the 03090 NUL-termination convention of the 03091 lexer. */ 03092 struct typed_stoken *vec = XNEW (struct typed_stoken); 03093 (yyval.svec).len = 1; 03094 (yyval.svec).tokens = vec; 03095 03096 vec->type = (yyvsp[(1) - (1)].tsval).type; 03097 vec->length = (yyvsp[(1) - (1)].tsval).length; 03098 vec->ptr = xmalloc ((yyvsp[(1) - (1)].tsval).length + 1); 03099 memcpy (vec->ptr, (yyvsp[(1) - (1)].tsval).ptr, (yyvsp[(1) - (1)].tsval).length + 1); 03100 } 03101 break; 03102 03103 case 102: 03104 03105 /* Line 1806 of yacc.c */ 03106 #line 818 "../../src/gdb/c-exp.y" 03107 { 03108 /* Note that we NUL-terminate here, but just 03109 for convenience. */ 03110 char *p; 03111 ++(yyval.svec).len; 03112 (yyval.svec).tokens = xrealloc ((yyval.svec).tokens, 03113 (yyval.svec).len * sizeof (struct typed_stoken)); 03114 03115 p = xmalloc ((yyvsp[(2) - (2)].tsval).length + 1); 03116 memcpy (p, (yyvsp[(2) - (2)].tsval).ptr, (yyvsp[(2) - (2)].tsval).length + 1); 03117 03118 (yyval.svec).tokens[(yyval.svec).len - 1].type = (yyvsp[(2) - (2)].tsval).type; 03119 (yyval.svec).tokens[(yyval.svec).len - 1].length = (yyvsp[(2) - (2)].tsval).length; 03120 (yyval.svec).tokens[(yyval.svec).len - 1].ptr = p; 03121 } 03122 break; 03123 03124 case 103: 03125 03126 /* Line 1806 of yacc.c */ 03127 #line 836 "../../src/gdb/c-exp.y" 03128 { 03129 int i; 03130 enum c_string_type type = C_STRING; 03131 03132 for (i = 0; i < (yyvsp[(1) - (1)].svec).len; ++i) 03133 { 03134 switch ((yyvsp[(1) - (1)].svec).tokens[i].type) 03135 { 03136 case C_STRING: 03137 break; 03138 case C_WIDE_STRING: 03139 case C_STRING_16: 03140 case C_STRING_32: 03141 if (type != C_STRING 03142 && type != (yyvsp[(1) - (1)].svec).tokens[i].type) 03143 error (_("Undefined string concatenation.")); 03144 type = (yyvsp[(1) - (1)].svec).tokens[i].type; 03145 break; 03146 default: 03147 /* internal error */ 03148 internal_error (__FILE__, __LINE__, 03149 "unrecognized type in string concatenation"); 03150 } 03151 } 03152 03153 write_exp_string_vector (type, &(yyvsp[(1) - (1)].svec)); 03154 for (i = 0; i < (yyvsp[(1) - (1)].svec).len; ++i) 03155 xfree ((yyvsp[(1) - (1)].svec).tokens[i].ptr); 03156 xfree ((yyvsp[(1) - (1)].svec).tokens); 03157 } 03158 break; 03159 03160 case 104: 03161 03162 /* Line 1806 of yacc.c */ 03163 #line 871 "../../src/gdb/c-exp.y" 03164 { write_exp_elt_opcode (OP_OBJC_NSSTRING); 03165 write_exp_string ((yyvsp[(1) - (1)].sval)); 03166 write_exp_elt_opcode (OP_OBJC_NSSTRING); } 03167 break; 03168 03169 case 105: 03170 03171 /* Line 1806 of yacc.c */ 03172 #line 878 "../../src/gdb/c-exp.y" 03173 { write_exp_elt_opcode (OP_LONG); 03174 write_exp_elt_type (parse_type->builtin_bool); 03175 write_exp_elt_longcst ((LONGEST) 1); 03176 write_exp_elt_opcode (OP_LONG); } 03177 break; 03178 03179 case 106: 03180 03181 /* Line 1806 of yacc.c */ 03182 #line 885 "../../src/gdb/c-exp.y" 03183 { write_exp_elt_opcode (OP_LONG); 03184 write_exp_elt_type (parse_type->builtin_bool); 03185 write_exp_elt_longcst ((LONGEST) 0); 03186 write_exp_elt_opcode (OP_LONG); } 03187 break; 03188 03189 case 107: 03190 03191 /* Line 1806 of yacc.c */ 03192 #line 894 "../../src/gdb/c-exp.y" 03193 { 03194 if ((yyvsp[(1) - (1)].ssym).sym) 03195 (yyval.bval) = SYMBOL_BLOCK_VALUE ((yyvsp[(1) - (1)].ssym).sym); 03196 else 03197 error (_("No file or function \"%s\"."), 03198 copy_name ((yyvsp[(1) - (1)].ssym).stoken)); 03199 } 03200 break; 03201 03202 case 108: 03203 03204 /* Line 1806 of yacc.c */ 03205 #line 902 "../../src/gdb/c-exp.y" 03206 { 03207 (yyval.bval) = (yyvsp[(1) - (1)].bval); 03208 } 03209 break; 03210 03211 case 109: 03212 03213 /* Line 1806 of yacc.c */ 03214 #line 908 "../../src/gdb/c-exp.y" 03215 { struct symbol *tem 03216 = lookup_symbol (copy_name ((yyvsp[(3) - (3)].sval)), (yyvsp[(1) - (3)].bval), 03217 VAR_DOMAIN, NULL); 03218 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) 03219 error (_("No function \"%s\" in specified context."), 03220 copy_name ((yyvsp[(3) - (3)].sval))); 03221 (yyval.bval) = SYMBOL_BLOCK_VALUE (tem); } 03222 break; 03223 03224 case 110: 03225 03226 /* Line 1806 of yacc.c */ 03227 #line 918 "../../src/gdb/c-exp.y" 03228 { struct symbol *sym = (yyvsp[(1) - (2)].ssym).sym; 03229 03230 if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym) 03231 || !symbol_read_needs_frame (sym)) 03232 error (_("@entry can be used only for function " 03233 "parameters, not for \"%s\""), 03234 copy_name ((yyvsp[(1) - (2)].ssym).stoken)); 03235 03236 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 03237 write_exp_elt_sym (sym); 03238 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 03239 } 03240 break; 03241 03242 case 111: 03243 03244 /* Line 1806 of yacc.c */ 03245 #line 933 "../../src/gdb/c-exp.y" 03246 { struct symbol *sym; 03247 sym = lookup_symbol (copy_name ((yyvsp[(3) - (3)].sval)), (yyvsp[(1) - (3)].bval), 03248 VAR_DOMAIN, NULL); 03249 if (sym == 0) 03250 error (_("No symbol \"%s\" in specified context."), 03251 copy_name ((yyvsp[(3) - (3)].sval))); 03252 if (symbol_read_needs_frame (sym)) 03253 { 03254 if (innermost_block == 0 03255 || contained_in (block_found, 03256 innermost_block)) 03257 innermost_block = block_found; 03258 } 03259 03260 write_exp_elt_opcode (OP_VAR_VALUE); 03261 /* block_found is set by lookup_symbol. */ 03262 write_exp_elt_block (block_found); 03263 write_exp_elt_sym (sym); 03264 write_exp_elt_opcode (OP_VAR_VALUE); } 03265 break; 03266 03267 case 112: 03268 03269 /* Line 1806 of yacc.c */ 03270 #line 955 "../../src/gdb/c-exp.y" 03271 { 03272 struct type *type = (yyvsp[(1) - (3)].tsym).type; 03273 CHECK_TYPEDEF (type); 03274 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 03275 && TYPE_CODE (type) != TYPE_CODE_UNION 03276 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE) 03277 error (_("`%s' is not defined as an aggregate type."), 03278 TYPE_SAFE_NAME (type)); 03279 03280 write_exp_elt_opcode (OP_SCOPE); 03281 write_exp_elt_type (type); 03282 write_exp_string ((yyvsp[(3) - (3)].sval)); 03283 write_exp_elt_opcode (OP_SCOPE); 03284 } 03285 break; 03286 03287 case 113: 03288 03289 /* Line 1806 of yacc.c */ 03290 #line 970 "../../src/gdb/c-exp.y" 03291 { 03292 struct type *type = (yyvsp[(1) - (4)].tsym).type; 03293 struct stoken tmp_token; 03294 char *buf; 03295 03296 CHECK_TYPEDEF (type); 03297 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 03298 && TYPE_CODE (type) != TYPE_CODE_UNION 03299 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE) 03300 error (_("`%s' is not defined as an aggregate type."), 03301 TYPE_SAFE_NAME (type)); 03302 buf = alloca ((yyvsp[(4) - (4)].sval).length + 2); 03303 tmp_token.ptr = buf; 03304 tmp_token.length = (yyvsp[(4) - (4)].sval).length + 1; 03305 buf[0] = '~'; 03306 memcpy (buf+1, (yyvsp[(4) - (4)].sval).ptr, (yyvsp[(4) - (4)].sval).length); 03307 buf[tmp_token.length] = 0; 03308 03309 /* Check for valid destructor name. */ 03310 destructor_name_p (tmp_token.ptr, (yyvsp[(1) - (4)].tsym).type); 03311 write_exp_elt_opcode (OP_SCOPE); 03312 write_exp_elt_type (type); 03313 write_exp_string (tmp_token); 03314 write_exp_elt_opcode (OP_SCOPE); 03315 } 03316 break; 03317 03318 case 114: 03319 03320 /* Line 1806 of yacc.c */ 03321 #line 996 "../../src/gdb/c-exp.y" 03322 { 03323 char *copy = copy_name ((yyvsp[(3) - (5)].sval)); 03324 error (_("No type \"%s\" within class " 03325 "or namespace \"%s\"."), 03326 copy, TYPE_SAFE_NAME ((yyvsp[(1) - (5)].tsym).type)); 03327 } 03328 break; 03329 03330 case 116: 03331 03332 /* Line 1806 of yacc.c */ 03333 #line 1006 "../../src/gdb/c-exp.y" 03334 { 03335 char *name = copy_name ((yyvsp[(2) - (2)].ssym).stoken); 03336 struct symbol *sym; 03337 struct bound_minimal_symbol msymbol; 03338 03339 sym = 03340 lookup_symbol (name, (const struct block *) NULL, 03341 VAR_DOMAIN, NULL); 03342 if (sym) 03343 { 03344 write_exp_elt_opcode (OP_VAR_VALUE); 03345 write_exp_elt_block (NULL); 03346 write_exp_elt_sym (sym); 03347 write_exp_elt_opcode (OP_VAR_VALUE); 03348 break; 03349 } 03350 03351 msymbol = lookup_bound_minimal_symbol (name); 03352 if (msymbol.minsym != NULL) 03353 write_exp_msymbol (msymbol); 03354 else if (!have_full_symbols () && !have_partial_symbols ()) 03355 error (_("No symbol table is loaded. Use the \"file\" command.")); 03356 else 03357 error (_("No symbol \"%s\" in current context."), name); 03358 } 03359 break; 03360 03361 case 117: 03362 03363 /* Line 1806 of yacc.c */ 03364 #line 1034 "../../src/gdb/c-exp.y" 03365 { struct symbol *sym = (yyvsp[(1) - (1)].ssym).sym; 03366 03367 if (sym) 03368 { 03369 if (symbol_read_needs_frame (sym)) 03370 { 03371 if (innermost_block == 0 03372 || contained_in (block_found, 03373 innermost_block)) 03374 innermost_block = block_found; 03375 } 03376 03377 write_exp_elt_opcode (OP_VAR_VALUE); 03378 /* We want to use the selected frame, not 03379 another more inner frame which happens to 03380 be in the same block. */ 03381 write_exp_elt_block (NULL); 03382 write_exp_elt_sym (sym); 03383 write_exp_elt_opcode (OP_VAR_VALUE); 03384 } 03385 else if ((yyvsp[(1) - (1)].ssym).is_a_field_of_this) 03386 { 03387 /* C++: it hangs off of `this'. Must 03388 not inadvertently convert from a method call 03389 to data ref. */ 03390 if (innermost_block == 0 03391 || contained_in (block_found, 03392 innermost_block)) 03393 innermost_block = block_found; 03394 write_exp_elt_opcode (OP_THIS); 03395 write_exp_elt_opcode (OP_THIS); 03396 write_exp_elt_opcode (STRUCTOP_PTR); 03397 write_exp_string ((yyvsp[(1) - (1)].ssym).stoken); 03398 write_exp_elt_opcode (STRUCTOP_PTR); 03399 } 03400 else 03401 { 03402 struct bound_minimal_symbol msymbol; 03403 char *arg = copy_name ((yyvsp[(1) - (1)].ssym).stoken); 03404 03405 msymbol = 03406 lookup_bound_minimal_symbol (arg); 03407 if (msymbol.minsym != NULL) 03408 write_exp_msymbol (msymbol); 03409 else if (!have_full_symbols () && !have_partial_symbols ()) 03410 error (_("No symbol table is loaded. Use the \"file\" command.")); 03411 else 03412 error (_("No symbol \"%s\" in current context."), 03413 copy_name ((yyvsp[(1) - (1)].ssym).stoken)); 03414 } 03415 } 03416 break; 03417 03418 case 118: 03419 03420 /* Line 1806 of yacc.c */ 03421 #line 1088 "../../src/gdb/c-exp.y" 03422 { insert_type_address_space (copy_name ((yyvsp[(2) - (2)].ssym).stoken)); } 03423 break; 03424 03425 case 126: 03426 03427 /* Line 1806 of yacc.c */ 03428 #line 1109 "../../src/gdb/c-exp.y" 03429 { insert_type (tp_pointer); } 03430 break; 03431 03432 case 128: 03433 03434 /* Line 1806 of yacc.c */ 03435 #line 1112 "../../src/gdb/c-exp.y" 03436 { insert_type (tp_pointer); } 03437 break; 03438 03439 case 130: 03440 03441 /* Line 1806 of yacc.c */ 03442 #line 1115 "../../src/gdb/c-exp.y" 03443 { insert_type (tp_reference); } 03444 break; 03445 03446 case 131: 03447 03448 /* Line 1806 of yacc.c */ 03449 #line 1117 "../../src/gdb/c-exp.y" 03450 { insert_type (tp_reference); } 03451 break; 03452 03453 case 132: 03454 03455 /* Line 1806 of yacc.c */ 03456 #line 1121 "../../src/gdb/c-exp.y" 03457 { 03458 (yyval.type_stack) = get_type_stack (); 03459 /* This cleanup is eventually run by 03460 c_parse. */ 03461 make_cleanup (type_stack_cleanup, (yyval.type_stack)); 03462 } 03463 break; 03464 03465 case 133: 03466 03467 /* Line 1806 of yacc.c */ 03468 #line 1130 "../../src/gdb/c-exp.y" 03469 { (yyval.type_stack) = append_type_stack ((yyvsp[(2) - (2)].type_stack), (yyvsp[(1) - (2)].type_stack)); } 03470 break; 03471 03472 case 136: 03473 03474 /* Line 1806 of yacc.c */ 03475 #line 1136 "../../src/gdb/c-exp.y" 03476 { (yyval.type_stack) = (yyvsp[(2) - (3)].type_stack); } 03477 break; 03478 03479 case 137: 03480 03481 /* Line 1806 of yacc.c */ 03482 #line 1138 "../../src/gdb/c-exp.y" 03483 { 03484 push_type_stack ((yyvsp[(1) - (2)].type_stack)); 03485 push_type_int ((yyvsp[(2) - (2)].lval)); 03486 push_type (tp_array); 03487 (yyval.type_stack) = get_type_stack (); 03488 } 03489 break; 03490 03491 case 138: 03492 03493 /* Line 1806 of yacc.c */ 03494 #line 1145 "../../src/gdb/c-exp.y" 03495 { 03496 push_type_int ((yyvsp[(1) - (1)].lval)); 03497 push_type (tp_array); 03498 (yyval.type_stack) = get_type_stack (); 03499 } 03500 break; 03501 03502 case 139: 03503 03504 /* Line 1806 of yacc.c */ 03505 #line 1152 "../../src/gdb/c-exp.y" 03506 { 03507 push_type_stack ((yyvsp[(1) - (2)].type_stack)); 03508 push_typelist ((yyvsp[(2) - (2)].tvec)); 03509 (yyval.type_stack) = get_type_stack (); 03510 } 03511 break; 03512 03513 case 140: 03514 03515 /* Line 1806 of yacc.c */ 03516 #line 1158 "../../src/gdb/c-exp.y" 03517 { 03518 push_typelist ((yyvsp[(1) - (1)].tvec)); 03519 (yyval.type_stack) = get_type_stack (); 03520 } 03521 break; 03522 03523 case 141: 03524 03525 /* Line 1806 of yacc.c */ 03526 #line 1165 "../../src/gdb/c-exp.y" 03527 { (yyval.lval) = -1; } 03528 break; 03529 03530 case 142: 03531 03532 /* Line 1806 of yacc.c */ 03533 #line 1167 "../../src/gdb/c-exp.y" 03534 { (yyval.lval) = -1; } 03535 break; 03536 03537 case 143: 03538 03539 /* Line 1806 of yacc.c */ 03540 #line 1169 "../../src/gdb/c-exp.y" 03541 { (yyval.lval) = (yyvsp[(2) - (3)].typed_val_int).val; } 03542 break; 03543 03544 case 144: 03545 03546 /* Line 1806 of yacc.c */ 03547 #line 1171 "../../src/gdb/c-exp.y" 03548 { (yyval.lval) = (yyvsp[(2) - (3)].typed_val_int).val; } 03549 break; 03550 03551 case 145: 03552 03553 /* Line 1806 of yacc.c */ 03554 #line 1175 "../../src/gdb/c-exp.y" 03555 { (yyval.tvec) = NULL; } 03556 break; 03557 03558 case 146: 03559 03560 /* Line 1806 of yacc.c */ 03561 #line 1177 "../../src/gdb/c-exp.y" 03562 { (yyval.tvec) = (yyvsp[(2) - (3)].tvec); } 03563 break; 03564 03565 case 148: 03566 03567 /* Line 1806 of yacc.c */ 03568 #line 1193 "../../src/gdb/c-exp.y" 03569 { (yyval.tval) = (yyvsp[(1) - (1)].tsym).type; } 03570 break; 03571 03572 case 149: 03573 03574 /* Line 1806 of yacc.c */ 03575 #line 1195 "../../src/gdb/c-exp.y" 03576 { (yyval.tval) = lookup_signed_typename (parse_language, 03577 parse_gdbarch, 03578 "int"); } 03579 break; 03580 03581 case 150: 03582 03583 /* Line 1806 of yacc.c */ 03584 #line 1199 "../../src/gdb/c-exp.y" 03585 { (yyval.tval) = lookup_signed_typename (parse_language, 03586 parse_gdbarch, 03587 "long"); } 03588 break; 03589 03590 case 151: 03591 03592 /* Line 1806 of yacc.c */ 03593 #line 1203 "../../src/gdb/c-exp.y" 03594 { (yyval.tval) = lookup_signed_typename (parse_language, 03595 parse_gdbarch, 03596 "short"); } 03597 break; 03598 03599 case 152: 03600 03601 /* Line 1806 of yacc.c */ 03602 #line 1207 "../../src/gdb/c-exp.y" 03603 { (yyval.tval) = lookup_signed_typename (parse_language, 03604 parse_gdbarch, 03605 "long"); } 03606 break; 03607 03608 case 153: 03609 03610 /* Line 1806 of yacc.c */ 03611 #line 1211 "../../src/gdb/c-exp.y" 03612 { (yyval.tval) = lookup_signed_typename (parse_language, 03613 parse_gdbarch, 03614 "long"); } 03615 break; 03616 03617 case 154: 03618 03619 /* Line 1806 of yacc.c */ 03620 #line 1215 "../../src/gdb/c-exp.y" 03621 { (yyval.tval) = lookup_signed_typename (parse_language, 03622 parse_gdbarch, 03623 "long"); } 03624 break; 03625 03626 case 155: 03627 03628 /* Line 1806 of yacc.c */ 03629 #line 1219 "../../src/gdb/c-exp.y" 03630 { (yyval.tval) = lookup_signed_typename (parse_language, 03631 parse_gdbarch, 03632 "long"); } 03633 break; 03634 03635 case 156: 03636 03637 /* Line 1806 of yacc.c */ 03638 #line 1223 "../../src/gdb/c-exp.y" 03639 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03640 parse_gdbarch, 03641 "long"); } 03642 break; 03643 03644 case 157: 03645 03646 /* Line 1806 of yacc.c */ 03647 #line 1227 "../../src/gdb/c-exp.y" 03648 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03649 parse_gdbarch, 03650 "long"); } 03651 break; 03652 03653 case 158: 03654 03655 /* Line 1806 of yacc.c */ 03656 #line 1231 "../../src/gdb/c-exp.y" 03657 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03658 parse_gdbarch, 03659 "long"); } 03660 break; 03661 03662 case 159: 03663 03664 /* Line 1806 of yacc.c */ 03665 #line 1235 "../../src/gdb/c-exp.y" 03666 { (yyval.tval) = lookup_signed_typename (parse_language, 03667 parse_gdbarch, 03668 "long long"); } 03669 break; 03670 03671 case 160: 03672 03673 /* Line 1806 of yacc.c */ 03674 #line 1239 "../../src/gdb/c-exp.y" 03675 { (yyval.tval) = lookup_signed_typename (parse_language, 03676 parse_gdbarch, 03677 "long long"); } 03678 break; 03679 03680 case 161: 03681 03682 /* Line 1806 of yacc.c */ 03683 #line 1243 "../../src/gdb/c-exp.y" 03684 { (yyval.tval) = lookup_signed_typename (parse_language, 03685 parse_gdbarch, 03686 "long long"); } 03687 break; 03688 03689 case 162: 03690 03691 /* Line 1806 of yacc.c */ 03692 #line 1247 "../../src/gdb/c-exp.y" 03693 { (yyval.tval) = lookup_signed_typename (parse_language, 03694 parse_gdbarch, 03695 "long long"); } 03696 break; 03697 03698 case 163: 03699 03700 /* Line 1806 of yacc.c */ 03701 #line 1251 "../../src/gdb/c-exp.y" 03702 { (yyval.tval) = lookup_signed_typename (parse_language, 03703 parse_gdbarch, 03704 "long long"); } 03705 break; 03706 03707 case 164: 03708 03709 /* Line 1806 of yacc.c */ 03710 #line 1255 "../../src/gdb/c-exp.y" 03711 { (yyval.tval) = lookup_signed_typename (parse_language, 03712 parse_gdbarch, 03713 "long long"); } 03714 break; 03715 03716 case 165: 03717 03718 /* Line 1806 of yacc.c */ 03719 #line 1259 "../../src/gdb/c-exp.y" 03720 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03721 parse_gdbarch, 03722 "long long"); } 03723 break; 03724 03725 case 166: 03726 03727 /* Line 1806 of yacc.c */ 03728 #line 1263 "../../src/gdb/c-exp.y" 03729 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03730 parse_gdbarch, 03731 "long long"); } 03732 break; 03733 03734 case 167: 03735 03736 /* Line 1806 of yacc.c */ 03737 #line 1267 "../../src/gdb/c-exp.y" 03738 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03739 parse_gdbarch, 03740 "long long"); } 03741 break; 03742 03743 case 168: 03744 03745 /* Line 1806 of yacc.c */ 03746 #line 1271 "../../src/gdb/c-exp.y" 03747 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03748 parse_gdbarch, 03749 "long long"); } 03750 break; 03751 03752 case 169: 03753 03754 /* Line 1806 of yacc.c */ 03755 #line 1275 "../../src/gdb/c-exp.y" 03756 { (yyval.tval) = lookup_signed_typename (parse_language, 03757 parse_gdbarch, 03758 "short"); } 03759 break; 03760 03761 case 170: 03762 03763 /* Line 1806 of yacc.c */ 03764 #line 1279 "../../src/gdb/c-exp.y" 03765 { (yyval.tval) = lookup_signed_typename (parse_language, 03766 parse_gdbarch, 03767 "short"); } 03768 break; 03769 03770 case 171: 03771 03772 /* Line 1806 of yacc.c */ 03773 #line 1283 "../../src/gdb/c-exp.y" 03774 { (yyval.tval) = lookup_signed_typename (parse_language, 03775 parse_gdbarch, 03776 "short"); } 03777 break; 03778 03779 case 172: 03780 03781 /* Line 1806 of yacc.c */ 03782 #line 1287 "../../src/gdb/c-exp.y" 03783 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03784 parse_gdbarch, 03785 "short"); } 03786 break; 03787 03788 case 173: 03789 03790 /* Line 1806 of yacc.c */ 03791 #line 1291 "../../src/gdb/c-exp.y" 03792 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03793 parse_gdbarch, 03794 "short"); } 03795 break; 03796 03797 case 174: 03798 03799 /* Line 1806 of yacc.c */ 03800 #line 1295 "../../src/gdb/c-exp.y" 03801 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03802 parse_gdbarch, 03803 "short"); } 03804 break; 03805 03806 case 175: 03807 03808 /* Line 1806 of yacc.c */ 03809 #line 1299 "../../src/gdb/c-exp.y" 03810 { (yyval.tval) = lookup_typename (parse_language, parse_gdbarch, 03811 "double", (struct block *) NULL, 03812 0); } 03813 break; 03814 03815 case 176: 03816 03817 /* Line 1806 of yacc.c */ 03818 #line 1303 "../../src/gdb/c-exp.y" 03819 { (yyval.tval) = lookup_typename (parse_language, parse_gdbarch, 03820 "long double", 03821 (struct block *) NULL, 0); } 03822 break; 03823 03824 case 177: 03825 03826 /* Line 1806 of yacc.c */ 03827 #line 1307 "../../src/gdb/c-exp.y" 03828 { (yyval.tval) = lookup_struct (copy_name ((yyvsp[(2) - (2)].sval)), 03829 expression_context_block); } 03830 break; 03831 03832 case 178: 03833 03834 /* Line 1806 of yacc.c */ 03835 #line 1310 "../../src/gdb/c-exp.y" 03836 { 03837 mark_completion_tag (TYPE_CODE_STRUCT, "", 0); 03838 (yyval.tval) = NULL; 03839 } 03840 break; 03841 03842 case 179: 03843 03844 /* Line 1806 of yacc.c */ 03845 #line 1315 "../../src/gdb/c-exp.y" 03846 { 03847 mark_completion_tag (TYPE_CODE_STRUCT, (yyvsp[(2) - (3)].sval).ptr, 03848 (yyvsp[(2) - (3)].sval).length); 03849 (yyval.tval) = NULL; 03850 } 03851 break; 03852 03853 case 180: 03854 03855 /* Line 1806 of yacc.c */ 03856 #line 1321 "../../src/gdb/c-exp.y" 03857 { (yyval.tval) = lookup_struct (copy_name ((yyvsp[(2) - (2)].sval)), 03858 expression_context_block); } 03859 break; 03860 03861 case 181: 03862 03863 /* Line 1806 of yacc.c */ 03864 #line 1324 "../../src/gdb/c-exp.y" 03865 { 03866 mark_completion_tag (TYPE_CODE_CLASS, "", 0); 03867 (yyval.tval) = NULL; 03868 } 03869 break; 03870 03871 case 182: 03872 03873 /* Line 1806 of yacc.c */ 03874 #line 1329 "../../src/gdb/c-exp.y" 03875 { 03876 mark_completion_tag (TYPE_CODE_CLASS, (yyvsp[(2) - (3)].sval).ptr, 03877 (yyvsp[(2) - (3)].sval).length); 03878 (yyval.tval) = NULL; 03879 } 03880 break; 03881 03882 case 183: 03883 03884 /* Line 1806 of yacc.c */ 03885 #line 1335 "../../src/gdb/c-exp.y" 03886 { (yyval.tval) = lookup_union (copy_name ((yyvsp[(2) - (2)].sval)), 03887 expression_context_block); } 03888 break; 03889 03890 case 184: 03891 03892 /* Line 1806 of yacc.c */ 03893 #line 1338 "../../src/gdb/c-exp.y" 03894 { 03895 mark_completion_tag (TYPE_CODE_UNION, "", 0); 03896 (yyval.tval) = NULL; 03897 } 03898 break; 03899 03900 case 185: 03901 03902 /* Line 1806 of yacc.c */ 03903 #line 1343 "../../src/gdb/c-exp.y" 03904 { 03905 mark_completion_tag (TYPE_CODE_UNION, (yyvsp[(2) - (3)].sval).ptr, 03906 (yyvsp[(2) - (3)].sval).length); 03907 (yyval.tval) = NULL; 03908 } 03909 break; 03910 03911 case 186: 03912 03913 /* Line 1806 of yacc.c */ 03914 #line 1349 "../../src/gdb/c-exp.y" 03915 { (yyval.tval) = lookup_enum (copy_name ((yyvsp[(2) - (2)].sval)), 03916 expression_context_block); } 03917 break; 03918 03919 case 187: 03920 03921 /* Line 1806 of yacc.c */ 03922 #line 1352 "../../src/gdb/c-exp.y" 03923 { 03924 mark_completion_tag (TYPE_CODE_ENUM, "", 0); 03925 (yyval.tval) = NULL; 03926 } 03927 break; 03928 03929 case 188: 03930 03931 /* Line 1806 of yacc.c */ 03932 #line 1357 "../../src/gdb/c-exp.y" 03933 { 03934 mark_completion_tag (TYPE_CODE_ENUM, (yyvsp[(2) - (3)].sval).ptr, 03935 (yyvsp[(2) - (3)].sval).length); 03936 (yyval.tval) = NULL; 03937 } 03938 break; 03939 03940 case 189: 03941 03942 /* Line 1806 of yacc.c */ 03943 #line 1363 "../../src/gdb/c-exp.y" 03944 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03945 parse_gdbarch, 03946 TYPE_NAME((yyvsp[(2) - (2)].tsym).type)); } 03947 break; 03948 03949 case 190: 03950 03951 /* Line 1806 of yacc.c */ 03952 #line 1367 "../../src/gdb/c-exp.y" 03953 { (yyval.tval) = lookup_unsigned_typename (parse_language, 03954 parse_gdbarch, 03955 "int"); } 03956 break; 03957 03958 case 191: 03959 03960 /* Line 1806 of yacc.c */ 03961 #line 1371 "../../src/gdb/c-exp.y" 03962 { (yyval.tval) = lookup_signed_typename (parse_language, 03963 parse_gdbarch, 03964 TYPE_NAME((yyvsp[(2) - (2)].tsym).type)); } 03965 break; 03966 03967 case 192: 03968 03969 /* Line 1806 of yacc.c */ 03970 #line 1375 "../../src/gdb/c-exp.y" 03971 { (yyval.tval) = lookup_signed_typename (parse_language, 03972 parse_gdbarch, 03973 "int"); } 03974 break; 03975 03976 case 193: 03977 03978 /* Line 1806 of yacc.c */ 03979 #line 1382 "../../src/gdb/c-exp.y" 03980 { (yyval.tval) = lookup_template_type(copy_name((yyvsp[(2) - (5)].sval)), (yyvsp[(4) - (5)].tval), 03981 expression_context_block); 03982 } 03983 break; 03984 03985 case 194: 03986 03987 /* Line 1806 of yacc.c */ 03988 #line 1386 "../../src/gdb/c-exp.y" 03989 { (yyval.tval) = follow_types ((yyvsp[(2) - (2)].tval)); } 03990 break; 03991 03992 case 195: 03993 03994 /* Line 1806 of yacc.c */ 03995 #line 1388 "../../src/gdb/c-exp.y" 03996 { (yyval.tval) = follow_types ((yyvsp[(1) - (2)].tval)); } 03997 break; 03998 03999 case 197: 04000 04001 /* Line 1806 of yacc.c */ 04002 #line 1393 "../../src/gdb/c-exp.y" 04003 { 04004 (yyval.tsym).stoken.ptr = "int"; 04005 (yyval.tsym).stoken.length = 3; 04006 (yyval.tsym).type = lookup_signed_typename (parse_language, 04007 parse_gdbarch, 04008 "int"); 04009 } 04010 break; 04011 04012 case 198: 04013 04014 /* Line 1806 of yacc.c */ 04015 #line 1401 "../../src/gdb/c-exp.y" 04016 { 04017 (yyval.tsym).stoken.ptr = "long"; 04018 (yyval.tsym).stoken.length = 4; 04019 (yyval.tsym).type = lookup_signed_typename (parse_language, 04020 parse_gdbarch, 04021 "long"); 04022 } 04023 break; 04024 04025 case 199: 04026 04027 /* Line 1806 of yacc.c */ 04028 #line 1409 "../../src/gdb/c-exp.y" 04029 { 04030 (yyval.tsym).stoken.ptr = "short"; 04031 (yyval.tsym).stoken.length = 5; 04032 (yyval.tsym).type = lookup_signed_typename (parse_language, 04033 parse_gdbarch, 04034 "short"); 04035 } 04036 break; 04037 04038 case 200: 04039 04040 /* Line 1806 of yacc.c */ 04041 #line 1420 "../../src/gdb/c-exp.y" 04042 { check_parameter_typelist ((yyvsp[(1) - (1)].tvec)); } 04043 break; 04044 04045 case 201: 04046 04047 /* Line 1806 of yacc.c */ 04048 #line 1422 "../../src/gdb/c-exp.y" 04049 { 04050 VEC_safe_push (type_ptr, (yyvsp[(1) - (3)].tvec), NULL); 04051 check_parameter_typelist ((yyvsp[(1) - (3)].tvec)); 04052 (yyval.tvec) = (yyvsp[(1) - (3)].tvec); 04053 } 04054 break; 04055 04056 case 202: 04057 04058 /* Line 1806 of yacc.c */ 04059 #line 1431 "../../src/gdb/c-exp.y" 04060 { 04061 VEC (type_ptr) *typelist = NULL; 04062 VEC_safe_push (type_ptr, typelist, (yyvsp[(1) - (1)].tval)); 04063 (yyval.tvec) = typelist; 04064 } 04065 break; 04066 04067 case 203: 04068 04069 /* Line 1806 of yacc.c */ 04070 #line 1437 "../../src/gdb/c-exp.y" 04071 { 04072 VEC_safe_push (type_ptr, (yyvsp[(1) - (3)].tvec), (yyvsp[(3) - (3)].tval)); 04073 (yyval.tvec) = (yyvsp[(1) - (3)].tvec); 04074 } 04075 break; 04076 04077 case 205: 04078 04079 /* Line 1806 of yacc.c */ 04080 #line 1445 "../../src/gdb/c-exp.y" 04081 { 04082 push_type_stack ((yyvsp[(2) - (2)].type_stack)); 04083 (yyval.tval) = follow_types ((yyvsp[(1) - (2)].tval)); 04084 } 04085 break; 04086 04087 case 206: 04088 04089 /* Line 1806 of yacc.c */ 04090 #line 1452 "../../src/gdb/c-exp.y" 04091 { (yyval.tval) = follow_types ((yyvsp[(1) - (2)].tval)); } 04092 break; 04093 04094 case 211: 04095 04096 /* Line 1806 of yacc.c */ 04097 #line 1464 "../../src/gdb/c-exp.y" 04098 { insert_type (tp_const); 04099 insert_type (tp_volatile); 04100 } 04101 break; 04102 04103 case 212: 04104 04105 /* Line 1806 of yacc.c */ 04106 #line 1468 "../../src/gdb/c-exp.y" 04107 { insert_type (tp_const); } 04108 break; 04109 04110 case 213: 04111 04112 /* Line 1806 of yacc.c */ 04113 #line 1470 "../../src/gdb/c-exp.y" 04114 { insert_type (tp_volatile); } 04115 break; 04116 04117 case 214: 04118 04119 /* Line 1806 of yacc.c */ 04120 #line 1474 "../../src/gdb/c-exp.y" 04121 { (yyval.sval) = operator_stoken (" new"); } 04122 break; 04123 04124 case 215: 04125 04126 /* Line 1806 of yacc.c */ 04127 #line 1476 "../../src/gdb/c-exp.y" 04128 { (yyval.sval) = operator_stoken (" delete"); } 04129 break; 04130 04131 case 216: 04132 04133 /* Line 1806 of yacc.c */ 04134 #line 1478 "../../src/gdb/c-exp.y" 04135 { (yyval.sval) = operator_stoken (" new[]"); } 04136 break; 04137 04138 case 217: 04139 04140 /* Line 1806 of yacc.c */ 04141 #line 1480 "../../src/gdb/c-exp.y" 04142 { (yyval.sval) = operator_stoken (" delete[]"); } 04143 break; 04144 04145 case 218: 04146 04147 /* Line 1806 of yacc.c */ 04148 #line 1482 "../../src/gdb/c-exp.y" 04149 { (yyval.sval) = operator_stoken (" new[]"); } 04150 break; 04151 04152 case 219: 04153 04154 /* Line 1806 of yacc.c */ 04155 #line 1484 "../../src/gdb/c-exp.y" 04156 { (yyval.sval) = operator_stoken (" delete[]"); } 04157 break; 04158 04159 case 220: 04160 04161 /* Line 1806 of yacc.c */ 04162 #line 1486 "../../src/gdb/c-exp.y" 04163 { (yyval.sval) = operator_stoken ("+"); } 04164 break; 04165 04166 case 221: 04167 04168 /* Line 1806 of yacc.c */ 04169 #line 1488 "../../src/gdb/c-exp.y" 04170 { (yyval.sval) = operator_stoken ("-"); } 04171 break; 04172 04173 case 222: 04174 04175 /* Line 1806 of yacc.c */ 04176 #line 1490 "../../src/gdb/c-exp.y" 04177 { (yyval.sval) = operator_stoken ("*"); } 04178 break; 04179 04180 case 223: 04181 04182 /* Line 1806 of yacc.c */ 04183 #line 1492 "../../src/gdb/c-exp.y" 04184 { (yyval.sval) = operator_stoken ("/"); } 04185 break; 04186 04187 case 224: 04188 04189 /* Line 1806 of yacc.c */ 04190 #line 1494 "../../src/gdb/c-exp.y" 04191 { (yyval.sval) = operator_stoken ("%"); } 04192 break; 04193 04194 case 225: 04195 04196 /* Line 1806 of yacc.c */ 04197 #line 1496 "../../src/gdb/c-exp.y" 04198 { (yyval.sval) = operator_stoken ("^"); } 04199 break; 04200 04201 case 226: 04202 04203 /* Line 1806 of yacc.c */ 04204 #line 1498 "../../src/gdb/c-exp.y" 04205 { (yyval.sval) = operator_stoken ("&"); } 04206 break; 04207 04208 case 227: 04209 04210 /* Line 1806 of yacc.c */ 04211 #line 1500 "../../src/gdb/c-exp.y" 04212 { (yyval.sval) = operator_stoken ("|"); } 04213 break; 04214 04215 case 228: 04216 04217 /* Line 1806 of yacc.c */ 04218 #line 1502 "../../src/gdb/c-exp.y" 04219 { (yyval.sval) = operator_stoken ("~"); } 04220 break; 04221 04222 case 229: 04223 04224 /* Line 1806 of yacc.c */ 04225 #line 1504 "../../src/gdb/c-exp.y" 04226 { (yyval.sval) = operator_stoken ("!"); } 04227 break; 04228 04229 case 230: 04230 04231 /* Line 1806 of yacc.c */ 04232 #line 1506 "../../src/gdb/c-exp.y" 04233 { (yyval.sval) = operator_stoken ("="); } 04234 break; 04235 04236 case 231: 04237 04238 /* Line 1806 of yacc.c */ 04239 #line 1508 "../../src/gdb/c-exp.y" 04240 { (yyval.sval) = operator_stoken ("<"); } 04241 break; 04242 04243 case 232: 04244 04245 /* Line 1806 of yacc.c */ 04246 #line 1510 "../../src/gdb/c-exp.y" 04247 { (yyval.sval) = operator_stoken (">"); } 04248 break; 04249 04250 case 233: 04251 04252 /* Line 1806 of yacc.c */ 04253 #line 1512 "../../src/gdb/c-exp.y" 04254 { const char *op = "unknown"; 04255 switch ((yyvsp[(2) - (2)].opcode)) 04256 { 04257 case BINOP_RSH: 04258 op = ">>="; 04259 break; 04260 case BINOP_LSH: 04261 op = "<<="; 04262 break; 04263 case BINOP_ADD: 04264 op = "+="; 04265 break; 04266 case BINOP_SUB: 04267 op = "-="; 04268 break; 04269 case BINOP_MUL: 04270 op = "*="; 04271 break; 04272 case BINOP_DIV: 04273 op = "/="; 04274 break; 04275 case BINOP_REM: 04276 op = "%="; 04277 break; 04278 case BINOP_BITWISE_IOR: 04279 op = "|="; 04280 break; 04281 case BINOP_BITWISE_AND: 04282 op = "&="; 04283 break; 04284 case BINOP_BITWISE_XOR: 04285 op = "^="; 04286 break; 04287 default: 04288 break; 04289 } 04290 04291 (yyval.sval) = operator_stoken (op); 04292 } 04293 break; 04294 04295 case 234: 04296 04297 /* Line 1806 of yacc.c */ 04298 #line 1552 "../../src/gdb/c-exp.y" 04299 { (yyval.sval) = operator_stoken ("<<"); } 04300 break; 04301 04302 case 235: 04303 04304 /* Line 1806 of yacc.c */ 04305 #line 1554 "../../src/gdb/c-exp.y" 04306 { (yyval.sval) = operator_stoken (">>"); } 04307 break; 04308 04309 case 236: 04310 04311 /* Line 1806 of yacc.c */ 04312 #line 1556 "../../src/gdb/c-exp.y" 04313 { (yyval.sval) = operator_stoken ("=="); } 04314 break; 04315 04316 case 237: 04317 04318 /* Line 1806 of yacc.c */ 04319 #line 1558 "../../src/gdb/c-exp.y" 04320 { (yyval.sval) = operator_stoken ("!="); } 04321 break; 04322 04323 case 238: 04324 04325 /* Line 1806 of yacc.c */ 04326 #line 1560 "../../src/gdb/c-exp.y" 04327 { (yyval.sval) = operator_stoken ("<="); } 04328 break; 04329 04330 case 239: 04331 04332 /* Line 1806 of yacc.c */ 04333 #line 1562 "../../src/gdb/c-exp.y" 04334 { (yyval.sval) = operator_stoken (">="); } 04335 break; 04336 04337 case 240: 04338 04339 /* Line 1806 of yacc.c */ 04340 #line 1564 "../../src/gdb/c-exp.y" 04341 { (yyval.sval) = operator_stoken ("&&"); } 04342 break; 04343 04344 case 241: 04345 04346 /* Line 1806 of yacc.c */ 04347 #line 1566 "../../src/gdb/c-exp.y" 04348 { (yyval.sval) = operator_stoken ("||"); } 04349 break; 04350 04351 case 242: 04352 04353 /* Line 1806 of yacc.c */ 04354 #line 1568 "../../src/gdb/c-exp.y" 04355 { (yyval.sval) = operator_stoken ("++"); } 04356 break; 04357 04358 case 243: 04359 04360 /* Line 1806 of yacc.c */ 04361 #line 1570 "../../src/gdb/c-exp.y" 04362 { (yyval.sval) = operator_stoken ("--"); } 04363 break; 04364 04365 case 244: 04366 04367 /* Line 1806 of yacc.c */ 04368 #line 1572 "../../src/gdb/c-exp.y" 04369 { (yyval.sval) = operator_stoken (","); } 04370 break; 04371 04372 case 245: 04373 04374 /* Line 1806 of yacc.c */ 04375 #line 1574 "../../src/gdb/c-exp.y" 04376 { (yyval.sval) = operator_stoken ("->*"); } 04377 break; 04378 04379 case 246: 04380 04381 /* Line 1806 of yacc.c */ 04382 #line 1576 "../../src/gdb/c-exp.y" 04383 { (yyval.sval) = operator_stoken ("->"); } 04384 break; 04385 04386 case 247: 04387 04388 /* Line 1806 of yacc.c */ 04389 #line 1578 "../../src/gdb/c-exp.y" 04390 { (yyval.sval) = operator_stoken ("()"); } 04391 break; 04392 04393 case 248: 04394 04395 /* Line 1806 of yacc.c */ 04396 #line 1580 "../../src/gdb/c-exp.y" 04397 { (yyval.sval) = operator_stoken ("[]"); } 04398 break; 04399 04400 case 249: 04401 04402 /* Line 1806 of yacc.c */ 04403 #line 1582 "../../src/gdb/c-exp.y" 04404 { (yyval.sval) = operator_stoken ("[]"); } 04405 break; 04406 04407 case 250: 04408 04409 /* Line 1806 of yacc.c */ 04410 #line 1584 "../../src/gdb/c-exp.y" 04411 { char *name; 04412 long length; 04413 struct ui_file *buf = mem_fileopen (); 04414 04415 c_print_type ((yyvsp[(2) - (2)].tval), NULL, buf, -1, 0, 04416 &type_print_raw_options); 04417 name = ui_file_xstrdup (buf, &length); 04418 ui_file_delete (buf); 04419 (yyval.sval) = operator_stoken (name); 04420 xfree (name); 04421 } 04422 break; 04423 04424 case 251: 04425 04426 /* Line 1806 of yacc.c */ 04427 #line 1599 "../../src/gdb/c-exp.y" 04428 { (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; } 04429 break; 04430 04431 case 252: 04432 04433 /* Line 1806 of yacc.c */ 04434 #line 1600 "../../src/gdb/c-exp.y" 04435 { (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; } 04436 break; 04437 04438 case 253: 04439 04440 /* Line 1806 of yacc.c */ 04441 #line 1601 "../../src/gdb/c-exp.y" 04442 { (yyval.sval) = (yyvsp[(1) - (1)].tsym).stoken; } 04443 break; 04444 04445 case 254: 04446 04447 /* Line 1806 of yacc.c */ 04448 #line 1602 "../../src/gdb/c-exp.y" 04449 { (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; } 04450 break; 04451 04452 case 255: 04453 04454 /* Line 1806 of yacc.c */ 04455 #line 1603 "../../src/gdb/c-exp.y" 04456 { (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; } 04457 break; 04458 04459 case 256: 04460 04461 /* Line 1806 of yacc.c */ 04462 #line 1604 "../../src/gdb/c-exp.y" 04463 { (yyval.sval) = (yyvsp[(1) - (1)].sval); } 04464 break; 04465 04466 case 259: 04467 04468 /* Line 1806 of yacc.c */ 04469 #line 1617 "../../src/gdb/c-exp.y" 04470 { 04471 struct field_of_this_result is_a_field_of_this; 04472 04473 (yyval.ssym).stoken = (yyvsp[(1) - (1)].sval); 04474 (yyval.ssym).sym = lookup_symbol ((yyvsp[(1) - (1)].sval).ptr, 04475 expression_context_block, 04476 VAR_DOMAIN, 04477 &is_a_field_of_this); 04478 (yyval.ssym).is_a_field_of_this 04479 = is_a_field_of_this.type != NULL; 04480 } 04481 break; 04482 04483 04484 04485 /* Line 1806 of yacc.c */ 04486 #line 4488 "c-exp.c" 04487 default: break; 04488 } 04489 /* User semantic actions sometimes alter yychar, and that requires 04490 that yytoken be updated with the new translation. We take the 04491 approach of translating immediately before every use of yytoken. 04492 One alternative is translating here after every semantic action, 04493 but that translation would be missed if the semantic action invokes 04494 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 04495 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 04496 incorrect destructor might then be invoked immediately. In the 04497 case of YYERROR or YYBACKUP, subsequent parser actions might lead 04498 to an incorrect destructor call or verbose syntax error message 04499 before the lookahead is translated. */ 04500 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 04501 04502 YYPOPSTACK (yylen); 04503 yylen = 0; 04504 YY_STACK_PRINT (yyss, yyssp); 04505 04506 *++yyvsp = yyval; 04507 04508 /* Now `shift' the result of the reduction. Determine what state 04509 that goes to, based on the state we popped back to and the rule 04510 number reduced by. */ 04511 04512 yyn = yyr1[yyn]; 04513 04514 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 04515 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 04516 yystate = yytable[yystate]; 04517 else 04518 yystate = yydefgoto[yyn - YYNTOKENS]; 04519 04520 goto yynewstate; 04521 04522 04523 /*------------------------------------. 04524 | yyerrlab -- here on detecting error | 04525 `------------------------------------*/ 04526 yyerrlab: 04527 /* Make sure we have latest lookahead translation. See comments at 04528 user semantic actions for why this is necessary. */ 04529 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 04530 04531 /* If not already recovering from an error, report this error. */ 04532 if (!yyerrstatus) 04533 { 04534 ++yynerrs; 04535 #if ! YYERROR_VERBOSE 04536 yyerror (YY_("syntax error")); 04537 #else 04538 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 04539 yyssp, yytoken) 04540 { 04541 char const *yymsgp = YY_("syntax error"); 04542 int yysyntax_error_status; 04543 yysyntax_error_status = YYSYNTAX_ERROR; 04544 if (yysyntax_error_status == 0) 04545 yymsgp = yymsg; 04546 else if (yysyntax_error_status == 1) 04547 { 04548 if (yymsg != yymsgbuf) 04549 YYSTACK_FREE (yymsg); 04550 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 04551 if (!yymsg) 04552 { 04553 yymsg = yymsgbuf; 04554 yymsg_alloc = sizeof yymsgbuf; 04555 yysyntax_error_status = 2; 04556 } 04557 else 04558 { 04559 yysyntax_error_status = YYSYNTAX_ERROR; 04560 yymsgp = yymsg; 04561 } 04562 } 04563 yyerror (yymsgp); 04564 if (yysyntax_error_status == 2) 04565 goto yyexhaustedlab; 04566 } 04567 # undef YYSYNTAX_ERROR 04568 #endif 04569 } 04570 04571 04572 04573 if (yyerrstatus == 3) 04574 { 04575 /* If just tried and failed to reuse lookahead token after an 04576 error, discard it. */ 04577 04578 if (yychar <= YYEOF) 04579 { 04580 /* Return failure if at end of input. */ 04581 if (yychar == YYEOF) 04582 YYABORT; 04583 } 04584 else 04585 { 04586 yydestruct ("Error: discarding", 04587 yytoken, &yylval); 04588 yychar = YYEMPTY; 04589 } 04590 } 04591 04592 /* Else will try to reuse lookahead token after shifting the error 04593 token. */ 04594 goto yyerrlab1; 04595 04596 04597 /*---------------------------------------------------. 04598 | yyerrorlab -- error raised explicitly by YYERROR. | 04599 `---------------------------------------------------*/ 04600 yyerrorlab: 04601 04602 /* Pacify compilers like GCC when the user code never invokes 04603 YYERROR and the label yyerrorlab therefore never appears in user 04604 code. */ 04605 if (/*CONSTCOND*/ 0) 04606 goto yyerrorlab; 04607 04608 /* Do not reclaim the symbols of the rule which action triggered 04609 this YYERROR. */ 04610 YYPOPSTACK (yylen); 04611 yylen = 0; 04612 YY_STACK_PRINT (yyss, yyssp); 04613 yystate = *yyssp; 04614 goto yyerrlab1; 04615 04616 04617 /*-------------------------------------------------------------. 04618 | yyerrlab1 -- common code for both syntax error and YYERROR. | 04619 `-------------------------------------------------------------*/ 04620 yyerrlab1: 04621 yyerrstatus = 3; /* Each real token shifted decrements this. */ 04622 04623 for (;;) 04624 { 04625 yyn = yypact[yystate]; 04626 if (!yypact_value_is_default (yyn)) 04627 { 04628 yyn += YYTERROR; 04629 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 04630 { 04631 yyn = yytable[yyn]; 04632 if (0 < yyn) 04633 break; 04634 } 04635 } 04636 04637 /* Pop the current state because it cannot handle the error token. */ 04638 if (yyssp == yyss) 04639 YYABORT; 04640 04641 04642 yydestruct ("Error: popping", 04643 yystos[yystate], yyvsp); 04644 YYPOPSTACK (1); 04645 yystate = *yyssp; 04646 YY_STACK_PRINT (yyss, yyssp); 04647 } 04648 04649 *++yyvsp = yylval; 04650 04651 04652 /* Shift the error token. */ 04653 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 04654 04655 yystate = yyn; 04656 goto yynewstate; 04657 04658 04659 /*-------------------------------------. 04660 | yyacceptlab -- YYACCEPT comes here. | 04661 `-------------------------------------*/ 04662 yyacceptlab: 04663 yyresult = 0; 04664 goto yyreturn; 04665 04666 /*-----------------------------------. 04667 | yyabortlab -- YYABORT comes here. | 04668 `-----------------------------------*/ 04669 yyabortlab: 04670 yyresult = 1; 04671 goto yyreturn; 04672 04673 #if !defined(yyoverflow) || YYERROR_VERBOSE 04674 /*-------------------------------------------------. 04675 | yyexhaustedlab -- memory exhaustion comes here. | 04676 `-------------------------------------------------*/ 04677 yyexhaustedlab: 04678 yyerror (YY_("memory exhausted")); 04679 yyresult = 2; 04680 /* Fall through. */ 04681 #endif 04682 04683 yyreturn: 04684 if (yychar != YYEMPTY) 04685 { 04686 /* Make sure we have latest lookahead translation. See comments at 04687 user semantic actions for why this is necessary. */ 04688 yytoken = YYTRANSLATE (yychar); 04689 yydestruct ("Cleanup: discarding lookahead", 04690 yytoken, &yylval); 04691 } 04692 /* Do not reclaim the symbols of the rule which action triggered 04693 this YYABORT or YYACCEPT. */ 04694 YYPOPSTACK (yylen); 04695 YY_STACK_PRINT (yyss, yyssp); 04696 while (yyssp != yyss) 04697 { 04698 yydestruct ("Cleanup: popping", 04699 yystos[*yyssp], yyvsp); 04700 YYPOPSTACK (1); 04701 } 04702 #ifndef yyoverflow 04703 if (yyss != yyssa) 04704 YYSTACK_FREE (yyss); 04705 #endif 04706 #if YYERROR_VERBOSE 04707 if (yymsg != yymsgbuf) 04708 YYSTACK_FREE (yymsg); 04709 #endif 04710 /* Make sure YYID is used. */ 04711 return YYID (yyresult); 04712 } 04713 04714 04715 04716 /* Line 2067 of yacc.c */ 04717 #line 1631 "../../src/gdb/c-exp.y" 04718 04719 04720 /* Like write_exp_string, but prepends a '~'. */ 04721 04722 static void 04723 write_destructor_name (struct stoken token) 04724 { 04725 char *copy = alloca (token.length + 1); 04726 04727 copy[0] = '~'; 04728 memcpy (©[1], token.ptr, token.length); 04729 04730 token.ptr = copy; 04731 ++token.length; 04732 04733 write_exp_string (token); 04734 } 04735 04736 /* Returns a stoken of the operator name given by OP (which does not 04737 include the string "operator"). */ 04738 static struct stoken 04739 operator_stoken (const char *op) 04740 { 04741 static const char *operator_string = "operator"; 04742 struct stoken st = { NULL, 0 }; 04743 char *buf; 04744 04745 st.length = strlen (operator_string) + strlen (op); 04746 buf = xmalloc (st.length + 1); 04747 strcpy (buf, operator_string); 04748 strcat (buf, op); 04749 st.ptr = buf; 04750 04751 /* The toplevel (c_parse) will free the memory allocated here. */ 04752 make_cleanup (xfree, buf); 04753 return st; 04754 }; 04755 04756 /* Validate a parameter typelist. */ 04757 04758 static void 04759 check_parameter_typelist (VEC (type_ptr) *params) 04760 { 04761 struct type *type; 04762 int ix; 04763 04764 for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix) 04765 { 04766 if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) 04767 { 04768 if (ix == 0) 04769 { 04770 if (VEC_length (type_ptr, params) == 1) 04771 { 04772 /* Ok. */ 04773 break; 04774 } 04775 VEC_free (type_ptr, params); 04776 error (_("parameter types following 'void'")); 04777 } 04778 else 04779 { 04780 VEC_free (type_ptr, params); 04781 error (_("'void' invalid as parameter type")); 04782 } 04783 } 04784 } 04785 } 04786 04787 /* Take care of parsing a number (anything that starts with a digit). 04788 Set yylval and return the token type; update lexptr. 04789 LEN is the number of characters in it. */ 04790 04791 /*** Needs some error checking for the float case ***/ 04792 04793 static int 04794 parse_number (const char *buf, int len, int parsed_float, YYSTYPE *putithere) 04795 { 04796 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values 04797 here, and we do kind of silly things like cast to unsigned. */ 04798 LONGEST n = 0; 04799 LONGEST prevn = 0; 04800 ULONGEST un; 04801 04802 int i = 0; 04803 int c; 04804 int base = input_radix; 04805 int unsigned_p = 0; 04806 04807 /* Number of "L" suffixes encountered. */ 04808 int long_p = 0; 04809 04810 /* We have found a "L" or "U" suffix. */ 04811 int found_suffix = 0; 04812 04813 ULONGEST high_bit; 04814 struct type *signed_type; 04815 struct type *unsigned_type; 04816 char *p; 04817 04818 p = alloca (len); 04819 memcpy (p, buf, len); 04820 04821 if (parsed_float) 04822 { 04823 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating 04824 point. Return DECFLOAT. */ 04825 04826 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f') 04827 { 04828 p[len - 2] = '\0'; 04829 putithere->typed_val_decfloat.type 04830 = parse_type->builtin_decfloat; 04831 decimal_from_string (putithere->typed_val_decfloat.val, 4, 04832 gdbarch_byte_order (parse_gdbarch), p); 04833 p[len - 2] = 'd'; 04834 return DECFLOAT; 04835 } 04836 04837 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd') 04838 { 04839 p[len - 2] = '\0'; 04840 putithere->typed_val_decfloat.type 04841 = parse_type->builtin_decdouble; 04842 decimal_from_string (putithere->typed_val_decfloat.val, 8, 04843 gdbarch_byte_order (parse_gdbarch), p); 04844 p[len - 2] = 'd'; 04845 return DECFLOAT; 04846 } 04847 04848 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l') 04849 { 04850 p[len - 2] = '\0'; 04851 putithere->typed_val_decfloat.type 04852 = parse_type->builtin_declong; 04853 decimal_from_string (putithere->typed_val_decfloat.val, 16, 04854 gdbarch_byte_order (parse_gdbarch), p); 04855 p[len - 2] = 'd'; 04856 return DECFLOAT; 04857 } 04858 04859 if (! parse_c_float (parse_gdbarch, p, len, 04860 &putithere->typed_val_float.dval, 04861 &putithere->typed_val_float.type)) 04862 return ERROR; 04863 return FLOAT; 04864 } 04865 04866 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ 04867 if (p[0] == '0') 04868 switch (p[1]) 04869 { 04870 case 'x': 04871 case 'X': 04872 if (len >= 3) 04873 { 04874 p += 2; 04875 base = 16; 04876 len -= 2; 04877 } 04878 break; 04879 04880 case 'b': 04881 case 'B': 04882 if (len >= 3) 04883 { 04884 p += 2; 04885 base = 2; 04886 len -= 2; 04887 } 04888 break; 04889 04890 case 't': 04891 case 'T': 04892 case 'd': 04893 case 'D': 04894 if (len >= 3) 04895 { 04896 p += 2; 04897 base = 10; 04898 len -= 2; 04899 } 04900 break; 04901 04902 default: 04903 base = 8; 04904 break; 04905 } 04906 04907 while (len-- > 0) 04908 { 04909 c = *p++; 04910 if (c >= 'A' && c <= 'Z') 04911 c += 'a' - 'A'; 04912 if (c != 'l' && c != 'u') 04913 n *= base; 04914 if (c >= '0' && c <= '9') 04915 { 04916 if (found_suffix) 04917 return ERROR; 04918 n += i = c - '0'; 04919 } 04920 else 04921 { 04922 if (base > 10 && c >= 'a' && c <= 'f') 04923 { 04924 if (found_suffix) 04925 return ERROR; 04926 n += i = c - 'a' + 10; 04927 } 04928 else if (c == 'l') 04929 { 04930 ++long_p; 04931 found_suffix = 1; 04932 } 04933 else if (c == 'u') 04934 { 04935 unsigned_p = 1; 04936 found_suffix = 1; 04937 } 04938 else 04939 return ERROR; /* Char not a digit */ 04940 } 04941 if (i >= base) 04942 return ERROR; /* Invalid digit in this base */ 04943 04944 /* Portably test for overflow (only works for nonzero values, so make 04945 a second check for zero). FIXME: Can't we just make n and prevn 04946 unsigned and avoid this? */ 04947 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0) 04948 unsigned_p = 1; /* Try something unsigned */ 04949 04950 /* Portably test for unsigned overflow. 04951 FIXME: This check is wrong; for example it doesn't find overflow 04952 on 0x123456789 when LONGEST is 32 bits. */ 04953 if (c != 'l' && c != 'u' && n != 0) 04954 { 04955 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n)) 04956 error (_("Numeric constant too large.")); 04957 } 04958 prevn = n; 04959 } 04960 04961 /* An integer constant is an int, a long, or a long long. An L 04962 suffix forces it to be long; an LL suffix forces it to be long 04963 long. If not forced to a larger size, it gets the first type of 04964 the above that it fits in. To figure out whether it fits, we 04965 shift it right and see whether anything remains. Note that we 04966 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one 04967 operation, because many compilers will warn about such a shift 04968 (which always produces a zero result). Sometimes gdbarch_int_bit 04969 or gdbarch_long_bit will be that big, sometimes not. To deal with 04970 the case where it is we just always shift the value more than 04971 once, with fewer bits each time. */ 04972 04973 un = (ULONGEST)n >> 2; 04974 if (long_p == 0 04975 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0) 04976 { 04977 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1); 04978 04979 /* A large decimal (not hex or octal) constant (between INT_MAX 04980 and UINT_MAX) is a long or unsigned long, according to ANSI, 04981 never an unsigned int, but this code treats it as unsigned 04982 int. This probably should be fixed. GCC gives a warning on 04983 such constants. */ 04984 04985 unsigned_type = parse_type->builtin_unsigned_int; 04986 signed_type = parse_type->builtin_int; 04987 } 04988 else if (long_p <= 1 04989 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0) 04990 { 04991 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1); 04992 unsigned_type = parse_type->builtin_unsigned_long; 04993 signed_type = parse_type->builtin_long; 04994 } 04995 else 04996 { 04997 int shift; 04998 if (sizeof (ULONGEST) * HOST_CHAR_BIT 04999 < gdbarch_long_long_bit (parse_gdbarch)) 05000 /* A long long does not fit in a LONGEST. */ 05001 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); 05002 else 05003 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1); 05004 high_bit = (ULONGEST) 1 << shift; 05005 unsigned_type = parse_type->builtin_unsigned_long_long; 05006 signed_type = parse_type->builtin_long_long; 05007 } 05008 05009 putithere->typed_val_int.val = n; 05010 05011 /* If the high bit of the worked out type is set then this number 05012 has to be unsigned. */ 05013 05014 if (unsigned_p || (n & high_bit)) 05015 { 05016 putithere->typed_val_int.type = unsigned_type; 05017 } 05018 else 05019 { 05020 putithere->typed_val_int.type = signed_type; 05021 } 05022 05023 return INT; 05024 } 05025 05026 /* Temporary obstack used for holding strings. */ 05027 static struct obstack tempbuf; 05028 static int tempbuf_init; 05029 05030 /* Parse a C escape sequence. The initial backslash of the sequence 05031 is at (*PTR)[-1]. *PTR will be updated to point to just after the 05032 last character of the sequence. If OUTPUT is not NULL, the 05033 translated form of the escape sequence will be written there. If 05034 OUTPUT is NULL, no output is written and the call will only affect 05035 *PTR. If an escape sequence is expressed in target bytes, then the 05036 entire sequence will simply be copied to OUTPUT. Return 1 if any 05037 character was emitted, 0 otherwise. */ 05038 05039 int 05040 c_parse_escape (const char **ptr, struct obstack *output) 05041 { 05042 const char *tokptr = *ptr; 05043 int result = 1; 05044 05045 /* Some escape sequences undergo character set conversion. Those we 05046 translate here. */ 05047 switch (*tokptr) 05048 { 05049 /* Hex escapes do not undergo character set conversion, so keep 05050 the escape sequence for later. */ 05051 case 'x': 05052 if (output) 05053 obstack_grow_str (output, "\\x"); 05054 ++tokptr; 05055 if (!isxdigit (*tokptr)) 05056 error (_("\\x escape without a following hex digit")); 05057 while (isxdigit (*tokptr)) 05058 { 05059 if (output) 05060 obstack_1grow (output, *tokptr); 05061 ++tokptr; 05062 } 05063 break; 05064 05065 /* Octal escapes do not undergo character set conversion, so 05066 keep the escape sequence for later. */ 05067 case '0': 05068 case '1': 05069 case '2': 05070 case '3': 05071 case '4': 05072 case '5': 05073 case '6': 05074 case '7': 05075 { 05076 int i; 05077 if (output) 05078 obstack_grow_str (output, "\\"); 05079 for (i = 0; 05080 i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9'; 05081 ++i) 05082 { 05083 if (output) 05084 obstack_1grow (output, *tokptr); 05085 ++tokptr; 05086 } 05087 } 05088 break; 05089 05090 /* We handle UCNs later. We could handle them here, but that 05091 would mean a spurious error in the case where the UCN could 05092 be converted to the target charset but not the host 05093 charset. */ 05094 case 'u': 05095 case 'U': 05096 { 05097 char c = *tokptr; 05098 int i, len = c == 'U' ? 8 : 4; 05099 if (output) 05100 { 05101 obstack_1grow (output, '\\'); 05102 obstack_1grow (output, *tokptr); 05103 } 05104 ++tokptr; 05105 if (!isxdigit (*tokptr)) 05106 error (_("\\%c escape without a following hex digit"), c); 05107 for (i = 0; i < len && isxdigit (*tokptr); ++i) 05108 { 05109 if (output) 05110 obstack_1grow (output, *tokptr); 05111 ++tokptr; 05112 } 05113 } 05114 break; 05115 05116 /* We must pass backslash through so that it does not 05117 cause quoting during the second expansion. */ 05118 case '\\': 05119 if (output) 05120 obstack_grow_str (output, "\\\\"); 05121 ++tokptr; 05122 break; 05123 05124 /* Escapes which undergo conversion. */ 05125 case 'a': 05126 if (output) 05127 obstack_1grow (output, '\a'); 05128 ++tokptr; 05129 break; 05130 case 'b': 05131 if (output) 05132 obstack_1grow (output, '\b'); 05133 ++tokptr; 05134 break; 05135 case 'f': 05136 if (output) 05137 obstack_1grow (output, '\f'); 05138 ++tokptr; 05139 break; 05140 case 'n': 05141 if (output) 05142 obstack_1grow (output, '\n'); 05143 ++tokptr; 05144 break; 05145 case 'r': 05146 if (output) 05147 obstack_1grow (output, '\r'); 05148 ++tokptr; 05149 break; 05150 case 't': 05151 if (output) 05152 obstack_1grow (output, '\t'); 05153 ++tokptr; 05154 break; 05155 case 'v': 05156 if (output) 05157 obstack_1grow (output, '\v'); 05158 ++tokptr; 05159 break; 05160 05161 /* GCC extension. */ 05162 case 'e': 05163 if (output) 05164 obstack_1grow (output, HOST_ESCAPE_CHAR); 05165 ++tokptr; 05166 break; 05167 05168 /* Backslash-newline expands to nothing at all. */ 05169 case '\n': 05170 ++tokptr; 05171 result = 0; 05172 break; 05173 05174 /* A few escapes just expand to the character itself. */ 05175 case '\'': 05176 case '\"': 05177 case '?': 05178 /* GCC extensions. */ 05179 case '(': 05180 case '{': 05181 case '[': 05182 case '%': 05183 /* Unrecognized escapes turn into the character itself. */ 05184 default: 05185 if (output) 05186 obstack_1grow (output, *tokptr); 05187 ++tokptr; 05188 break; 05189 } 05190 *ptr = tokptr; 05191 return result; 05192 } 05193 05194 /* Parse a string or character literal from TOKPTR. The string or 05195 character may be wide or unicode. *OUTPTR is set to just after the 05196 end of the literal in the input string. The resulting token is 05197 stored in VALUE. This returns a token value, either STRING or 05198 CHAR, depending on what was parsed. *HOST_CHARS is set to the 05199 number of host characters in the literal. */ 05200 static int 05201 parse_string_or_char (const char *tokptr, const char **outptr, 05202 struct typed_stoken *value, int *host_chars) 05203 { 05204 int quote; 05205 enum c_string_type type; 05206 int is_objc = 0; 05207 05208 /* Build the gdb internal form of the input string in tempbuf. Note 05209 that the buffer is null byte terminated *only* for the 05210 convenience of debugging gdb itself and printing the buffer 05211 contents when the buffer contains no embedded nulls. Gdb does 05212 not depend upon the buffer being null byte terminated, it uses 05213 the length string instead. This allows gdb to handle C strings 05214 (as well as strings in other languages) with embedded null 05215 bytes */ 05216 05217 if (!tempbuf_init) 05218 tempbuf_init = 1; 05219 else 05220 obstack_free (&tempbuf, NULL); 05221 obstack_init (&tempbuf); 05222 05223 /* Record the string type. */ 05224 if (*tokptr == 'L') 05225 { 05226 type = C_WIDE_STRING; 05227 ++tokptr; 05228 } 05229 else if (*tokptr == 'u') 05230 { 05231 type = C_STRING_16; 05232 ++tokptr; 05233 } 05234 else if (*tokptr == 'U') 05235 { 05236 type = C_STRING_32; 05237 ++tokptr; 05238 } 05239 else if (*tokptr == '@') 05240 { 05241 /* An Objective C string. */ 05242 is_objc = 1; 05243 type = C_STRING; 05244 ++tokptr; 05245 } 05246 else 05247 type = C_STRING; 05248 05249 /* Skip the quote. */ 05250 quote = *tokptr; 05251 if (quote == '\'') 05252 type |= C_CHAR; 05253 ++tokptr; 05254 05255 *host_chars = 0; 05256 05257 while (*tokptr) 05258 { 05259 char c = *tokptr; 05260 if (c == '\\') 05261 { 05262 ++tokptr; 05263 *host_chars += c_parse_escape (&tokptr, &tempbuf); 05264 } 05265 else if (c == quote) 05266 break; 05267 else 05268 { 05269 obstack_1grow (&tempbuf, c); 05270 ++tokptr; 05271 /* FIXME: this does the wrong thing with multi-byte host 05272 characters. We could use mbrlen here, but that would 05273 make "set host-charset" a bit less useful. */ 05274 ++*host_chars; 05275 } 05276 } 05277 05278 if (*tokptr != quote) 05279 { 05280 if (quote == '"') 05281 error (_("Unterminated string in expression.")); 05282 else 05283 error (_("Unmatched single quote.")); 05284 } 05285 ++tokptr; 05286 05287 value->type = type; 05288 value->ptr = obstack_base (&tempbuf); 05289 value->length = obstack_object_size (&tempbuf); 05290 05291 *outptr = tokptr; 05292 05293 return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR; 05294 } 05295 05296 /* This is used to associate some attributes with a token. */ 05297 05298 enum token_flags 05299 { 05300 /* If this bit is set, the token is C++-only. */ 05301 05302 FLAG_CXX = 1, 05303 05304 /* If this bit is set, the token is conditional: if there is a 05305 symbol of the same name, then the token is a symbol; otherwise, 05306 the token is a keyword. */ 05307 05308 FLAG_SHADOW = 2 05309 }; 05310 05311 struct token 05312 { 05313 char *operator; 05314 int token; 05315 enum exp_opcode opcode; 05316 enum token_flags flags; 05317 }; 05318 05319 static const struct token tokentab3[] = 05320 { 05321 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0}, 05322 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0}, 05323 {"->*", ARROW_STAR, BINOP_END, FLAG_CXX}, 05324 {"...", DOTDOTDOT, BINOP_END, 0} 05325 }; 05326 05327 static const struct token tokentab2[] = 05328 { 05329 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0}, 05330 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0}, 05331 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0}, 05332 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0}, 05333 {"%=", ASSIGN_MODIFY, BINOP_REM, 0}, 05334 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0}, 05335 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0}, 05336 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0}, 05337 {"++", INCREMENT, BINOP_END, 0}, 05338 {"--", DECREMENT, BINOP_END, 0}, 05339 {"->", ARROW, BINOP_END, 0}, 05340 {"&&", ANDAND, BINOP_END, 0}, 05341 {"||", OROR, BINOP_END, 0}, 05342 /* "::" is *not* only C++: gdb overrides its meaning in several 05343 different ways, e.g., 'filename'::func, function::variable. */ 05344 {"::", COLONCOLON, BINOP_END, 0}, 05345 {"<<", LSH, BINOP_END, 0}, 05346 {">>", RSH, BINOP_END, 0}, 05347 {"==", EQUAL, BINOP_END, 0}, 05348 {"!=", NOTEQUAL, BINOP_END, 0}, 05349 {"<=", LEQ, BINOP_END, 0}, 05350 {">=", GEQ, BINOP_END, 0}, 05351 {".*", DOT_STAR, BINOP_END, FLAG_CXX} 05352 }; 05353 05354 /* Identifier-like tokens. */ 05355 static const struct token ident_tokens[] = 05356 { 05357 {"unsigned", UNSIGNED, OP_NULL, 0}, 05358 {"template", TEMPLATE, OP_NULL, FLAG_CXX}, 05359 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0}, 05360 {"struct", STRUCT, OP_NULL, 0}, 05361 {"signed", SIGNED_KEYWORD, OP_NULL, 0}, 05362 {"sizeof", SIZEOF, OP_NULL, 0}, 05363 {"double", DOUBLE_KEYWORD, OP_NULL, 0}, 05364 {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX}, 05365 {"class", CLASS, OP_NULL, FLAG_CXX}, 05366 {"union", UNION, OP_NULL, 0}, 05367 {"short", SHORT, OP_NULL, 0}, 05368 {"const", CONST_KEYWORD, OP_NULL, 0}, 05369 {"enum", ENUM, OP_NULL, 0}, 05370 {"long", LONG, OP_NULL, 0}, 05371 {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX}, 05372 {"int", INT_KEYWORD, OP_NULL, 0}, 05373 {"new", NEW, OP_NULL, FLAG_CXX}, 05374 {"delete", DELETE, OP_NULL, FLAG_CXX}, 05375 {"operator", OPERATOR, OP_NULL, FLAG_CXX}, 05376 05377 {"and", ANDAND, BINOP_END, FLAG_CXX}, 05378 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX}, 05379 {"bitand", '&', OP_NULL, FLAG_CXX}, 05380 {"bitor", '|', OP_NULL, FLAG_CXX}, 05381 {"compl", '~', OP_NULL, FLAG_CXX}, 05382 {"not", '!', OP_NULL, FLAG_CXX}, 05383 {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX}, 05384 {"or", OROR, BINOP_END, FLAG_CXX}, 05385 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX}, 05386 {"xor", '^', OP_NULL, FLAG_CXX}, 05387 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX}, 05388 05389 {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX }, 05390 {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX }, 05391 {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX }, 05392 {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX }, 05393 05394 {"__typeof__", TYPEOF, OP_TYPEOF, 0 }, 05395 {"__typeof", TYPEOF, OP_TYPEOF, 0 }, 05396 {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW }, 05397 {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX }, 05398 {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW }, 05399 05400 {"typeid", TYPEID, OP_TYPEID, FLAG_CXX} 05401 }; 05402 05403 /* When we find that lexptr (the global var defined in parse.c) is 05404 pointing at a macro invocation, we expand the invocation, and call 05405 scan_macro_expansion to save the old lexptr here and point lexptr 05406 into the expanded text. When we reach the end of that, we call 05407 end_macro_expansion to pop back to the value we saved here. The 05408 macro expansion code promises to return only fully-expanded text, 05409 so we don't need to "push" more than one level. 05410 05411 This is disgusting, of course. It would be cleaner to do all macro 05412 expansion beforehand, and then hand that to lexptr. But we don't 05413 really know where the expression ends. Remember, in a command like 05414 05415 (gdb) break *ADDRESS if CONDITION 05416 05417 we evaluate ADDRESS in the scope of the current frame, but we 05418 evaluate CONDITION in the scope of the breakpoint's location. So 05419 it's simply wrong to try to macro-expand the whole thing at once. */ 05420 static const char *macro_original_text; 05421 05422 /* We save all intermediate macro expansions on this obstack for the 05423 duration of a single parse. The expansion text may sometimes have 05424 to live past the end of the expansion, due to yacc lookahead. 05425 Rather than try to be clever about saving the data for a single 05426 token, we simply keep it all and delete it after parsing has 05427 completed. */ 05428 static struct obstack expansion_obstack; 05429 05430 static void 05431 scan_macro_expansion (char *expansion) 05432 { 05433 char *copy; 05434 05435 /* We'd better not be trying to push the stack twice. */ 05436 gdb_assert (! macro_original_text); 05437 05438 /* Copy to the obstack, and then free the intermediate 05439 expansion. */ 05440 copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion)); 05441 xfree (expansion); 05442 05443 /* Save the old lexptr value, so we can return to it when we're done 05444 parsing the expanded text. */ 05445 macro_original_text = lexptr; 05446 lexptr = copy; 05447 } 05448 05449 05450 static int 05451 scanning_macro_expansion (void) 05452 { 05453 return macro_original_text != 0; 05454 } 05455 05456 05457 static void 05458 finished_macro_expansion (void) 05459 { 05460 /* There'd better be something to pop back to. */ 05461 gdb_assert (macro_original_text); 05462 05463 /* Pop back to the original text. */ 05464 lexptr = macro_original_text; 05465 macro_original_text = 0; 05466 } 05467 05468 05469 static void 05470 scan_macro_cleanup (void *dummy) 05471 { 05472 if (macro_original_text) 05473 finished_macro_expansion (); 05474 05475 obstack_free (&expansion_obstack, NULL); 05476 } 05477 05478 /* Return true iff the token represents a C++ cast operator. */ 05479 05480 static int 05481 is_cast_operator (const char *token, int len) 05482 { 05483 return (! strncmp (token, "dynamic_cast", len) 05484 || ! strncmp (token, "static_cast", len) 05485 || ! strncmp (token, "reinterpret_cast", len) 05486 || ! strncmp (token, "const_cast", len)); 05487 } 05488 05489 /* The scope used for macro expansion. */ 05490 static struct macro_scope *expression_macro_scope; 05491 05492 /* This is set if a NAME token appeared at the very end of the input 05493 string, with no whitespace separating the name from the EOF. This 05494 is used only when parsing to do field name completion. */ 05495 static int saw_name_at_eof; 05496 05497 /* This is set if the previously-returned token was a structure 05498 operator -- either '.' or ARROW. This is used only when parsing to 05499 do field name completion. */ 05500 static int last_was_structop; 05501 05502 /* Read one token, getting characters through lexptr. */ 05503 05504 static int 05505 lex_one_token (void) 05506 { 05507 int c; 05508 int namelen; 05509 unsigned int i; 05510 const char *tokstart; 05511 int saw_structop = last_was_structop; 05512 char *copy; 05513 05514 last_was_structop = 0; 05515 05516 retry: 05517 05518 /* Check if this is a macro invocation that we need to expand. */ 05519 if (! scanning_macro_expansion ()) 05520 { 05521 char *expanded = macro_expand_next (&lexptr, 05522 standard_macro_lookup, 05523 expression_macro_scope); 05524 05525 if (expanded) 05526 scan_macro_expansion (expanded); 05527 } 05528 05529 prev_lexptr = lexptr; 05530 05531 tokstart = lexptr; 05532 /* See if it is a special token of length 3. */ 05533 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) 05534 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0) 05535 { 05536 if ((tokentab3[i].flags & FLAG_CXX) != 0 05537 && parse_language->la_language != language_cplus) 05538 break; 05539 05540 lexptr += 3; 05541 yylval.opcode = tokentab3[i].opcode; 05542 return tokentab3[i].token; 05543 } 05544 05545 /* See if it is a special token of length 2. */ 05546 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) 05547 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0) 05548 { 05549 if ((tokentab2[i].flags & FLAG_CXX) != 0 05550 && parse_language->la_language != language_cplus) 05551 break; 05552 05553 lexptr += 2; 05554 yylval.opcode = tokentab2[i].opcode; 05555 if (parse_completion && tokentab2[i].token == ARROW) 05556 last_was_structop = 1; 05557 return tokentab2[i].token; 05558 } 05559 05560 switch (c = *tokstart) 05561 { 05562 case 0: 05563 /* If we were just scanning the result of a macro expansion, 05564 then we need to resume scanning the original text. 05565 If we're parsing for field name completion, and the previous 05566 token allows such completion, return a COMPLETE token. 05567 Otherwise, we were already scanning the original text, and 05568 we're really done. */ 05569 if (scanning_macro_expansion ()) 05570 { 05571 finished_macro_expansion (); 05572 goto retry; 05573 } 05574 else if (saw_name_at_eof) 05575 { 05576 saw_name_at_eof = 0; 05577 return COMPLETE; 05578 } 05579 else if (saw_structop) 05580 return COMPLETE; 05581 else 05582 return 0; 05583 05584 case ' ': 05585 case '\t': 05586 case '\n': 05587 lexptr++; 05588 goto retry; 05589 05590 case '[': 05591 case '(': 05592 paren_depth++; 05593 lexptr++; 05594 if (parse_language->la_language == language_objc && c == '[') 05595 return OBJC_LBRAC; 05596 return c; 05597 05598 case ']': 05599 case ')': 05600 if (paren_depth == 0) 05601 return 0; 05602 paren_depth--; 05603 lexptr++; 05604 return c; 05605 05606 case ',': 05607 if (comma_terminates 05608 && paren_depth == 0 05609 && ! scanning_macro_expansion ()) 05610 return 0; 05611 lexptr++; 05612 return c; 05613 05614 case '.': 05615 /* Might be a floating point number. */ 05616 if (lexptr[1] < '0' || lexptr[1] > '9') 05617 { 05618 if (parse_completion) 05619 last_was_structop = 1; 05620 goto symbol; /* Nope, must be a symbol. */ 05621 } 05622 /* FALL THRU into number case. */ 05623 05624 case '0': 05625 case '1': 05626 case '2': 05627 case '3': 05628 case '4': 05629 case '5': 05630 case '6': 05631 case '7': 05632 case '8': 05633 case '9': 05634 { 05635 /* It's a number. */ 05636 int got_dot = 0, got_e = 0, toktype; 05637 const char *p = tokstart; 05638 int hex = input_radix > 10; 05639 05640 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 05641 { 05642 p += 2; 05643 hex = 1; 05644 } 05645 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) 05646 { 05647 p += 2; 05648 hex = 0; 05649 } 05650 05651 for (;; ++p) 05652 { 05653 /* This test includes !hex because 'e' is a valid hex digit 05654 and thus does not indicate a floating point number when 05655 the radix is hex. */ 05656 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 05657 got_dot = got_e = 1; 05658 /* This test does not include !hex, because a '.' always indicates 05659 a decimal floating point number regardless of the radix. */ 05660 else if (!got_dot && *p == '.') 05661 got_dot = 1; 05662 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 05663 && (*p == '-' || *p == '+')) 05664 /* This is the sign of the exponent, not the end of the 05665 number. */ 05666 continue; 05667 /* We will take any letters or digits. parse_number will 05668 complain if past the radix, or if L or U are not final. */ 05669 else if ((*p < '0' || *p > '9') 05670 && ((*p < 'a' || *p > 'z') 05671 && (*p < 'A' || *p > 'Z'))) 05672 break; 05673 } 05674 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); 05675 if (toktype == ERROR) 05676 { 05677 char *err_copy = (char *) alloca (p - tokstart + 1); 05678 05679 memcpy (err_copy, tokstart, p - tokstart); 05680 err_copy[p - tokstart] = 0; 05681 error (_("Invalid number \"%s\"."), err_copy); 05682 } 05683 lexptr = p; 05684 return toktype; 05685 } 05686 05687 case '@': 05688 { 05689 const char *p = &tokstart[1]; 05690 size_t len = strlen ("entry"); 05691 05692 if (parse_language->la_language == language_objc) 05693 { 05694 size_t len = strlen ("selector"); 05695 05696 if (strncmp (p, "selector", len) == 0 05697 && (p[len] == '\0' || isspace (p[len]))) 05698 { 05699 lexptr = p + len; 05700 return SELECTOR; 05701 } 05702 else if (*p == '"') 05703 goto parse_string; 05704 } 05705 05706 while (isspace (*p)) 05707 p++; 05708 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len]) 05709 && p[len] != '_') 05710 { 05711 lexptr = &p[len]; 05712 return ENTRY; 05713 } 05714 } 05715 /* FALLTHRU */ 05716 case '+': 05717 case '-': 05718 case '*': 05719 case '/': 05720 case '%': 05721 case '|': 05722 case '&': 05723 case '^': 05724 case '~': 05725 case '!': 05726 case '<': 05727 case '>': 05728 case '?': 05729 case ':': 05730 case '=': 05731 case '{': 05732 case '}': 05733 symbol: 05734 lexptr++; 05735 return c; 05736 05737 case 'L': 05738 case 'u': 05739 case 'U': 05740 if (tokstart[1] != '"' && tokstart[1] != '\'') 05741 break; 05742 /* Fall through. */ 05743 case '\'': 05744 case '"': 05745 05746 parse_string: 05747 { 05748 int host_len; 05749 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval, 05750 &host_len); 05751 if (result == CHAR) 05752 { 05753 if (host_len == 0) 05754 error (_("Empty character constant.")); 05755 else if (host_len > 2 && c == '\'') 05756 { 05757 ++tokstart; 05758 namelen = lexptr - tokstart - 1; 05759 goto tryname; 05760 } 05761 else if (host_len > 1) 05762 error (_("Invalid character constant.")); 05763 } 05764 return result; 05765 } 05766 } 05767 05768 if (!(c == '_' || c == '$' 05769 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 05770 /* We must have come across a bad character (e.g. ';'). */ 05771 error (_("Invalid character '%c' in expression."), c); 05772 05773 /* It's a name. See how long it is. */ 05774 namelen = 0; 05775 for (c = tokstart[namelen]; 05776 (c == '_' || c == '$' || (c >= '0' && c <= '9') 05777 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');) 05778 { 05779 /* Template parameter lists are part of the name. 05780 FIXME: This mishandles `print $a<4&&$a>3'. */ 05781 05782 if (c == '<') 05783 { 05784 if (! is_cast_operator (tokstart, namelen)) 05785 { 05786 /* Scan ahead to get rest of the template specification. Note 05787 that we look ahead only when the '<' adjoins non-whitespace 05788 characters; for comparison expressions, e.g. "a < b > c", 05789 there must be spaces before the '<', etc. */ 05790 05791 const char *p = find_template_name_end (tokstart + namelen); 05792 05793 if (p) 05794 namelen = p - tokstart; 05795 } 05796 break; 05797 } 05798 c = tokstart[++namelen]; 05799 } 05800 05801 /* The token "if" terminates the expression and is NOT removed from 05802 the input stream. It doesn't count if it appears in the 05803 expansion of a macro. */ 05804 if (namelen == 2 05805 && tokstart[0] == 'i' 05806 && tokstart[1] == 'f' 05807 && ! scanning_macro_expansion ()) 05808 { 05809 return 0; 05810 } 05811 05812 /* For the same reason (breakpoint conditions), "thread N" 05813 terminates the expression. "thread" could be an identifier, but 05814 an identifier is never followed by a number without intervening 05815 punctuation. "task" is similar. Handle abbreviations of these, 05816 similarly to breakpoint.c:find_condition_and_thread. */ 05817 if (namelen >= 1 05818 && (strncmp (tokstart, "thread", namelen) == 0 05819 || strncmp (tokstart, "task", namelen) == 0) 05820 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t') 05821 && ! scanning_macro_expansion ()) 05822 { 05823 const char *p = tokstart + namelen + 1; 05824 05825 while (*p == ' ' || *p == '\t') 05826 p++; 05827 if (*p >= '0' && *p <= '9') 05828 return 0; 05829 } 05830 05831 lexptr += namelen; 05832 05833 tryname: 05834 05835 yylval.sval.ptr = tokstart; 05836 yylval.sval.length = namelen; 05837 05838 /* Catch specific keywords. */ 05839 copy = copy_name (yylval.sval); 05840 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++) 05841 if (strcmp (copy, ident_tokens[i].operator) == 0) 05842 { 05843 if ((ident_tokens[i].flags & FLAG_CXX) != 0 05844 && parse_language->la_language != language_cplus) 05845 break; 05846 05847 if ((ident_tokens[i].flags & FLAG_SHADOW) != 0) 05848 { 05849 struct field_of_this_result is_a_field_of_this; 05850 05851 if (lookup_symbol (copy, expression_context_block, 05852 VAR_DOMAIN, 05853 (parse_language->la_language == language_cplus 05854 ? &is_a_field_of_this 05855 : NULL)) 05856 != NULL) 05857 { 05858 /* The keyword is shadowed. */ 05859 break; 05860 } 05861 } 05862 05863 /* It is ok to always set this, even though we don't always 05864 strictly need to. */ 05865 yylval.opcode = ident_tokens[i].opcode; 05866 return ident_tokens[i].token; 05867 } 05868 05869 if (*tokstart == '$') 05870 return VARIABLE; 05871 05872 if (parse_completion && *lexptr == '\0') 05873 saw_name_at_eof = 1; 05874 05875 yylval.ssym.stoken = yylval.sval; 05876 yylval.ssym.sym = NULL; 05877 yylval.ssym.is_a_field_of_this = 0; 05878 return NAME; 05879 } 05880 05881 /* An object of this type is pushed on a FIFO by the "outer" lexer. */ 05882 typedef struct 05883 { 05884 int token; 05885 YYSTYPE value; 05886 } token_and_value; 05887 05888 DEF_VEC_O (token_and_value); 05889 05890 /* A FIFO of tokens that have been read but not yet returned to the 05891 parser. */ 05892 static VEC (token_and_value) *token_fifo; 05893 05894 /* Non-zero if the lexer should return tokens from the FIFO. */ 05895 static int popping; 05896 05897 /* Temporary storage for c_lex; this holds symbol names as they are 05898 built up. */ 05899 static struct obstack name_obstack; 05900 05901 /* Classify a NAME token. The contents of the token are in `yylval'. 05902 Updates yylval and returns the new token type. BLOCK is the block 05903 in which lookups start; this can be NULL to mean the global 05904 scope. */ 05905 static int 05906 classify_name (const struct block *block) 05907 { 05908 struct symbol *sym; 05909 char *copy; 05910 struct field_of_this_result is_a_field_of_this; 05911 05912 copy = copy_name (yylval.sval); 05913 05914 /* Initialize this in case we *don't* use it in this call; that way 05915 we can refer to it unconditionally below. */ 05916 memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this)); 05917 05918 sym = lookup_symbol (copy, block, VAR_DOMAIN, 05919 parse_language->la_name_of_this 05920 ? &is_a_field_of_this : NULL); 05921 05922 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 05923 { 05924 yylval.ssym.sym = sym; 05925 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 05926 return BLOCKNAME; 05927 } 05928 else if (!sym) 05929 { 05930 /* See if it's a file name. */ 05931 struct symtab *symtab; 05932 05933 symtab = lookup_symtab (copy); 05934 if (symtab) 05935 { 05936 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); 05937 return FILENAME; 05938 } 05939 05940 /* If we found a field of 'this', we might have erroneously 05941 found a constructor where we wanted a type name. Handle this 05942 case by noticing that we found a constructor and then look up 05943 the type tag instead. */ 05944 if (is_a_field_of_this.type != NULL 05945 && is_a_field_of_this.fn_field != NULL 05946 && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields, 05947 0)) 05948 { 05949 struct field_of_this_result inner_is_a_field_of_this; 05950 05951 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, 05952 &inner_is_a_field_of_this); 05953 if (sym != NULL) 05954 { 05955 yylval.tsym.type = SYMBOL_TYPE (sym); 05956 return TYPENAME; 05957 } 05958 } 05959 } 05960 05961 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF) 05962 { 05963 yylval.tsym.type = SYMBOL_TYPE (sym); 05964 return TYPENAME; 05965 } 05966 05967 yylval.tsym.type 05968 = language_lookup_primitive_type_by_name (parse_language, 05969 parse_gdbarch, copy); 05970 if (yylval.tsym.type != NULL) 05971 return TYPENAME; 05972 05973 /* See if it's an ObjC classname. */ 05974 if (parse_language->la_language == language_objc && !sym) 05975 { 05976 CORE_ADDR Class = lookup_objc_class (parse_gdbarch, copy); 05977 if (Class) 05978 { 05979 yylval.class.class = Class; 05980 sym = lookup_struct_typedef (copy, expression_context_block, 1); 05981 if (sym) 05982 yylval.class.type = SYMBOL_TYPE (sym); 05983 return CLASSNAME; 05984 } 05985 } 05986 05987 /* Input names that aren't symbols but ARE valid hex numbers, when 05988 the input radix permits them, can be names or numbers depending 05989 on the parse. Note we support radixes > 16 here. */ 05990 if (!sym 05991 && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10) 05992 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10))) 05993 { 05994 YYSTYPE newlval; /* Its value is ignored. */ 05995 int hextype = parse_number (copy, yylval.sval.length, 0, &newlval); 05996 if (hextype == INT) 05997 { 05998 yylval.ssym.sym = sym; 05999 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 06000 return NAME_OR_INT; 06001 } 06002 } 06003 06004 /* Any other kind of symbol */ 06005 yylval.ssym.sym = sym; 06006 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 06007 06008 if (sym == NULL 06009 && parse_language->la_language == language_cplus 06010 && is_a_field_of_this.type == NULL 06011 && !lookup_minimal_symbol (copy, NULL, NULL)) 06012 return UNKNOWN_CPP_NAME; 06013 06014 return NAME; 06015 } 06016 06017 /* Like classify_name, but used by the inner loop of the lexer, when a 06018 name might have already been seen. CONTEXT is the context type, or 06019 NULL if this is the first component of a name. */ 06020 06021 static int 06022 classify_inner_name (const struct block *block, struct type *context) 06023 { 06024 struct type *type; 06025 char *copy; 06026 06027 if (context == NULL) 06028 return classify_name (block); 06029 06030 type = check_typedef (context); 06031 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 06032 && TYPE_CODE (type) != TYPE_CODE_UNION 06033 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE) 06034 return ERROR; 06035 06036 copy = copy_name (yylval.ssym.stoken); 06037 yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block); 06038 if (yylval.ssym.sym == NULL) 06039 return ERROR; 06040 06041 switch (SYMBOL_CLASS (yylval.ssym.sym)) 06042 { 06043 case LOC_BLOCK: 06044 case LOC_LABEL: 06045 return ERROR; 06046 06047 case LOC_TYPEDEF: 06048 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);; 06049 return TYPENAME; 06050 06051 default: 06052 return NAME; 06053 } 06054 internal_error (__FILE__, __LINE__, _("not reached")); 06055 } 06056 06057 /* The outer level of a two-level lexer. This calls the inner lexer 06058 to return tokens. It then either returns these tokens, or 06059 aggregates them into a larger token. This lets us work around a 06060 problem in our parsing approach, where the parser could not 06061 distinguish between qualified names and qualified types at the 06062 right point. 06063 06064 This approach is still not ideal, because it mishandles template 06065 types. See the comment in lex_one_token for an example. However, 06066 this is still an improvement over the earlier approach, and will 06067 suffice until we move to better parsing technology. */ 06068 static int 06069 yylex (void) 06070 { 06071 token_and_value current; 06072 int first_was_coloncolon, last_was_coloncolon; 06073 struct type *context_type = NULL; 06074 int last_to_examine, next_to_examine, checkpoint; 06075 const struct block *search_block; 06076 06077 if (popping && !VEC_empty (token_and_value, token_fifo)) 06078 goto do_pop; 06079 popping = 0; 06080 06081 /* Read the first token and decide what to do. Most of the 06082 subsequent code is C++-only; but also depends on seeing a "::" or 06083 name-like token. */ 06084 current.token = lex_one_token (); 06085 if (current.token == NAME) 06086 current.token = classify_name (expression_context_block); 06087 if (parse_language->la_language != language_cplus 06088 || (current.token != TYPENAME && current.token != COLONCOLON 06089 && current.token != FILENAME)) 06090 return current.token; 06091 06092 /* Read any sequence of alternating "::" and name-like tokens into 06093 the token FIFO. */ 06094 current.value = yylval; 06095 VEC_safe_push (token_and_value, token_fifo, ¤t); 06096 last_was_coloncolon = current.token == COLONCOLON; 06097 while (1) 06098 { 06099 current.token = lex_one_token (); 06100 current.value = yylval; 06101 VEC_safe_push (token_and_value, token_fifo, ¤t); 06102 06103 if ((last_was_coloncolon && current.token != NAME) 06104 || (!last_was_coloncolon && current.token != COLONCOLON)) 06105 break; 06106 last_was_coloncolon = !last_was_coloncolon; 06107 } 06108 popping = 1; 06109 06110 /* We always read one extra token, so compute the number of tokens 06111 to examine accordingly. */ 06112 last_to_examine = VEC_length (token_and_value, token_fifo) - 2; 06113 next_to_examine = 0; 06114 06115 current = *VEC_index (token_and_value, token_fifo, next_to_examine); 06116 ++next_to_examine; 06117 06118 obstack_free (&name_obstack, obstack_base (&name_obstack)); 06119 checkpoint = 0; 06120 if (current.token == FILENAME) 06121 search_block = current.value.bval; 06122 else if (current.token == COLONCOLON) 06123 search_block = NULL; 06124 else 06125 { 06126 gdb_assert (current.token == TYPENAME); 06127 search_block = expression_context_block; 06128 obstack_grow (&name_obstack, current.value.sval.ptr, 06129 current.value.sval.length); 06130 context_type = current.value.tsym.type; 06131 checkpoint = 1; 06132 } 06133 06134 first_was_coloncolon = current.token == COLONCOLON; 06135 last_was_coloncolon = first_was_coloncolon; 06136 06137 while (next_to_examine <= last_to_examine) 06138 { 06139 token_and_value *next; 06140 06141 next = VEC_index (token_and_value, token_fifo, next_to_examine); 06142 ++next_to_examine; 06143 06144 if (next->token == NAME && last_was_coloncolon) 06145 { 06146 int classification; 06147 06148 yylval = next->value; 06149 classification = classify_inner_name (search_block, context_type); 06150 /* We keep going until we either run out of names, or until 06151 we have a qualified name which is not a type. */ 06152 if (classification != TYPENAME && classification != NAME) 06153 break; 06154 06155 /* Accept up to this token. */ 06156 checkpoint = next_to_examine; 06157 06158 /* Update the partial name we are constructing. */ 06159 if (context_type != NULL) 06160 { 06161 /* We don't want to put a leading "::" into the name. */ 06162 obstack_grow_str (&name_obstack, "::"); 06163 } 06164 obstack_grow (&name_obstack, next->value.sval.ptr, 06165 next->value.sval.length); 06166 06167 yylval.sval.ptr = obstack_base (&name_obstack); 06168 yylval.sval.length = obstack_object_size (&name_obstack); 06169 current.value = yylval; 06170 current.token = classification; 06171 06172 last_was_coloncolon = 0; 06173 06174 if (classification == NAME) 06175 break; 06176 06177 context_type = yylval.tsym.type; 06178 } 06179 else if (next->token == COLONCOLON && !last_was_coloncolon) 06180 last_was_coloncolon = 1; 06181 else 06182 { 06183 /* We've reached the end of the name. */ 06184 break; 06185 } 06186 } 06187 06188 /* If we have a replacement token, install it as the first token in 06189 the FIFO, and delete the other constituent tokens. */ 06190 if (checkpoint > 0) 06191 { 06192 current.value.sval.ptr = obstack_copy0 (&expansion_obstack, 06193 current.value.sval.ptr, 06194 current.value.sval.length); 06195 06196 VEC_replace (token_and_value, token_fifo, 0, ¤t); 06197 if (checkpoint > 1) 06198 VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1); 06199 } 06200 06201 do_pop: 06202 current = *VEC_index (token_and_value, token_fifo, 0); 06203 VEC_ordered_remove (token_and_value, token_fifo, 0); 06204 yylval = current.value; 06205 return current.token; 06206 } 06207 06208 int 06209 c_parse (void) 06210 { 06211 int result; 06212 struct cleanup *back_to = make_cleanup (free_current_contents, 06213 &expression_macro_scope); 06214 06215 /* Set up the scope for macro expansion. */ 06216 expression_macro_scope = NULL; 06217 06218 if (expression_context_block) 06219 expression_macro_scope 06220 = sal_macro_scope (find_pc_line (expression_context_pc, 0)); 06221 else 06222 expression_macro_scope = default_macro_scope (); 06223 if (! expression_macro_scope) 06224 expression_macro_scope = user_macro_scope (); 06225 06226 /* Initialize macro expansion code. */ 06227 obstack_init (&expansion_obstack); 06228 gdb_assert (! macro_original_text); 06229 make_cleanup (scan_macro_cleanup, 0); 06230 06231 make_cleanup_restore_integer (&yydebug); 06232 yydebug = parser_debug; 06233 06234 /* Initialize some state used by the lexer. */ 06235 last_was_structop = 0; 06236 saw_name_at_eof = 0; 06237 06238 VEC_free (token_and_value, token_fifo); 06239 popping = 0; 06240 obstack_init (&name_obstack); 06241 make_cleanup_obstack_free (&name_obstack); 06242 06243 result = yyparse (); 06244 do_cleanups (back_to); 06245 return result; 06246 } 06247 06248 /* This is called via the YYPRINT macro when parser debugging is 06249 enabled. It prints a token's value. */ 06250 06251 static void 06252 c_print_token (FILE *file, int type, YYSTYPE value) 06253 { 06254 switch (type) 06255 { 06256 case INT: 06257 fprintf (file, "typed_val_int<%s, %s>", 06258 TYPE_SAFE_NAME (value.typed_val_int.type), 06259 pulongest (value.typed_val_int.val)); 06260 break; 06261 06262 case CHAR: 06263 case STRING: 06264 { 06265 char *copy = alloca (value.tsval.length + 1); 06266 06267 memcpy (copy, value.tsval.ptr, value.tsval.length); 06268 copy[value.tsval.length] = '\0'; 06269 06270 fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy); 06271 } 06272 break; 06273 06274 case NSSTRING: 06275 case VARIABLE: 06276 fprintf (file, "sval<%s>", copy_name (value.sval)); 06277 break; 06278 06279 case TYPENAME: 06280 fprintf (file, "tsym<type=%s, name=%s>", 06281 TYPE_SAFE_NAME (value.tsym.type), 06282 copy_name (value.tsym.stoken)); 06283 break; 06284 06285 case NAME: 06286 case UNKNOWN_CPP_NAME: 06287 case NAME_OR_INT: 06288 case BLOCKNAME: 06289 fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>", 06290 copy_name (value.ssym.stoken), 06291 (value.ssym.sym == NULL 06292 ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym)), 06293 value.ssym.is_a_field_of_this); 06294 break; 06295 06296 case FILENAME: 06297 fprintf (file, "bval<%s>", host_address_to_string (value.bval)); 06298 break; 06299 } 06300 } 06301 06302 void 06303 yyerror (char *msg) 06304 { 06305 if (prev_lexptr) 06306 lexptr = prev_lexptr; 06307 06308 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); 06309 } 06310
1.7.6.1
