gdb/cp-name-parser.y

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