contrib/gdb-7/gdb/cp-name-parser.y

   1 /* YACC parser for C++ names, for GDB.
   2
   3    Copyright (C) 2003-2005, 2007-2012 Free Software Foundation, Inc.
   4
   5    Parts of the lexer are based on c-exp.y from GDB.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 /* Note that malloc's and realloc's in this file are transformed to
  23    xmalloc and xrealloc respectively by the same sed command in the
  24    makefile that remaps any other malloc/realloc inserted by the parser
  25    generator.  Doing this with #defines and trying to control the interaction
  26    with include files (<malloc.h> and <stdlib.h> for example) just became
  27    too messy, particularly when such includes can be inserted at random
  28    times by the parser generator.  */
  29
  30 %{
  31
  32 #include "defs.h"
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <unistd.h>
  37 #include <string.h>
  38
  39 #include "safe-ctype.h"
  40 #include "libiberty.h"
  41 #include "demangle.h"
  42 #include "cp-support.h"
  43 #include "gdb_assert.h"
  44
  45 /* Bison does not make it easy to create a parser without global
  46    state, unfortunately.  Here are all the global variables used
  47    in this parser.  */
  48
  49 /* LEXPTR is the current pointer into our lex buffer.  PREV_LEXPTR
  50    is the start of the last token lexed, only used for diagnostics.
  51    ERROR_LEXPTR is the first place an error occurred.  GLOBAL_ERRMSG
  52    is the first error message encountered.  */
  53
  54 static const char *lexptr, *prev_lexptr, *error_lexptr, *global_errmsg;
  55
  56 /* The components built by the parser are allocated ahead of time,
  57    and cached in this structure.  */
  58
  59 #define ALLOC_CHUNK 100
  60
  61 struct demangle_info {
  62   int used;
  63   struct demangle_info *next;
  64   struct demangle_component comps[ALLOC_CHUNK];
  65 };
  66
  67 static struct demangle_info *demangle_info;
  68
  69 static struct demangle_component *
  70 d_grab (void)
  71 {
  72   struct demangle_info *more;
  73
  74   if (demangle_info->used >= ALLOC_CHUNK)
  75     {
  76       if (demangle_info->next == NULL)
  77         {
  78           more = malloc (sizeof (struct demangle_info));
  79           more->next = NULL;
  80           demangle_info->next = more;
  81         }
  82       else
  83         more = demangle_info->next;
  84
  85       more->used = 0;
  86       demangle_info = more;
  87     }
  88   return &demangle_info->comps[demangle_info->used++];
  89 }
  90
  91 /* The parse tree created by the parser is stored here after a successful
  92    parse.  */
  93
  94 static struct demangle_component *global_result;
  95
  96 /* Prototypes for helper functions used when constructing the parse
  97    tree.  */
  98
  99 static struct demangle_component *d_qualify (struct demangle_component *, int,
 100                                              int);
 101
 102 static struct demangle_component *d_int_type (int);
 103
 104 static struct demangle_component *d_unary (const char *,
 105                                            struct demangle_component *);
 106 static struct demangle_component *d_binary (const char *,
 107                                             struct demangle_component *,
 108                                             struct demangle_component *);
 109
 110 /* Flags passed to d_qualify.  */
 111
 112 #define QUAL_CONST 1
 113 #define QUAL_RESTRICT 2
 114 #define QUAL_VOLATILE 4
 115
 116 /* Flags passed to d_int_type.  */
 117
 118 #define INT_CHAR        (1 << 0)
 119 #define INT_SHORT       (1 << 1)
 120 #define INT_LONG        (1 << 2)
 121 #define INT_LLONG       (1 << 3)
 122
 123 #define INT_SIGNED      (1 << 4)
 124 #define INT_UNSIGNED    (1 << 5)
 125
 126 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
 127    as well as gratuitiously global symbol names, so we can have multiple
 128    yacc generated parsers in gdb.  Note that these are only the variables
 129    produced by yacc.  If other parser generators (bison, byacc, etc) produce
 130    additional global names that conflict at link time, then those parser
 131    generators need to be fixed instead of adding those names to this list. */
 132
 133 #define yymaxdepth cpname_maxdepth
 134 #define yyparse cpname_parse
 135 #define yylex   cpname_lex
 136 #define yyerror cpname_error
 137 #define yylval  cpname_lval
 138 #define yychar  cpname_char
 139 #define yydebug cpname_debug
 140 #define yypact  cpname_pact
 141 #define yyr1    cpname_r1
 142 #define yyr2    cpname_r2
 143 #define yydef   cpname_def
 144 #define yychk   cpname_chk
 145 #define yypgo   cpname_pgo
 146 #define yyact   cpname_act
 147 #define yyexca  cpname_exca
 148 #define yyerrflag cpname_errflag
 149 #define yynerrs cpname_nerrs
 150 #define yyps    cpname_ps
 151 #define yypv    cpname_pv
 152 #define yys     cpname_s
 153 #define yy_yys  cpname_yys
 154 #define yystate cpname_state
 155 #define yytmp   cpname_tmp
 156 #define yyv     cpname_v
 157 #define yy_yyv  cpname_yyv
 158 #define yyval   cpname_val
 159 #define yylloc  cpname_lloc
 160 #define yyreds  cpname_reds             /* With YYDEBUG defined */
 161 #define yytoks  cpname_toks             /* With YYDEBUG defined */
 162 #define yyname  cpname_name             /* With YYDEBUG defined */
 163 #define yyrule  cpname_rule             /* With YYDEBUG defined */
 164 #define yylhs   cpname_yylhs
 165 #define yylen   cpname_yylen
 166 #define yydefred cpname_yydefred
 167 #define yydgoto cpname_yydgoto
 168 #define yysindex cpname_yysindex
 169 #define yyrindex cpname_yyrindex
 170 #define yygindex cpname_yygindex
 171 #define yytable  cpname_yytable
 172 #define yycheck  cpname_yycheck
 173
 174 int yyparse (void);
 175 static int yylex (void);
 176 static void yyerror (char *);
 177
 178 /* Enable yydebug for the stand-alone parser.  */
 179 #ifdef TEST_CPNAMES
 180 # define YYDEBUG        1
 181 #endif
 182
 183 /* Helper functions.  These wrap the demangler tree interface, handle
 184    allocation from our global store, and return the allocated component.  */
 185
 186 static struct demangle_component *
 187 fill_comp (enum demangle_component_type d_type, struct demangle_component *lhs,
 188            struct demangle_component *rhs)
 189 {
 190   struct demangle_component *ret = d_grab ();
 191   cplus_demangle_fill_component (ret, d_type, lhs, rhs);
 192   return ret;
 193 }
 194
 195 static struct demangle_component *
 196 make_empty (enum demangle_component_type d_type)
 197 {
 198   struct demangle_component *ret = d_grab ();
 199   ret->type = d_type;
 200   return ret;
 201 }
 202
 203 static struct demangle_component *
 204 make_operator (const char *name, int args)
 205 {
 206   struct demangle_component *ret = d_grab ();
 207   cplus_demangle_fill_operator (ret, name, args);
 208   return ret;
 209 }
 210
 211 static struct demangle_component *
 212 make_dtor (enum gnu_v3_dtor_kinds kind, struct demangle_component *name)
 213 {
 214   struct demangle_component *ret = d_grab ();
 215   cplus_demangle_fill_dtor (ret, kind, name);
 216   return ret;
 217 }
 218
 219 static struct demangle_component *
 220 make_builtin_type (const char *name)
 221 {
 222   struct demangle_component *ret = d_grab ();
 223   cplus_demangle_fill_builtin_type (ret, name);
 224   return ret;
 225 }
 226
 227 static struct demangle_component *
 228 make_name (const char *name, int len)
 229 {
 230   struct demangle_component *ret = d_grab ();
 231   cplus_demangle_fill_name (ret, name, len);
 232   return ret;
 233 }
 234
 235 #define d_left(dc) (dc)->u.s_binary.left
 236 #define d_right(dc) (dc)->u.s_binary.right
 237
 238 %}
 239
 240 %union
 241   {
 242     struct demangle_component *comp;
 243     struct nested {
 244       struct demangle_component *comp;
 245       struct demangle_component **last;
 246     } nested;
 247     struct {
 248       struct demangle_component *comp, *last;
 249     } nested1;
 250     struct {
 251       struct demangle_component *comp, **last;
 252       struct nested fn;
 253       struct demangle_component *start;
 254       int fold_flag;
 255     } abstract;
 256     int lval;
 257     const char *opname;
 258   }
 259
 260 %type <comp> exp exp1 type start start_opt operator colon_name
 261 %type <comp> unqualified_name colon_ext_name
 262 %type <comp> template template_arg
 263 %type <comp> builtin_type
 264 %type <comp> typespec_2 array_indicator
 265 %type <comp> colon_ext_only ext_only_name
 266
 267 %type <comp> demangler_special function conversion_op
 268 %type <nested> conversion_op_name
 269
 270 %type <abstract> abstract_declarator direct_abstract_declarator
 271 %type <abstract> abstract_declarator_fn
 272 %type <nested> declarator direct_declarator function_arglist
 273
 274 %type <nested> declarator_1 direct_declarator_1
 275
 276 %type <nested> template_params function_args
 277 %type <nested> ptr_operator
 278
 279 %type <nested1> nested_name
 280
 281 %type <lval> qualifier qualifiers qualifiers_opt
 282
 283 %type <lval> int_part int_seq
 284
 285 %token <comp> INT
 286 %token <comp> FLOAT
 287
 288 %token <comp> NAME
 289 %type <comp> name
 290
 291 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 292 %token TEMPLATE
 293 %token ERROR
 294 %token NEW DELETE OPERATOR
 295 %token STATIC_CAST REINTERPRET_CAST DYNAMIC_CAST
 296
 297 /* Special type cases, put in to allow the parser to distinguish different
 298    legal basetypes.  */
 299 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD BOOL
 300 %token ELLIPSIS RESTRICT VOID FLOAT_KEYWORD CHAR WCHAR_T
 301
 302 %token <opname> ASSIGN_MODIFY
 303
 304 /* C++ */
 305 %token TRUEKEYWORD
 306 %token FALSEKEYWORD
 307
 308 /* Non-C++ things we get from the demangler.  */
 309 %token <lval> DEMANGLER_SPECIAL
 310 %token CONSTRUCTION_VTABLE CONSTRUCTION_IN
 311
 312 /* Precedence declarations.  */
 313
 314 /* Give NAME lower precedence than COLONCOLON, so that nested_name will
 315    associate greedily.  */
 316 %nonassoc NAME
 317
 318 /* Give NEW and DELETE lower precedence than ']', because we can not
 319    have an array of type operator new.  This causes NEW '[' to be
 320    parsed as operator new[].  */
 321 %nonassoc NEW DELETE
 322
 323 /* Give VOID higher precedence than NAME.  Then we can use %prec NAME
 324    to prefer (VOID) to (function_args).  */
 325 %nonassoc VOID
 326
 327 /* Give VOID lower precedence than ')' for similar reasons.  */
 328 %nonassoc ')'
 329
 330 %left ','
 331 %right '=' ASSIGN_MODIFY
 332 %right '?'
 333 %left OROR
 334 %left ANDAND
 335 %left '|'
 336 %left '^'
 337 %left '&'
 338 %left EQUAL NOTEQUAL
 339 %left '<' '>' LEQ GEQ
 340 %left LSH RSH
 341 %left '@'
 342 %left '+' '-'
 343 %left '*' '/' '%'
 344 %right UNARY INCREMENT DECREMENT
 345
 346 /* We don't need a precedence for '(' in this reduced grammar, and it
 347    can mask some unpleasant bugs, so disable it for now.  */
 348
 349 %right ARROW '.' '[' /* '(' */
 350 %left COLONCOLON
 351
 352 \f
 353 %%
 354
 355 result          :       start
 356                         { global_result = $1; }
 357                 ;
 358
 359 start           :       type
 360
 361                 |       demangler_special
 362
 363                 |       function
 364
 365                 ;
 366
 367 start_opt       :       /* */
 368                         { $$ = NULL; }
 369                 |       COLONCOLON start
 370                         { $$ = $2; }
 371                 ;
 372
 373 function
 374                 /* Function with a return type.  declarator_1 is used to prevent
 375                    ambiguity with the next rule.  */
 376                 :       typespec_2 declarator_1
 377                         { $$ = $2.comp;
 378                           *$2.last = $1;
 379                         }
 380
 381                 /* Function without a return type.  We need to use typespec_2
 382                    to prevent conflicts from qualifiers_opt - harmless.  The
 383                    start_opt is used to handle "function-local" variables and
 384                    types.  */
 385                 |       typespec_2 function_arglist start_opt
 386                         { $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
 387                           if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
 388                 |       colon_ext_only function_arglist start_opt
 389                         { $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
 390                           if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
 391
 392                 |       conversion_op_name start_opt
 393                         { $$ = $1.comp;
 394                           if ($2) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2); }
 395                 |       conversion_op_name abstract_declarator_fn
 396                         { if ($2.last)
 397                             {
 398                                /* First complete the abstract_declarator's type using
 399                                   the typespec from the conversion_op_name.  */
 400                               *$2.last = *$1.last;
 401                               /* Then complete the conversion_op_name with the type.  */
 402                               *$1.last = $2.comp;
 403                             }
 404                           /* If we have an arglist, build a function type.  */
 405                           if ($2.fn.comp)
 406                             $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1.comp, $2.fn.comp);
 407                           else
 408                             $$ = $1.comp;
 409                           if ($2.start) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2.start);
 410                         }
 411                 ;
 412
 413 demangler_special
 414                 :       DEMANGLER_SPECIAL start
 415                         { $$ = make_empty ($1);
 416                           d_left ($$) = $2;
 417                           d_right ($$) = NULL; }
 418                 |       CONSTRUCTION_VTABLE start CONSTRUCTION_IN start
 419                         { $$ = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, $2, $4); }
 420                 ;
 421
 422 operator        :       OPERATOR NEW
 423                         { $$ = make_operator ("new", 1); }
 424                 |       OPERATOR DELETE
 425                         { $$ = make_operator ("delete", 1); }
 426                 |       OPERATOR NEW '[' ']'
 427                         { $$ = make_operator ("new[]", 1); }
 428                 |       OPERATOR DELETE '[' ']'
 429                         { $$ = make_operator ("delete[]", 1); }
 430                 |       OPERATOR '+'
 431                         { $$ = make_operator ("+", 2); }
 432                 |       OPERATOR '-'
 433                         { $$ = make_operator ("-", 2); }
 434                 |       OPERATOR '*'
 435                         { $$ = make_operator ("*", 2); }
 436                 |       OPERATOR '/'
 437                         { $$ = make_operator ("/", 2); }
 438                 |       OPERATOR '%'
 439                         { $$ = make_operator ("%", 2); }
 440                 |       OPERATOR '^'
 441                         { $$ = make_operator ("^", 2); }
 442                 |       OPERATOR '&'
 443                         { $$ = make_operator ("&", 2); }
 444                 |       OPERATOR '|'
 445                         { $$ = make_operator ("|", 2); }
 446                 |       OPERATOR '~'
 447                         { $$ = make_operator ("~", 1); }
 448                 |       OPERATOR '!'
 449                         { $$ = make_operator ("!", 1); }
 450                 |       OPERATOR '='
 451                         { $$ = make_operator ("=", 2); }
 452                 |       OPERATOR '<'
 453                         { $$ = make_operator ("<", 2); }
 454                 |       OPERATOR '>'
 455                         { $$ = make_operator (">", 2); }
 456                 |       OPERATOR ASSIGN_MODIFY
 457                         { $$ = make_operator ($2, 2); }
 458                 |       OPERATOR LSH
 459                         { $$ = make_operator ("<<", 2); }
 460                 |       OPERATOR RSH
 461                         { $$ = make_operator (">>", 2); }
 462                 |       OPERATOR EQUAL
 463                         { $$ = make_operator ("==", 2); }
 464                 |       OPERATOR NOTEQUAL
 465                         { $$ = make_operator ("!=", 2); }
 466                 |       OPERATOR LEQ
 467                         { $$ = make_operator ("<=", 2); }
 468                 |       OPERATOR GEQ
 469                         { $$ = make_operator (">=", 2); }
 470                 |       OPERATOR ANDAND
 471                         { $$ = make_operator ("&&", 2); }
 472                 |       OPERATOR OROR
 473                         { $$ = make_operator ("||", 2); }
 474                 |       OPERATOR INCREMENT
 475                         { $$ = make_operator ("++", 1); }
 476                 |       OPERATOR DECREMENT
 477                         { $$ = make_operator ("--", 1); }
 478                 |       OPERATOR ','
 479                         { $$ = make_operator (",", 2); }
 480                 |       OPERATOR ARROW '*'
 481                         { $$ = make_operator ("->*", 2); }
 482                 |       OPERATOR ARROW
 483                         { $$ = make_operator ("->", 2); }
 484                 |       OPERATOR '(' ')'
 485                         { $$ = make_operator ("()", 2); }
 486                 |       OPERATOR '[' ']'
 487                         { $$ = make_operator ("[]", 2); }
 488                 ;
 489
 490                 /* Conversion operators.  We don't try to handle some of
 491                    the wackier demangler output for function pointers,
 492                    since it's not clear that it's parseable.  */
 493 conversion_op
 494                 :       OPERATOR typespec_2
 495                         { $$ = fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL); }
 496                 ;
 497
 498 conversion_op_name
 499                 :       nested_name conversion_op
 500                         { $$.comp = $1.comp;
 501                           d_right ($1.last) = $2;
 502                           $$.last = &d_left ($2);
 503                         }
 504                 |       conversion_op
 505                         { $$.comp = $1;
 506                           $$.last = &d_left ($1);
 507                         }
 508                 |       COLONCOLON nested_name conversion_op
 509                         { $$.comp = $2.comp;
 510                           d_right ($2.last) = $3;
 511                           $$.last = &d_left ($3);
 512                         }
 513                 |       COLONCOLON conversion_op
 514                         { $$.comp = $2;
 515                           $$.last = &d_left ($2);
 516                         }
 517                 ;
 518
 519 /* DEMANGLE_COMPONENT_NAME */
 520 /* This accepts certain invalid placements of '~'.  */
 521 unqualified_name:       operator
 522                 |       operator '<' template_params '>'
 523                         { $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
 524                 |       '~' NAME
 525                         { $$ = make_dtor (gnu_v3_complete_object_dtor, $2); }
 526                 ;
 527
 528 /* This rule is used in name and nested_name, and expanded inline there
 529    for efficiency.  */
 530 /*
 531 scope_id        :       NAME
 532                 |       template
 533                 ;
 534 */
 535
 536 colon_name      :       name
 537                 |       COLONCOLON name
 538                         { $$ = $2; }
 539                 ;
 540
 541 /* DEMANGLE_COMPONENT_QUAL_NAME */
 542 /* DEMANGLE_COMPONENT_CTOR / DEMANGLE_COMPONENT_DTOR ? */
 543 name            :       nested_name NAME %prec NAME
 544                         { $$ = $1.comp; d_right ($1.last) = $2; }
 545                 |       NAME %prec NAME
 546                 |       nested_name template %prec NAME
 547                         { $$ = $1.comp; d_right ($1.last) = $2; }
 548                 |       template %prec NAME
 549                 ;
 550
 551 colon_ext_name  :       colon_name
 552                 |       colon_ext_only
 553                 ;
 554
 555 colon_ext_only  :       ext_only_name
 556                 |       COLONCOLON ext_only_name
 557                         { $$ = $2; }
 558                 ;
 559
 560 ext_only_name   :       nested_name unqualified_name
 561                         { $$ = $1.comp; d_right ($1.last) = $2; }
 562                 |       unqualified_name
 563                 ;
 564
 565 nested_name     :       NAME COLONCOLON
 566                         { $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
 567                           d_left ($$.comp) = $1;
 568                           d_right ($$.comp) = NULL;
 569                           $$.last = $$.comp;
 570                         }
 571                 |       nested_name NAME COLONCOLON
 572                         { $$.comp = $1.comp;
 573                           d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
 574                           $$.last = d_right ($1.last);
 575                           d_left ($$.last) = $2;
 576                           d_right ($$.last) = NULL;
 577                         }
 578                 |       template COLONCOLON
 579                         { $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
 580                           d_left ($$.comp) = $1;
 581                           d_right ($$.comp) = NULL;
 582                           $$.last = $$.comp;
 583                         }
 584                 |       nested_name template COLONCOLON
 585                         { $$.comp = $1.comp;
 586                           d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
 587                           $$.last = d_right ($1.last);
 588                           d_left ($$.last) = $2;
 589                           d_right ($$.last) = NULL;
 590                         }
 591                 ;
 592
 593 /* DEMANGLE_COMPONENT_TEMPLATE */
 594 /* DEMANGLE_COMPONENT_TEMPLATE_ARGLIST */
 595 template        :       NAME '<' template_params '>'
 596                         { $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
 597                 ;
 598
 599 template_params :       template_arg
 600                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $1, NULL);
 601                         $$.last = &d_right ($$.comp); }
 602                 |       template_params ',' template_arg
 603                         { $$.comp = $1.comp;
 604                           *$1.last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $3, NULL);
 605                           $$.last = &d_right (*$1.last);
 606                         }
 607                 ;
 608
 609 /* "type" is inlined into template_arg and function_args.  */
 610
 611 /* Also an integral constant-expression of integral type, and a
 612    pointer to member (?) */
 613 template_arg    :       typespec_2
 614                 |       typespec_2 abstract_declarator
 615                         { $$ = $2.comp;
 616                           *$2.last = $1;
 617                         }
 618                 |       '&' start
 619                         { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
 620                 |       '&' '(' start ')'
 621                         { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
 622                 |       exp
 623                 ;
 624
 625 function_args   :       typespec_2
 626                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $1, NULL);
 627                           $$.last = &d_right ($$.comp);
 628                         }
 629                 |       typespec_2 abstract_declarator
 630                         { *$2.last = $1;
 631                           $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $2.comp, NULL);
 632                           $$.last = &d_right ($$.comp);
 633                         }
 634                 |       function_args ',' typespec_2
 635                         { *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $3, NULL);
 636                           $$.comp = $1.comp;
 637                           $$.last = &d_right (*$1.last);
 638                         }
 639                 |       function_args ',' typespec_2 abstract_declarator
 640                         { *$4.last = $3;
 641                           *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $4.comp, NULL);
 642                           $$.comp = $1.comp;
 643                           $$.last = &d_right (*$1.last);
 644                         }
 645                 |       function_args ',' ELLIPSIS
 646                         { *$1.last
 647                             = fill_comp (DEMANGLE_COMPONENT_ARGLIST,
 648                                            make_builtin_type ("..."),
 649                                            NULL);
 650                           $$.comp = $1.comp;
 651                           $$.last = &d_right (*$1.last);
 652                         }
 653                 ;
 654
 655 function_arglist:       '(' function_args ')' qualifiers_opt %prec NAME
 656                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, $2.comp);
 657                           $$.last = &d_left ($$.comp);
 658                           $$.comp = d_qualify ($$.comp, $4, 1); }
 659                 |       '(' VOID ')' qualifiers_opt
 660                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
 661                           $$.last = &d_left ($$.comp);
 662                           $$.comp = d_qualify ($$.comp, $4, 1); }
 663                 |       '(' ')' qualifiers_opt
 664                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
 665                           $$.last = &d_left ($$.comp);
 666                           $$.comp = d_qualify ($$.comp, $3, 1); }
 667                 ;
 668
 669 /* Should do something about DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL */
 670 qualifiers_opt  :       /* epsilon */
 671                         { $$ = 0; }
 672                 |       qualifiers
 673                 ;
 674
 675 qualifier       :       RESTRICT
 676                         { $$ = QUAL_RESTRICT; }
 677                 |       VOLATILE_KEYWORD
 678                         { $$ = QUAL_VOLATILE; }
 679                 |       CONST_KEYWORD
 680                         { $$ = QUAL_CONST; }
 681                 ;
 682
 683 qualifiers      :       qualifier
 684                 |       qualifier qualifiers
 685                         { $$ = $1 | $2; }
 686                 ;
 687
 688 /* This accepts all sorts of invalid constructions and produces
 689    invalid output for them - an error would be better.  */
 690
 691 int_part        :       INT_KEYWORD
 692                         { $$ = 0; }
 693                 |       SIGNED_KEYWORD
 694                         { $$ = INT_SIGNED; }
 695                 |       UNSIGNED
 696                         { $$ = INT_UNSIGNED; }
 697                 |       CHAR
 698                         { $$ = INT_CHAR; }
 699                 |       LONG
 700                         { $$ = INT_LONG; }
 701                 |       SHORT
 702                         { $$ = INT_SHORT; }
 703                 ;
 704
 705 int_seq         :       int_part
 706                 |       int_seq int_part
 707                         { $$ = $1 | $2; if ($1 & $2 & INT_LONG) $$ = $1 | INT_LLONG; }
 708                 ;
 709
 710 builtin_type    :       int_seq
 711                         { $$ = d_int_type ($1); }
 712                 |       FLOAT_KEYWORD
 713                         { $$ = make_builtin_type ("float"); }
 714                 |       DOUBLE_KEYWORD
 715                         { $$ = make_builtin_type ("double"); }
 716                 |       LONG DOUBLE_KEYWORD
 717                         { $$ = make_builtin_type ("long double"); }
 718                 |       BOOL
 719                         { $$ = make_builtin_type ("bool"); }
 720                 |       WCHAR_T
 721                         { $$ = make_builtin_type ("wchar_t"); }
 722                 |       VOID
 723                         { $$ = make_builtin_type ("void"); }
 724                 ;
 725
 726 ptr_operator    :       '*' qualifiers_opt
 727                         { $$.comp = make_empty (DEMANGLE_COMPONENT_POINTER);
 728                           $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
 729                           $$.last = &d_left ($$.comp);
 730                           $$.comp = d_qualify ($$.comp, $2, 0); }
 731                 /* g++ seems to allow qualifiers after the reference?  */
 732                 |       '&'
 733                         { $$.comp = make_empty (DEMANGLE_COMPONENT_REFERENCE);
 734                           $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
 735                           $$.last = &d_left ($$.comp); }
 736                 |       nested_name '*' qualifiers_opt
 737                         { $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
 738                           $$.comp->u.s_binary.left = $1.comp;
 739                           /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME.  */
 740                           *$1.last = *d_left ($1.last);
 741                           $$.comp->u.s_binary.right = NULL;
 742                           $$.last = &d_right ($$.comp);
 743                           $$.comp = d_qualify ($$.comp, $3, 0); }
 744                 |       COLONCOLON nested_name '*' qualifiers_opt
 745                         { $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
 746                           $$.comp->u.s_binary.left = $2.comp;
 747                           /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME.  */
 748                           *$2.last = *d_left ($2.last);
 749                           $$.comp->u.s_binary.right = NULL;
 750                           $$.last = &d_right ($$.comp);
 751                           $$.comp = d_qualify ($$.comp, $4, 0); }
 752                 ;
 753
 754 array_indicator :       '[' ']'
 755                         { $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
 756                           d_left ($$) = NULL;
 757                         }
 758                 |       '[' INT ']'
 759                         { $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
 760                           d_left ($$) = $2;
 761                         }
 762                 ;
 763
 764 /* Details of this approach inspired by the G++ < 3.4 parser.  */
 765
 766 /* This rule is only used in typespec_2, and expanded inline there for
 767    efficiency.  */
 768 /*
 769 typespec        :       builtin_type
 770                 |       colon_name
 771                 ;
 772 */
 773
 774 typespec_2      :       builtin_type qualifiers
 775                         { $$ = d_qualify ($1, $2, 0); }
 776                 |       builtin_type
 777                 |       qualifiers builtin_type qualifiers
 778                         { $$ = d_qualify ($2, $1 | $3, 0); }
 779                 |       qualifiers builtin_type
 780                         { $$ = d_qualify ($2, $1, 0); }
 781
 782                 |       name qualifiers
 783                         { $$ = d_qualify ($1, $2, 0); }
 784                 |       name
 785                 |       qualifiers name qualifiers
 786                         { $$ = d_qualify ($2, $1 | $3, 0); }
 787                 |       qualifiers name
 788                         { $$ = d_qualify ($2, $1, 0); }
 789
 790                 |       COLONCOLON name qualifiers
 791                         { $$ = d_qualify ($2, $3, 0); }
 792                 |       COLONCOLON name
 793                         { $$ = $2; }
 794                 |       qualifiers COLONCOLON name qualifiers
 795                         { $$ = d_qualify ($3, $1 | $4, 0); }
 796                 |       qualifiers COLONCOLON name
 797                         { $$ = d_qualify ($3, $1, 0); }
 798                 ;
 799
 800 abstract_declarator
 801                 :       ptr_operator
 802                         { $$.comp = $1.comp; $$.last = $1.last;
 803                           $$.fn.comp = NULL; $$.fn.last = NULL; }
 804                 |       ptr_operator abstract_declarator
 805                         { $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL;
 806                           if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
 807                           *$$.last = $1.comp;
 808                           $$.last = $1.last; }
 809                 |       direct_abstract_declarator
 810                         { $$.fn.comp = NULL; $$.fn.last = NULL;
 811                           if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
 812                         }
 813                 ;
 814
 815 direct_abstract_declarator
 816                 :       '(' abstract_declarator ')'
 817                         { $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 1;
 818                           if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
 819                         }
 820                 |       direct_abstract_declarator function_arglist
 821                         { $$.fold_flag = 0;
 822                           if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
 823                           if ($1.fold_flag)
 824                             {
 825                               *$$.last = $2.comp;
 826                               $$.last = $2.last;
 827                             }
 828                           else
 829                             $$.fn = $2;
 830                         }
 831                 |       direct_abstract_declarator array_indicator
 832                         { $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
 833                           if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
 834                           *$1.last = $2;
 835                           $$.last = &d_right ($2);
 836                         }
 837                 |       array_indicator
 838                         { $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
 839                           $$.comp = $1;
 840                           $$.last = &d_right ($1);
 841                         }
 842                 /* G++ has the following except for () and (type).  Then
 843                    (type) is handled in regcast_or_absdcl and () is handled
 844                    in fcast_or_absdcl.
 845
 846                    However, this is only useful for function types, and
 847                    generates reduce/reduce conflicts with direct_declarator.
 848                    We're interested in pointer-to-function types, and in
 849                    functions, but not in function types - so leave this
 850                    out.  */
 851                 /* |    function_arglist */
 852                 ;
 853
 854 abstract_declarator_fn
 855                 :       ptr_operator
 856                         { $$.comp = $1.comp; $$.last = $1.last;
 857                           $$.fn.comp = NULL; $$.fn.last = NULL; $$.start = NULL; }
 858                 |       ptr_operator abstract_declarator_fn
 859                         { $$ = $2;
 860                           if ($2.last)
 861                             *$$.last = $1.comp;
 862                           else
 863                             $$.comp = $1.comp;
 864                           $$.last = $1.last;
 865                         }
 866                 |       direct_abstract_declarator
 867                         { $$.comp = $1.comp; $$.last = $1.last; $$.fn = $1.fn; $$.start = NULL; }
 868                 |       direct_abstract_declarator function_arglist COLONCOLON start
 869                         { $$.start = $4;
 870                           if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
 871                           if ($1.fold_flag)
 872                             {
 873                               *$$.last = $2.comp;
 874                               $$.last = $2.last;
 875                             }
 876                           else
 877                             $$.fn = $2;
 878                         }
 879                 |       function_arglist start_opt
 880                         { $$.fn = $1;
 881                           $$.start = $2;
 882                           $$.comp = NULL; $$.last = NULL;
 883                         }
 884                 ;
 885
 886 type            :       typespec_2
 887                 |       typespec_2 abstract_declarator
 888                         { $$ = $2.comp;
 889                           *$2.last = $1;
 890                         }
 891                 ;
 892
 893 declarator      :       ptr_operator declarator
 894                         { $$.comp = $2.comp;
 895                           $$.last = $1.last;
 896                           *$2.last = $1.comp; }
 897                 |       direct_declarator
 898                 ;
 899
 900 direct_declarator
 901                 :       '(' declarator ')'
 902                         { $$ = $2; }
 903                 |       direct_declarator function_arglist
 904                         { $$.comp = $1.comp;
 905                           *$1.last = $2.comp;
 906                           $$.last = $2.last;
 907                         }
 908                 |       direct_declarator array_indicator
 909                         { $$.comp = $1.comp;
 910                           *$1.last = $2;
 911                           $$.last = &d_right ($2);
 912                         }
 913                 |       colon_ext_name
 914                         { $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
 915                           d_left ($$.comp) = $1;
 916                           $$.last = &d_right ($$.comp);
 917                         }
 918                 ;
 919
 920 /* These are similar to declarator and direct_declarator except that they
 921    do not permit ( colon_ext_name ), which is ambiguous with a function
 922    argument list.  They also don't permit a few other forms with redundant
 923    parentheses around the colon_ext_name; any colon_ext_name in parentheses
 924    must be followed by an argument list or an array indicator, or preceded
 925    by a pointer.  */
 926 declarator_1    :       ptr_operator declarator_1
 927                         { $$.comp = $2.comp;
 928                           $$.last = $1.last;
 929                           *$2.last = $1.comp; }
 930                 |       colon_ext_name
 931                         { $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
 932                           d_left ($$.comp) = $1;
 933                           $$.last = &d_right ($$.comp);
 934                         }
 935                 |       direct_declarator_1
 936
 937                         /* Function local variable or type.  The typespec to
 938                            our left is the type of the containing function.
 939                            This should be OK, because function local types
 940                            can not be templates, so the return types of their
 941                            members will not be mangled.  If they are hopefully
 942                            they'll end up to the right of the ::.  */
 943                 |       colon_ext_name function_arglist COLONCOLON start
 944                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
 945                           $$.last = $2.last;
 946                           $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
 947                         }
 948                 |       direct_declarator_1 function_arglist COLONCOLON start
 949                         { $$.comp = $1.comp;
 950                           *$1.last = $2.comp;
 951                           $$.last = $2.last;
 952                           $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
 953                         }
 954                 ;
 955
 956 direct_declarator_1
 957                 :       '(' ptr_operator declarator ')'
 958                         { $$.comp = $3.comp;
 959                           $$.last = $2.last;
 960                           *$3.last = $2.comp; }
 961                 |       direct_declarator_1 function_arglist
 962                         { $$.comp = $1.comp;
 963                           *$1.last = $2.comp;
 964                           $$.last = $2.last;
 965                         }
 966                 |       direct_declarator_1 array_indicator
 967                         { $$.comp = $1.comp;
 968                           *$1.last = $2;
 969                           $$.last = &d_right ($2);
 970                         }
 971                 |       colon_ext_name function_arglist
 972                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
 973                           $$.last = $2.last;
 974                         }
 975                 |       colon_ext_name array_indicator
 976                         { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2);
 977                           $$.last = &d_right ($2);
 978                         }
 979                 ;
 980
 981 exp     :       '(' exp1 ')'
 982                 { $$ = $2; }
 983         ;
 984
 985 /* Silly trick.  Only allow '>' when parenthesized, in order to
 986    handle conflict with templates.  */
 987 exp1    :       exp
 988         ;
 989
 990 exp1    :       exp '>' exp
 991                 { $$ = d_binary (">", $1, $3); }
 992         ;
 993
 994 /* References.  Not allowed everywhere in template parameters, only
 995    at the top level, but treat them as expressions in case they are wrapped
 996    in parentheses.  */
 997 exp1    :       '&' start
 998                 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
 999         |       '&' '(' start ')'
