1/* A Bison parser, made by GNU Bison 1.875c. */ 2 3/* Skeleton parser for Yacc-like parsing with Bison, 4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, 19 Boston, MA 02111-1307, USA. */ 20 21/* As a special exception, when this file is copied by Bison into a 22 Bison output file, you may use that output file without restriction. 23 This special exception was added by the Free Software Foundation 24 in version 1.24 of Bison. */ 25 26/* Written by Richard Stallman by simplifying the original so called 27 ``semantic'' parser. */ 28 29/* All symbols defined below should begin with yy or YY, to avoid 30 infringing on user name space. This should be done even for local 31 variables, as they might otherwise be expanded by user macros. 32 There are some unavoidable exceptions within include files to 33 define necessary library symbols; they are noted "INFRINGES ON 34 USER NAME SPACE" below. */ 35 36/* Identify Bison output. */ 37#define YYBISON 1 38 39/* Skeleton name. */ 40#define YYSKELETON_NAME "yacc.c" 41 42/* Pure parsers. */ 43#define YYPURE 0 44 45/* Using locations. */ 46#define YYLSP_NEEDED 0 47 48 49 50/* Tokens. */ 51#ifndef YYTOKENTYPE 52# define YYTOKENTYPE 53 /* Put the tokens into the symbol table, so that GDB and other debuggers 54 know about them. */ 55 enum yytokentype { 56 INT = 258, 57 FLOAT = 259, 58 NAME = 260, 59 STRUCT = 261, 60 CLASS = 262, 61 UNION = 263, 62 ENUM = 264, 63 SIZEOF = 265, 64 UNSIGNED = 266, 65 COLONCOLON = 267, 66 TEMPLATE = 268, 67 ERROR = 269, 68 NEW = 270, 69 DELETE = 271, 70 OPERATOR = 272, 71 STATIC_CAST = 273, 72 REINTERPRET_CAST = 274, 73 DYNAMIC_CAST = 275, 74 SIGNED_KEYWORD = 276, 75 LONG = 277, 76 SHORT = 278, 77 INT_KEYWORD = 279, 78 CONST_KEYWORD = 280, 79 VOLATILE_KEYWORD = 281, 80 DOUBLE_KEYWORD = 282, 81 BOOL = 283, 82 ELLIPSIS = 284, 83 RESTRICT = 285, 84 VOID = 286, 85 FLOAT_KEYWORD = 287, 86 CHAR = 288, 87 WCHAR_T = 289, 88 ASSIGN_MODIFY = 290, 89 TRUEKEYWORD = 291, 90 FALSEKEYWORD = 292, 91 DEMANGLER_SPECIAL = 293, 92 CONSTRUCTION_VTABLE = 294, 93 CONSTRUCTION_IN = 295, 94 GLOBAL = 296, 95 OROR = 297, 96 ANDAND = 298, 97 NOTEQUAL = 299, 98 EQUAL = 300, 99 GEQ = 301, 100 LEQ = 302, 101 RSH = 303, 102 LSH = 304, 103 DECREMENT = 305, 104 INCREMENT = 306, 105 UNARY = 307, 106 ARROW = 308 107 }; 108#endif 109#define INT 258 110#define FLOAT 259 111#define NAME 260 112#define STRUCT 261 113#define CLASS 262 114#define UNION 263 115#define ENUM 264 116#define SIZEOF 265 117#define UNSIGNED 266 118#define COLONCOLON 267 119#define TEMPLATE 268 120#define ERROR 269 121#define NEW 270 122#define DELETE 271 123#define OPERATOR 272 124#define STATIC_CAST 273 125#define REINTERPRET_CAST 274 126#define DYNAMIC_CAST 275 127#define SIGNED_KEYWORD 276 128#define LONG 277 129#define SHORT 278 130#define INT_KEYWORD 279 131#define CONST_KEYWORD 280 132#define VOLATILE_KEYWORD 281 133#define DOUBLE_KEYWORD 282 134#define BOOL 283 135#define ELLIPSIS 284 136#define RESTRICT 285 137#define VOID 286 138#define FLOAT_KEYWORD 287 139#define CHAR 288 140#define WCHAR_T 289 141#define ASSIGN_MODIFY 290 142#define TRUEKEYWORD 291 143#define FALSEKEYWORD 292 144#define DEMANGLER_SPECIAL 293 145#define CONSTRUCTION_VTABLE 294 146#define CONSTRUCTION_IN 295 147#define GLOBAL 296 148#define OROR 297 149#define ANDAND 298 150#define NOTEQUAL 299 151#define EQUAL 300 152#define GEQ 301 153#define LEQ 302 154#define RSH 303 155#define LSH 304 156#define DECREMENT 305 157#define INCREMENT 306 158#define UNARY 307 159#define ARROW 308 160 161 162 163 164/* Copy the first part of user declarations. */ 165#line 32 "cp-name-parser.y" 166 167 168#include <stdio.h> 169#include <stdlib.h> 170#include <unistd.h> 171#include <string.h> 172 173#include "safe-ctype.h" 174#include "libiberty.h" 175#include "demangle.h" 176 177/* Bison does not make it easy to create a parser without global 178 state, unfortunately. Here are all the global variables used 179 in this parser. */ 180 181/* LEXPTR is the current pointer into our lex buffer. PREV_LEXPTR 182 is the start of the last token lexed, only used for diagnostics. 183 ERROR_LEXPTR is the first place an error occurred. GLOBAL_ERRMSG 184 is the first error message encountered. */ 185 186static const char *lexptr, *prev_lexptr, *error_lexptr, *global_errmsg; 187 188/* The components built by the parser are allocated ahead of time, 189 and cached in this structure. */ 190 191struct demangle_info { 192 int used; 193 struct demangle_component comps[1]; 194}; 195 196static struct demangle_info *demangle_info; 197#define d_grab() (&demangle_info->comps[demangle_info->used++]) 198 199/* The parse tree created by the parser is stored here after a successful 200 parse. */ 201 202static struct demangle_component *global_result; 203 204/* Prototypes for helper functions used when constructing the parse 205 tree. */ 206 207static struct demangle_component *d_qualify (struct demangle_component *, int, 208 int); 209 210static struct demangle_component *d_int_type (int); 211 212static struct demangle_component *d_unary (const char *, 213 struct demangle_component *); 214static struct demangle_component *d_binary (const char *, 215 struct demangle_component *, 216 struct demangle_component *); 217 218/* Flags passed to d_qualify. */ 219 220#define QUAL_CONST 1 221#define QUAL_RESTRICT 2 222#define QUAL_VOLATILE 4 223 224/* Flags passed to d_int_type. */ 225 226#define INT_CHAR (1 << 0) 227#define INT_SHORT (1 << 1) 228#define INT_LONG (1 << 2) 229#define INT_LLONG (1 << 3) 230 231#define INT_SIGNED (1 << 4) 232#define INT_UNSIGNED (1 << 5) 233 234/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 235 as well as gratuitiously global symbol names, so we can have multiple 236 yacc generated parsers in gdb. Note that these are only the variables 237 produced by yacc. If other parser generators (bison, byacc, etc) produce 238 additional global names that conflict at link time, then those parser 239 generators need to be fixed instead of adding those names to this list. */ 240 241#define yymaxdepth cpname_maxdepth 242#define yyparse cpname_parse 243#define yylex cpname_lex 244#define yyerror cpname_error 245#define yylval cpname_lval 246#define yychar cpname_char 247#define yydebug cpname_debug 248#define yypact cpname_pact 249#define yyr1 cpname_r1 250#define yyr2 cpname_r2 251#define yydef cpname_def 252#define yychk cpname_chk 253#define yypgo cpname_pgo 254#define yyact cpname_act 255#define yyexca cpname_exca 256#define yyerrflag cpname_errflag 257#define yynerrs cpname_nerrs 258#define yyps cpname_ps 259#define yypv cpname_pv 260#define yys cpname_s 261#define yy_yys cpname_yys 262#define yystate cpname_state 263#define yytmp cpname_tmp 264#define yyv cpname_v 265#define yy_yyv cpname_yyv 266#define yyval cpname_val 267#define yylloc cpname_lloc 268#define yyreds cpname_reds /* With YYDEBUG defined */ 269#define yytoks cpname_toks /* With YYDEBUG defined */ 270#define yyname cpname_name /* With YYDEBUG defined */ 271#define yyrule cpname_rule /* With YYDEBUG defined */ 272#define yylhs cpname_yylhs 273#define yylen cpname_yylen 274#define yydefred cpname_yydefred 275#define yydgoto cpname_yydgoto 276#define yysindex cpname_yysindex 277#define yyrindex cpname_yyrindex 278#define yygindex cpname_yygindex 279#define yytable cpname_yytable 280#define yycheck cpname_yycheck 281 282int yyparse (void); 283static int yylex (void); 284static void yyerror (char *); 285 286/* Enable yydebug for the stand-alone parser. */ 287#ifdef TEST_CPNAMES 288# define YYDEBUG 1 289#endif 290 291/* Helper functions. These wrap the demangler tree interface, handle 292 allocation from our global store, and return the allocated component. */ 293 294static struct demangle_component * 295fill_comp (enum demangle_component_type d_type, struct demangle_component *lhs, 296 struct demangle_component *rhs) 297{ 298 struct demangle_component *ret = d_grab (); 299 cplus_demangle_fill_component (ret, d_type, lhs, rhs); 300 return ret; 301} 302 303static struct demangle_component * 304make_empty (enum demangle_component_type d_type) 305{ 306 struct demangle_component *ret = d_grab (); 307 ret->type = d_type; 308 return ret; 309} 310 311static struct demangle_component * 312make_operator (const char *name, int args) 313{ 314 struct demangle_component *ret = d_grab (); 315 cplus_demangle_fill_operator (ret, name, args); 316 return ret; 317} 318 319static struct demangle_component * 320make_dtor (enum gnu_v3_dtor_kinds kind, struct demangle_component *name) 321{ 322 struct demangle_component *ret = d_grab (); 323 cplus_demangle_fill_dtor (ret, kind, name); 324 return ret; 325} 326 327static struct demangle_component * 328make_builtin_type (const char *name) 329{ 330 struct demangle_component *ret = d_grab (); 331 cplus_demangle_fill_builtin_type (ret, name); 332 return ret; 333} 334 335static struct demangle_component * 336make_name (const char *name, int len) 337{ 338 struct demangle_component *ret = d_grab (); 339 cplus_demangle_fill_name (ret, name, len); 340 return ret; 341} 342 343#define d_left(dc) (dc)->u.s_binary.left 344#define d_right(dc) (dc)->u.s_binary.right 345 346 347 348/* Enabling traces. */ 349#ifndef YYDEBUG 350# define YYDEBUG 0 351#endif 352 353/* Enabling verbose error messages. */ 354#ifdef YYERROR_VERBOSE 355# undef YYERROR_VERBOSE 356# define YYERROR_VERBOSE 1 357#else 358# define YYERROR_VERBOSE 0 359#endif 360 361#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 362#line 215 "cp-name-parser.y" 363typedef union YYSTYPE { 364 struct demangle_component *comp; 365 struct nested { 366 struct demangle_component *comp; 367 struct demangle_component **last; 368 } nested; 369 struct { 370 struct demangle_component *comp, *last; 371 } nested1; 372 struct { 373 struct demangle_component *comp, **last; 374 struct nested fn; 375 struct demangle_component *start; 376 int fold_flag; 377 } abstract; 378 int lval; 379 struct { 380 int val; 381 struct demangle_component *type; 382 } typed_val_int; 383 const char *opname; 384 } YYSTYPE; 385/* Line 191 of yacc.c. */ 386#line 387 "cp-name-parser.c.tmp" 387# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 388# define YYSTYPE_IS_DECLARED 1 389# define YYSTYPE_IS_TRIVIAL 1 390#endif 391 392 393 394/* Copy the second part of user declarations. */ 395#line 291 "cp-name-parser.y" 396 397enum { 398 GLOBAL_CONSTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 20, 399 GLOBAL_DESTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 21 400}; 401 402 403/* Line 214 of yacc.c. */ 404#line 405 "cp-name-parser.c.tmp" 405 406#if ! defined (yyoverflow) || YYERROR_VERBOSE 407 408# ifndef YYFREE 409# define YYFREE free 410# endif 411# ifndef YYMALLOC 412# define YYMALLOC xmalloc 413# endif 414 415/* The parser invokes alloca or xmalloc; define the necessary symbols. */ 416 417# ifdef YYSTACK_USE_ALLOCA 418# if YYSTACK_USE_ALLOCA 419# define YYSTACK_ALLOC alloca 420# endif 421# else 422# if defined (alloca) || defined (_ALLOCA_H) 423# define YYSTACK_ALLOC alloca 424# else 425# ifdef __GNUC__ 426# define YYSTACK_ALLOC __builtin_alloca 427# endif 428# endif 429# endif 430 431# ifdef YYSTACK_ALLOC 432 /* Pacify GCC's `empty if-body' warning. */ 433# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 434# else 435# if defined (__STDC__) || defined (__cplusplus) 436# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 437# define YYSIZE_T size_t 438# endif 439# define YYSTACK_ALLOC YYMALLOC 440# define YYSTACK_FREE YYFREE 441# endif 442#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 443 444 445#if (! defined (yyoverflow) \ 446 && (! defined (__cplusplus) \ 447 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) 448 449/* A type that is properly aligned for any stack member. */ 450union yyalloc 451{ 452 short yyss; 453 YYSTYPE yyvs; 454 }; 455 456/* The size of the maximum gap between one aligned stack and the next. */ 457# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 458 459/* The size of an array large to enough to hold all stacks, each with 460 N elements. */ 461# define YYSTACK_BYTES(N) \ 462 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ 463 + YYSTACK_GAP_MAXIMUM) 464 465/* Copy COUNT objects from FROM to TO. The source and destination do 466 not overlap. */ 467# ifndef YYCOPY 468# if defined (__GNUC__) && 1 < __GNUC__ 469# define YYCOPY(To, From, Count) \ 470 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 471# else 472# define YYCOPY(To, From, Count) \ 473 do \ 474 { \ 475 register YYSIZE_T yyi; \ 476 for (yyi = 0; yyi < (Count); yyi++) \ 477 (To)[yyi] = (From)[yyi]; \ 478 } \ 479 while (0) 480# endif 481# endif 482 483/* Relocate STACK from its old location to the new one. The 484 local variables YYSIZE and YYSTACKSIZE give the old and new number of 485 elements in the stack, and YYPTR gives the new location of the 486 stack. Advance YYPTR to a properly aligned location for the next 487 stack. */ 488# define YYSTACK_RELOCATE(Stack) \ 489 do \ 490 { \ 491 YYSIZE_T yynewbytes; \ 492 YYCOPY (&yyptr->Stack, Stack, yysize); \ 493 Stack = &yyptr->Stack; \ 494 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 495 yyptr += yynewbytes / sizeof (*yyptr); \ 496 } \ 497 while (0) 498 499#endif 500 501#if defined (__STDC__) || defined (__cplusplus) 502 typedef signed char yysigned_char; 503#else 504 typedef short yysigned_char; 505#endif 506 507/* YYFINAL -- State number of the termination state. */ 508#define YYFINAL 85 509/* YYLAST -- Last index in YYTABLE. */ 510#define YYLAST 1199 511 512/* YYNTOKENS -- Number of terminals. */ 513#define YYNTOKENS 76 514/* YYNNTS -- Number of nonterminals. */ 515#define YYNNTS 40 516/* YYNRULES -- Number of rules. */ 517#define YYNRULES 195 518/* YYNRULES -- Number of states. */ 519#define YYNSTATES 330 520 521/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 522#define YYUNDEFTOK 2 523#define YYMAXUTOK 308 524 525#define YYTRANSLATE(YYX) \ 526 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 527 528/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 529static const unsigned char yytranslate[] = 530{ 531 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 534 2, 2, 2, 73, 2, 2, 2, 64, 50, 2, 535 74, 42, 62, 60, 43, 61, 68, 63, 2, 2, 536 2, 2, 2, 2, 2, 2, 2, 2, 75, 2, 537 53, 44, 54, 45, 59, 2, 2, 2, 2, 2, 538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 540 2, 69, 2, 71, 49, 2, 2, 2, 2, 2, 541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 543 2, 2, 2, 2, 48, 2, 72, 2, 2, 2, 544 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 545 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 546 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 549 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 550 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 551 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 552 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 553 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 554 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 555 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 556 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 557 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 558 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 559 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 560 35, 36, 37, 38, 39, 40, 41, 46, 47, 51, 561 52, 55, 56, 57, 58, 65, 66, 67, 70 562}; 563 564#if YYDEBUG 565/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 566 YYRHS. */ 567static const unsigned short yyprhs[] = 568{ 569 0, 0, 3, 5, 7, 9, 11, 12, 15, 18, 570 22, 26, 29, 32, 35, 40, 42, 45, 48, 53, 571 58, 61, 64, 67, 70, 73, 76, 79, 82, 85, 572 88, 91, 94, 97, 100, 103, 106, 109, 112, 115, 573 118, 121, 124, 127, 130, 133, 137, 140, 144, 148, 574 151, 154, 156, 160, 163, 165, 170, 173, 175, 178, 575 181, 183, 186, 188, 190, 192, 194, 197, 200, 202, 576 205, 209, 212, 216, 221, 223, 227, 229, 232, 235, 577 240, 242, 244, 247, 251, 256, 260, 265, 270, 274, 578 275, 277, 279, 281, 283, 285, 288, 290, 292, 294, 579 296, 298, 300, 302, 305, 307, 309, 311, 314, 316, 580 318, 320, 323, 325, 329, 334, 337, 341, 344, 346, 581 350, 353, 356, 358, 362, 365, 369, 372, 377, 381, 582 383, 386, 388, 392, 395, 398, 400, 402, 405, 407, 583 412, 415, 417, 420, 423, 425, 429, 432, 435, 437, 584 440, 442, 444, 449, 454, 459, 462, 465, 468, 471, 585 475, 477, 481, 484, 487, 490, 493, 498, 506, 514, 586 522, 527, 531, 535, 539, 543, 547, 551, 555, 559, 587 563, 567, 571, 575, 579, 583, 587, 591, 595, 599, 588 603, 609, 611, 613, 618, 620 589}; 590 591/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 592static const yysigned_char yyrhs[] = 593{ 594 77, 0, -1, 78, -1, 109, -1, 81, -1, 80, 595 -1, -1, 12, 78, -1, 105, 112, -1, 105, 96, 596 79, -1, 89, 96, 79, -1, 84, 79, -1, 84, 597 108, -1, 38, 78, -1, 39, 78, 40, 78, -1, 598 41, -1, 17, 15, -1, 17, 16, -1, 17, 15, 599 69, 71, -1, 17, 16, 69, 71, -1, 17, 60, 600 -1, 17, 61, -1, 17, 62, -1, 17, 63, -1, 601 17, 64, -1, 17, 49, -1, 17, 50, -1, 17, 602 48, -1, 17, 72, -1, 17, 73, -1, 17, 44, 603 -1, 17, 53, -1, 17, 54, -1, 17, 35, -1, 604 17, 58, -1, 17, 57, -1, 17, 52, -1, 17, 605 51, -1, 17, 56, -1, 17, 55, -1, 17, 47, 606 -1, 17, 46, -1, 17, 66, -1, 17, 65, -1, 607 17, 43, -1, 17, 70, 62, -1, 17, 70, -1, 608 17, 74, 42, -1, 17, 69, 71, -1, 17, 105, 609 -1, 91, 83, -1, 83, -1, 12, 91, 83, -1, 610 12, 83, -1, 82, -1, 82, 53, 93, 54, -1, 611 72, 5, -1, 87, -1, 12, 87, -1, 91, 5, 612 -1, 5, -1, 91, 92, -1, 92, -1, 86, -1, 613 89, -1, 90, -1, 12, 90, -1, 91, 85, -1, 614 85, -1, 5, 12, -1, 91, 5, 12, -1, 92, 615 12, -1, 91, 92, 12, -1, 5, 53, 93, 54, 616 -1, 94, -1, 93, 43, 94, -1, 105, -1, 105, 617 106, -1, 50, 78, -1, 50, 74, 78, 42, -1, 618 114, -1, 105, -1, 105, 106, -1, 95, 43, 105, 619 -1, 95, 43, 105, 106, -1, 95, 43, 29, -1, 620 74, 95, 42, 97, -1, 74, 31, 42, 97, -1, 621 74, 42, 97, -1, -1, 99, -1, 30, -1, 26, 622 -1, 25, -1, 98, -1, 98, 99, -1, 24, -1, 623 21, -1, 11, -1, 33, -1, 22, -1, 23, -1, 624 100, -1, 101, 100, -1, 101, -1, 32, -1, 27, 625 -1, 22, 27, -1, 28, -1, 34, -1, 31, -1, 626 62, 97, -1, 50, -1, 91, 62, 97, -1, 12, 627 91, 62, 97, -1, 69, 71, -1, 69, 3, 71, 628 -1, 102, 99, -1, 102, -1, 99, 102, 99, -1, 629 99, 102, -1, 87, 99, -1, 87, -1, 99, 87, 630 99, -1, 99, 87, -1, 12, 87, 99, -1, 12, 631 87, -1, 99, 12, 87, 99, -1, 99, 12, 87, 632 -1, 103, -1, 103, 106, -1, 107, -1, 74, 106, 633 42, -1, 107, 96, -1, 107, 104, -1, 104, -1, 634 103, -1, 103, 108, -1, 107, -1, 107, 96, 12, 635 78, -1, 96, 79, -1, 105, -1, 105, 106, -1, 636 103, 110, -1, 111, -1, 74, 110, 42, -1, 111, 637 96, -1, 111, 104, -1, 88, -1, 103, 112, -1, 638 88, -1, 113, -1, 88, 96, 12, 78, -1, 113, 639 96, 12, 78, -1, 74, 103, 110, 42, -1, 113, 640 96, -1, 113, 104, -1, 88, 96, -1, 88, 104, 641 -1, 74, 115, 42, -1, 114, -1, 114, 54, 114, 642 -1, 50, 78, -1, 61, 114, -1, 73, 114, -1, 643 72, 114, -1, 74, 109, 42, 114, -1, 18, 53, 644 109, 54, 74, 115, 42, -1, 20, 53, 109, 54, 645 74, 115, 42, -1, 19, 53, 109, 54, 74, 115, 646 42, -1, 105, 74, 115, 42, -1, 114, 62, 114, 647 -1, 114, 63, 114, -1, 114, 64, 114, -1, 114, 648 60, 114, -1, 114, 61, 114, -1, 114, 58, 114, 649 -1, 114, 57, 114, -1, 114, 52, 114, -1, 114, 650 51, 114, -1, 114, 56, 114, -1, 114, 55, 114, 651 -1, 114, 53, 114, -1, 114, 50, 114, -1, 114, 652 49, 114, -1, 114, 48, 114, -1, 114, 47, 114, 653 -1, 114, 46, 114, -1, 114, 70, 5, -1, 114, 654 68, 5, -1, 114, 45, 114, 75, 114, -1, 3, 655 -1, 4, -1, 10, 74, 109, 42, -1, 36, -1, 656 37, -1 657}; 658 659/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 660static const unsigned short yyrline[] = 661{ 662 0, 341, 341, 345, 347, 349, 354, 355, 362, 371, 663 374, 378, 381, 400, 404, 406, 412, 414, 416, 418, 664 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 665 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 666 460, 462, 464, 466, 468, 470, 472, 474, 476, 484, 667 489, 494, 498, 503, 511, 512, 514, 526, 527, 533, 668 535, 536, 538, 541, 542, 545, 546, 550, 552, 555, 669 561, 568, 574, 585, 589, 592, 603, 604, 608, 610, 670 612, 615, 619, 624, 629, 635, 645, 649, 653, 661, 671 662, 665, 667, 669, 673, 674, 681, 683, 685, 687, 672 689, 691, 695, 696, 700, 702, 704, 706, 708, 710, 673 712, 716, 722, 726, 734, 744, 748, 764, 766, 767, 674 769, 772, 774, 775, 777, 780, 782, 784, 786, 791, 675 794, 799, 806, 810, 821, 827, 845, 848, 856, 858, 676 869, 876, 877, 883, 887, 891, 893, 898, 903, 916, 677 920, 925, 933, 938, 947, 951, 956, 961, 965, 971, 678 977, 980, 987, 992, 996, 1000, 1007, 1023, 1030, 1037, 679 1050, 1061, 1065, 1069, 1073, 1077, 1081, 1085, 1089, 1093, 680 1097, 1101, 1105, 1109, 1113, 1117, 1121, 1125, 1130, 1134, 681 1138, 1145, 1149, 1152, 1157, 1166 682}; 683#endif 684 685#if YYDEBUG || YYERROR_VERBOSE 686/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 687 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 688static const char *const yytname[] = 689{ 690 "$end", "error", "$undefined", "INT", "FLOAT", "NAME", "STRUCT", 691 "CLASS", "UNION", "ENUM", "SIZEOF", "UNSIGNED", "COLONCOLON", "TEMPLATE", 692 "ERROR", "NEW", "DELETE", "OPERATOR", "STATIC_CAST", "REINTERPRET_CAST", 693 "DYNAMIC_CAST", "SIGNED_KEYWORD", "LONG", "SHORT", "INT_KEYWORD", 694 "CONST_KEYWORD", "VOLATILE_KEYWORD", "DOUBLE_KEYWORD", "BOOL", 695 "ELLIPSIS", "RESTRICT", "VOID", "FLOAT_KEYWORD", "CHAR", "WCHAR_T", 696 "ASSIGN_MODIFY", "TRUEKEYWORD", "FALSEKEYWORD", "DEMANGLER_SPECIAL", 697 "CONSTRUCTION_VTABLE", "CONSTRUCTION_IN", "GLOBAL", "')'", "','", "'='", 698 "'?'", "OROR", "ANDAND", "'|'", "'^'", "'&'", "NOTEQUAL", "EQUAL", "'<'", 699 "'>'", "GEQ", "LEQ", "RSH", "LSH", "'@'", "'+'", "'-'", "'*'", "'/'", 700 "'%'", "DECREMENT", "INCREMENT", "UNARY", "'.'", "'['", "ARROW", "']'", 701 "'~'", "'!'", "'('", "':'", "$accept", "result", "start", "start_opt", 702 "function", "demangler_special", "operator", "conversion_op", 703 "conversion_op_name", "unqualified_name", "colon_name", "name", 704 "colon_ext_name", "colon_ext_only", "ext_only_name", "nested_name", 705 "template", "template_params", "template_arg", "function_args", 706 "function_arglist", "qualifiers_opt", "qualifier", "qualifiers", 707 "int_part", "int_seq", "builtin_type", "ptr_operator", "array_indicator", 708 "typespec_2", "abstract_declarator", "direct_abstract_declarator", 709 "abstract_declarator_fn", "type", "declarator", "direct_declarator", 710 "declarator_1", "direct_declarator_1", "exp", "exp1", 0 711}; 712#endif 713 714# ifdef YYPRINT 715/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 716 token YYLEX-NUM. */ 717static const unsigned short yytoknum[] = 718{ 719 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 720 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 721 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 722 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 723 295, 296, 41, 44, 61, 63, 297, 298, 124, 94, 724 38, 299, 300, 60, 62, 301, 302, 303, 304, 64, 725 43, 45, 42, 47, 37, 305, 306, 307, 46, 91, 726 308, 93, 126, 33, 40, 58 727}; 728# endif 729 730/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 731static const unsigned char yyr1[] = 732{ 733 0, 76, 77, 78, 78, 78, 79, 79, 80, 80, 734 80, 80, 80, 81, 81, 81, 82, 82, 82, 82, 735 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 736 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 737 82, 82, 82, 82, 82, 82, 82, 82, 82, 83, 738 84, 84, 84, 84, 85, 85, 85, 86, 86, 87, 739 87, 87, 87, 88, 88, 89, 89, 90, 90, 91, 740 91, 91, 91, 92, 93, 93, 94, 94, 94, 94, 741 94, 95, 95, 95, 95, 95, 96, 96, 96, 97, 742 97, 98, 98, 98, 99, 99, 100, 100, 100, 100, 743 100, 100, 101, 101, 102, 102, 102, 102, 102, 102, 744 102, 103, 103, 103, 103, 104, 104, 105, 105, 105, 745 105, 105, 105, 105, 105, 105, 105, 105, 105, 106, 746 106, 106, 107, 107, 107, 107, 108, 108, 108, 108, 747 108, 109, 109, 110, 110, 111, 111, 111, 111, 112, 748 112, 112, 112, 112, 113, 113, 113, 113, 113, 114, 749 115, 115, 115, 114, 114, 114, 114, 114, 114, 114, 750 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, 751 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, 752 114, 114, 114, 114, 114, 114 753}; 754 755/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 756static const unsigned char yyr2[] = 757{ 758 0, 2, 1, 1, 1, 1, 0, 2, 2, 3, 759 3, 2, 2, 2, 4, 1, 2, 2, 4, 4, 760 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 761 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 762 2, 2, 2, 2, 2, 3, 2, 3, 3, 2, 763 2, 1, 3, 2, 1, 4, 2, 1, 2, 2, 764 1, 2, 1, 1, 1, 1, 2, 2, 1, 2, 765 3, 2, 3, 4, 1, 3, 1, 2, 2, 4, 766 1, 1, 2, 3, 4, 3, 4, 4, 3, 0, 767 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 768 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 769 1, 2, 1, 3, 4, 2, 3, 2, 1, 3, 770 2, 2, 1, 3, 2, 3, 2, 4, 3, 1, 771 2, 1, 3, 2, 2, 1, 1, 2, 1, 4, 772 2, 1, 2, 2, 1, 3, 2, 2, 1, 2, 773 1, 1, 4, 4, 4, 2, 2, 2, 2, 3, 774 1, 3, 2, 2, 2, 2, 4, 7, 7, 7, 775 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 776 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 777 5, 1, 1, 4, 1, 1 778}; 779 780/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 781 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 782 means the default is an error. */ 783static const unsigned char yydefact[] = 784{ 785 0, 60, 98, 0, 0, 97, 100, 101, 96, 93, 786 92, 106, 108, 91, 110, 105, 99, 109, 0, 0, 787 15, 0, 0, 2, 5, 4, 54, 51, 6, 68, 788 122, 0, 65, 0, 62, 94, 0, 102, 104, 118, 789 141, 3, 69, 0, 53, 126, 66, 0, 0, 16, 790 17, 33, 44, 30, 41, 40, 27, 25, 26, 37, 791 36, 31, 32, 39, 38, 35, 34, 20, 21, 22, 792 23, 24, 43, 42, 0, 46, 28, 29, 0, 0, 793 49, 107, 13, 0, 56, 1, 0, 0, 0, 112, 794 89, 0, 0, 11, 0, 0, 6, 136, 135, 138, 795 12, 121, 0, 6, 59, 50, 67, 61, 71, 95, 796 0, 124, 120, 100, 103, 117, 0, 0, 0, 63, 797 57, 150, 64, 0, 6, 129, 142, 131, 8, 151, 798 191, 192, 0, 0, 0, 0, 194, 195, 0, 0, 799 0, 0, 0, 0, 74, 76, 80, 125, 52, 0, 800 0, 48, 45, 47, 0, 0, 7, 0, 111, 90, 801 0, 115, 0, 110, 89, 0, 0, 0, 129, 81, 802 0, 0, 89, 0, 0, 140, 0, 137, 133, 134, 803 10, 70, 72, 128, 123, 119, 58, 0, 129, 157, 804 158, 9, 0, 130, 149, 133, 155, 156, 0, 0, 805 0, 0, 0, 78, 0, 163, 165, 164, 0, 141, 806 0, 160, 0, 0, 73, 0, 77, 0, 0, 0, 807 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 808 0, 0, 0, 0, 0, 0, 0, 18, 19, 14, 809 55, 89, 116, 0, 89, 88, 89, 0, 82, 132, 810 113, 0, 0, 127, 0, 148, 129, 0, 144, 0, 811 0, 141, 0, 0, 0, 0, 0, 0, 162, 0, 812 0, 159, 75, 112, 0, 0, 0, 187, 186, 185, 813 184, 183, 179, 178, 182, 181, 180, 177, 176, 174, 814 175, 171, 172, 173, 189, 188, 114, 87, 86, 85, 815 83, 139, 0, 143, 154, 146, 147, 152, 153, 193, 816 0, 0, 0, 79, 166, 161, 170, 0, 84, 145, 817 0, 0, 0, 190, 0, 0, 0, 167, 169, 168 818}; 819 820/* YYDEFGOTO[NTERM-NUM]. */ 821static const short yydefgoto[] = 822{ 823 -1, 22, 156, 93, 24, 25, 26, 27, 28, 29, 824 119, 30, 255, 31, 32, 79, 34, 143, 144, 167, 825 96, 158, 35, 36, 37, 38, 39, 168, 98, 204, 826 170, 127, 100, 41, 257, 258, 128, 129, 211, 212 827}; 828 829/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 830 STATE-NUM. */ 831#define YYPACT_NINF -142 832static const short yypact[] = 833{ 834 777, 9, -142, 10, 625, -142, -15, -142, -142, -142, 835 -142, -142, -142, -142, -142, -142, -142, -142, 777, 777, 836 -142, 11, 38, -142, -142, -142, -11, -142, 21, -142, 837 147, -10, -142, 32, 58, 147, 1007, -142, 375, 147, 838 274, -142, -142, 439, -142, 147, -142, 32, 76, 37, 839 62, -142, -142, -142, -142, -142, -142, -142, -142, -142, 840 -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, 841 -142, -142, -142, -142, 30, 34, -142, -142, 81, 124, 842 -142, -142, -142, 94, -142, -142, 439, 9, 777, -142, 843 147, 8, 722, -142, 12, 58, 125, 359, -142, -18, 844 -142, -142, 895, 125, 54, -142, -142, 129, -142, -142, 845 76, 147, 147, -142, -142, -142, 50, 829, 722, -142, 846 -142, -18, -142, 68, 125, 435, -142, -18, -142, -18, 847 -142, -142, 74, 97, 100, 104, -142, -142, 691, 571, 848 571, 571, 512, -13, -142, 491, 1023, -142, -142, 71, 849 93, -142, -142, -142, 777, 60, -142, 139, -142, -142, 850 99, -142, 76, 136, 147, 559, 27, 33, 559, 559, 851 151, 54, 147, 129, 777, -142, 161, -142, 169, -142, 852 -142, -142, -142, 147, -142, -142, -142, 179, 723, 182, 853 -142, -142, 559, -142, -142, -142, 183, -142, 983, 983, 854 983, 983, 777, -142, 123, -7, -7, -7, 777, 491, 855 156, 997, 158, 439, -142, 357, -142, 571, 571, 571, 856 571, 571, 571, 571, 571, 571, 571, 571, 571, 571, 857 571, 571, 571, 571, 571, 198, 202, -142, -142, -142, 858 -142, 147, -142, 43, 147, -142, 147, 953, -142, -142, 859 -142, 48, 777, -142, 723, -142, 723, 171, -18, 777, 860 777, 559, 172, 163, 168, 178, 193, 512, -142, 571, 861 571, -142, -142, 802, 357, 194, 893, 1047, 1070, 1092, 862 1113, 795, 1129, 1129, 554, 554, 554, 267, 267, 142, 863 142, -7, -7, -7, -142, -142, -142, -142, -142, -142, 864 559, -142, 200, -142, -142, -142, -142, -142, -142, -142, 865 170, 173, 175, -142, -7, 1023, -142, 571, -142, -142, 866 512, 512, 512, 1023, 201, 203, 204, -142, -142, -142 867}; 868 869/* YYPGOTO[NTERM-NUM]. */ 870static const short yypgoto[] = 871{ 872 -142, -142, 80, 56, -142, -142, -142, 3, -142, -2, 873 -142, -1, -32, -17, 4, 0, 247, 176, 44, -142, 874 -27, -95, -142, -25, 220, -142, 229, -6, -75, 25, 875 95, -19, 174, -141, -128, -142, 141, -142, 89, -131 876}; 877 878/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 879 positive, shift that token. If negative, reduce the rule which 880 number is the opposite. If zero, do what YYDEFACT says. 881 If YYTABLE_NINF, syntax error. */ 882#define YYTABLE_NINF -1 883static const unsigned short yytable[] = 884{ 885 33, 210, 45, 47, 103, 101, 44, 46, 121, 99, 886 109, 160, 81, 124, 115, 1, 84, 171, 33, 33, 887 147, 42, 97, 122, 179, 40, 87, 4, 94, 80, 888 213, 106, 104, 88, 125, 111, 105, 104, 85, 120, 889 123, 214, 86, 40, 40, 106, 190, 45, 104, 4, 890 148, 91, 179, 171, 197, 1, 102, 262, 263, 264, 891 265, 235, 43, 236, 102, 159, 181, 117, 145, 245, 892 108, 89, 178, 104, 172, 246, 247, 250, 99, 161, 893 23, 1, 21, 90, 275, 117, 184, 185, 157, 172, 894 91, 97, 166, 121, 189, 92, 152, 94, 82, 83, 895 195, 151, 196, 213, 21, 241, 149, 43, 122, 183, 896 241, 145, 188, 40, 240, 186, 187, 169, 166, 125, 897 46, 106, 21, 153, 120, 123, 302, 169, 303, 104, 898 172, 150, 146, 210, 154, 126, 275, 174, 33, 159, 899 21, 182, 237, 169, 104, 94, 296, 159, 198, 297, 900 199, 298, 175, 200, 33, 106, 4, 201, 253, 180, 901 105, 45, 243, 40, 238, 94, 87, 209, 94, 94, 902 242, 122, 9, 10, 33, 146, 251, 13, 244, 40, 903 191, 252, 256, 306, 104, 106, 188, 120, 123, 324, 904 325, 326, 94, 249, 259, 260, 117, 267, 269, 40, 905 271, 241, 33, 294, 232, 233, 234, 295, 33, 94, 906 235, 21, 236, 304, 309, 166, 159, 310, 203, 159, 907 193, 159, 311, 261, 261, 261, 261, 40, 205, 206, 908 207, 305, 312, 40, 239, 313, 316, 122, 145, 122, 909 216, 241, 319, 327, 320, 328, 329, 321, 256, 322, 910 256, 21, 33, 120, 123, 120, 123, 272, 114, 33, 911 33, 94, 155, 193, 248, 112, 194, 0, 0, 0, 912 0, 177, 300, 33, 166, 95, 0, 40, 0, 1, 913 107, 0, 266, 193, 40, 40, 116, 0, 268, 0, 914 0, 117, 0, 0, 107, 0, 0, 0, 40, 209, 915 94, 0, 146, 0, 126, 0, 276, 277, 278, 279, 916 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 917 290, 291, 292, 293, 89, 0, 107, 230, 231, 232, 918 233, 234, 301, 0, 0, 235, 90, 236, 0, 307, 919 308, 173, 0, 91, 95, 0, 21, 0, 118, 0, 920 0, 193, 0, 268, 0, 0, 126, 0, 314, 315, 921 130, 131, 1, 0, 87, 0, 0, 132, 2, 162, 922 107, 176, 0, 0, 0, 133, 134, 135, 5, 6, 923 7, 8, 9, 10, 11, 12, 2, 13, 14, 15, 924 16, 17, 95, 136, 137, 318, 5, 113, 7, 8, 925 0, 0, 0, 0, 107, 0, 323, 273, 16, 89, 926 0, 0, 95, 107, 0, 95, 95, 0, 139, 90, 927 0, 90, 0, 95, 0, 0, 91, 0, 91, 140, 928 141, 274, 0, 92, 107, 0, 0, 0, 0, 95, 929 1, 0, 130, 131, 1, 0, 0, 116, 0, 132, 930 2, 48, 117, 0, 0, 0, 95, 133, 134, 135, 931 5, 6, 7, 8, 9, 10, 11, 12, 0, 13, 932 14, 15, 16, 17, 0, 136, 137, 0, 0, 0, 933 0, 0, 0, 0, 0, 89, 0, 0, 0, 138, 934 107, 0, 0, 0, 0, 0, 87, 90, 173, 0, 935 139, 0, 0, 176, 91, 0, 0, 21, 95, 192, 936 0, 140, 141, 142, 0, 130, 131, 1, 0, 0, 937 0, 0, 132, 2, 48, 0, 0, 0, 0, 0, 938 133, 134, 135, 5, 6, 7, 8, 9, 10, 11, 939 12, 89, 13, 14, 15, 16, 17, 95, 136, 137, 940 0, 0, 0, 90, 0, 0, 0, 0, 0, 0, 941 91, 0, 208, 0, 87, 215, 0, 0, 0, 0, 942 0, 176, 0, 139, 130, 131, 1, 0, 0, 0, 943 0, 132, 2, 48, 140, 141, 142, 0, 0, 133, 944 134, 135, 5, 6, 7, 8, 9, 10, 11, 12, 945 0, 13, 14, 15, 16, 17, 0, 136, 137, 89, 946 0, 228, 229, 0, 230, 231, 232, 233, 234, 0, 947 0, 90, 235, 0, 236, 0, 0, 0, 91, 0, 948 1, 0, 139, 165, 0, 0, 2, 48, 0, 0, 949 49, 50, 0, 140, 141, 142, 5, 6, 7, 8, 950 9, 10, 11, 12, 0, 13, 14, 15, 16, 17, 951 51, 0, 0, 0, 0, 0, 0, 0, 52, 53, 952 0, 54, 55, 56, 57, 58, 59, 60, 61, 62, 953 63, 64, 65, 66, 0, 67, 68, 69, 70, 71, 954 72, 73, 0, 0, 74, 75, 1, 76, 77, 78, 955 0, 0, 2, 3, 0, 0, 0, 0, 4, 0, 956 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 957 0, 13, 14, 15, 16, 17, 0, 1, 1, 18, 958 19, 0, 20, 2, 162, 116, 0, 0, 0, 0, 959 117, 0, 0, 5, 6, 7, 8, 9, 10, 11, 960 12, 0, 13, 163, 15, 16, 17, 0, 0, 0, 961 0, 0, 0, 21, 164, 202, 0, 0, 0, 0, 962 0, 0, 89, 89, 0, 0, 0, 0, 0, 0, 963 0, 0, 1, 0, 90, 90, 0, 0, 2, 3, 964 0, 91, 91, 0, 4, 21, 165, 254, 5, 6, 965 7, 8, 9, 10, 11, 12, 0, 13, 14, 15, 966 16, 17, 0, 2, 3, 18, 19, 0, 20, 4, 967 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 968 12, 0, 13, 14, 15, 16, 17, 0, 0, 0, 969 18, 19, 0, 20, 49, 50, 223, 224, 225, 21, 970 226, 227, 228, 229, 0, 230, 231, 232, 233, 234, 971 0, 0, 0, 235, 51, 236, 0, 0, 0, 0, 972 0, 0, 52, 53, 21, 54, 55, 56, 57, 58, 973 59, 60, 61, 62, 63, 64, 65, 66, 0, 67, 974 68, 69, 70, 71, 72, 73, 0, 0, 74, 75, 975 1, 76, 77, 78, 0, 0, 2, 48, 0, 0, 976 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 977 9, 10, 11, 12, 0, 13, 163, 15, 16, 17, 978 0, 0, 0, 0, 0, 0, 0, 164, 217, 218, 979 219, 220, 221, 222, 223, 224, 225, 0, 226, 227, 980 228, 229, 0, 230, 231, 232, 233, 234, 1, 0, 981 0, 235, 0, 236, 2, 48, 0, 0, 317, 0, 982 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 983 11, 12, 299, 13, 14, 15, 16, 17, 1, 0, 984 0, 0, 0, 0, 2, 48, 0, 0, 0, 0, 985 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 986 11, 12, 1, 13, 14, 15, 16, 17, 2, 110, 987 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, 988 7, 8, 0, 0, 11, 12, 0, 0, 14, 15, 989 16, 17, 217, 218, 219, 220, 221, 222, 223, 224, 990 225, 270, 226, 227, 228, 229, 0, 230, 231, 232, 991 233, 234, 0, 0, 0, 235, 0, 236, 217, 218, 992 219, 220, 221, 222, 223, 224, 225, 0, 226, 227, 993 228, 229, 0, 230, 231, 232, 233, 234, 0, 0, 994 0, 235, 0, 236, 219, 220, 221, 222, 223, 224, 995 225, 0, 226, 227, 228, 229, 0, 230, 231, 232, 996 233, 234, 0, 0, 0, 235, 0, 236, 220, 221, 997 222, 223, 224, 225, 0, 226, 227, 228, 229, 0, 998 230, 231, 232, 233, 234, 0, 0, 0, 235, 0, 999 236, 221, 222, 223, 224, 225, 0, 226, 227, 228, 1000 229, 0, 230, 231, 232, 233, 234, 0, 0, 0, 1001 235, 0, 236, 222, 223, 224, 225, 0, 226, 227, 1002 228, 229, 0, 230, 231, 232, 233, 234, 0, 0, 1003 0, 235, 225, 236, 226, 227, 228, 229, 0, 230, 1004 231, 232, 233, 234, 0, 0, 0, 235, 0, 236 1005}; 1006 1007static const short yycheck[] = 1008{ 1009 0, 142, 3, 3, 31, 30, 3, 3, 40, 28, 1010 35, 3, 27, 40, 39, 5, 5, 5, 18, 19, 1011 45, 12, 28, 40, 99, 0, 5, 17, 28, 4, 1012 43, 33, 5, 12, 40, 36, 33, 5, 0, 40, 1013 40, 54, 53, 18, 19, 47, 121, 48, 5, 17, 1014 47, 69, 127, 5, 129, 5, 74, 198, 199, 200, 1015 201, 68, 53, 70, 74, 90, 12, 17, 43, 164, 1016 12, 50, 99, 5, 62, 42, 43, 172, 97, 71, 1017 0, 5, 72, 62, 215, 17, 111, 112, 88, 62, 1018 69, 97, 92, 125, 121, 74, 62, 97, 18, 19, 1019 127, 71, 129, 43, 72, 62, 69, 53, 125, 110, 1020 62, 86, 118, 88, 54, 116, 116, 92, 118, 125, 1021 116, 123, 72, 42, 125, 125, 254, 102, 256, 5, 1022 62, 69, 43, 274, 40, 40, 267, 12, 138, 164, 1023 72, 12, 71, 118, 5, 145, 241, 172, 74, 244, 1024 53, 246, 96, 53, 154, 157, 17, 53, 183, 103, 1025 157, 162, 162, 138, 71, 165, 5, 142, 168, 169, 1026 71, 188, 25, 26, 174, 86, 176, 30, 42, 154, 1027 124, 12, 188, 258, 5, 187, 192, 188, 188, 320, 1028 321, 322, 192, 42, 12, 12, 17, 74, 42, 174, 1029 42, 62, 202, 5, 62, 63, 64, 5, 208, 209, 1030 68, 72, 70, 42, 42, 215, 241, 54, 138, 244, 1031 125, 246, 54, 198, 199, 200, 201, 202, 139, 140, 1032 141, 258, 54, 208, 154, 42, 42, 254, 213, 256, 1033 145, 62, 42, 42, 74, 42, 42, 74, 254, 74, 1034 256, 72, 252, 254, 254, 256, 256, 213, 38, 259, 1035 260, 261, 86, 168, 169, 36, 125, -1, -1, -1, 1036 -1, 97, 247, 273, 274, 28, -1, 252, -1, 5, 1037 33, -1, 202, 188, 259, 260, 12, -1, 208, -1, 1038 -1, 17, -1, -1, 47, -1, -1, -1, 273, 274, 1039 300, -1, 213, -1, 209, -1, 217, 218, 219, 220, 1040 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 1041 231, 232, 233, 234, 50, -1, 79, 60, 61, 62, 1042 63, 64, 252, -1, -1, 68, 62, 70, -1, 259, 1043 260, 94, -1, 69, 97, -1, 72, -1, 74, -1, 1044 -1, 256, -1, 273, -1, -1, 261, -1, 269, 270, 1045 3, 4, 5, -1, 5, -1, -1, 10, 11, 12, 1046 123, 12, -1, -1, -1, 18, 19, 20, 21, 22, 1047 23, 24, 25, 26, 27, 28, 11, 30, 31, 32, 1048 33, 34, 145, 36, 37, 300, 21, 22, 23, 24, 1049 -1, -1, -1, -1, 157, -1, 317, 50, 33, 50, 1050 -1, -1, 165, 166, -1, 168, 169, -1, 61, 62, 1051 -1, 62, -1, 176, -1, -1, 69, -1, 69, 72, 1052 73, 74, -1, 74, 187, -1, -1, -1, -1, 192, 1053 5, -1, 3, 4, 5, -1, -1, 12, -1, 10, 1054 11, 12, 17, -1, -1, -1, 209, 18, 19, 20, 1055 21, 22, 23, 24, 25, 26, 27, 28, -1, 30, 1056 31, 32, 33, 34, -1, 36, 37, -1, -1, -1, 1057 -1, -1, -1, -1, -1, 50, -1, -1, -1, 50, 1058 243, -1, -1, -1, -1, -1, 5, 62, 251, -1, 1059 61, -1, -1, 12, 69, -1, -1, 72, 261, 74, 1060 -1, 72, 73, 74, -1, 3, 4, 5, -1, -1, 1061 -1, -1, 10, 11, 12, -1, -1, -1, -1, -1, 1062 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1063 28, 50, 30, 31, 32, 33, 34, 300, 36, 37, 1064 -1, -1, -1, 62, -1, -1, -1, -1, -1, -1, 1065 69, -1, 50, -1, 5, 74, -1, -1, -1, -1, 1066 -1, 12, -1, 61, 3, 4, 5, -1, -1, -1, 1067 -1, 10, 11, 12, 72, 73, 74, -1, -1, 18, 1068 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1069 -1, 30, 31, 32, 33, 34, -1, 36, 37, 50, 1070 -1, 57, 58, -1, 60, 61, 62, 63, 64, -1, 1071 -1, 62, 68, -1, 70, -1, -1, -1, 69, -1, 1072 5, -1, 61, 74, -1, -1, 11, 12, -1, -1, 1073 15, 16, -1, 72, 73, 74, 21, 22, 23, 24, 1074 25, 26, 27, 28, -1, 30, 31, 32, 33, 34, 1075 35, -1, -1, -1, -1, -1, -1, -1, 43, 44, 1076 -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 1077 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, 1078 65, 66, -1, -1, 69, 70, 5, 72, 73, 74, 1079 -1, -1, 11, 12, -1, -1, -1, -1, 17, -1, 1080 -1, -1, 21, 22, 23, 24, 25, 26, 27, 28, 1081 -1, 30, 31, 32, 33, 34, -1, 5, 5, 38, 1082 39, -1, 41, 11, 12, 12, -1, -1, -1, -1, 1083 17, -1, -1, 21, 22, 23, 24, 25, 26, 27, 1084 28, -1, 30, 31, 32, 33, 34, -1, -1, -1, 1085 -1, -1, -1, 72, 42, 74, -1, -1, -1, -1, 1086 -1, -1, 50, 50, -1, -1, -1, -1, -1, -1, 1087 -1, -1, 5, -1, 62, 62, -1, -1, 11, 12, 1088 -1, 69, 69, -1, 17, 72, 74, 74, 21, 22, 1089 23, 24, 25, 26, 27, 28, -1, 30, 31, 32, 1090 33, 34, -1, 11, 12, 38, 39, -1, 41, 17, 1091 -1, -1, -1, 21, 22, 23, 24, 25, 26, 27, 1092 28, -1, 30, 31, 32, 33, 34, -1, -1, -1, 1093 38, 39, -1, 41, 15, 16, 51, 52, 53, 72, 1094 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, 1095 -1, -1, -1, 68, 35, 70, -1, -1, -1, -1, 1096 -1, -1, 43, 44, 72, 46, 47, 48, 49, 50, 1097 51, 52, 53, 54, 55, 56, 57, 58, -1, 60, 1098 61, 62, 63, 64, 65, 66, -1, -1, 69, 70, 1099 5, 72, 73, 74, -1, -1, 11, 12, -1, -1, 1100 -1, -1, -1, -1, -1, -1, 21, 22, 23, 24, 1101 25, 26, 27, 28, -1, 30, 31, 32, 33, 34, 1102 -1, -1, -1, -1, -1, -1, -1, 42, 45, 46, 1103 47, 48, 49, 50, 51, 52, 53, -1, 55, 56, 1104 57, 58, -1, 60, 61, 62, 63, 64, 5, -1, 1105 -1, 68, -1, 70, 11, 12, -1, -1, 75, -1, 1106 -1, -1, -1, -1, 21, 22, 23, 24, 25, 26, 1107 27, 28, 29, 30, 31, 32, 33, 34, 5, -1, 1108 -1, -1, -1, -1, 11, 12, -1, -1, -1, -1, 1109 -1, -1, -1, -1, 21, 22, 23, 24, 25, 26, 1110 27, 28, 5, 30, 31, 32, 33, 34, 11, 12, 1111 -1, -1, -1, -1, -1, -1, -1, -1, 21, 22, 1112 23, 24, -1, -1, 27, 28, -1, -1, 31, 32, 1113 33, 34, 45, 46, 47, 48, 49, 50, 51, 52, 1114 53, 54, 55, 56, 57, 58, -1, 60, 61, 62, 1115 63, 64, -1, -1, -1, 68, -1, 70, 45, 46, 1116 47, 48, 49, 50, 51, 52, 53, -1, 55, 56, 1117 57, 58, -1, 60, 61, 62, 63, 64, -1, -1, 1118 -1, 68, -1, 70, 47, 48, 49, 50, 51, 52, 1119 53, -1, 55, 56, 57, 58, -1, 60, 61, 62, 1120 63, 64, -1, -1, -1, 68, -1, 70, 48, 49, 1121 50, 51, 52, 53, -1, 55, 56, 57, 58, -1, 1122 60, 61, 62, 63, 64, -1, -1, -1, 68, -1, 1123 70, 49, 50, 51, 52, 53, -1, 55, 56, 57, 1124 58, -1, 60, 61, 62, 63, 64, -1, -1, -1, 1125 68, -1, 70, 50, 51, 52, 53, -1, 55, 56, 1126 57, 58, -1, 60, 61, 62, 63, 64, -1, -1, 1127 -1, 68, 53, 70, 55, 56, 57, 58, -1, 60, 1128 61, 62, 63, 64, -1, -1, -1, 68, -1, 70 1129}; 1130 1131/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1132 symbol of state STATE-NUM. */ 1133static const unsigned char yystos[] = 1134{ 1135 0, 5, 11, 12, 17, 21, 22, 23, 24, 25, 1136 26, 27, 28, 30, 31, 32, 33, 34, 38, 39, 1137 41, 72, 77, 78, 80, 81, 82, 83, 84, 85, 1138 87, 89, 90, 91, 92, 98, 99, 100, 101, 102, 1139 105, 109, 12, 53, 83, 87, 90, 91, 12, 15, 1140 16, 35, 43, 44, 46, 47, 48, 49, 50, 51, 1141 52, 53, 54, 55, 56, 57, 58, 60, 61, 62, 1142 63, 64, 65, 66, 69, 70, 72, 73, 74, 91, 1143 105, 27, 78, 78, 5, 0, 53, 5, 12, 50, 1144 62, 69, 74, 79, 91, 92, 96, 103, 104, 107, 1145 108, 99, 74, 96, 5, 83, 85, 92, 12, 99, 1146 12, 87, 102, 22, 100, 99, 12, 17, 74, 86, 1147 87, 88, 89, 91, 96, 103, 106, 107, 112, 113, 1148 3, 4, 10, 18, 19, 20, 36, 37, 50, 61, 1149 72, 73, 74, 93, 94, 105, 114, 99, 83, 69, 1150 69, 71, 62, 42, 40, 93, 78, 91, 97, 99, 1151 3, 71, 12, 31, 42, 74, 91, 95, 103, 105, 1152 106, 5, 62, 92, 12, 79, 12, 108, 96, 104, 1153 79, 12, 12, 87, 99, 99, 87, 91, 103, 96, 1154 104, 79, 74, 106, 112, 96, 96, 104, 74, 53, 1155 53, 53, 74, 78, 105, 114, 114, 114, 50, 105, 1156 109, 114, 115, 43, 54, 74, 106, 45, 46, 47, 1157 48, 49, 50, 51, 52, 53, 55, 56, 57, 58, 1158 60, 61, 62, 63, 64, 68, 70, 71, 71, 78, 1159 54, 62, 71, 91, 42, 97, 42, 43, 106, 42, 1160 97, 91, 12, 99, 74, 88, 103, 110, 111, 12, 1161 12, 105, 109, 109, 109, 109, 78, 74, 78, 42, 1162 54, 42, 94, 50, 74, 115, 114, 114, 114, 114, 1163 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, 1164 114, 114, 114, 114, 5, 5, 97, 97, 97, 29, 1165 105, 78, 110, 110, 42, 96, 104, 78, 78, 42, 1166 54, 54, 54, 42, 114, 114, 42, 75, 106, 42, 1167 74, 74, 74, 114, 115, 115, 115, 42, 42, 42 1168}; 1169 1170#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 1171# define YYSIZE_T __SIZE_TYPE__ 1172#endif 1173#if ! defined (YYSIZE_T) && defined (size_t) 1174# define YYSIZE_T size_t 1175#endif 1176#if ! defined (YYSIZE_T) 1177# if defined (__STDC__) || defined (__cplusplus) 1178# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 1179# define YYSIZE_T size_t 1180# endif 1181#endif 1182#if ! defined (YYSIZE_T) 1183# define YYSIZE_T unsigned int 1184#endif 1185 1186#define yyerrok (yyerrstatus = 0) 1187#define yyclearin (yychar = YYEMPTY) 1188#define YYEMPTY (-2) 1189#define YYEOF 0 1190 1191#define YYACCEPT goto yyacceptlab 1192#define YYABORT goto yyabortlab 1193#define YYERROR goto yyerrorlab 1194 1195 1196/* Like YYERROR except do call yyerror. This remains here temporarily 1197 to ease the transition to the new meaning of YYERROR, for GCC. 1198 Once GCC version 2 has supplanted version 1, this can go. */ 1199 1200#define YYFAIL goto yyerrlab 1201 1202#define YYRECOVERING() (!!yyerrstatus) 1203 1204#define YYBACKUP(Token, Value) \ 1205do \ 1206 if (yychar == YYEMPTY && yylen == 1) \ 1207 { \ 1208 yychar = (Token); \ 1209 yylval = (Value); \ 1210 yytoken = YYTRANSLATE (yychar); \ 1211 YYPOPSTACK; \ 1212 goto yybackup; \ 1213 } \ 1214 else \ 1215 { \ 1216 yyerror ("syntax error: cannot back up");\ 1217 YYERROR; \ 1218 } \ 1219while (0) 1220 1221#define YYTERROR 1 1222#define YYERRCODE 256 1223 1224/* YYLLOC_DEFAULT -- Compute the default location (before the actions 1225 are run). */ 1226 1227#ifndef YYLLOC_DEFAULT 1228# define YYLLOC_DEFAULT(Current, Rhs, N) \ 1229 ((Current).first_line = (Rhs)[1].first_line, \ 1230 (Current).first_column = (Rhs)[1].first_column, \ 1231 (Current).last_line = (Rhs)[N].last_line, \ 1232 (Current).last_column = (Rhs)[N].last_column) 1233#endif 1234 1235/* YYLEX -- calling `yylex' with the right arguments. */ 1236 1237#ifdef YYLEX_PARAM 1238# define YYLEX yylex (YYLEX_PARAM) 1239#else 1240# define YYLEX yylex () 1241#endif 1242 1243/* Enable debugging if requested. */ 1244#if YYDEBUG 1245 1246# ifndef YYFPRINTF 1247# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1248# define YYFPRINTF fprintf 1249# endif 1250 1251# define YYDPRINTF(Args) \ 1252do { \ 1253 if (yydebug) \ 1254 YYFPRINTF Args; \ 1255} while (0) 1256 1257# define YYDSYMPRINT(Args) \ 1258do { \ 1259 if (yydebug) \ 1260 yysymprint Args; \ 1261} while (0) 1262 1263# define YYDSYMPRINTF(Title, Token, Value, Location) \ 1264do { \ 1265 if (yydebug) \ 1266 { \ 1267 YYFPRINTF (stderr, "%s ", Title); \ 1268 yysymprint (stderr, \ 1269 Token, Value); \ 1270 YYFPRINTF (stderr, "\n"); \ 1271 } \ 1272} while (0) 1273 1274/*------------------------------------------------------------------. 1275| yy_stack_print -- Print the state stack from its BOTTOM up to its | 1276| TOP (included). | 1277`------------------------------------------------------------------*/ 1278 1279#if defined (__STDC__) || defined (__cplusplus) 1280static void 1281yy_stack_print (short *bottom, short *top) 1282#else 1283static void 1284yy_stack_print (bottom, top) 1285 short *bottom; 1286 short *top; 1287#endif 1288{ 1289 YYFPRINTF (stderr, "Stack now"); 1290 for (/* Nothing. */; bottom <= top; ++bottom) 1291 YYFPRINTF (stderr, " %d", *bottom); 1292 YYFPRINTF (stderr, "\n"); 1293} 1294 1295# define YY_STACK_PRINT(Bottom, Top) \ 1296do { \ 1297 if (yydebug) \ 1298 yy_stack_print ((Bottom), (Top)); \ 1299} while (0) 1300 1301 1302/*------------------------------------------------. 1303| Report that the YYRULE is going to be reduced. | 1304`------------------------------------------------*/ 1305 1306#if defined (__STDC__) || defined (__cplusplus) 1307static void 1308yy_reduce_print (int yyrule) 1309#else 1310static void 1311yy_reduce_print (yyrule) 1312 int yyrule; 1313#endif 1314{ 1315 int yyi; 1316 unsigned int yylno = yyrline[yyrule]; 1317 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", 1318 yyrule - 1, yylno); 1319 /* Print the symbols being reduced, and their result. */ 1320 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 1321 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); 1322 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); 1323} 1324 1325# define YY_REDUCE_PRINT(Rule) \ 1326do { \ 1327 if (yydebug) \ 1328 yy_reduce_print (Rule); \ 1329} while (0) 1330 1331/* Nonzero means print parse trace. It is left uninitialized so that 1332 multiple parsers can coexist. */ 1333int yydebug; 1334#else /* !YYDEBUG */ 1335# define YYDPRINTF(Args) 1336# define YYDSYMPRINT(Args) 1337# define YYDSYMPRINTF(Title, Token, Value, Location) 1338# define YY_STACK_PRINT(Bottom, Top) 1339# define YY_REDUCE_PRINT(Rule) 1340#endif /* !YYDEBUG */ 1341 1342 1343/* YYINITDEPTH -- initial size of the parser's stacks. */ 1344#ifndef YYINITDEPTH 1345# define YYINITDEPTH 200 1346#endif 1347 1348/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1349 if the built-in stack extension method is used). 1350 1351 Do not make this value too large; the results are undefined if 1352 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) 1353 evaluated with infinite-precision integer arithmetic. */ 1354 1355#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 1356# undef YYMAXDEPTH 1357#endif 1358 1359#ifndef YYMAXDEPTH 1360# define YYMAXDEPTH 10000 1361#endif 1362 1363 1364 1365#if YYERROR_VERBOSE 1366 1367# ifndef yystrlen 1368# if defined (__GLIBC__) && defined (_STRING_H) 1369# define yystrlen strlen 1370# else 1371/* Return the length of YYSTR. */ 1372static YYSIZE_T 1373# if defined (__STDC__) || defined (__cplusplus) 1374yystrlen (const char *yystr) 1375# else 1376yystrlen (yystr) 1377 const char *yystr; 1378# endif 1379{ 1380 register const char *yys = yystr; 1381 1382 while (*yys++ != '\0') 1383 continue; 1384 1385 return yys - yystr - 1; 1386} 1387# endif 1388# endif 1389 1390# ifndef yystpcpy 1391# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 1392# define yystpcpy stpcpy 1393# else 1394/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1395 YYDEST. */ 1396static char * 1397# if defined (__STDC__) || defined (__cplusplus) 1398yystpcpy (char *yydest, const char *yysrc) 1399# else 1400yystpcpy (yydest, yysrc) 1401 char *yydest; 1402 const char *yysrc; 1403# endif 1404{ 1405 register char *yyd = yydest; 1406 register const char *yys = yysrc; 1407 1408 while ((*yyd++ = *yys++) != '\0') 1409 continue; 1410 1411 return yyd - 1; 1412} 1413# endif 1414# endif 1415 1416#endif /* !YYERROR_VERBOSE */ 1417 1418 1419 1420#if YYDEBUG 1421/*--------------------------------. 1422| Print this symbol on YYOUTPUT. | 1423`--------------------------------*/ 1424 1425#if defined (__STDC__) || defined (__cplusplus) 1426static void 1427yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) 1428#else 1429static void 1430yysymprint (yyoutput, yytype, yyvaluep) 1431 FILE *yyoutput; 1432 int yytype; 1433 YYSTYPE *yyvaluep; 1434#endif 1435{ 1436 /* Pacify ``unused variable'' warnings. */ 1437 (void) yyvaluep; 1438 1439 if (yytype < YYNTOKENS) 1440 { 1441 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1442# ifdef YYPRINT 1443 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1444# endif 1445 } 1446 else 1447 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1448 1449 switch (yytype) 1450 { 1451 default: 1452 break; 1453 } 1454 YYFPRINTF (yyoutput, ")"); 1455} 1456 1457#endif /* ! YYDEBUG */ 1458/*-----------------------------------------------. 1459| Release the memory associated to this symbol. | 1460`-----------------------------------------------*/ 1461 1462#if defined (__STDC__) || defined (__cplusplus) 1463static void 1464yydestruct (int yytype, YYSTYPE *yyvaluep) 1465#else 1466static void 1467yydestruct (yytype, yyvaluep) 1468 int yytype; 1469 YYSTYPE *yyvaluep; 1470#endif 1471{ 1472 /* Pacify ``unused variable'' warnings. */ 1473 (void) yyvaluep; 1474 1475 switch (yytype) 1476 { 1477 1478 default: 1479 break; 1480 } 1481} 1482 1483 1484/* Prevent warnings from -Wmissing-prototypes. */ 1485 1486#ifdef YYPARSE_PARAM 1487# if defined (__STDC__) || defined (__cplusplus) 1488int yyparse (void *YYPARSE_PARAM); 1489# else 1490int yyparse (); 1491# endif 1492#else /* ! YYPARSE_PARAM */ 1493#if defined (__STDC__) || defined (__cplusplus) 1494int yyparse (void); 1495#else 1496int yyparse (); 1497#endif 1498#endif /* ! YYPARSE_PARAM */ 1499 1500 1501 1502/* The lookahead symbol. */ 1503int yychar; 1504 1505/* The semantic value of the lookahead symbol. */ 1506YYSTYPE yylval; 1507 1508/* Number of syntax errors so far. */ 1509int yynerrs; 1510 1511 1512 1513/*----------. 1514| yyparse. | 1515`----------*/ 1516 1517#ifdef YYPARSE_PARAM 1518# if defined (__STDC__) || defined (__cplusplus) 1519int yyparse (void *YYPARSE_PARAM) 1520# else 1521int yyparse (YYPARSE_PARAM) 1522 void *YYPARSE_PARAM; 1523# endif 1524#else /* ! YYPARSE_PARAM */ 1525#if defined (__STDC__) || defined (__cplusplus) 1526int 1527yyparse (void) 1528#else 1529int 1530yyparse () 1531 1532#endif 1533#endif 1534{ 1535 1536 register int yystate; 1537 register int yyn; 1538 int yyresult; 1539 /* Number of tokens to shift before error messages enabled. */ 1540 int yyerrstatus; 1541 /* Lookahead token as an internal (translated) token number. */ 1542 int yytoken = 0; 1543 1544 /* Three stacks and their tools: 1545 `yyss': related to states, 1546 `yyvs': related to semantic values, 1547 `yyls': related to locations. 1548 1549 Refer to the stacks thru separate pointers, to allow yyoverflow 1550 to xreallocate them elsewhere. */ 1551 1552 /* The state stack. */ 1553 short yyssa[YYINITDEPTH]; 1554 short *yyss = yyssa; 1555 register short *yyssp; 1556 1557 /* The semantic value stack. */ 1558 YYSTYPE yyvsa[YYINITDEPTH]; 1559 YYSTYPE *yyvs = yyvsa; 1560 register YYSTYPE *yyvsp; 1561 1562 1563 1564#define YYPOPSTACK (yyvsp--, yyssp--) 1565 1566 YYSIZE_T yystacksize = YYINITDEPTH; 1567 1568 /* The variables used to return semantic value and location from the 1569 action routines. */ 1570 YYSTYPE yyval; 1571 1572 1573 /* When reducing, the number of symbols on the RHS of the reduced 1574 rule. */ 1575 int yylen; 1576 1577 YYDPRINTF ((stderr, "Starting parse\n")); 1578 1579 yystate = 0; 1580 yyerrstatus = 0; 1581 yynerrs = 0; 1582 yychar = YYEMPTY; /* Cause a token to be read. */ 1583 1584 /* Initialize stack pointers. 1585 Waste one element of value and location stack 1586 so that they stay on the same level as the state stack. 1587 The wasted elements are never initialized. */ 1588 1589 yyssp = yyss; 1590 yyvsp = yyvs; 1591 1592 goto yysetstate; 1593 1594/*------------------------------------------------------------. 1595| yynewstate -- Push a new state, which is found in yystate. | 1596`------------------------------------------------------------*/ 1597 yynewstate: 1598 /* In all cases, when you get here, the value and location stacks 1599 have just been pushed. so pushing a state here evens the stacks. 1600 */ 1601 yyssp++; 1602 1603 yysetstate: 1604 *yyssp = yystate; 1605 1606 if (yyss + yystacksize - 1 <= yyssp) 1607 { 1608 /* Get the current used size of the three stacks, in elements. */ 1609 YYSIZE_T yysize = yyssp - yyss + 1; 1610 1611#ifdef yyoverflow 1612 { 1613 /* Give user a chance to xreallocate the stack. Use copies of 1614 these so that the &'s don't force the real ones into 1615 memory. */ 1616 YYSTYPE *yyvs1 = yyvs; 1617 short *yyss1 = yyss; 1618 1619 1620 /* Each stack pointer address is followed by the size of the 1621 data in use in that stack, in bytes. This used to be a 1622 conditional around just the two extra args, but that might 1623 be undefined if yyoverflow is a macro. */ 1624 yyoverflow ("parser stack overflow", 1625 &yyss1, yysize * sizeof (*yyssp), 1626 &yyvs1, yysize * sizeof (*yyvsp), 1627 1628 &yystacksize); 1629 1630 yyss = yyss1; 1631 yyvs = yyvs1; 1632 } 1633#else /* no yyoverflow */ 1634# ifndef YYSTACK_RELOCATE 1635 goto yyoverflowlab; 1636# else 1637 /* Extend the stack our own way. */ 1638 if (YYMAXDEPTH <= yystacksize) 1639 goto yyoverflowlab; 1640 yystacksize *= 2; 1641 if (YYMAXDEPTH < yystacksize) 1642 yystacksize = YYMAXDEPTH; 1643 1644 { 1645 short *yyss1 = yyss; 1646 union yyalloc *yyptr = 1647 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1648 if (! yyptr) 1649 goto yyoverflowlab; 1650 YYSTACK_RELOCATE (yyss); 1651 YYSTACK_RELOCATE (yyvs); 1652 1653# undef YYSTACK_RELOCATE 1654 if (yyss1 != yyssa) 1655 YYSTACK_FREE (yyss1); 1656 } 1657# endif 1658#endif /* no yyoverflow */ 1659 1660 yyssp = yyss + yysize - 1; 1661 yyvsp = yyvs + yysize - 1; 1662 1663 1664 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1665 (unsigned long int) yystacksize)); 1666 1667 if (yyss + yystacksize - 1 <= yyssp) 1668 YYABORT; 1669 } 1670 1671 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1672 1673 goto yybackup; 1674 1675/*-----------. 1676| yybackup. | 1677`-----------*/ 1678yybackup: 1679 1680/* Do appropriate processing given the current state. */ 1681/* Read a lookahead token if we need one and don't already have one. */ 1682/* yyresume: */ 1683 1684 /* First try to decide what to do without reference to lookahead token. */ 1685 1686 yyn = yypact[yystate]; 1687 if (yyn == YYPACT_NINF) 1688 goto yydefault; 1689 1690 /* Not known => get a lookahead token if don't already have one. */ 1691 1692 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1693 if (yychar == YYEMPTY) 1694 { 1695 YYDPRINTF ((stderr, "Reading a token: ")); 1696 yychar = YYLEX; 1697 } 1698 1699 if (yychar <= YYEOF) 1700 { 1701 yychar = yytoken = YYEOF; 1702 YYDPRINTF ((stderr, "Now at end of input.\n")); 1703 } 1704 else 1705 { 1706 yytoken = YYTRANSLATE (yychar); 1707 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); 1708 } 1709 1710 /* If the proper action on seeing token YYTOKEN is to reduce or to 1711 detect an error, take that action. */ 1712 yyn += yytoken; 1713 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1714 goto yydefault; 1715 yyn = yytable[yyn]; 1716 if (yyn <= 0) 1717 { 1718 if (yyn == 0 || yyn == YYTABLE_NINF) 1719 goto yyerrlab; 1720 yyn = -yyn; 1721 goto yyreduce; 1722 } 1723 1724 if (yyn == YYFINAL) 1725 YYACCEPT; 1726 1727 /* Shift the lookahead token. */ 1728 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); 1729 1730 /* Discard the token being shifted unless it is eof. */ 1731 if (yychar != YYEOF) 1732 yychar = YYEMPTY; 1733 1734 *++yyvsp = yylval; 1735 1736 1737 /* Count tokens shifted since error; after three, turn off error 1738 status. */ 1739 if (yyerrstatus) 1740 yyerrstatus--; 1741 1742 yystate = yyn; 1743 goto yynewstate; 1744 1745 1746/*-----------------------------------------------------------. 1747| yydefault -- do the default action for the current state. | 1748`-----------------------------------------------------------*/ 1749yydefault: 1750 yyn = yydefact[yystate]; 1751 if (yyn == 0) 1752 goto yyerrlab; 1753 goto yyreduce; 1754 1755 1756/*-----------------------------. 1757| yyreduce -- Do a reduction. | 1758`-----------------------------*/ 1759yyreduce: 1760 /* yyn is the number of a rule to reduce with. */ 1761 yylen = yyr2[yyn]; 1762 1763 /* If YYLEN is nonzero, implement the default value of the action: 1764 `$$ = $1'. 1765 1766 Otherwise, the following line sets YYVAL to garbage. 1767 This behavior is undocumented and Bison 1768 users should not rely upon it. Assigning to YYVAL 1769 unconditionally makes the parser a bit smaller, and it avoids a 1770 GCC warning that YYVAL may be used uninitialized. */ 1771 yyval = yyvsp[1-yylen]; 1772 1773 1774 YY_REDUCE_PRINT (yyn); 1775 switch (yyn) 1776 { 1777 case 2: 1778#line 342 "cp-name-parser.y" 1779 { global_result = yyvsp[0].comp; } 1780 break; 1781 1782 case 6: 1783#line 354 "cp-name-parser.y" 1784 { yyval.comp = NULL; } 1785 break; 1786 1787 case 7: 1788#line 356 "cp-name-parser.y" 1789 { yyval.comp = yyvsp[0].comp; } 1790 break; 1791 1792 case 8: 1793#line 363 "cp-name-parser.y" 1794 { yyval.comp = yyvsp[0].nested.comp; 1795 *yyvsp[0].nested.last = yyvsp[-1].comp; 1796 } 1797 break; 1798 1799 case 9: 1800#line 372 "cp-name-parser.y" 1801 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-2].comp, yyvsp[-1].nested.comp); 1802 if (yyvsp[0].comp) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].comp); } 1803 break; 1804 1805 case 10: 1806#line 375 "cp-name-parser.y" 1807 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-2].comp, yyvsp[-1].nested.comp); 1808 if (yyvsp[0].comp) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].comp); } 1809 break; 1810 1811 case 11: 1812#line 379 "cp-name-parser.y" 1813 { yyval.comp = yyvsp[-1].nested.comp; 1814 if (yyvsp[0].comp) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].comp); } 1815 break; 1816 1817 case 12: 1818#line 382 "cp-name-parser.y" 1819 { if (yyvsp[0].abstract.last) 1820 { 1821 /* First complete the abstract_declarator's type using 1822 the typespec from the conversion_op_name. */ 1823 *yyvsp[0].abstract.last = *yyvsp[-1].nested.last; 1824 /* Then complete the conversion_op_name with the type. */ 1825 *yyvsp[-1].nested.last = yyvsp[0].abstract.comp; 1826 } 1827 /* If we have an arglist, build a function type. */ 1828 if (yyvsp[0].abstract.fn.comp) 1829 yyval.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-1].nested.comp, yyvsp[0].abstract.fn.comp); 1830 else 1831 yyval.comp = yyvsp[-1].nested.comp; 1832 if (yyvsp[0].abstract.start) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].abstract.start); 1833 } 1834 break; 1835 1836 case 13: 1837#line 401 "cp-name-parser.y" 1838 { yyval.comp = make_empty (yyvsp[-1].lval); 1839 d_left (yyval.comp) = yyvsp[0].comp; 1840 d_right (yyval.comp) = NULL; } 1841 break; 1842 1843 case 14: 1844#line 405 "cp-name-parser.y" 1845 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, yyvsp[-2].comp, yyvsp[0].comp); } 1846 break; 1847 1848 case 15: 1849#line 407 "cp-name-parser.y" 1850 { yyval.comp = make_empty (yyvsp[0].typed_val_int.val); 1851 d_left (yyval.comp) = yyvsp[0].typed_val_int.type; 1852 d_right (yyval.comp) = NULL; } 1853 break; 1854 1855 case 16: 1856#line 413 "cp-name-parser.y" 1857 { yyval.comp = make_operator ("new", 1); } 1858 break; 1859 1860 case 17: 1861#line 415 "cp-name-parser.y" 1862 { yyval.comp = make_operator ("delete", 1); } 1863 break; 1864 1865 case 18: 1866#line 417 "cp-name-parser.y" 1867 { yyval.comp = make_operator ("new[]", 1); } 1868 break; 1869 1870 case 19: 1871#line 419 "cp-name-parser.y" 1872 { yyval.comp = make_operator ("delete[]", 1); } 1873 break; 1874 1875 case 20: 1876#line 421 "cp-name-parser.y" 1877 { yyval.comp = make_operator ("+", 2); } 1878 break; 1879 1880 case 21: 1881#line 423 "cp-name-parser.y" 1882 { yyval.comp = make_operator ("-", 2); } 1883 break; 1884 1885 case 22: 1886#line 425 "cp-name-parser.y" 1887 { yyval.comp = make_operator ("*", 2); } 1888 break; 1889 1890 case 23: 1891#line 427 "cp-name-parser.y" 1892 { yyval.comp = make_operator ("/", 2); } 1893 break; 1894 1895 case 24: 1896#line 429 "cp-name-parser.y" 1897 { yyval.comp = make_operator ("%", 2); } 1898 break; 1899 1900 case 25: 1901#line 431 "cp-name-parser.y" 1902 { yyval.comp = make_operator ("^", 2); } 1903 break; 1904 1905 case 26: 1906#line 433 "cp-name-parser.y" 1907 { yyval.comp = make_operator ("&", 2); } 1908 break; 1909 1910 case 27: 1911#line 435 "cp-name-parser.y" 1912 { yyval.comp = make_operator ("|", 2); } 1913 break; 1914 1915 case 28: 1916#line 437 "cp-name-parser.y" 1917 { yyval.comp = make_operator ("~", 1); } 1918 break; 1919 1920 case 29: 1921#line 439 "cp-name-parser.y" 1922 { yyval.comp = make_operator ("!", 1); } 1923 break; 1924 1925 case 30: 1926#line 441 "cp-name-parser.y" 1927 { yyval.comp = make_operator ("=", 2); } 1928 break; 1929 1930 case 31: 1931#line 443 "cp-name-parser.y" 1932 { yyval.comp = make_operator ("<", 2); } 1933 break; 1934 1935 case 32: 1936#line 445 "cp-name-parser.y" 1937 { yyval.comp = make_operator (">", 2); } 1938 break; 1939 1940 case 33: 1941#line 447 "cp-name-parser.y" 1942 { yyval.comp = make_operator (yyvsp[0].opname, 2); } 1943 break; 1944 1945 case 34: 1946#line 449 "cp-name-parser.y" 1947 { yyval.comp = make_operator ("<<", 2); } 1948 break; 1949 1950 case 35: 1951#line 451 "cp-name-parser.y" 1952 { yyval.comp = make_operator (">>", 2); } 1953 break; 1954 1955 case 36: 1956#line 453 "cp-name-parser.y" 1957 { yyval.comp = make_operator ("==", 2); } 1958 break; 1959 1960 case 37: 1961#line 455 "cp-name-parser.y" 1962 { yyval.comp = make_operator ("!=", 2); } 1963 break; 1964 1965 case 38: 1966#line 457 "cp-name-parser.y" 1967 { yyval.comp = make_operator ("<=", 2); } 1968 break; 1969 1970 case 39: 1971#line 459 "cp-name-parser.y" 1972 { yyval.comp = make_operator (">=", 2); } 1973 break; 1974 1975 case 40: 1976#line 461 "cp-name-parser.y" 1977 { yyval.comp = make_operator ("&&", 2); } 1978 break; 1979 1980 case 41: 1981#line 463 "cp-name-parser.y" 1982 { yyval.comp = make_operator ("||", 2); } 1983 break; 1984 1985 case 42: 1986#line 465 "cp-name-parser.y" 1987 { yyval.comp = make_operator ("++", 1); } 1988 break; 1989 1990 case 43: 1991#line 467 "cp-name-parser.y" 1992 { yyval.comp = make_operator ("--", 1); } 1993 break; 1994 1995 case 44: 1996#line 469 "cp-name-parser.y" 1997 { yyval.comp = make_operator (",", 2); } 1998 break; 1999 2000 case 45: 2001#line 471 "cp-name-parser.y" 2002 { yyval.comp = make_operator ("->*", 2); } 2003 break; 2004 2005 case 46: 2006#line 473 "cp-name-parser.y" 2007 { yyval.comp = make_operator ("->", 2); } 2008 break; 2009 2010 case 47: 2011#line 475 "cp-name-parser.y" 2012 { yyval.comp = make_operator ("()", 0); } 2013 break; 2014 2015 case 48: 2016#line 477 "cp-name-parser.y" 2017 { yyval.comp = make_operator ("[]", 2); } 2018 break; 2019 2020 case 49: 2021#line 485 "cp-name-parser.y" 2022 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[0].comp, NULL); } 2023 break; 2024 2025 case 50: 2026#line 490 "cp-name-parser.y" 2027 { yyval.nested.comp = yyvsp[-1].nested1.comp; 2028 d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; 2029 yyval.nested.last = &d_left (yyvsp[0].comp); 2030 } 2031 break; 2032 2033 case 51: 2034#line 495 "cp-name-parser.y" 2035 { yyval.nested.comp = yyvsp[0].comp; 2036 yyval.nested.last = &d_left (yyvsp[0].comp); 2037 } 2038 break; 2039 2040 case 52: 2041#line 499 "cp-name-parser.y" 2042 { yyval.nested.comp = yyvsp[-1].nested1.comp; 2043 d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; 2044 yyval.nested.last = &d_left (yyvsp[0].comp); 2045 } 2046 break; 2047 2048 case 53: 2049#line 504 "cp-name-parser.y" 2050 { yyval.nested.comp = yyvsp[0].comp; 2051 yyval.nested.last = &d_left (yyvsp[0].comp); 2052 } 2053 break; 2054 2055 case 55: 2056#line 513 "cp-name-parser.y" 2057 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, yyvsp[-3].comp, yyvsp[-1].nested.comp); } 2058 break; 2059 2060 case 56: 2061#line 515 "cp-name-parser.y" 2062 { yyval.comp = make_dtor (gnu_v3_complete_object_dtor, yyvsp[0].comp); } 2063 break; 2064 2065 case 58: 2066#line 528 "cp-name-parser.y" 2067 { yyval.comp = yyvsp[0].comp; } 2068 break; 2069 2070 case 59: 2071#line 534 "cp-name-parser.y" 2072 { yyval.comp = yyvsp[-1].nested1.comp; d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; } 2073 break; 2074 2075 case 61: 2076#line 537 "cp-name-parser.y" 2077 { yyval.comp = yyvsp[-1].nested1.comp; d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; } 2078 break; 2079 2080 case 66: 2081#line 547 "cp-name-parser.y" 2082 { yyval.comp = yyvsp[0].comp; } 2083 break; 2084 2085 case 67: 2086#line 551 "cp-name-parser.y" 2087 { yyval.comp = yyvsp[-1].nested1.comp; d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; } 2088 break; 2089 2090 case 69: 2091#line 556 "cp-name-parser.y" 2092 { yyval.nested1.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); 2093 d_left (yyval.nested1.comp) = yyvsp[-1].comp; 2094 d_right (yyval.nested1.comp) = NULL; 2095 yyval.nested1.last = yyval.nested1.comp; 2096 } 2097 break; 2098 2099 case 70: 2100#line 562 "cp-name-parser.y" 2101 { yyval.nested1.comp = yyvsp[-2].nested1.comp; 2102 d_right (yyvsp[-2].nested1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); 2103 yyval.nested1.last = d_right (yyvsp[-2].nested1.last); 2104 d_left (yyval.nested1.last) = yyvsp[-1].comp; 2105 d_right (yyval.nested1.last) = NULL; 2106 } 2107 break; 2108 2109 case 71: 2110#line 569 "cp-name-parser.y" 2111 { yyval.nested1.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); 2112 d_left (yyval.nested1.comp) = yyvsp[-1].comp; 2113 d_right (yyval.nested1.comp) = NULL; 2114 yyval.nested1.last = yyval.nested1.comp; 2115 } 2116 break; 2117 2118 case 72: 2119#line 575 "cp-name-parser.y" 2120 { yyval.nested1.comp = yyvsp[-2].nested1.comp; 2121 d_right (yyvsp[-2].nested1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); 2122 yyval.nested1.last = d_right (yyvsp[-2].nested1.last); 2123 d_left (yyval.nested1.last) = yyvsp[-1].comp; 2124 d_right (yyval.nested1.last) = NULL; 2125 } 2126 break; 2127 2128 case 73: 2129#line 586 "cp-name-parser.y" 2130 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, yyvsp[-3].comp, yyvsp[-1].nested.comp); } 2131 break; 2132 2133 case 74: 2134#line 590 "cp-name-parser.y" 2135 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, yyvsp[0].comp, NULL); 2136 yyval.nested.last = &d_right (yyval.nested.comp); } 2137 break; 2138 2139 case 75: 2140#line 593 "cp-name-parser.y" 2141 { yyval.nested.comp = yyvsp[-2].nested.comp; 2142 *yyvsp[-2].nested.last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, yyvsp[0].comp, NULL); 2143 yyval.nested.last = &d_right (*yyvsp[-2].nested.last); 2144 } 2145 break; 2146 2147 case 77: 2148#line 605 "cp-name-parser.y" 2149 { yyval.comp = yyvsp[0].abstract.comp; 2150 *yyvsp[0].abstract.last = yyvsp[-1].comp; 2151 } 2152 break; 2153 2154 case 78: 2155#line 609 "cp-name-parser.y" 2156 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), yyvsp[0].comp); } 2157 break; 2158 2159 case 79: 2160#line 611 "cp-name-parser.y" 2161 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), yyvsp[-1].comp); } 2162 break; 2163 2164 case 81: 2165#line 616 "cp-name-parser.y" 2166 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].comp, NULL); 2167 yyval.nested.last = &d_right (yyval.nested.comp); 2168 } 2169 break; 2170 2171 case 82: 2172#line 620 "cp-name-parser.y" 2173 { *yyvsp[0].abstract.last = yyvsp[-1].comp; 2174 yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].abstract.comp, NULL); 2175 yyval.nested.last = &d_right (yyval.nested.comp); 2176 } 2177 break; 2178 2179 case 83: 2180#line 625 "cp-name-parser.y" 2181 { *yyvsp[-2].nested.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].comp, NULL); 2182 yyval.nested.comp = yyvsp[-2].nested.comp; 2183 yyval.nested.last = &d_right (*yyvsp[-2].nested.last); 2184 } 2185 break; 2186 2187 case 84: 2188#line 630 "cp-name-parser.y" 2189 { *yyvsp[0].abstract.last = yyvsp[-1].comp; 2190 *yyvsp[-3].nested.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].abstract.comp, NULL); 2191 yyval.nested.comp = yyvsp[-3].nested.comp; 2192 yyval.nested.last = &d_right (*yyvsp[-3].nested.last); 2193 } 2194 break; 2195 2196 case 85: 2197#line 636 "cp-name-parser.y" 2198 { *yyvsp[-2].nested.last 2199 = fill_comp (DEMANGLE_COMPONENT_ARGLIST, 2200 make_builtin_type ("..."), 2201 NULL); 2202 yyval.nested.comp = yyvsp[-2].nested.comp; 2203 yyval.nested.last = &d_right (*yyvsp[-2].nested.last); 2204 } 2205 break; 2206 2207 case 86: 2208#line 646 "cp-name-parser.y" 2209 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, yyvsp[-2].nested.comp); 2210 yyval.nested.last = &d_left (yyval.nested.comp); 2211 yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 1); } 2212 break; 2213 2214 case 87: 2215#line 650 "cp-name-parser.y" 2216 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL); 2217 yyval.nested.last = &d_left (yyval.nested.comp); 2218 yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 1); } 2219 break; 2220 2221 case 88: 2222#line 654 "cp-name-parser.y" 2223 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL); 2224 yyval.nested.last = &d_left (yyval.nested.comp); 2225 yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 1); } 2226 break; 2227 2228 case 89: 2229#line 661 "cp-name-parser.y" 2230 { yyval.lval = 0; } 2231 break; 2232 2233 case 91: 2234#line 666 "cp-name-parser.y" 2235 { yyval.lval = QUAL_RESTRICT; } 2236 break; 2237 2238 case 92: 2239#line 668 "cp-name-parser.y" 2240 { yyval.lval = QUAL_VOLATILE; } 2241 break; 2242 2243 case 93: 2244#line 670 "cp-name-parser.y" 2245 { yyval.lval = QUAL_CONST; } 2246 break; 2247 2248 case 95: 2249#line 675 "cp-name-parser.y" 2250 { yyval.lval = yyvsp[-1].lval | yyvsp[0].lval; } 2251 break; 2252 2253 case 96: 2254#line 682 "cp-name-parser.y" 2255 { yyval.lval = 0; } 2256 break; 2257 2258 case 97: 2259#line 684 "cp-name-parser.y" 2260 { yyval.lval = INT_SIGNED; } 2261 break; 2262 2263 case 98: 2264#line 686 "cp-name-parser.y" 2265 { yyval.lval = INT_UNSIGNED; } 2266 break; 2267 2268 case 99: 2269#line 688 "cp-name-parser.y" 2270 { yyval.lval = INT_CHAR; } 2271 break; 2272 2273 case 100: 2274#line 690 "cp-name-parser.y" 2275 { yyval.lval = INT_LONG; } 2276 break; 2277 2278 case 101: 2279#line 692 "cp-name-parser.y" 2280 { yyval.lval = INT_SHORT; } 2281 break; 2282 2283 case 103: 2284#line 697 "cp-name-parser.y" 2285 { yyval.lval = yyvsp[-1].lval | yyvsp[0].lval; if (yyvsp[-1].lval & yyvsp[0].lval & INT_LONG) yyval.lval = yyvsp[-1].lval | INT_LLONG; } 2286 break; 2287 2288 case 104: 2289#line 701 "cp-name-parser.y" 2290 { yyval.comp = d_int_type (yyvsp[0].lval); } 2291 break; 2292 2293 case 105: 2294#line 703 "cp-name-parser.y" 2295 { yyval.comp = make_builtin_type ("float"); } 2296 break; 2297 2298 case 106: 2299#line 705 "cp-name-parser.y" 2300 { yyval.comp = make_builtin_type ("double"); } 2301 break; 2302 2303 case 107: 2304#line 707 "cp-name-parser.y" 2305 { yyval.comp = make_builtin_type ("long double"); } 2306 break; 2307 2308 case 108: 2309#line 709 "cp-name-parser.y" 2310 { yyval.comp = make_builtin_type ("bool"); } 2311 break; 2312 2313 case 109: 2314#line 711 "cp-name-parser.y" 2315 { yyval.comp = make_builtin_type ("wchar_t"); } 2316 break; 2317 2318 case 110: 2319#line 713 "cp-name-parser.y" 2320 { yyval.comp = make_builtin_type ("void"); } 2321 break; 2322 2323 case 111: 2324#line 717 "cp-name-parser.y" 2325 { yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_POINTER); 2326 yyval.nested.comp->u.s_binary.left = yyval.nested.comp->u.s_binary.right = NULL; 2327 yyval.nested.last = &d_left (yyval.nested.comp); 2328 yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 0); } 2329 break; 2330 2331 case 112: 2332#line 723 "cp-name-parser.y" 2333 { yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_REFERENCE); 2334 yyval.nested.comp->u.s_binary.left = yyval.nested.comp->u.s_binary.right = NULL; 2335 yyval.nested.last = &d_left (yyval.nested.comp); } 2336 break; 2337 2338 case 113: 2339#line 727 "cp-name-parser.y" 2340 { yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE); 2341 yyval.nested.comp->u.s_binary.left = yyvsp[-2].nested1.comp; 2342 /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */ 2343 *yyvsp[-2].nested1.last = *d_left (yyvsp[-2].nested1.last); 2344 yyval.nested.comp->u.s_binary.right = NULL; 2345 yyval.nested.last = &d_right (yyval.nested.comp); 2346 yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 0); } 2347 break; 2348 2349 case 114: 2350#line 735 "cp-name-parser.y" 2351 { yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE); 2352 yyval.nested.comp->u.s_binary.left = yyvsp[-2].nested1.comp; 2353 /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */ 2354 *yyvsp[-2].nested1.last = *d_left (yyvsp[-2].nested1.last); 2355 yyval.nested.comp->u.s_binary.right = NULL; 2356 yyval.nested.last = &d_right (yyval.nested.comp); 2357 yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 0); } 2358 break; 2359 2360 case 115: 2361#line 745 "cp-name-parser.y" 2362 { yyval.comp = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE); 2363 d_left (yyval.comp) = NULL; 2364 } 2365 break; 2366 2367 case 116: 2368#line 749 "cp-name-parser.y" 2369 { yyval.comp = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE); 2370 d_left (yyval.comp) = yyvsp[-1].comp; 2371 } 2372 break; 2373 2374 case 117: 2375#line 765 "cp-name-parser.y" 2376 { yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[0].lval, 0); } 2377 break; 2378 2379 case 119: 2380#line 768 "cp-name-parser.y" 2381 { yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[-2].lval | yyvsp[0].lval, 0); } 2382 break; 2383 2384 case 120: 2385#line 770 "cp-name-parser.y" 2386 { yyval.comp = d_qualify (yyvsp[0].comp, yyvsp[-1].lval, 0); } 2387 break; 2388 2389 case 121: 2390#line 773 "cp-name-parser.y" 2391 { yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[0].lval, 0); } 2392 break; 2393 2394 case 123: 2395#line 776 "cp-name-parser.y" 2396 { yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[-2].lval | yyvsp[0].lval, 0); } 2397 break; 2398 2399 case 124: 2400#line 778 "cp-name-parser.y" 2401 { yyval.comp = d_qualify (yyvsp[0].comp, yyvsp[-1].lval, 0); } 2402 break; 2403 2404 case 125: 2405#line 781 "cp-name-parser.y" 2406 { yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[0].lval, 0); } 2407 break; 2408 2409 case 126: 2410#line 783 "cp-name-parser.y" 2411 { yyval.comp = yyvsp[0].comp; } 2412 break; 2413 2414 case 127: 2415#line 785 "cp-name-parser.y" 2416 { yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[-3].lval | yyvsp[0].lval, 0); } 2417 break; 2418 2419 case 128: 2420#line 787 "cp-name-parser.y" 2421 { yyval.comp = d_qualify (yyvsp[0].comp, yyvsp[-2].lval, 0); } 2422 break; 2423 2424 case 129: 2425#line 792 "cp-name-parser.y" 2426 { yyval.abstract.comp = yyvsp[0].nested.comp; yyval.abstract.last = yyvsp[0].nested.last; 2427 yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; } 2428 break; 2429 2430 case 130: 2431#line 795 "cp-name-parser.y" 2432 { yyval.abstract = yyvsp[0].abstract; yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; 2433 if (yyvsp[0].abstract.fn.comp) { yyval.abstract.last = yyvsp[0].abstract.fn.last; *yyvsp[0].abstract.last = yyvsp[0].abstract.fn.comp; } 2434 *yyval.abstract.last = yyvsp[-1].nested.comp; 2435 yyval.abstract.last = yyvsp[-1].nested.last; } 2436 break; 2437 2438 case 131: 2439#line 800 "cp-name-parser.y" 2440 { yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; 2441 if (yyvsp[0].abstract.fn.comp) { yyval.abstract.last = yyvsp[0].abstract.fn.last; *yyvsp[0].abstract.last = yyvsp[0].abstract.fn.comp; } 2442 } 2443 break; 2444 2445 case 132: 2446#line 807 "cp-name-parser.y" 2447 { yyval.abstract = yyvsp[-1].abstract; yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.fold_flag = 1; 2448 if (yyvsp[-1].abstract.fn.comp) { yyval.abstract.last = yyvsp[-1].abstract.fn.last; *yyvsp[-1].abstract.last = yyvsp[-1].abstract.fn.comp; } 2449 } 2450 break; 2451 2452 case 133: 2453#line 811 "cp-name-parser.y" 2454 { yyval.abstract.fold_flag = 0; 2455 if (yyvsp[-1].abstract.fn.comp) { yyval.abstract.last = yyvsp[-1].abstract.fn.last; *yyvsp[-1].abstract.last = yyvsp[-1].abstract.fn.comp; } 2456 if (yyvsp[-1].abstract.fold_flag) 2457 { 2458 *yyval.abstract.last = yyvsp[0].nested.comp; 2459 yyval.abstract.last = yyvsp[0].nested.last; 2460 } 2461 else 2462 yyval.abstract.fn = yyvsp[0].nested; 2463 } 2464 break; 2465 2466 case 134: 2467#line 822 "cp-name-parser.y" 2468 { yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.fold_flag = 0; 2469 if (yyvsp[-1].abstract.fn.comp) { yyval.abstract.last = yyvsp[-1].abstract.fn.last; *yyvsp[-1].abstract.last = yyvsp[-1].abstract.fn.comp; } 2470 *yyvsp[-1].abstract.last = yyvsp[0].comp; 2471 yyval.abstract.last = &d_right (yyvsp[0].comp); 2472 } 2473 break; 2474 2475 case 135: 2476#line 828 "cp-name-parser.y" 2477 { yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.fold_flag = 0; 2478 yyval.abstract.comp = yyvsp[0].comp; 2479 yyval.abstract.last = &d_right (yyvsp[0].comp); 2480 } 2481 break; 2482 2483 case 136: 2484#line 846 "cp-name-parser.y" 2485 { yyval.abstract.comp = yyvsp[0].nested.comp; yyval.abstract.last = yyvsp[0].nested.last; 2486 yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.start = NULL; } 2487 break; 2488 2489 case 137: 2490#line 849 "cp-name-parser.y" 2491 { yyval.abstract = yyvsp[0].abstract; 2492 if (yyvsp[0].abstract.last) 2493 *yyval.abstract.last = yyvsp[-1].nested.comp; 2494 else 2495 yyval.abstract.comp = yyvsp[-1].nested.comp; 2496 yyval.abstract.last = yyvsp[-1].nested.last; 2497 } 2498 break; 2499 2500 case 138: 2501#line 857 "cp-name-parser.y" 2502 { yyval.abstract.comp = yyvsp[0].abstract.comp; yyval.abstract.last = yyvsp[0].abstract.last; yyval.abstract.fn = yyvsp[0].abstract.fn; yyval.abstract.start = NULL; } 2503 break; 2504 2505 case 139: 2506#line 859 "cp-name-parser.y" 2507 { yyval.abstract.start = yyvsp[0].comp; 2508 if (yyvsp[-3].abstract.fn.comp) { yyval.abstract.last = yyvsp[-3].abstract.fn.last; *yyvsp[-3].abstract.last = yyvsp[-3].abstract.fn.comp; } 2509 if (yyvsp[-3].abstract.fold_flag) 2510 { 2511 *yyval.abstract.last = yyvsp[-2].nested.comp; 2512 yyval.abstract.last = yyvsp[-2].nested.last; 2513 } 2514 else 2515 yyval.abstract.fn = yyvsp[-2].nested; 2516 } 2517 break; 2518 2519 case 140: 2520#line 870 "cp-name-parser.y" 2521 { yyval.abstract.fn = yyvsp[-1].nested; 2522 yyval.abstract.start = yyvsp[0].comp; 2523 yyval.abstract.comp = NULL; yyval.abstract.last = NULL; 2524 } 2525 break; 2526 2527 case 142: 2528#line 878 "cp-name-parser.y" 2529 { yyval.comp = yyvsp[0].abstract.comp; 2530 *yyvsp[0].abstract.last = yyvsp[-1].comp; 2531 } 2532 break; 2533 2534 case 143: 2535#line 884 "cp-name-parser.y" 2536 { yyval.nested.comp = yyvsp[0].nested.comp; 2537 yyval.nested.last = yyvsp[-1].nested.last; 2538 *yyvsp[0].nested.last = yyvsp[-1].nested.comp; } 2539 break; 2540 2541 case 145: 2542#line 892 "cp-name-parser.y" 2543 { yyval.nested = yyvsp[-1].nested; } 2544 break; 2545 2546 case 146: 2547#line 894 "cp-name-parser.y" 2548 { yyval.nested.comp = yyvsp[-1].nested.comp; 2549 *yyvsp[-1].nested.last = yyvsp[0].nested.comp; 2550 yyval.nested.last = yyvsp[0].nested.last; 2551 } 2552 break; 2553 2554 case 147: 2555#line 899 "cp-name-parser.y" 2556 { yyval.nested.comp = yyvsp[-1].nested.comp; 2557 *yyvsp[-1].nested.last = yyvsp[0].comp; 2558 yyval.nested.last = &d_right (yyvsp[0].comp); 2559 } 2560 break; 2561 2562 case 148: 2563#line 904 "cp-name-parser.y" 2564 { yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME); 2565 d_left (yyval.nested.comp) = yyvsp[0].comp; 2566 yyval.nested.last = &d_right (yyval.nested.comp); 2567 } 2568 break; 2569 2570 case 149: 2571#line 917 "cp-name-parser.y" 2572 { yyval.nested.comp = yyvsp[0].nested.comp; 2573 yyval.nested.last = yyvsp[-1].nested.last; 2574 *yyvsp[0].nested.last = yyvsp[-1].nested.comp; } 2575 break; 2576 2577 case 150: 2578#line 921 "cp-name-parser.y" 2579 { yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME); 2580 d_left (yyval.nested.comp) = yyvsp[0].comp; 2581 yyval.nested.last = &d_right (yyval.nested.comp); 2582 } 2583 break; 2584 2585 case 152: 2586#line 934 "cp-name-parser.y" 2587 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-3].comp, yyvsp[-2].nested.comp); 2588 yyval.nested.last = yyvsp[-2].nested.last; 2589 yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.nested.comp, yyvsp[0].comp); 2590 } 2591 break; 2592 2593 case 153: 2594#line 939 "cp-name-parser.y" 2595 { yyval.nested.comp = yyvsp[-3].nested.comp; 2596 *yyvsp[-3].nested.last = yyvsp[-2].nested.comp; 2597 yyval.nested.last = yyvsp[-2].nested.last; 2598 yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.nested.comp, yyvsp[0].comp); 2599 } 2600 break; 2601 2602 case 154: 2603#line 948 "cp-name-parser.y" 2604 { yyval.nested.comp = yyvsp[-1].nested.comp; 2605 yyval.nested.last = yyvsp[-2].nested.last; 2606 *yyvsp[-1].nested.last = yyvsp[-2].nested.comp; } 2607 break; 2608 2609 case 155: 2610#line 952 "cp-name-parser.y" 2611 { yyval.nested.comp = yyvsp[-1].nested.comp; 2612 *yyvsp[-1].nested.last = yyvsp[0].nested.comp; 2613 yyval.nested.last = yyvsp[0].nested.last; 2614 } 2615 break; 2616 2617 case 156: 2618#line 957 "cp-name-parser.y" 2619 { yyval.nested.comp = yyvsp[-1].nested.comp; 2620 *yyvsp[-1].nested.last = yyvsp[0].comp; 2621 yyval.nested.last = &d_right (yyvsp[0].comp); 2622 } 2623 break; 2624 2625 case 157: 2626#line 962 "cp-name-parser.y" 2627 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-1].comp, yyvsp[0].nested.comp); 2628 yyval.nested.last = yyvsp[0].nested.last; 2629 } 2630 break; 2631 2632 case 158: 2633#line 966 "cp-name-parser.y" 2634 { yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-1].comp, yyvsp[0].comp); 2635 yyval.nested.last = &d_right (yyvsp[0].comp); 2636 } 2637 break; 2638 2639 case 159: 2640#line 972 "cp-name-parser.y" 2641 { yyval.comp = yyvsp[-1].comp; } 2642 break; 2643 2644 case 161: 2645#line 981 "cp-name-parser.y" 2646 { yyval.comp = d_binary (">", yyvsp[-2].comp, yyvsp[0].comp); } 2647 break; 2648 2649 case 162: 2650#line 988 "cp-name-parser.y" 2651 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), yyvsp[0].comp); } 2652 break; 2653 2654 case 163: 2655#line 993 "cp-name-parser.y" 2656 { yyval.comp = d_unary ("-", yyvsp[0].comp); } 2657 break; 2658 2659 case 164: 2660#line 997 "cp-name-parser.y" 2661 { yyval.comp = d_unary ("!", yyvsp[0].comp); } 2662 break; 2663 2664 case 165: 2665#line 1001 "cp-name-parser.y" 2666 { yyval.comp = d_unary ("~", yyvsp[0].comp); } 2667 break; 2668 2669 case 166: 2670#line 1008 "cp-name-parser.y" 2671 { if (yyvsp[0].comp->type == DEMANGLE_COMPONENT_LITERAL 2672 || yyvsp[0].comp->type == DEMANGLE_COMPONENT_LITERAL_NEG) 2673 { 2674 yyval.comp = yyvsp[0].comp; 2675 d_left (yyvsp[0].comp) = yyvsp[-2].comp; 2676 } 2677 else 2678 yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, 2679 fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-2].comp, NULL), 2680 yyvsp[0].comp); 2681 } 2682 break; 2683 2684 case 167: 2685#line 1024 "cp-name-parser.y" 2686 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, 2687 fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-4].comp, NULL), 2688 yyvsp[-1].comp); 2689 } 2690 break; 2691 2692 case 168: 2693#line 1031 "cp-name-parser.y" 2694 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, 2695 fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-4].comp, NULL), 2696 yyvsp[-1].comp); 2697 } 2698 break; 2699 2700 case 169: 2701#line 1038 "cp-name-parser.y" 2702 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, 2703 fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-4].comp, NULL), 2704 yyvsp[-1].comp); 2705 } 2706 break; 2707 2708 case 170: 2709#line 1051 "cp-name-parser.y" 2710 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, 2711 fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-3].comp, NULL), 2712 yyvsp[-1].comp); 2713 } 2714 break; 2715 2716 case 171: 2717#line 1062 "cp-name-parser.y" 2718 { yyval.comp = d_binary ("*", yyvsp[-2].comp, yyvsp[0].comp); } 2719 break; 2720 2721 case 172: 2722#line 1066 "cp-name-parser.y" 2723 { yyval.comp = d_binary ("/", yyvsp[-2].comp, yyvsp[0].comp); } 2724 break; 2725 2726 case 173: 2727#line 1070 "cp-name-parser.y" 2728 { yyval.comp = d_binary ("%", yyvsp[-2].comp, yyvsp[0].comp); } 2729 break; 2730 2731 case 174: 2732#line 1074 "cp-name-parser.y" 2733 { yyval.comp = d_binary ("+", yyvsp[-2].comp, yyvsp[0].comp); } 2734 break; 2735 2736 case 175: 2737#line 1078 "cp-name-parser.y" 2738 { yyval.comp = d_binary ("-", yyvsp[-2].comp, yyvsp[0].comp); } 2739 break; 2740 2741 case 176: 2742#line 1082 "cp-name-parser.y" 2743 { yyval.comp = d_binary ("<<", yyvsp[-2].comp, yyvsp[0].comp); } 2744 break; 2745 2746 case 177: 2747#line 1086 "cp-name-parser.y" 2748 { yyval.comp = d_binary (">>", yyvsp[-2].comp, yyvsp[0].comp); } 2749 break; 2750 2751 case 178: 2752#line 1090 "cp-name-parser.y" 2753 { yyval.comp = d_binary ("==", yyvsp[-2].comp, yyvsp[0].comp); } 2754 break; 2755 2756 case 179: 2757#line 1094 "cp-name-parser.y" 2758 { yyval.comp = d_binary ("!=", yyvsp[-2].comp, yyvsp[0].comp); } 2759 break; 2760 2761 case 180: 2762#line 1098 "cp-name-parser.y" 2763 { yyval.comp = d_binary ("<=", yyvsp[-2].comp, yyvsp[0].comp); } 2764 break; 2765 2766 case 181: 2767#line 1102 "cp-name-parser.y" 2768 { yyval.comp = d_binary (">=", yyvsp[-2].comp, yyvsp[0].comp); } 2769 break; 2770 2771 case 182: 2772#line 1106 "cp-name-parser.y" 2773 { yyval.comp = d_binary ("<", yyvsp[-2].comp, yyvsp[0].comp); } 2774 break; 2775 2776 case 183: 2777#line 1110 "cp-name-parser.y" 2778 { yyval.comp = d_binary ("&", yyvsp[-2].comp, yyvsp[0].comp); } 2779 break; 2780 2781 case 184: 2782#line 1114 "cp-name-parser.y" 2783 { yyval.comp = d_binary ("^", yyvsp[-2].comp, yyvsp[0].comp); } 2784 break; 2785 2786 case 185: 2787#line 1118 "cp-name-parser.y" 2788 { yyval.comp = d_binary ("|", yyvsp[-2].comp, yyvsp[0].comp); } 2789 break; 2790 2791 case 186: 2792#line 1122 "cp-name-parser.y" 2793 { yyval.comp = d_binary ("&&", yyvsp[-2].comp, yyvsp[0].comp); } 2794 break; 2795 2796 case 187: 2797#line 1126 "cp-name-parser.y" 2798 { yyval.comp = d_binary ("||", yyvsp[-2].comp, yyvsp[0].comp); } 2799 break; 2800 2801 case 188: 2802#line 1131 "cp-name-parser.y" 2803 { yyval.comp = d_binary ("->", yyvsp[-2].comp, yyvsp[0].comp); } 2804 break; 2805 2806 case 189: 2807#line 1135 "cp-name-parser.y" 2808 { yyval.comp = d_binary (".", yyvsp[-2].comp, yyvsp[0].comp); } 2809 break; 2810 2811 case 190: 2812#line 1139 "cp-name-parser.y" 2813 { yyval.comp = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3), 2814 fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, yyvsp[-4].comp, 2815 fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, yyvsp[-2].comp, yyvsp[0].comp))); 2816 } 2817 break; 2818 2819 case 193: 2820#line 1153 "cp-name-parser.y" 2821 { yyval.comp = d_unary ("sizeof", yyvsp[-1].comp); } 2822 break; 2823 2824 case 194: 2825#line 1158 "cp-name-parser.y" 2826 { struct demangle_component *i; 2827 i = make_name ("1", 1); 2828 yyval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL, 2829 make_builtin_type ("bool"), 2830 i); 2831 } 2832 break; 2833 2834 case 195: 2835#line 1167 "cp-name-parser.y" 2836 { struct demangle_component *i; 2837 i = make_name ("0", 1); 2838 yyval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL, 2839 make_builtin_type ("bool"), 2840 i); 2841 } 2842 break; 2843 2844 2845 } 2846 2847/* Line 1000 of yacc.c. */ 2848#line 2849 "cp-name-parser.c.tmp" 2849 2850 yyvsp -= yylen; 2851 yyssp -= yylen; 2852 2853 2854 YY_STACK_PRINT (yyss, yyssp); 2855 2856 *++yyvsp = yyval; 2857 2858 2859 /* Now `shift' the result of the reduction. Determine what state 2860 that goes to, based on the state we popped back to and the rule 2861 number reduced by. */ 2862 2863 yyn = yyr1[yyn]; 2864 2865 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2866 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2867 yystate = yytable[yystate]; 2868 else 2869 yystate = yydefgoto[yyn - YYNTOKENS]; 2870 2871 goto yynewstate; 2872 2873 2874/*------------------------------------. 2875| yyerrlab -- here on detecting error | 2876`------------------------------------*/ 2877yyerrlab: 2878 /* If not already recovering from an error, report this error. */ 2879 if (!yyerrstatus) 2880 { 2881 ++yynerrs; 2882#if YYERROR_VERBOSE 2883 yyn = yypact[yystate]; 2884 2885 if (YYPACT_NINF < yyn && yyn < YYLAST) 2886 { 2887 YYSIZE_T yysize = 0; 2888 int yytype = YYTRANSLATE (yychar); 2889 const char* yyprefix; 2890 char *yymsg; 2891 int yyx; 2892 2893 /* Start YYX at -YYN if negative to avoid negative indexes in 2894 YYCHECK. */ 2895 int yyxbegin = yyn < 0 ? -yyn : 0; 2896 2897 /* Stay within bounds of both yycheck and yytname. */ 2898 int yychecklim = YYLAST - yyn; 2899 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2900 int yycount = 0; 2901 2902 yyprefix = ", expecting "; 2903 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2904 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2905 { 2906 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); 2907 yycount += 1; 2908 if (yycount == 5) 2909 { 2910 yysize = 0; 2911 break; 2912 } 2913 } 2914 yysize += (sizeof ("syntax error, unexpected ") 2915 + yystrlen (yytname[yytype])); 2916 yymsg = (char *) YYSTACK_ALLOC (yysize); 2917 if (yymsg != 0) 2918 { 2919 char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); 2920 yyp = yystpcpy (yyp, yytname[yytype]); 2921 2922 if (yycount < 5) 2923 { 2924 yyprefix = ", expecting "; 2925 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2926 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2927 { 2928 yyp = yystpcpy (yyp, yyprefix); 2929 yyp = yystpcpy (yyp, yytname[yyx]); 2930 yyprefix = " or "; 2931 } 2932 } 2933 yyerror (yymsg); 2934 YYSTACK_FREE (yymsg); 2935 } 2936 else 2937 yyerror ("syntax error; also virtual memory exhausted"); 2938 } 2939 else 2940#endif /* YYERROR_VERBOSE */ 2941 yyerror ("syntax error"); 2942 } 2943 2944 2945 2946 if (yyerrstatus == 3) 2947 { 2948 /* If just tried and failed to reuse lookahead token after an 2949 error, discard it. */ 2950 2951 if (yychar <= YYEOF) 2952 { 2953 /* If at end of input, pop the error token, 2954 then the rest of the stack, then return failure. */ 2955 if (yychar == YYEOF) 2956 for (;;) 2957 { 2958 YYPOPSTACK; 2959 if (yyssp == yyss) 2960 YYABORT; 2961 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 2962 yydestruct (yystos[*yyssp], yyvsp); 2963 } 2964 } 2965 else 2966 { 2967 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); 2968 yydestruct (yytoken, &yylval); 2969 yychar = YYEMPTY; 2970 2971 } 2972 } 2973 2974 /* Else will try to reuse lookahead token after shifting the error 2975 token. */ 2976 goto yyerrlab1; 2977 2978 2979/*---------------------------------------------------. 2980| yyerrorlab -- error raised explicitly by YYERROR. | 2981`---------------------------------------------------*/ 2982yyerrorlab: 2983 2984#ifdef __GNUC__ 2985 /* Pacify GCC when the user code never invokes YYERROR and the label 2986 yyerrorlab therefore never appears in user code. */ 2987 if (0) 2988 goto yyerrorlab; 2989#endif 2990 2991 yyvsp -= yylen; 2992 yyssp -= yylen; 2993 yystate = *yyssp; 2994 goto yyerrlab1; 2995 2996 2997/*-------------------------------------------------------------. 2998| yyerrlab1 -- common code for both syntax error and YYERROR. | 2999`-------------------------------------------------------------*/ 3000yyerrlab1: 3001 yyerrstatus = 3; /* Each real token shifted decrements this. */ 3002 3003 for (;;) 3004 { 3005 yyn = yypact[yystate]; 3006 if (yyn != YYPACT_NINF) 3007 { 3008 yyn += YYTERROR; 3009 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 3010 { 3011 yyn = yytable[yyn]; 3012 if (0 < yyn) 3013 break; 3014 } 3015 } 3016 3017 /* Pop the current state because it cannot handle the error token. */ 3018 if (yyssp == yyss) 3019 YYABORT; 3020 3021 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 3022 yydestruct (yystos[yystate], yyvsp); 3023 YYPOPSTACK; 3024 yystate = *yyssp; 3025 YY_STACK_PRINT (yyss, yyssp); 3026 } 3027 3028 if (yyn == YYFINAL) 3029 YYACCEPT; 3030 3031 YYDPRINTF ((stderr, "Shifting error token, ")); 3032 3033 *++yyvsp = yylval; 3034 3035 3036 yystate = yyn; 3037 goto yynewstate; 3038 3039 3040/*-------------------------------------. 3041| yyacceptlab -- YYACCEPT comes here. | 3042`-------------------------------------*/ 3043yyacceptlab: 3044 yyresult = 0; 3045 goto yyreturn; 3046 3047/*-----------------------------------. 3048| yyabortlab -- YYABORT comes here. | 3049`-----------------------------------*/ 3050yyabortlab: 3051 yyresult = 1; 3052 goto yyreturn; 3053 3054#ifndef yyoverflow 3055/*----------------------------------------------. 3056| yyoverflowlab -- parser overflow comes here. | 3057`----------------------------------------------*/ 3058yyoverflowlab: 3059 yyerror ("parser stack overflow"); 3060 yyresult = 2; 3061 /* Fall through. */ 3062#endif 3063 3064yyreturn: 3065#ifndef yyoverflow 3066 if (yyss != yyssa) 3067 YYSTACK_FREE (yyss); 3068#endif 3069 return yyresult; 3070} 3071 3072 3073#line 1177 "cp-name-parser.y" 3074 3075 3076/* Apply QUALIFIERS to LHS and return a qualified component. IS_METHOD 3077 is set if LHS is a method, in which case the qualifiers are logically 3078 applied to "this". We apply qualifiers in a consistent order; LHS 3079 may already be qualified; duplicate qualifiers are not created. */ 3080 3081struct demangle_component * 3082d_qualify (struct demangle_component *lhs, int qualifiers, int is_method) 3083{ 3084 struct demangle_component **inner_p; 3085 enum demangle_component_type type; 3086 3087 /* For now the order is CONST (innermost), VOLATILE, RESTRICT. */ 3088 3089#define HANDLE_QUAL(TYPE, MTYPE, QUAL) \ 3090 if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE)) \ 3091 { \ 3092 *inner_p = fill_comp (is_method ? MTYPE : TYPE, \ 3093 *inner_p, NULL); \ 3094 inner_p = &d_left (*inner_p); \ 3095 type = (*inner_p)->type; \ 3096 } \ 3097 else if (type == TYPE || type == MTYPE) \ 3098 { \ 3099 inner_p = &d_left (*inner_p); \ 3100 type = (*inner_p)->type; \ 3101 } 3102 3103 inner_p = &lhs; 3104 3105 type = (*inner_p)->type; 3106 3107 HANDLE_QUAL (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, QUAL_RESTRICT); 3108 HANDLE_QUAL (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, QUAL_VOLATILE); 3109 HANDLE_QUAL (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, QUAL_CONST); 3110 3111 return lhs; 3112} 3113 3114/* Return a builtin type corresponding to FLAGS. */ 3115 3116static struct demangle_component * 3117d_int_type (int flags) 3118{ 3119 const char *name; 3120 3121 switch (flags) 3122 { 3123 case INT_SIGNED | INT_CHAR: 3124 name = "signed char"; 3125 break; 3126 case INT_CHAR: 3127 name = "char"; 3128 break; 3129 case INT_UNSIGNED | INT_CHAR: 3130 name = "unsigned char"; 3131 break; 3132 case 0: 3133 case INT_SIGNED: 3134 name = "int"; 3135 break; 3136 case INT_UNSIGNED: 3137 name = "unsigned int"; 3138 break; 3139 case INT_LONG: 3140 case INT_SIGNED | INT_LONG: 3141 name = "long"; 3142 break; 3143 case INT_UNSIGNED | INT_LONG: 3144 name = "unsigned long"; 3145 break; 3146 case INT_SHORT: 3147 case INT_SIGNED | INT_SHORT: 3148 name = "short"; 3149 break; 3150 case INT_UNSIGNED | INT_SHORT: 3151 name = "unsigned short"; 3152 break; 3153 case INT_LLONG | INT_LONG: 3154 case INT_SIGNED | INT_LLONG | INT_LONG: 3155 name = "long long"; 3156 break; 3157 case INT_UNSIGNED | INT_LLONG | INT_LONG: 3158 name = "unsigned long long"; 3159 break; 3160 default: 3161 return NULL; 3162 } 3163 3164 return make_builtin_type (name); 3165} 3166 3167/* Wrapper to create a unary operation. */ 3168 3169static struct demangle_component * 3170d_unary (const char *name, struct demangle_component *lhs) 3171{ 3172 return fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator (name, 1), lhs); 3173} 3174 3175/* Wrapper to create a binary operation. */ 3176 3177static struct demangle_component * 3178d_binary (const char *name, struct demangle_component *lhs, struct demangle_component *rhs) 3179{ 3180 return fill_comp (DEMANGLE_COMPONENT_BINARY, make_operator (name, 2), 3181 fill_comp (DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs)); 3182} 3183 3184/* Find the end of a symbol name starting at LEXPTR. */ 3185 3186static const char * 3187symbol_end (const char *lexptr) 3188{ 3189 const char *p = lexptr; 3190 3191 while (*p && (ISALNUM (*p) || *p == '_' || *p == '$' || *p == '.')) 3192 p++; 3193 3194 return p; 3195} 3196 3197/* Take care of parsing a number (anything that starts with a digit). 3198 The number starts at P and contains LEN characters. Store the result in 3199 YYLVAL. */ 3200 3201static int 3202parse_number (const char *p, int len, int parsed_float) 3203{ 3204 int unsigned_p = 0; 3205 3206 /* Number of "L" suffixes encountered. */ 3207 int long_p = 0; 3208 3209 struct demangle_component *signed_type; 3210 struct demangle_component *unsigned_type; 3211 struct demangle_component *type, *name; 3212 enum demangle_component_type literal_type; 3213 3214 if (p[0] == '-') 3215 { 3216 literal_type = DEMANGLE_COMPONENT_LITERAL_NEG; 3217 p++; 3218 len--; 3219 } 3220 else 3221 literal_type = DEMANGLE_COMPONENT_LITERAL; 3222 3223 if (parsed_float) 3224 { 3225 /* It's a float since it contains a point or an exponent. */ 3226 char c; 3227 3228 /* The GDB lexer checks the result of scanf at this point. Not doing 3229 this leaves our error checking slightly weaker but only for invalid 3230 data. */ 3231 3232 /* See if it has `f' or `l' suffix (float or long double). */ 3233 3234 c = TOLOWER (p[len - 1]); 3235 3236 if (c == 'f') 3237 { 3238 len--; 3239 type = make_builtin_type ("float"); 3240 } 3241 else if (c == 'l') 3242 { 3243 len--; 3244 type = make_builtin_type ("long double"); 3245 } 3246 else if (ISDIGIT (c) || c == '.') 3247 type = make_builtin_type ("double"); 3248 else 3249 return ERROR; 3250 3251 name = make_name (p, len); 3252 yylval.comp = fill_comp (literal_type, type, name); 3253 3254 return FLOAT; 3255 } 3256 3257 /* This treats 0x1 and 1 as different literals. We also do not 3258 automatically generate unsigned types. */ 3259 3260 long_p = 0; 3261 unsigned_p = 0; 3262 while (len > 0) 3263 { 3264 if (p[len - 1] == 'l' || p[len - 1] == 'L') 3265 { 3266 len--; 3267 long_p++; 3268 continue; 3269 } 3270 if (p[len - 1] == 'u' || p[len - 1] == 'U') 3271 { 3272 len--; 3273 unsigned_p++; 3274 continue; 3275 } 3276 break; 3277 } 3278 3279 if (long_p == 0) 3280 { 3281 unsigned_type = make_builtin_type ("unsigned int"); 3282 signed_type = make_builtin_type ("int"); 3283 } 3284 else if (long_p == 1) 3285 { 3286 unsigned_type = make_builtin_type ("unsigned long"); 3287 signed_type = make_builtin_type ("long"); 3288 } 3289 else 3290 { 3291 unsigned_type = make_builtin_type ("unsigned long long"); 3292 signed_type = make_builtin_type ("long long"); 3293 } 3294 3295 if (unsigned_p) 3296 type = unsigned_type; 3297 else 3298 type = signed_type; 3299 3300 name = make_name (p, len); 3301 yylval.comp = fill_comp (literal_type, type, name); 3302 3303 return INT; 3304} 3305 3306static char backslashable[] = "abefnrtv"; 3307static char represented[] = "\a\b\e\f\n\r\t\v"; 3308 3309/* Translate the backslash the way we would in the host character set. */ 3310static int 3311c_parse_backslash (int host_char, int *target_char) 3312{ 3313 const char *ix; 3314 ix = strchr (backslashable, host_char); 3315 if (! ix) 3316 return 0; 3317 else 3318 *target_char = represented[ix - backslashable]; 3319 return 1; 3320} 3321 3322/* Parse a C escape sequence. STRING_PTR points to a variable 3323 containing a pointer to the string to parse. That pointer 3324 should point to the character after the \. That pointer 3325 is updated past the characters we use. The value of the 3326 escape sequence is returned. 3327 3328 A negative value means the sequence \ newline was seen, 3329 which is supposed to be equivalent to nothing at all. 3330 3331 If \ is followed by a null character, we return a negative 3332 value and leave the string pointer pointing at the null character. 3333 3334 If \ is followed by 000, we return 0 and leave the string pointer 3335 after the zeros. A value of 0 does not mean end of string. */ 3336 3337static int 3338parse_escape (const char **string_ptr) 3339{ 3340 int target_char; 3341 int c = *(*string_ptr)++; 3342 if (c_parse_backslash (c, &target_char)) 3343 return target_char; 3344 else 3345 switch (c) 3346 { 3347 case '\n': 3348 return -2; 3349 case 0: 3350 (*string_ptr)--; 3351 return 0; 3352 case '^': 3353 { 3354 c = *(*string_ptr)++; 3355 3356 if (c == '?') 3357 return 0177; 3358 else if (c == '\\') 3359 target_char = parse_escape (string_ptr); 3360 else 3361 target_char = c; 3362 3363 /* Now target_char is something like `c', and we want to find 3364 its control-character equivalent. */ 3365 target_char = target_char & 037; 3366 3367 return target_char; 3368 } 3369 3370 case '0': 3371 case '1': 3372 case '2': 3373 case '3': 3374 case '4': 3375 case '5': 3376 case '6': 3377 case '7': 3378 { 3379 int i = c - '0'; 3380 int count = 0; 3381 while (++count < 3) 3382 { 3383 c = (**string_ptr); 3384 if (c >= '0' && c <= '7') 3385 { 3386 (*string_ptr)++; 3387 i *= 8; 3388 i += c - '0'; 3389 } 3390 else 3391 { 3392 break; 3393 } 3394 } 3395 return i; 3396 } 3397 default: 3398 return c; 3399 } 3400} 3401 3402#define HANDLE_SPECIAL(string, comp) \ 3403 if (strncmp (tokstart, string, sizeof (string) - 1) == 0) \ 3404 { \ 3405 lexptr = tokstart + sizeof (string) - 1; \ 3406 yylval.lval = comp; \ 3407 return DEMANGLER_SPECIAL; \ 3408 } 3409 3410#define HANDLE_TOKEN2(string, token) \ 3411 if (lexptr[1] == string[1]) \ 3412 { \ 3413 lexptr += 2; \ 3414 yylval.opname = string; \ 3415 return token; \ 3416 } 3417 3418#define HANDLE_TOKEN3(string, token) \ 3419 if (lexptr[1] == string[1] && lexptr[2] == string[2]) \ 3420 { \ 3421 lexptr += 3; \ 3422 yylval.opname = string; \ 3423 return token; \ 3424 } 3425 3426/* Read one token, getting characters through LEXPTR. */ 3427 3428static int 3429yylex (void) 3430{ 3431 int c; 3432 int namelen; 3433 const char *tokstart, *tokptr; 3434 3435 retry: 3436 prev_lexptr = lexptr; 3437 tokstart = lexptr; 3438 3439 switch (c = *tokstart) 3440 { 3441 case 0: 3442 return 0; 3443 3444 case ' ': 3445 case '\t': 3446 case '\n': 3447 lexptr++; 3448 goto retry; 3449 3450 case '\'': 3451 /* We either have a character constant ('0' or '\177' for example) 3452 or we have a quoted symbol reference ('foo(int,int)' in C++ 3453 for example). */ 3454 lexptr++; 3455 c = *lexptr++; 3456 if (c == '\\') 3457 c = parse_escape (&lexptr); 3458 else if (c == '\'') 3459 { 3460 yyerror ("empty character constant"); 3461 return ERROR; 3462 } 3463 3464 c = *lexptr++; 3465 if (c != '\'') 3466 { 3467 yyerror ("invalid character constant"); 3468 return ERROR; 3469 } 3470 3471 /* FIXME: We should refer to a canonical form of the character, 3472 presumably the same one that appears in manglings - the decimal 3473 representation. But if that isn't in our input then we have to 3474 allocate memory for it somewhere. */ 3475 yylval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL, 3476 make_builtin_type ("char"), 3477 make_name (tokstart, lexptr - tokstart)); 3478 3479 return INT; 3480 3481 case '(': 3482 if (strncmp (tokstart, "(anonymous namespace)", 21) == 0) 3483 { 3484 lexptr += 21; 3485 yylval.comp = make_name ("(anonymous namespace)", 3486 sizeof "(anonymous namespace)" - 1); 3487 return NAME; 3488 } 3489 /* FALL THROUGH */ 3490 3491 case ')': 3492 case ',': 3493 lexptr++; 3494 return c; 3495 3496 case '.': 3497 if (lexptr[1] == '.' && lexptr[2] == '.') 3498 { 3499 lexptr += 3; 3500 return ELLIPSIS; 3501 } 3502 3503 /* Might be a floating point number. */ 3504 if (lexptr[1] < '0' || lexptr[1] > '9') 3505 goto symbol; /* Nope, must be a symbol. */ 3506 3507 goto try_number; 3508 3509 case '-': 3510 HANDLE_TOKEN2 ("-=", ASSIGN_MODIFY); 3511 HANDLE_TOKEN2 ("--", DECREMENT); 3512 HANDLE_TOKEN2 ("->", ARROW); 3513 3514 /* For construction vtables. This is kind of hokey. */ 3515 if (strncmp (tokstart, "-in-", 4) == 0) 3516 { 3517 lexptr += 4; 3518 return CONSTRUCTION_IN; 3519 } 3520 3521 if (lexptr[1] < '0' || lexptr[1] > '9') 3522 { 3523 lexptr++; 3524 return '-'; 3525 } 3526 /* FALL THRU into number case. */ 3527 3528 try_number: 3529 case '0': 3530 case '1': 3531 case '2': 3532 case '3': 3533 case '4': 3534 case '5': 3535 case '6': 3536 case '7': 3537 case '8': 3538 case '9': 3539 { 3540 /* It's a number. */ 3541 int got_dot = 0, got_e = 0, toktype; 3542 const char *p = tokstart; 3543 int hex = 0; 3544 3545 if (c == '-') 3546 p++; 3547 3548 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 3549 { 3550 p += 2; 3551 hex = 1; 3552 } 3553 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) 3554 { 3555 p += 2; 3556 hex = 0; 3557 } 3558 3559 for (;; ++p) 3560 { 3561 /* This test includes !hex because 'e' is a valid hex digit 3562 and thus does not indicate a floating point number when 3563 the radix is hex. */ 3564 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 3565 got_dot = got_e = 1; 3566 /* This test does not include !hex, because a '.' always indicates 3567 a decimal floating point number regardless of the radix. 3568 3569 NOTE drow/2005-03-09: This comment is not accurate in C99; 3570 however, it's not clear that all the floating point support 3571 in this file is doing any good here. */ 3572 else if (!got_dot && *p == '.') 3573 got_dot = 1; 3574 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 3575 && (*p == '-' || *p == '+')) 3576 /* This is the sign of the exponent, not the end of the 3577 number. */ 3578 continue; 3579 /* We will take any letters or digits. parse_number will 3580 complain if past the radix, or if L or U are not final. */ 3581 else if (! ISALNUM (*p)) 3582 break; 3583 } 3584 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e); 3585 if (toktype == ERROR) 3586 { 3587 char *err_copy = (char *) alloca (p - tokstart + 1); 3588 3589 memcpy (err_copy, tokstart, p - tokstart); 3590 err_copy[p - tokstart] = 0; 3591 yyerror ("invalid number"); 3592 return ERROR; 3593 } 3594 lexptr = p; 3595 return toktype; 3596 } 3597 3598 case '+': 3599 HANDLE_TOKEN2 ("+=", ASSIGN_MODIFY); 3600 HANDLE_TOKEN2 ("++", INCREMENT); 3601 lexptr++; 3602 return c; 3603 case '*': 3604 HANDLE_TOKEN2 ("*=", ASSIGN_MODIFY); 3605 lexptr++; 3606 return c; 3607 case '/': 3608 HANDLE_TOKEN2 ("/=", ASSIGN_MODIFY); 3609 lexptr++; 3610 return c; 3611 case '%': 3612 HANDLE_TOKEN2 ("%=", ASSIGN_MODIFY); 3613 lexptr++; 3614 return c; 3615 case '|': 3616 HANDLE_TOKEN2 ("|=", ASSIGN_MODIFY); 3617 HANDLE_TOKEN2 ("||", OROR); 3618 lexptr++; 3619 return c; 3620 case '&': 3621 HANDLE_TOKEN2 ("&=", ASSIGN_MODIFY); 3622 HANDLE_TOKEN2 ("&&", ANDAND); 3623 lexptr++; 3624 return c; 3625 case '^': 3626 HANDLE_TOKEN2 ("^=", ASSIGN_MODIFY); 3627 lexptr++; 3628 return c; 3629 case '!': 3630 HANDLE_TOKEN2 ("!=", NOTEQUAL); 3631 lexptr++; 3632 return c; 3633 case '<': 3634 HANDLE_TOKEN3 ("<<=", ASSIGN_MODIFY); 3635 HANDLE_TOKEN2 ("<=", LEQ); 3636 HANDLE_TOKEN2 ("<<", LSH); 3637 lexptr++; 3638 return c; 3639 case '>': 3640 HANDLE_TOKEN3 (">>=", ASSIGN_MODIFY); 3641 HANDLE_TOKEN2 (">=", GEQ); 3642 HANDLE_TOKEN2 (">>", RSH); 3643 lexptr++; 3644 return c; 3645 case '=': 3646 HANDLE_TOKEN2 ("==", EQUAL); 3647 lexptr++; 3648 return c; 3649 case ':': 3650 HANDLE_TOKEN2 ("::", COLONCOLON); 3651 lexptr++; 3652 return c; 3653 3654 case '[': 3655 case ']': 3656 case '?': 3657 case '@': 3658 case '~': 3659 case '{': 3660 case '}': 3661 symbol: 3662 lexptr++; 3663 return c; 3664 3665 case '"': 3666 /* These can't occur in C++ names. */ 3667 yyerror ("unexpected string literal"); 3668 return ERROR; 3669 } 3670 3671 if (!(c == '_' || c == '$' || ISALPHA (c))) 3672 { 3673 /* We must have come across a bad character (e.g. ';'). */ 3674 yyerror ("invalid character"); 3675 return ERROR; 3676 } 3677 3678 /* It's a name. See how long it is. */ 3679 namelen = 0; 3680 do 3681 c = tokstart[++namelen]; 3682 while (ISALNUM (c) || c == '_' || c == '$'); 3683 3684 lexptr += namelen; 3685 3686 /* Catch specific keywords. Notice that some of the keywords contain 3687 spaces, and are sorted by the length of the first word. They must 3688 all include a trailing space in the string comparison. */ 3689 switch (namelen) 3690 { 3691 case 16: 3692 if (strncmp (tokstart, "reinterpret_cast", 16) == 0) 3693 return REINTERPRET_CAST; 3694 break; 3695 case 12: 3696 if (strncmp (tokstart, "construction vtable for ", 24) == 0) 3697 { 3698 lexptr = tokstart + 24; 3699 return CONSTRUCTION_VTABLE; 3700 } 3701 if (strncmp (tokstart, "dynamic_cast", 12) == 0) 3702 return DYNAMIC_CAST; 3703 break; 3704 case 11: 3705 if (strncmp (tokstart, "static_cast", 11) == 0) 3706 return STATIC_CAST; 3707 break; 3708 case 9: 3709 HANDLE_SPECIAL ("covariant return thunk to ", DEMANGLE_COMPONENT_COVARIANT_THUNK); 3710 HANDLE_SPECIAL ("reference temporary for ", DEMANGLE_COMPONENT_REFTEMP); 3711 break; 3712 case 8: 3713 HANDLE_SPECIAL ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO); 3714 HANDLE_SPECIAL ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN); 3715 HANDLE_SPECIAL ("typeinfo name for ", DEMANGLE_COMPONENT_TYPEINFO_NAME); 3716 if (strncmp (tokstart, "operator", 8) == 0) 3717 return OPERATOR; 3718 if (strncmp (tokstart, "restrict", 8) == 0) 3719 return RESTRICT; 3720 if (strncmp (tokstart, "unsigned", 8) == 0) 3721 return UNSIGNED; 3722 if (strncmp (tokstart, "template", 8) == 0) 3723 return TEMPLATE; 3724 if (strncmp (tokstart, "volatile", 8) == 0) 3725 return VOLATILE_KEYWORD; 3726 break; 3727 case 7: 3728 HANDLE_SPECIAL ("virtual thunk to ", DEMANGLE_COMPONENT_VIRTUAL_THUNK); 3729 if (strncmp (tokstart, "wchar_t", 7) == 0) 3730 return WCHAR_T; 3731 break; 3732 case 6: 3733 if (strncmp (tokstart, "global constructors keyed to ", 29) == 0) 3734 { 3735 const char *p; 3736 lexptr = tokstart + 29; 3737 yylval.typed_val_int.val = GLOBAL_CONSTRUCTORS; 3738 /* Find the end of the symbol. */ 3739 p = symbol_end (lexptr); 3740 yylval.typed_val_int.type = make_name (lexptr, p - lexptr); 3741 lexptr = p; 3742 return GLOBAL; 3743 } 3744 if (strncmp (tokstart, "global destructors keyed to ", 28) == 0) 3745 { 3746 const char *p; 3747 lexptr = tokstart + 28; 3748 yylval.typed_val_int.val = GLOBAL_DESTRUCTORS; 3749 /* Find the end of the symbol. */ 3750 p = symbol_end (lexptr); 3751 yylval.typed_val_int.type = make_name (lexptr, p - lexptr); 3752 lexptr = p; 3753 return GLOBAL; 3754 } 3755 3756 HANDLE_SPECIAL ("vtable for ", DEMANGLE_COMPONENT_VTABLE); 3757 if (strncmp (tokstart, "delete", 6) == 0) 3758 return DELETE; 3759 if (strncmp (tokstart, "struct", 6) == 0) 3760 return STRUCT; 3761 if (strncmp (tokstart, "signed", 6) == 0) 3762 return SIGNED_KEYWORD; 3763 if (strncmp (tokstart, "sizeof", 6) == 0) 3764 return SIZEOF; 3765 if (strncmp (tokstart, "double", 6) == 0) 3766 return DOUBLE_KEYWORD; 3767 break; 3768 case 5: 3769 HANDLE_SPECIAL ("guard variable for ", DEMANGLE_COMPONENT_GUARD); 3770 if (strncmp (tokstart, "false", 5) == 0) 3771 return FALSEKEYWORD; 3772 if (strncmp (tokstart, "class", 5) == 0) 3773 return CLASS; 3774 if (strncmp (tokstart, "union", 5) == 0) 3775 return UNION; 3776 if (strncmp (tokstart, "float", 5) == 0) 3777 return FLOAT_KEYWORD; 3778 if (strncmp (tokstart, "short", 5) == 0) 3779 return SHORT; 3780 if (strncmp (tokstart, "const", 5) == 0) 3781 return CONST_KEYWORD; 3782 break; 3783 case 4: 3784 if (strncmp (tokstart, "void", 4) == 0) 3785 return VOID; 3786 if (strncmp (tokstart, "bool", 4) == 0) 3787 return BOOL; 3788 if (strncmp (tokstart, "char", 4) == 0) 3789 return CHAR; 3790 if (strncmp (tokstart, "enum", 4) == 0) 3791 return ENUM; 3792 if (strncmp (tokstart, "long", 4) == 0) 3793 return LONG; 3794 if (strncmp (tokstart, "true", 4) == 0) 3795 return TRUEKEYWORD; 3796 break; 3797 case 3: 3798 HANDLE_SPECIAL ("VTT for ", DEMANGLE_COMPONENT_VTT); 3799 HANDLE_SPECIAL ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK); 3800 if (strncmp (tokstart, "new", 3) == 0) 3801 return NEW; 3802 if (strncmp (tokstart, "int", 3) == 0) 3803 return INT_KEYWORD; 3804 break; 3805 default: 3806 break; 3807 } 3808 3809 yylval.comp = make_name (tokstart, namelen); 3810 return NAME; 3811} 3812 3813static void 3814yyerror (char *msg) 3815{ 3816 if (global_errmsg) 3817 return; 3818 3819 error_lexptr = prev_lexptr; 3820 global_errmsg = msg ? msg : "parse error"; 3821} 3822 3823/* Allocate all the components we'll need to build a tree. We generally 3824 allocate too many components, but the extra memory usage doesn't hurt 3825 because the trees are temporary. If we start keeping the trees for 3826 a longer lifetime we'll need to be cleverer. */ 3827static struct demangle_info * 3828allocate_info (int comps) 3829{ 3830 struct demangle_info *ret; 3831 3832 ret = xmalloc (sizeof (struct demangle_info) 3833 + sizeof (struct demangle_component) * (comps - 1)); 3834 ret->used = 0; 3835 return ret; 3836} 3837 3838/* Convert RESULT to a string. The return value is allocated 3839 using xmalloc. ESTIMATED_LEN is used only as a guide to the 3840 length of the result. This functions handles a few cases that 3841 cplus_demangle_print does not, specifically the global destructor 3842 and constructor labels. */ 3843 3844char * 3845cp_comp_to_string (struct demangle_component *result, int estimated_len) 3846{ 3847 char *str, *prefix = NULL, *buf; 3848 size_t err = 0; 3849 3850 if (result->type == GLOBAL_DESTRUCTORS) 3851 { 3852 result = d_left (result); 3853 prefix = "global destructors keyed to "; 3854 } 3855 else if (result->type == GLOBAL_CONSTRUCTORS) 3856 { 3857 result = d_left (result); 3858 prefix = "global constructors keyed to "; 3859 } 3860 3861 str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, estimated_len, &err); 3862 if (str == NULL) 3863 return NULL; 3864 3865 if (prefix == NULL) 3866 return str; 3867 3868 buf = xmalloc (strlen (str) + strlen (prefix) + 1); 3869 strcpy (buf, prefix); 3870 strcat (buf, str); 3871 free (str); 3872 return (buf); 3873} 3874 3875/* Convert a demangled name to a demangle_component tree. *MEMORY is set to the 3876 block of used memory that should be freed when finished with the 3877 tree. On error, NULL is returned, and an error message will be 3878 set in *ERRMSG (which does not need to be freed). */ 3879 3880struct demangle_component * 3881cp_demangled_name_to_comp (const char *demangled_name, void **memory, 3882 const char **errmsg) 3883{ 3884 static char errbuf[60]; 3885 struct demangle_component *result; 3886 3887 int len = strlen (demangled_name); 3888 3889 len = len + len / 8; 3890 prev_lexptr = lexptr = demangled_name; 3891 error_lexptr = NULL; 3892 global_errmsg = NULL; 3893 3894 demangle_info = allocate_info (len); 3895 3896 if (yyparse ()) 3897 { 3898 if (global_errmsg && errmsg) 3899 { 3900 snprintf (errbuf, sizeof (errbuf) - 2, "%s, near `%s", 3901 global_errmsg, error_lexptr); 3902 strcat (errbuf, "'"); 3903 *errmsg = errbuf; 3904 } 3905 free (demangle_info); 3906 return NULL; 3907 } 3908 3909 *memory = demangle_info; 3910 result = global_result; 3911 global_result = NULL; 3912 3913 return result; 3914} 3915 3916#ifdef TEST_CPNAMES 3917 3918static void 3919cp_print (struct demangle_component *result) 3920{ 3921 char *str; 3922 size_t err = 0; 3923 3924 if (result->type == GLOBAL_DESTRUCTORS) 3925 { 3926 result = d_left (result); 3927 fputs ("global destructors keyed to ", stdout); 3928 } 3929 else if (result->type == GLOBAL_CONSTRUCTORS) 3930 { 3931 result = d_left (result); 3932 fputs ("global constructors keyed to ", stdout); 3933 } 3934 3935 str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, 64, &err); 3936 if (str == NULL) 3937 return; 3938 3939 fputs (str, stdout); 3940 3941 free (str); 3942} 3943 3944static char 3945trim_chars (char *lexptr, char **extra_chars) 3946{ 3947 char *p = (char *) symbol_end (lexptr); 3948 char c = 0; 3949 3950 if (*p) 3951 { 3952 c = *p; 3953 *p = 0; 3954 *extra_chars = p + 1; 3955 } 3956 3957 return c; 3958} 3959 3960int 3961main (int argc, char **argv) 3962{ 3963 char *str2, *extra_chars, c; 3964 char buf[65536]; 3965 int arg; 3966 const char *errmsg; 3967 void *memory; 3968 struct demangle_component *result; 3969 3970 arg = 1; 3971 if (argv[arg] && strcmp (argv[arg], "--debug") == 0) 3972 { 3973 yydebug = 1; 3974 arg++; 3975 } 3976 3977 if (argv[arg] == NULL) 3978 while (fgets (buf, 65536, stdin) != NULL) 3979 { 3980 int len; 3981 buf[strlen (buf) - 1] = 0; 3982 /* Use DMGL_VERBOSE to get expanded standard substitutions. */ 3983 c = trim_chars (buf, &extra_chars); 3984 str2 = cplus_demangle (buf, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE); 3985 if (str2 == NULL) 3986 { 3987 /* printf ("Demangling error\n"); */ 3988 if (c) 3989 printf ("%s%c%s\n", buf, c, extra_chars); 3990 else 3991 printf ("%s\n", buf); 3992 continue; 3993 } 3994 result = cp_demangled_name_to_comp (str2, &memory, &errmsg); 3995 if (result == NULL) 3996 { 3997 fputs (errmsg, stderr); 3998 fputc ('\n', stderr); 3999 continue; 4000 } 4001 4002 cp_print (result); 4003 free (memory); 4004 4005 free (str2); 4006 if (c) 4007 { 4008 putchar (c); 4009 fputs (extra_chars, stdout); 4010 } 4011 putchar ('\n'); 4012 } 4013 else 4014 { 4015 result = cp_demangled_name_to_comp (argv[arg], &memory, &errmsg); 4016 if (result == NULL) 4017 { 4018 fputs (errmsg, stderr); 4019 fputc ('\n', stderr); 4020 return 0; 4021 } 4022 cp_print (result); 4023 putchar ('\n'); 4024 free (memory); 4025 } 4026 return 0; 4027} 4028 4029#endif 4030 4031 4032