1000                 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
1001         ;
1002
1003 /* Expressions, not including the comma operator.  */
1004 exp     :       '-' exp    %prec UNARY
1005                 { $$ = d_unary ("-", $2); }
1006         ;
1007
1008 exp     :       '!' exp    %prec UNARY
1009                 { $$ = d_unary ("!", $2); }
1010         ;
1011
1012 exp     :       '~' exp    %prec UNARY
1013                 { $$ = d_unary ("~", $2); }
1014         ;
1015
1016 /* Casts.  First your normal C-style cast.  If exp is a LITERAL, just change
1017    its type.  */
1018
1019 exp     :       '(' type ')' exp  %prec UNARY
1020                 { if ($4->type == DEMANGLE_COMPONENT_LITERAL
1021                       || $4->type == DEMANGLE_COMPONENT_LITERAL_NEG)
1022                     {
1023                       $$ = $4;
1024                       d_left ($4) = $2;
1025                     }
1026                   else
1027                     $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1028                                       fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL),
1029                                       $4);
1030                 }
1031         ;
1032
1033 /* Mangling does not differentiate between these, so we don't need to
1034    either.  */
1035 exp     :       STATIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1036                 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1037                                     fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1038                                     $6);
1039                 }
1040         ;
1041
1042 exp     :       DYNAMIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1043                 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1044                                     fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1045                                     $6);
1046                 }
1047         ;
1048
1049 exp     :       REINTERPRET_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1050                 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1051                                     fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1052                                     $6);
1053                 }
1054         ;
1055
1056 /* Another form of C++-style cast is "type ( exp1 )".  This creates too many
1057    conflicts to support.  For a while we supported the simpler
1058    "typespec_2 ( exp1 )", but that conflicts with "& ( start )" as a
1059    reference, deep within the wilderness of abstract declarators:
1060    Qux<int(&(*))> vs Qux<int(&(var))>, a shift-reduce conflict at the
1061    innermost left parenthesis.  So we do not support function-like casts.
1062    Fortunately they never appear in demangler output.  */
1063
1064 /* TO INVESTIGATE: ._0 style anonymous names; anonymous namespaces */
1065
1066 /* Binary operators in order of decreasing precedence.  */
1067
1068 exp     :       exp '*' exp
1069                 { $$ = d_binary ("*", $1, $3); }
1070         ;
1071
1072 exp     :       exp '/' exp
1073                 { $$ = d_binary ("/", $1, $3); }
1074         ;
1075
1076 exp     :       exp '%' exp
1077                 { $$ = d_binary ("%", $1, $3); }
1078         ;
1079
1080 exp     :       exp '+' exp
1081                 { $$ = d_binary ("+", $1, $3); }
1082         ;
1083
1084 exp     :       exp '-' exp
1085                 { $$ = d_binary ("-", $1, $3); }
1086         ;
1087
1088 exp     :       exp LSH exp
1089                 { $$ = d_binary ("<<", $1, $3); }
1090         ;
1091
1092 exp     :       exp RSH exp
1093                 { $$ = d_binary (">>", $1, $3); }
1094         ;
1095
1096 exp     :       exp EQUAL exp
1097                 { $$ = d_binary ("==", $1, $3); }
1098         ;
1099
1100 exp     :       exp NOTEQUAL exp
1101                 { $$ = d_binary ("!=", $1, $3); }
1102         ;
1103
1104 exp     :       exp LEQ exp
1105                 { $$ = d_binary ("<=", $1, $3); }
1106         ;
1107
1108 exp     :       exp GEQ exp
1109                 { $$ = d_binary (">=", $1, $3); }
1110         ;
1111
1112 exp     :       exp '<' exp
1113                 { $$ = d_binary ("<", $1, $3); }
1114         ;
1115
1116 exp     :       exp '&' exp
1117                 { $$ = d_binary ("&", $1, $3); }
1118         ;
1119
1120 exp     :       exp '^' exp
1121                 { $$ = d_binary ("^", $1, $3); }
1122         ;
1123
1124 exp     :       exp '|' exp
1125                 { $$ = d_binary ("|", $1, $3); }
1126         ;
1127
1128 exp     :       exp ANDAND exp
1129                 { $$ = d_binary ("&&", $1, $3); }
1130         ;
1131
1132 exp     :       exp OROR exp
1133                 { $$ = d_binary ("||", $1, $3); }
1134         ;
1135
1136 /* Not 100% sure these are necessary, but they're harmless.  */
1137 exp     :       exp ARROW NAME
1138                 { $$ = d_binary ("->", $1, $3); }
1139         ;
1140
1141 exp     :       exp '.' NAME
1142                 { $$ = d_binary (".", $1, $3); }
1143         ;
1144
1145 exp     :       exp '?' exp ':' exp     %prec '?'
1146                 { $$ = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3),
1147                                     fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, $1,
1148                                                  fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, $3, $5)));
1149                 }
1150         ;
1151
1152 exp     :       INT
1153         ;
1154
1155 /* Not generally allowed.  */
1156 exp     :       FLOAT
1157         ;
1158
1159 exp     :       SIZEOF '(' type ')'     %prec UNARY
1160                 { $$ = d_unary ("sizeof", $3); }
1161         ;
1162
1163 /* C++.  */
1164 exp     :       TRUEKEYWORD
1165                 { struct demangle_component *i;
1166                   i = make_name ("1", 1);
1167                   $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1168                                     make_builtin_type ("bool"),
1169                                     i);
1170                 }
1171         ;
1172
1173 exp     :       FALSEKEYWORD
1174                 { struct demangle_component *i;
1175                   i = make_name ("0", 1);
1176                   $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1177                                     make_builtin_type ("bool"),
1178                                     i);
1179                 }
1180         ;
1181
1182 /* end of C++.  */
1183
1184 %%
1185
1186 /* Apply QUALIFIERS to LHS and return a qualified component.  IS_METHOD
1187    is set if LHS is a method, in which case the qualifiers are logically
1188    applied to "this".  We apply qualifiers in a consistent order; LHS
1189    may already be qualified; duplicate qualifiers are not created.  */
1190
1191 struct demangle_component *
1192 d_qualify (struct demangle_component *lhs, int qualifiers, int is_method)
1193 {
1194   struct demangle_component **inner_p;
1195   enum demangle_component_type type;
1196
1197   /* For now the order is CONST (innermost), VOLATILE, RESTRICT.  */
1198
1199 #define HANDLE_QUAL(TYPE, MTYPE, QUAL)                          \
1200   if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE)) \
1201     {                                                           \
1202       *inner_p = fill_comp (is_method ? MTYPE : TYPE,   \
1203                               *inner_p, NULL);                  \
1204       inner_p = &d_left (*inner_p);                             \
1205       type = (*inner_p)->type;                                  \
1206     }                                                           \
1207   else if (type == TYPE || type == MTYPE)                       \
1208     {                                                           \
1209       inner_p = &d_left (*inner_p);                             \
1210       type = (*inner_p)->type;                                  \
1211     }
1212
1213   inner_p = &lhs;
1214
1215   type = (*inner_p)->type;
1216
1217   HANDLE_QUAL (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, QUAL_RESTRICT);
1218   HANDLE_QUAL (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, QUAL_VOLATILE);
1219   HANDLE_QUAL (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, QUAL_CONST);
1220
1221   return lhs;
1222 }
1223
1224 /* Return a builtin type corresponding to FLAGS.  */
1225
1226 static struct demangle_component *
1227 d_int_type (int flags)
1228 {
1229   const char *name;
1230
1231   switch (flags)
1232     {
1233     case INT_SIGNED | INT_CHAR:
1234       name = "signed char";
1235       break;
1236     case INT_CHAR:
1237       name = "char";
1238       break;
1239     case INT_UNSIGNED | INT_CHAR:
1240       name = "unsigned char";
1241       break;
1242     case 0:
1243     case INT_SIGNED:
1244       name = "int";
1245       break;
1246     case INT_UNSIGNED:
1247       name = "unsigned int";
1248       break;
1249     case INT_LONG:
1250     case INT_SIGNED | INT_LONG:
1251       name = "long";
1252       break;
1253     case INT_UNSIGNED | INT_LONG:
1254       name = "unsigned long";
1255       break;
1256     case INT_SHORT:
1257     case INT_SIGNED | INT_SHORT:
1258       name = "short";
1259       break;
1260     case INT_UNSIGNED | INT_SHORT:
1261       name = "unsigned short";
1262       break;
1263     case INT_LLONG | INT_LONG:
1264     case INT_SIGNED | INT_LLONG | INT_LONG:
1265       name = "long long";
1266       break;
1267     case INT_UNSIGNED | INT_LLONG | INT_LONG:
1268       name = "unsigned long long";
1269       break;
1270     default:
1271       return NULL;
1272     }
1273
1274   return make_builtin_type (name);
1275 }
1276
1277 /* Wrapper to create a unary operation.  */
1278
1279 static struct demangle_component *
1280 d_unary (const char *name, struct demangle_component *lhs)
1281 {
1282   return fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator (name, 1), lhs);
1283 }
1284
1285 /* Wrapper to create a binary operation.  */
1286
1287 static struct demangle_component *
1288 d_binary (const char *name, struct demangle_component *lhs, struct demangle_component *rhs)
1289 {
1290   return fill_comp (DEMANGLE_COMPONENT_BINARY, make_operator (name, 2),
1291                       fill_comp (DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs));
1292 }
1293
1294 /* Find the end of a symbol name starting at LEXPTR.  */
1295
1296 static const char *
1297 symbol_end (const char *lexptr)
1298 {
1299   const char *p = lexptr;
1300
1301   while (*p && (ISALNUM (*p) || *p == '_' || *p == '$' || *p == '.'))
1302     p++;
1303
1304   return p;
1305 }
1306
1307 /* Take care of parsing a number (anything that starts with a digit).
1308    The number starts at P and contains LEN characters.  Store the result in
1309    YYLVAL.  */
1310
1311 static int
1312 parse_number (const char *p, int len, int parsed_float)
1313 {
1314   int unsigned_p = 0;
1315
1316   /* Number of "L" suffixes encountered.  */
1317   int long_p = 0;
1318
1319   struct demangle_component *signed_type;
1320   struct demangle_component *unsigned_type;
1321   struct demangle_component *type, *name;
1322   enum demangle_component_type literal_type;
1323
1324   if (p[0] == '-')
1325     {
1326       literal_type = DEMANGLE_COMPONENT_LITERAL_NEG;
1327       p++;
1328       len--;
1329     }
1330   else
1331     literal_type = DEMANGLE_COMPONENT_LITERAL;
1332
1333   if (parsed_float)
1334     {
1335       /* It's a float since it contains a point or an exponent.  */
1336       char c;
1337
1338       /* The GDB lexer checks the result of scanf at this point.  Not doing
1339          this leaves our error checking slightly weaker but only for invalid
1340          data.  */
1341
1342       /* See if it has `f' or `l' suffix (float or long double).  */
1343
1344       c = TOLOWER (p[len - 1]);
1345
1346       if (c == 'f')
1347         {
1348           len--;
1349           type = make_builtin_type ("float");
1350         }
1351       else if (c == 'l')
1352         {
1353           len--;
1354           type = make_builtin_type ("long double");
1355         }
1356       else if (ISDIGIT (c) || c == '.')
1357         type = make_builtin_type ("double");
1358       else
1359         return ERROR;
1360
1361       name = make_name (p, len);
1362       yylval.comp = fill_comp (literal_type, type, name);
1363
1364       return FLOAT;
1365     }
1366
1367   /* This treats 0x1 and 1 as different literals.  We also do not
1368      automatically generate unsigned types.  */
1369
1370   long_p = 0;
1371   unsigned_p = 0;
1372   while (len > 0)
1373     {
1374       if (p[len - 1] == 'l' || p[len - 1] == 'L')
1375         {
1376           len--;
1377           long_p++;
1378           continue;
1379         }
1380       if (p[len - 1] == 'u' || p[len - 1] == 'U')
1381         {
1382           len--;
1383           unsigned_p++;
1384           continue;
1385         }
1386       break;
1387     }
1388
1389   if (long_p == 0)
1390     {
1391       unsigned_type = make_builtin_type ("unsigned int");
1392       signed_type = make_builtin_type ("int");
1393     }
1394   else if (long_p == 1)
1395     {
1396       unsigned_type = make_builtin_type ("unsigned long");
1397       signed_type = make_builtin_type ("long");
1398     }
1399   else
1400     {
1401       unsigned_type = make_builtin_type ("unsigned long long");
1402       signed_type = make_builtin_type ("long long");
1403     }
1404
1405    if (unsigned_p)
1406      type = unsigned_type;
1407    else
1408      type = signed_type;
1409
1410    name = make_name (p, len);
1411    yylval.comp = fill_comp (literal_type, type, name);
1412
1413    return INT;
1414 }
1415
1416 static char backslashable[] = "abefnrtv";
1417 static char represented[] = "\a\b\e\f\n\r\t\v";
1418
1419 /* Translate the backslash the way we would in the host character set.  */
1420 static int
1421 c_parse_backslash (int host_char, int *target_char)
1422 {
1423   const char *ix;
1424   ix = strchr (backslashable, host_char);
1425   if (! ix)
1426     return 0;
1427   else
1428     *target_char = represented[ix - backslashable];
1429   return 1;
1430 }
1431
1432 /* Parse a C escape sequence.  STRING_PTR points to a variable
1433    containing a pointer to the string to parse.  That pointer
1434    should point to the character after the \.  That pointer
1435    is updated past the characters we use.  The value of the
1436    escape sequence is returned.
1437
1438    A negative value means the sequence \ newline was seen,
1439    which is supposed to be equivalent to nothing at all.
1440
1441    If \ is followed by a null character, we return a negative
1442    value and leave the string pointer pointing at the null character.
1443
1444    If \ is followed by 000, we return 0 and leave the string pointer
1445    after the zeros.  A value of 0 does not mean end of string.  */
1446
1447 static int
1448 cp_parse_escape (const char **string_ptr)
1449 {
1450   int target_char;
1451   int c = *(*string_ptr)++;
1452   if (c_parse_backslash (c, &target_char))
1453     return target_char;
1454   else
1455     switch (c)
1456       {
1457       case '\n':
1458         return -2;
1459       case 0:
1460         (*string_ptr)--;
1461         return 0;
1462       case '^':
1463         {
1464           c = *(*string_ptr)++;
1465
1466           if (c == '?')
1467             return 0177;
1468           else if (c == '\\')
1469             target_char = cp_parse_escape (string_ptr);
1470           else
1471             target_char = c;
1472
1473           /* Now target_char is something like `c', and we want to find
1474              its control-character equivalent.  */
1475           target_char = target_char & 037;
1476
1477           return target_char;
1478         }
1479
1480       case '0':
1481       case '1':
1482       case '2':
1483       case '3':
1484       case '4':
1485       case '5':
1486       case '6':
1487       case '7':
1488         {
1489           int i = c - '0';
1490           int count = 0;
1491           while (++count < 3)
1492             {
1493               c = (**string_ptr);
1494               if (c >= '0' && c <= '7')
1495                 {
1496                   (*string_ptr)++;
1497                   i *= 8;
1498                   i += c - '0';
1499                 }
1500               else
1501                 {
1502                   break;
1503                 }
1504             }
1505           return i;
1506         }
1507       default:
1508         return c;
1509       }
1510 }
1511
1512 #define HANDLE_SPECIAL(string, comp)                            \
1513   if (strncmp (tokstart, string, sizeof (string) - 1) == 0)     \
1514     {                                                           \
1515       lexptr = tokstart + sizeof (string) - 1;                  \
1516       yylval.lval = comp;                                       \
1517       return DEMANGLER_SPECIAL;                                 \
1518     }
1519
1520 #define HANDLE_TOKEN2(string, token)                    \
1521   if (lexptr[1] == string[1])                           \
1522     {                                                   \
1523       lexptr += 2;                                      \
1524       yylval.opname = string;                           \
1525       return token;                                     \
1526     }
1527
1528 #define HANDLE_TOKEN3(string, token)                    \
1529   if (lexptr[1] == string[1] && lexptr[2] == string[2]) \
1530     {                                                   \
1531       lexptr += 3;                                      \
1532       yylval.opname = string;                           \
1533       return token;                                     \
1534     }
1535
1536 /* Read one token, getting characters through LEXPTR.  */
1537
1538 static int
1539 yylex (void)
1540 {
1541   int c;
1542   int namelen;
1543   const char *tokstart;
1544
1545  retry:
1546   prev_lexptr = lexptr;
1547   tokstart = lexptr;
1548
1549   switch (c = *tokstart)
1550     {
1551     case 0:
1552       return 0;
1553
1554     case ' ':
1555     case '\t':
1556     case '\n':
1557       lexptr++;
1558       goto retry;
1559
1560     case '\'':
1561       /* We either have a character constant ('0' or '\177' for example)
1562          or we have a quoted symbol reference ('foo(int,int)' in C++
1563          for example). */
1564       lexptr++;
1565       c = *lexptr++;
1566       if (c == '\\')
1567         c = cp_parse_escape (&lexptr);
1568       else if (c == '\'')
1569         {
1570           yyerror (_("empty character constant"));
1571           return ERROR;
1572         }
1573
1574       c = *lexptr++;
1575       if (c != '\'')
1576         {
1577           yyerror (_("invalid character constant"));
1578           return ERROR;
1579         }
1580
1581       /* FIXME: We should refer to a canonical form of the character,
1582          presumably the same one that appears in manglings - the decimal
1583          representation.  But if that isn't in our input then we have to
1584          allocate memory for it somewhere.  */
1585       yylval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1586                                  make_builtin_type ("char"),
1587                                  make_name (tokstart, lexptr - tokstart));
1588
1589       return INT;
1590
1591     case '(':
1592       if (strncmp (tokstart, "(anonymous namespace)", 21) == 0)
1593         {
1594           lexptr += 21;
1595           yylval.comp = make_name ("(anonymous namespace)",
1596                                      sizeof "(anonymous namespace)" - 1);
1597           return NAME;
1598         }
1599         /* FALL THROUGH */
1600
1601     case ')':
1602     case ',':
1603       lexptr++;
1604       return c;
1605
1606     case '.':
1607       if (lexptr[1] == '.' && lexptr[2] == '.')
1608         {
1609           lexptr += 3;
1610           return ELLIPSIS;
1611         }
1612
1613       /* Might be a floating point number.  */
1614       if (lexptr[1] < '0' || lexptr[1] > '9')
1615         goto symbol;            /* Nope, must be a symbol. */
1616
1617       goto try_number;
1618
1619     case '-':
1620       HANDLE_TOKEN2 ("-=", ASSIGN_MODIFY);
1621       HANDLE_TOKEN2 ("--", DECREMENT);
1622       HANDLE_TOKEN2 ("->", ARROW);
1623
1624       /* For construction vtables.  This is kind of hokey.  */
1625       if (strncmp (tokstart, "-in-", 4) == 0)
1626         {
1627           lexptr += 4;
1628           return CONSTRUCTION_IN;
1629         }
1630
1631       if (lexptr[1] < '0' || lexptr[1] > '9')
1632         {
1633           lexptr++;
1634           return '-';
1635         }
1636       /* FALL THRU into number case.  */
1637
1638     try_number:
1639     case '0':
1640     case '1':
1641     case '2':
1642     case '3':
1643     case '4':
1644     case '5':
1645     case '6':
1646     case '7':
1647     case '8':
1648     case '9':
1649       {
1650         /* It's a number.  */
1651         int got_dot = 0, got_e = 0, toktype;
1652         const char *p = tokstart;
1653         int hex = 0;
1654
1655         if (c == '-')
1656           p++;
1657
1658         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1659           {
1660             p += 2;
1661             hex = 1;
1662           }
1663         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1664           {
1665             p += 2;
1666             hex = 0;
1667           }
1668
1669         for (;; ++p)
1670           {
1671             /* This test includes !hex because 'e' is a valid hex digit
1672                and thus does not indicate a floating point number when
1673                the radix is hex.  */
1674             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1675               got_dot = got_e = 1;
1676             /* This test does not include !hex, because a '.' always indicates
1677                a decimal floating point number regardless of the radix.
1678
1679                NOTE drow/2005-03-09: This comment is not accurate in C99;
1680                however, it's not clear that all the floating point support
1681                in this file is doing any good here.  */
1682             else if (!got_dot && *p == '.')
1683               got_dot = 1;
1684             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1685                      && (*p == '-' || *p == '+'))
1686               /* This is the sign of the exponent, not the end of the
1687                  number.  */
1688               continue;
1689             /* We will take any letters or digits.  parse_number will
1690                complain if past the radix, or if L or U are not final.  */
1691             else if (! ISALNUM (*p))
1692               break;
1693           }
1694         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e);
1695         if (toktype == ERROR)
1696           {
1697             char *err_copy = (char *) alloca (p - tokstart + 1);
1698
1699             memcpy (err_copy, tokstart, p - tokstart);
1700             err_copy[p - tokstart] = 0;
1701             yyerror (_("invalid number"));
1702             return ERROR;
1703           }
1704         lexptr = p;
1705         return toktype;
1706       }
1707
1708     case '+':
1709       HANDLE_TOKEN2 ("+=", ASSIGN_MODIFY);
1710       HANDLE_TOKEN2 ("++", INCREMENT);
1711       lexptr++;
1712       return c;
1713     case '*':
1714       HANDLE_TOKEN2 ("*=", ASSIGN_MODIFY);
1715       lexptr++;
1716       return c;
1717     case '/':
1718       HANDLE_TOKEN2 ("/=", ASSIGN_MODIFY);
1719       lexptr++;
1720       return c;
1721     case '%':
1722       HANDLE_TOKEN2 ("%=", ASSIGN_MODIFY);
1723       lexptr++;
1724       return c;
1725     case '|':
1726       HANDLE_TOKEN2 ("|=", ASSIGN_MODIFY);
1727       HANDLE_TOKEN2 ("||", OROR);
1728       lexptr++;
1729       return c;
1730     case '&':
1731       HANDLE_TOKEN2 ("&=", ASSIGN_MODIFY);
1732       HANDLE_TOKEN2 ("&&", ANDAND);
1733       lexptr++;
1734       return c;
1735     case '^':
1736       HANDLE_TOKEN2 ("^=", ASSIGN_MODIFY);
1737       lexptr++;
1738       return c;
1739     case '!':
1740       HANDLE_TOKEN2 ("!=", NOTEQUAL);
1741       lexptr++;
1742       return c;
1743     case '<':
1744       HANDLE_TOKEN3 ("<<=", ASSIGN_MODIFY);
1745       HANDLE_TOKEN2 ("<=", LEQ);
1746       HANDLE_TOKEN2 ("<<", LSH);
1747       lexptr++;
1748       return c;
1749     case '>':
1750       HANDLE_TOKEN3 (">>=", ASSIGN_MODIFY);
1751       HANDLE_TOKEN2 (">=", GEQ);
1752       HANDLE_TOKEN2 (">>", RSH);
1753       lexptr++;
1754       return c;
1755     case '=':
1756       HANDLE_TOKEN2 ("==", EQUAL);
1757       lexptr++;
1758       return c;
1759     case ':':
1760       HANDLE_TOKEN2 ("::", COLONCOLON);
1761       lexptr++;
1762       return c;
1763
1764     case '[':
1765     case ']':
1766     case '?':
1767     case '@':
1768     case '~':
1769     case '{':
1770     case '}':
1771     symbol:
1772       lexptr++;
1773       return c;
1774
1775     case '"':
1776       /* These can't occur in C++ names.  */
1777       yyerror (_("unexpected string literal"));
1778       return ERROR;
1779     }
1780
1781   if (!(c == '_' || c == '$' || ISALPHA (c)))
1782     {
1783       /* We must have come across a bad character (e.g. ';').  */
1784       yyerror (_("invalid character"));
1785       return ERROR;
1786     }
1787
1788   /* It's a name.  See how long it is.  */
1789   namelen = 0;
1790   do
1791     c = tokstart[++namelen];
1792   while (ISALNUM (c) || c == '_' || c == '$');
1793
1794   lexptr += namelen;
1795
1796   /* Catch specific keywords.  Notice that some of the keywords contain
1797      spaces, and are sorted by the length of the first word.  They must
1798      all include a trailing space in the string comparison.  */
1799   switch (namelen)
1800     {
1801     case 16:
1802       if (strncmp (tokstart, "reinterpret_cast", 16) == 0)
1803         return REINTERPRET_CAST;
1804       break;
1805     case 12:
1806       if (strncmp (tokstart, "construction vtable for ", 24) == 0)
1807         {
1808           lexptr = tokstart + 24;
1809           return CONSTRUCTION_VTABLE;
1810         }
1811       if (strncmp (tokstart, "dynamic_cast", 12) == 0)
1812         return DYNAMIC_CAST;
1813       break;
1814     case 11:
1815       if (strncmp (tokstart, "static_cast", 11) == 0)
1816         return STATIC_CAST;
1817       break;
1818     case 9:
1819       HANDLE_SPECIAL ("covariant return thunk to ", DEMANGLE_COMPONENT_COVARIANT_THUNK);
1820       HANDLE_SPECIAL ("reference temporary for ", DEMANGLE_COMPONENT_REFTEMP);
1821       break;
1822     case 8:
1823       HANDLE_SPECIAL ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO);
1824       HANDLE_SPECIAL ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN);
1825       HANDLE_SPECIAL ("typeinfo name for ", DEMANGLE_COMPONENT_TYPEINFO_NAME);
1826       if (strncmp (tokstart, "operator", 8) == 0)
1827         return OPERATOR;
1828       if (strncmp (tokstart, "restrict", 8) == 0)
1829         return RESTRICT;
1830       if (strncmp (tokstart, "unsigned", 8) == 0)
1831         return UNSIGNED;
1832       if (strncmp (tokstart, "template", 8) == 0)
1833         return TEMPLATE;
1834       if (strncmp (tokstart, "volatile", 8) == 0)
1835         return VOLATILE_KEYWORD;
1836       break;
1837     case 7:
1838       HANDLE_SPECIAL ("virtual thunk to ", DEMANGLE_COMPONENT_VIRTUAL_THUNK);
1839       if (strncmp (tokstart, "wchar_t", 7) == 0)
1840         return WCHAR_T;
1841       break;
1842     case 6:
1843       if (strncmp (tokstart, "global constructors keyed to ", 29) == 0)
1844         {
1845           const char *p;
1846           lexptr = tokstart + 29;
1847           yylval.lval = DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS;
1848           /* Find the end of the symbol.  */
1849           p = symbol_end (lexptr);
1850           yylval.comp = make_name (lexptr, p - lexptr);
1851           lexptr = p;
1852           return DEMANGLER_SPECIAL;
1853         }
1854       if (strncmp (tokstart, "global destructors keyed to ", 28) == 0)
1855         {
1856           const char *p;
1857           lexptr = tokstart + 28;
1858           yylval.lval = DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS;
1859           /* Find the end of the symbol.  */
1860           p = symbol_end (lexptr);
1861           yylval.comp = make_name (lexptr, p - lexptr);
1862           lexptr = p;
1863           return DEMANGLER_SPECIAL;
1864         }
1865
1866       HANDLE_SPECIAL ("vtable for ", DEMANGLE_COMPONENT_VTABLE);
1867       if (strncmp (tokstart, "delete", 6) == 0)
1868         return DELETE;
1869       if (strncmp (tokstart, "struct", 6) == 0)
1870         return STRUCT;
1871       if (strncmp (tokstart, "signed", 6) == 0)
1872         return SIGNED_KEYWORD;
1873       if (strncmp (tokstart, "sizeof", 6) == 0)
1874         return SIZEOF;
1875       if (strncmp (tokstart, "double", 6) == 0)
1876         return DOUBLE_KEYWORD;
1877       break;
1878     case 5:
1879       HANDLE_SPECIAL ("guard variable for ", DEMANGLE_COMPONENT_GUARD);
1880       if (strncmp (tokstart, "false", 5) == 0)
1881         return FALSEKEYWORD;
1882       if (strncmp (tokstart, "class", 5) == 0)
1883         return CLASS;
1884       if (strncmp (tokstart, "union", 5) == 0)
1885         return UNION;
1886       if (strncmp (tokstart, "float", 5) == 0)
1887         return FLOAT_KEYWORD;
1888       if (strncmp (tokstart, "short", 5) == 0)
1889         return SHORT;
1890       if (strncmp (tokstart, "const", 5) == 0)
1891         return CONST_KEYWORD;
1892       break;
1893     case 4:
1894       if (strncmp (tokstart, "void", 4) == 0)
1895         return VOID;
1896       if (strncmp (tokstart, "bool", 4) == 0)
1897         return BOOL;
1898       if (strncmp (tokstart, "char", 4) == 0)
1899         return CHAR;
1900       if (strncmp (tokstart, "enum", 4) == 0)
1901         return ENUM;
1902       if (strncmp (tokstart, "long", 4) == 0)
1903         return LONG;
1904       if (strncmp (tokstart, "true", 4) == 0)
1905         return TRUEKEYWORD;
1906       break;
1907     case 3:
1908       HANDLE_SPECIAL ("VTT for ", DEMANGLE_COMPONENT_VTT);
1909       HANDLE_SPECIAL ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK);
1910       if (strncmp (tokstart, "new", 3) == 0)
1911         return NEW;
1912       if (strncmp (tokstart, "int", 3) == 0)
1913         return INT_KEYWORD;
1914       break;
1915     default:
1916       break;
1917     }
1918
1919   yylval.comp = make_name (tokstart, namelen);
1920   return NAME;
1921 }
1922
1923 static void
1924 yyerror (char *msg)
1925 {
1926   if (global_errmsg)
1927     return;
1928
1929   error_lexptr = prev_lexptr;
1930   global_errmsg = msg ? msg : "parse error";
1931 }
1932
1933 /* Allocate a chunk of the components we'll need to build a tree.  We
1934    generally allocate too many components, but the extra memory usage
1935    doesn't hurt because the trees are temporary and the storage is
1936    reused.  More may be allocated later, by d_grab.  */
1937 static struct demangle_info *
1938 allocate_info (void)
1939 {
1940   struct demangle_info *info = malloc (sizeof (struct demangle_info));
1941
1942   info->next = NULL;
1943   info->used = 0;
1944   return info;
1945 }
1946
1947 /* Convert RESULT to a string.  The return value is allocated
1948    using xmalloc.  ESTIMATED_LEN is used only as a guide to the
1949    length of the result.  This functions handles a few cases that
1950    cplus_demangle_print does not, specifically the global destructor
1951    and constructor labels.  */
1952
1953 char *
1954 cp_comp_to_string (struct demangle_component *result, int estimated_len)
1955 {
1956   size_t err;
1957
1958   return cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, estimated_len,
1959                                &err);
1960 }
1961
1962 /* A convenience function to allocate and initialize a new struct
1963    demangled_parse_info.  */
1964
1965 struct demangle_parse_info *
1966 cp_new_demangle_parse_info (void)
1967 {
1968   struct demangle_parse_info *info;
1969
1970   info = malloc (sizeof (struct demangle_parse_info));
1971   info->info = NULL;
1972   info->tree = NULL;
1973   obstack_init (&info->obstack);
1974
1975   return info;
1976 }
1977
1978 /* Free any memory associated with the given PARSE_INFO.  */
1979
1980 void
1981 cp_demangled_name_parse_free (struct demangle_parse_info *parse_info)
1982 {
1983   struct demangle_info *info = parse_info->info;
1984
1985   /* Free any allocated chunks of memory for the parse.  */
1986   while (info != NULL)
1987     {
1988       struct demangle_info *next = info->next;
1989
1990       free (info);
1991       info = next;
1992     }
1993
1994   /* Free any memory allocated during typedef replacement.  */
1995   obstack_free (&parse_info->obstack, NULL);
1996
1997   /* Free the parser info.  */
1998   free (parse_info);
1999 }
2000
2001 /* Merge the two parse trees given by DEST and SRC.  The parse tree
2002    in SRC is attached to DEST at the node represented by TARGET.
2003    SRC is then freed.
2004
2005    NOTE 1: Since there is no API to merge obstacks, this function does
2006    even attempt to try it.  Fortunately, we do not (yet?) need this ability.
2007    The code will assert if SRC->obstack is not empty.
2008
2009    NOTE 2: The string from which SRC was parsed must not be freed, since
2010    this function will place pointers to that string into DEST.  */
2011
2012 void
2013 cp_merge_demangle_parse_infos (struct demangle_parse_info *dest,
2014                                struct demangle_component *target,
2015                                struct demangle_parse_info *src)
2016
2017 {
2018   struct demangle_info *di;
2019
2020   /* Copy the SRC's parse data into DEST.  */
2021   *target = *src->tree;
2022   di = dest->info;
2023   while (di->next != NULL)
2024     di = di->next;
2025   di->next = src->info;
2026
2027   /* Clear the (pointer to) SRC's parse data so that it is not freed when
2028      cp_demangled_parse_info_free is called.  */
2029   src->info = NULL;
2030
2031   /* Free SRC.  */
2032   cp_demangled_name_parse_free (src);
2033 }
2034
2035 /* Convert a demangled name to a demangle_component tree.  On success,
2036    a structure containing the root of the new tree is returned; it must
2037    be freed by calling cp_demangled_name_parse_free. On error, NULL is
2038    returned, and an error message will be set in *ERRMSG (which does
2039    not need to be freed).  */
2040
2041 struct demangle_parse_info *
2042 cp_demangled_name_to_comp (const char *demangled_name, const char **errmsg)
2043 {
2044   static char errbuf[60];
2045   struct demangle_parse_info *result;
2046
2047   prev_lexptr = lexptr = demangled_name;
2048   error_lexptr = NULL;
2049   global_errmsg = NULL;
2050
2051   demangle_info = allocate_info ();
2052
2053   result = cp_new_demangle_parse_info ();
2054   result->info = demangle_info;
2055
2056   if (yyparse ())
2057     {
2058       if (global_errmsg && errmsg)
2059         {
2060           snprintf (errbuf, sizeof (errbuf) - 2, "%s, near `%s",
2061                     global_errmsg, error_lexptr);
2062           strcat (errbuf, "'");
2063           *errmsg = errbuf;
2064         }
2065       cp_demangled_name_parse_free (result);
2066       return NULL;
2067     }
2068
2069   result->tree = global_result;
2070   global_result = NULL;
2071
2072   return result;
2073 }
2074
2075 #ifdef TEST_CPNAMES
2076
2077 static void
2078 cp_print (struct demangle_component *result)
2079 {
2080   char *str;
2081   size_t err = 0;
2082
2083   str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, 64, &err);
2084   if (str == NULL)
2085     return;
2086
2087   fputs (str, stdout);
2088
2089   free (str);
2090 }
2091
2092 static char
2093 trim_chars (char *lexptr, char **extra_chars)
2094 {
2095   char *p = (char *) symbol_end (lexptr);
2096   char c = 0;
2097
2098   if (*p)
2099     {
2100       c = *p;
2101       *p = 0;
2102       *extra_chars = p + 1;
2103     }
2104
2105   return c;
2106 }
2107
2108 /* When this file is built as a standalone program, xmalloc comes from
2109    libiberty --- in which case we have to provide xfree ourselves.  */
2110
2111 void
2112 xfree (void *ptr)
2113 {
2114   if (ptr != NULL)
2115     {
2116       /* Literal `free' would get translated back to xfree again.  */
2117       CONCAT2 (fr,ee) (ptr);
2118     }
2119 }
2120
2121 /* GDB normally defines internal_error itself, but when this file is built
2122    as a standalone program, we must also provide an implementation.  */
2123
2124 void
2125 internal_error (const char *file, int line, const char *fmt, ...)
2126 {
2127   va_list ap;
2128
2129   va_start (ap, fmt);
2130   fprintf (stderr, "%s:%d: internal error: ", file, line);
2131   vfprintf (stderr, fmt, ap);
2132   exit (1);
2133 }
2134
2135 int
2136 main (int argc, char **argv)
2137 {
2138   char *str2, *extra_chars = "", c;
2139   char buf[65536];
2140   int arg;
2141   const char *errmsg;
2142   struct demangle_parse_info *result;
2143
2144   arg = 1;
2145   if (argv[arg] && strcmp (argv[arg], "--debug") == 0)
2146     {
2147       yydebug = 1;
2148       arg++;
2149     }
2150
2151   if (argv[arg] == NULL)
2152     while (fgets (buf, 65536, stdin) != NULL)
2153       {
2154         int len;
2155         buf[strlen (buf) - 1] = 0;
2156         /* Use DMGL_VERBOSE to get expanded standard substitutions.  */
2157         c = trim_chars (buf, &extra_chars);
2158         str2 = cplus_demangle (buf, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
2159         if (str2 == NULL)
2160           {
2161             printf ("Demangling error\n");
2162             if (c)
2163               printf ("%s%c%s\n", buf, c, extra_chars);
2164             else
2165               printf ("%s\n", buf);
2166             continue;
2167           }
2168         result = cp_demangled_name_to_comp (str2, &errmsg);
2169         if (result == NULL)
2170           {
2171             fputs (errmsg, stderr);
2172             fputc ('\n', stderr);
2173             continue;
2174           }
2175
2176         cp_print (result->tree);
2177         cp_demangled_name_parse_free (result);
2178
2179         free (str2);
2180         if (c)
2181           {
2182             putchar (c);
2183             fputs (extra_chars, stdout);
2184           }
2185         putchar ('\n');
2186       }
2187   else
2188     {
2189       result = cp_demangled_name_to_comp (argv[arg], &errmsg);
2190       if (result == NULL)
2191         {
2192           fputs (errmsg, stderr);
2193           fputc ('\n', stderr);
2194           return 0;
2195         }
2196       cp_print (result->tree);
2197       cp_demangled_name_parse_free (result);
2198       putchar ('\n');
2199     }
2200   return 0;
2201 }
2202
2203 #endif