contrib/gdb-7/libiberty/cp-demangle.c

   1 /* Demangler for g++ V3 ABI.
   2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor <ian@wasabisystems.com>.
   5
   6    This file is part of the libiberty library, which is part of GCC.
   7
   8    This file is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    In addition to the permissions in the GNU General Public License, the
  14    Free Software Foundation gives you unlimited permission to link the
  15    compiled version of this file into combinations with other programs,
  16    and to distribute those combinations without any restriction coming
  17    from the use of this file.  (The General Public License restrictions
  18    do apply in other respects; for example, they cover modification of
  19    the file, and distribution when not linked into a combined
  20    executable.)
  21
  22    This program is distributed in the hope that it will be useful,
  23    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25    GNU General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program; if not, write to the Free Software
  29    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  30 */
  31
  32 /* This code implements a demangler for the g++ V3 ABI.  The ABI is
  33    described on this web page:
  34        http://www.codesourcery.com/cxx-abi/abi.html#mangling
  35
  36    This code was written while looking at the demangler written by
  37    Alex Samuel <samuel@codesourcery.com>.
  38
  39    This code first pulls the mangled name apart into a list of
  40    components, and then walks the list generating the demangled
  41    name.
  42
  43    This file will normally define the following functions, q.v.:
  44       char *cplus_demangle_v3(const char *mangled, int options)
  45       char *java_demangle_v3(const char *mangled)
  46       int cplus_demangle_v3_callback(const char *mangled, int options,
  47                                      demangle_callbackref callback)
  48       int java_demangle_v3_callback(const char *mangled,
  49                                     demangle_callbackref callback)
  50       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
  51       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
  52
  53    Also, the interface to the component list is public, and defined in
  54    demangle.h.  The interface consists of these types, which are
  55    defined in demangle.h:
  56       enum demangle_component_type
  57       struct demangle_component
  58       demangle_callbackref
  59    and these functions defined in this file:
  60       cplus_demangle_fill_name
  61       cplus_demangle_fill_extended_operator
  62       cplus_demangle_fill_ctor
  63       cplus_demangle_fill_dtor
  64       cplus_demangle_print
  65       cplus_demangle_print_callback
  66    and other functions defined in the file cp-demint.c.
  67
  68    This file also defines some other functions and variables which are
  69    only to be used by the file cp-demint.c.
  70
  71    Preprocessor macros you can define while compiling this file:
  72
  73    IN_LIBGCC2
  74       If defined, this file defines the following functions, q.v.:
  75          char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
  76                                int *status)
  77          int __gcclibcxx_demangle_callback (const char *,
  78                                             void (*)
  79                                               (const char *, size_t, void *),
  80                                             void *)
  81       instead of cplus_demangle_v3[_callback]() and
  82       java_demangle_v3[_callback]().
  83
  84    IN_GLIBCPP_V3
  85       If defined, this file defines only __cxa_demangle() and
  86       __gcclibcxx_demangle_callback(), and no other publically visible
  87       functions or variables.
  88
  89    STANDALONE_DEMANGLER
  90       If defined, this file defines a main() function which demangles
  91       any arguments, or, if none, demangles stdin.
  92
  93    CP_DEMANGLE_DEBUG
  94       If defined, turns on debugging mode, which prints information on
  95       stdout about the mangled string.  This is not generally useful.
  96 */
  97
  98 #if defined (_AIX) && !defined (__GNUC__)
  99  #pragma alloca
 100 #endif
 101
 102 #ifdef HAVE_CONFIG_H
 103 #include "config.h"
 104 #endif
 105
 106 #include <stdio.h>
 107
 108 #ifdef HAVE_STDLIB_H
 109 #include <stdlib.h>
 110 #endif
 111 #ifdef HAVE_STRING_H
 112 #include <string.h>
 113 #endif
 114
 115 #ifdef HAVE_ALLOCA_H
 116 # include <alloca.h>
 117 #else
 118 # ifndef alloca
 119 #  ifdef __GNUC__
 120 #   define alloca __builtin_alloca
 121 #  else
 122 extern char *alloca ();
 123 #  endif /* __GNUC__ */
 124 # endif /* alloca */
 125 #endif /* HAVE_ALLOCA_H */
 126
 127 #include "ansidecl.h"
 128 #include "libiberty.h"
 129 #include "demangle.h"
 130 #include "cp-demangle.h"
 131
 132 /* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
 133    also rename them via #define to avoid compiler errors when the
 134    static definition conflicts with the extern declaration in a header
 135    file.  */
 136 #ifdef IN_GLIBCPP_V3
 137
 138 #define CP_STATIC_IF_GLIBCPP_V3 static
 139
 140 #define cplus_demangle_fill_name d_fill_name
 141 static int d_fill_name (struct demangle_component *, const char *, int);
 142
 143 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
 144 static int
 145 d_fill_extended_operator (struct demangle_component *, int,
 146                           struct demangle_component *);
 147
 148 #define cplus_demangle_fill_ctor d_fill_ctor
 149 static int
 150 d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
 151              struct demangle_component *);
 152
 153 #define cplus_demangle_fill_dtor d_fill_dtor
 154 static int
 155 d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
 156              struct demangle_component *);
 157
 158 #define cplus_demangle_mangled_name d_mangled_name
 159 static struct demangle_component *d_mangled_name (struct d_info *, int);
 160
 161 #define cplus_demangle_type d_type
 162 static struct demangle_component *d_type (struct d_info *);
 163
 164 #define cplus_demangle_print d_print
 165 static char *d_print (int, const struct demangle_component *, int, size_t *);
 166
 167 #define cplus_demangle_print_callback d_print_callback
 168 static int d_print_callback (int, const struct demangle_component *,
 169                              demangle_callbackref, void *);
 170
 171 #define cplus_demangle_init_info d_init_info
 172 static void d_init_info (const char *, int, size_t, struct d_info *);
 173
 174 #else /* ! defined(IN_GLIBCPP_V3) */
 175 #define CP_STATIC_IF_GLIBCPP_V3
 176 #endif /* ! defined(IN_GLIBCPP_V3) */
 177
 178 /* See if the compiler supports dynamic arrays.  */
 179
 180 #ifdef __GNUC__
 181 #define CP_DYNAMIC_ARRAYS
 182 #else
 183 #ifdef __STDC__
 184 #ifdef __STDC_VERSION__
 185 #if __STDC_VERSION__ >= 199901L
 186 #define CP_DYNAMIC_ARRAYS
 187 #endif /* __STDC__VERSION >= 199901L */
 188 #endif /* defined (__STDC_VERSION__) */
 189 #endif /* defined (__STDC__) */
 190 #endif /* ! defined (__GNUC__) */
 191
 192 /* We avoid pulling in the ctype tables, to prevent pulling in
 193    additional unresolved symbols when this code is used in a library.
 194    FIXME: Is this really a valid reason?  This comes from the original
 195    V3 demangler code.
 196
 197    As of this writing this file has the following undefined references
 198    when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
 199    strcat, strlen.  */
 200
 201 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
 202 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
 203 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
 204
 205 /* The prefix prepended by GCC to an identifier represnting the
 206    anonymous namespace.  */
 207 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
 208 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
 209   (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
 210
 211 /* Information we keep for the standard substitutions.  */
 212
 213 struct d_standard_sub_info
 214 {
 215   /* The code for this substitution.  */
 216   char code;
 217   /* The simple string it expands to.  */
 218   const char *simple_expansion;
 219   /* The length of the simple expansion.  */
 220   int simple_len;
 221   /* The results of a full, verbose, expansion.  This is used when
 222      qualifying a constructor/destructor, or when in verbose mode.  */
 223   const char *full_expansion;
 224   /* The length of the full expansion.  */
 225   int full_len;
 226   /* What to set the last_name field of d_info to; NULL if we should
 227      not set it.  This is only relevant when qualifying a
 228      constructor/destructor.  */
 229   const char *set_last_name;
 230   /* The length of set_last_name.  */
 231   int set_last_name_len;
 232 };
 233
 234 /* Accessors for subtrees of struct demangle_component.  */
 235
 236 #define d_left(dc) ((dc)->u.s_binary.left)
 237 #define d_right(dc) ((dc)->u.s_binary.right)
 238
 239 /* A list of templates.  This is used while printing.  */
 240
 241 struct d_print_template
 242 {
 243   /* Next template on the list.  */
 244   struct d_print_template *next;
 245   /* This template.  */
 246   const struct demangle_component *template_decl;
 247 };
 248
 249 /* A list of type modifiers.  This is used while printing.  */
 250
 251 struct d_print_mod
 252 {
 253   /* Next modifier on the list.  These are in the reverse of the order
 254      in which they appeared in the mangled string.  */
 255   struct d_print_mod *next;
 256   /* The modifier.  */
 257   const struct demangle_component *mod;
 258   /* Whether this modifier was printed.  */
 259   int printed;
 260   /* The list of templates which applies to this modifier.  */
 261   struct d_print_template *templates;
 262 };
 263
 264 /* We use these structures to hold information during printing.  */
 265
 266 struct d_growable_string
 267 {
 268   /* Buffer holding the result.  */
 269   char *buf;
 270   /* Current length of data in buffer.  */
 271   size_t len;
 272   /* Allocated size of buffer.  */
 273   size_t alc;
 274   /* Set to 1 if we had a memory allocation failure.  */
 275   int allocation_failure;
 276 };
 277
 278 enum { D_PRINT_BUFFER_LENGTH = 256 };
 279 struct d_print_info
 280 {
 281   /* Fixed-length allocated buffer for demangled data, flushed to the
 282      callback with a NUL termination once full.  */
 283   char buf[D_PRINT_BUFFER_LENGTH];
 284   /* Current length of data in buffer.  */
 285   size_t len;
 286   /* The last character printed, saved individually so that it survives
 287      any buffer flush.  */
 288   char last_char;
 289   /* Callback function to handle demangled buffer flush.  */
 290   demangle_callbackref callback;
 291   /* Opaque callback argument.  */
 292   void *opaque;
 293   /* The current list of templates, if any.  */
 294   struct d_print_template *templates;
 295   /* The current list of modifiers (e.g., pointer, reference, etc.),
 296      if any.  */
 297   struct d_print_mod *modifiers;
 298   /* Set to 1 if we saw a demangling error.  */
 299   int demangle_failure;
 300   /* The current index into any template argument packs we are using
 301      for printing.  */
 302   int pack_index;
 303   /* Number of d_print_flush calls so far.  */
 304   unsigned long int flush_count;
 305 };
 306
 307 #ifdef CP_DEMANGLE_DEBUG
 308 static void d_dump (struct demangle_component *, int);
 309 #endif
 310
 311 static struct demangle_component *
 312 d_make_empty (struct d_info *);
 313
 314 static struct demangle_component *
 315 d_make_comp (struct d_info *, enum demangle_component_type,
 316              struct demangle_component *,
 317              struct demangle_component *);
 318
 319 static struct demangle_component *
 320 d_make_name (struct d_info *, const char *, int);
 321
 322 static struct demangle_component *
 323 d_make_demangle_mangled_name (struct d_info *, const char *);
 324
 325 static struct demangle_component *
 326 d_make_builtin_type (struct d_info *,
 327                      const struct demangle_builtin_type_info *);
 328
 329 static struct demangle_component *
 330 d_make_operator (struct d_info *,
 331                  const struct demangle_operator_info *);
 332
 333 static struct demangle_component *
 334 d_make_extended_operator (struct d_info *, int,
 335                           struct demangle_component *);
 336
 337 static struct demangle_component *
 338 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
 339              struct demangle_component *);
 340
 341 static struct demangle_component *
 342 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
 343              struct demangle_component *);
 344
 345 static struct demangle_component *
 346 d_make_template_param (struct d_info *, long);
 347
 348 static struct demangle_component *
 349 d_make_sub (struct d_info *, const char *, int);
 350
 351 static int
 352 has_return_type (struct demangle_component *);
 353
 354 static int
 355 is_ctor_dtor_or_conversion (struct demangle_component *);
 356
 357 static struct demangle_component *d_encoding (struct d_info *, int);
 358
 359 static struct demangle_component *d_name (struct d_info *);
 360
 361 static struct demangle_component *d_nested_name (struct d_info *);
 362
 363 static struct demangle_component *d_prefix (struct d_info *);
 364
 365 static struct demangle_component *d_unqualified_name (struct d_info *);
 366
 367 static struct demangle_component *d_source_name (struct d_info *);
 368
 369 static long d_number (struct d_info *);
 370
 371 static struct demangle_component *d_identifier (struct d_info *, int);
 372
 373 static struct demangle_component *d_operator_name (struct d_info *);
 374
 375 static struct demangle_component *d_special_name (struct d_info *);
 376
 377 static int d_call_offset (struct d_info *, int);
 378
 379 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
 380
 381 static struct demangle_component **
 382 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
 383
 384 static struct demangle_component *
 385 d_function_type (struct d_info *);
 386
 387 static struct demangle_component *
 388 d_bare_function_type (struct d_info *, int);
 389
 390 static struct demangle_component *
 391 d_class_enum_type (struct d_info *);
 392
 393 static struct demangle_component *d_array_type (struct d_info *);
 394
 395 static struct demangle_component *d_vector_type (struct d_info *);
 396
 397 static struct demangle_component *
 398 d_pointer_to_member_type (struct d_info *);
 399
 400 static struct demangle_component *
 401 d_template_param (struct d_info *);
 402
 403 static struct demangle_component *d_template_args (struct d_info *);
 404
 405 static struct demangle_component *
 406 d_template_arg (struct d_info *);
 407
 408 static struct demangle_component *d_expression (struct d_info *);
 409
 410 static struct demangle_component *d_expr_primary (struct d_info *);
 411
 412 static struct demangle_component *d_local_name (struct d_info *);
 413
 414 static int d_discriminator (struct d_info *);
 415
 416 static struct demangle_component *d_lambda (struct d_info *);
 417
 418 static struct demangle_component *d_unnamed_type (struct d_info *);
 419
 420 static struct demangle_component *
 421 d_clone_suffix (struct d_info *, struct demangle_component *);
 422
 423 static int
 424 d_add_substitution (struct d_info *, struct demangle_component *);
 425
 426 static struct demangle_component *d_substitution (struct d_info *, int);
 427
 428 static void d_growable_string_init (struct d_growable_string *, size_t);
 429
 430 static inline void
 431 d_growable_string_resize (struct d_growable_string *, size_t);
 432
 433 static inline void
 434 d_growable_string_append_buffer (struct d_growable_string *,
 435                                  const char *, size_t);
 436 static void
 437 d_growable_string_callback_adapter (const char *, size_t, void *);
 438
 439 static void
 440 d_print_init (struct d_print_info *, demangle_callbackref, void *);
 441
 442 static inline void d_print_error (struct d_print_info *);
 443
 444 static inline int d_print_saw_error (struct d_print_info *);
 445
 446 static inline void d_print_flush (struct d_print_info *);
 447
 448 static inline void d_append_char (struct d_print_info *, char);
 449
 450 static inline void d_append_buffer (struct d_print_info *,
 451                                     const char *, size_t);
 452
 453 static inline void d_append_string (struct d_print_info *, const char *);
 454
 455 static inline char d_last_char (struct d_print_info *);
 456
 457 static void
 458 d_print_comp (struct d_print_info *, int, const struct demangle_component *);
 459
 460 static void
 461 d_print_java_identifier (struct d_print_info *, const char *, int);
 462
 463 static void
 464 d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
 465
 466 static void
 467 d_print_mod (struct d_print_info *, int, const struct demangle_component *);
 468
 469 static void
 470 d_print_function_type (struct d_print_info *, int,
 471                        const struct demangle_component *,
 472                        struct d_print_mod *);
 473
 474 static void
 475 d_print_array_type (struct d_print_info *, int,
 476                     const struct demangle_component *,
 477                     struct d_print_mod *);
 478
 479 static void
 480 d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);
 481
 482 static void
 483 d_print_cast (struct d_print_info *, int, const struct demangle_component *);
 484
 485 static int d_demangle_callback (const char *, int,
 486                                 demangle_callbackref, void *);
 487 static char *d_demangle (const char *, int, size_t *);
 488
 489 #ifdef CP_DEMANGLE_DEBUG
 490
 491 static void
 492 d_dump (struct demangle_component *dc, int indent)
 493 {
 494   int i;
 495
 496   if (dc == NULL)
 497     {
 498       if (indent == 0)
 499         printf ("failed demangling\n");
 500       return;
 501     }
 502
 503   for (i = 0; i < indent; ++i)
 504     putchar (' ');
 505
 506   switch (dc->type)
 507     {
 508     case DEMANGLE_COMPONENT_NAME:
 509       printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
 510       return;
 511     case DEMANGLE_COMPONENT_TAGGED_NAME:
 512       printf ("tagged name\n");
 513       d_dump (dc->u.s_binary.left, indent + 2);
 514       d_dump (dc->u.s_binary.right, indent + 2);
 515       return;
 516     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
 517       printf ("template parameter %ld\n", dc->u.s_number.number);
 518       return;
 519     case DEMANGLE_COMPONENT_CTOR:
 520       printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
 521       d_dump (dc->u.s_ctor.name, indent + 2);
 522       return;
 523     case DEMANGLE_COMPONENT_DTOR:
 524       printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
 525       d_dump (dc->u.s_dtor.name, indent + 2);
 526       return;
 527     case DEMANGLE_COMPONENT_SUB_STD:
 528       printf ("standard substitution %s\n", dc->u.s_string.string);
 529       return;
 530     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
 531       printf ("builtin type %s\n", dc->u.s_builtin.type->name);
 532       return;
 533     case DEMANGLE_COMPONENT_OPERATOR:
 534       printf ("operator %s\n", dc->u.s_operator.op->name);
 535       return;
 536     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 537       printf ("extended operator with %d args\n",
 538               dc->u.s_extended_operator.args);
 539       d_dump (dc->u.s_extended_operator.name, indent + 2);
 540       return;
 541
 542     case DEMANGLE_COMPONENT_QUAL_NAME:
 543       printf ("qualified name\n");
 544       break;
 545     case DEMANGLE_COMPONENT_LOCAL_NAME:
 546       printf ("local name\n");
 547       break;
 548     case DEMANGLE_COMPONENT_TYPED_NAME:
 549       printf ("typed name\n");
 550       break;
 551     case DEMANGLE_COMPONENT_TEMPLATE:
 552       printf ("template\n");
 553       break;
 554     case DEMANGLE_COMPONENT_VTABLE:
 555       printf ("vtable\n");
 556       break;
 557     case DEMANGLE_COMPONENT_VTT:
 558       printf ("VTT\n");
 559       break;
 560     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 561       printf ("construction vtable\n");
 562       break;
 563     case DEMANGLE_COMPONENT_TYPEINFO:
 564       printf ("typeinfo\n");
 565       break;
 566     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 567       printf ("typeinfo name\n");
 568       break;
 569     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 570       printf ("typeinfo function\n");
 571       break;
 572     case DEMANGLE_COMPONENT_THUNK:
 573       printf ("thunk\n");
 574       break;
 575     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 576       printf ("virtual thunk\n");
 577       break;
 578     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 579       printf ("covariant thunk\n");
 580       break;
 581     case DEMANGLE_COMPONENT_JAVA_CLASS:
 582       printf ("java class\n");
 583       break;
 584     case DEMANGLE_COMPONENT_GUARD:
 585       printf ("guard\n");
 586       break;
 587     case DEMANGLE_COMPONENT_REFTEMP:
 588       printf ("reference temporary\n");
 589       break;
 590     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 591       printf ("hidden alias\n");
 592       break;
 593     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
 594       printf ("transaction clone\n");
 595       break;
 596     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
 597       printf ("non-transaction clone\n");
 598       break;
 599     case DEMANGLE_COMPONENT_RESTRICT:
 600       printf ("restrict\n");
 601       break;
 602     case DEMANGLE_COMPONENT_VOLATILE:
 603       printf ("volatile\n");
 604       break;
 605     case DEMANGLE_COMPONENT_CONST:
 606       printf ("const\n");
 607       break;
 608     case DEMANGLE_COMPONENT_RESTRICT_THIS:
 609       printf ("restrict this\n");
 610       break;
 611     case DEMANGLE_COMPONENT_VOLATILE_THIS:
 612       printf ("volatile this\n");
 613       break;
 614     case DEMANGLE_COMPONENT_CONST_THIS:
 615       printf ("const this\n");
 616       break;
 617     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 618       printf ("vendor type qualifier\n");
 619       break;
 620     case DEMANGLE_COMPONENT_POINTER:
 621       printf ("pointer\n");
 622       break;
 623     case DEMANGLE_COMPONENT_REFERENCE:
 624       printf ("reference\n");
 625       break;
 626     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 627       printf ("rvalue reference\n");
 628       break;
 629     case DEMANGLE_COMPONENT_COMPLEX:
 630       printf ("complex\n");
 631       break;
 632     case DEMANGLE_COMPONENT_IMAGINARY:
 633       printf ("imaginary\n");
 634       break;
 635     case DEMANGLE_COMPONENT_VENDOR_TYPE:
 636       printf ("vendor type\n");
 637       break;
 638     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 639       printf ("function type\n");
 640       break;
 641     case DEMANGLE_COMPONENT_ARRAY_TYPE:
 642       printf ("array type\n");
 643       break;
 644     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 645       printf ("pointer to member type\n");
 646       break;
 647     case DEMANGLE_COMPONENT_FIXED_TYPE:
 648       printf ("fixed-point type\n");
 649       break;
 650     case DEMANGLE_COMPONENT_ARGLIST:
 651       printf ("argument list\n");
 652       break;
 653     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 654       printf ("template argument list\n");
 655       break;
 656     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
 657       printf ("initializer list\n");
 658       break;
 659     case DEMANGLE_COMPONENT_CAST:
 660       printf ("cast\n");
 661       break;
 662     case DEMANGLE_COMPONENT_NULLARY:
 663       printf ("nullary operator\n");
 664       break;
 665     case DEMANGLE_COMPONENT_UNARY:
 666       printf ("unary operator\n");
 667       break;
 668     case DEMANGLE_COMPONENT_BINARY:
 669       printf ("binary operator\n");
 670       break;
 671     case DEMANGLE_COMPONENT_BINARY_ARGS:
 672       printf ("binary operator arguments\n");
 673       break;
 674     case DEMANGLE_COMPONENT_TRINARY:
 675       printf ("trinary operator\n");
 676       break;
 677     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 678       printf ("trinary operator arguments 1\n");
 679       break;
 680     case DEMANGLE_COMPONENT_TRINARY_ARG2:
 681       printf ("trinary operator arguments 1\n");
 682       break;
 683     case DEMANGLE_COMPONENT_LITERAL:
 684       printf ("literal\n");
 685       break;
 686     case DEMANGLE_COMPONENT_LITERAL_NEG:
 687       printf ("negative literal\n");
 688       break;
 689     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 690       printf ("java resource\n");
 691       break;
 692     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 693       printf ("compound name\n");
 694       break;
 695     case DEMANGLE_COMPONENT_CHARACTER:
 696       printf ("character '%c'\n",  dc->u.s_character.character);
 697       return;
 698     case DEMANGLE_COMPONENT_DECLTYPE:
 699       printf ("decltype\n");
 700       break;
 701     case DEMANGLE_COMPONENT_PACK_EXPANSION:
 702       printf ("pack expansion\n");
 703       break;
 704     case DEMANGLE_COMPONENT_TLS_INIT:
 705       printf ("tls init function\n");
 706       break;
 707     case DEMANGLE_COMPONENT_TLS_WRAPPER:
 708       printf ("tls wrapper function\n");
 709       break;
 710     case DEMANGLE_COMPONENT_DEFAULT_ARG:
 711       printf ("default argument %d\n", dc->u.s_unary_num.num);
 712       d_dump (dc->u.s_unary_num.sub, indent+2);
 713       return;
 714     case DEMANGLE_COMPONENT_LAMBDA:
 715       printf ("lambda %d\n", dc->u.s_unary_num.num);
 716       d_dump (dc->u.s_unary_num.sub, indent+2);
 717       return;
 718     }
 719
 720   d_dump (d_left (dc), indent + 2);
 721   d_dump (d_right (dc), indent + 2);
 722 }
 723
 724 #endif /* CP_DEMANGLE_DEBUG */
 725
 726 /* Fill in a DEMANGLE_COMPONENT_NAME.  */
 727
 728 CP_STATIC_IF_GLIBCPP_V3
 729 int
 730 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
 731 {
 732   if (p == NULL || s == NULL || len == 0)
 733     return 0;
 734   p->type = DEMANGLE_COMPONENT_NAME;
 735   p->u.s_name.s = s;
 736   p->u.s_name.len = len;
 737   return 1;
 738 }
 739
 740 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
 741
 742 CP_STATIC_IF_GLIBCPP_V3
 743 int
 744 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
 745                                        struct demangle_component *name)
 746 {
 747   if (p == NULL || args < 0 || name == NULL)
 748     return 0;
 749   p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
 750   p->u.s_extended_operator.args = args;
 751   p->u.s_extended_operator.name = name;
 752   return 1;
 753 }
 754
 755 /* Fill in a DEMANGLE_COMPONENT_CTOR.  */
 756
 757 CP_STATIC_IF_GLIBCPP_V3
 758 int
 759 cplus_demangle_fill_ctor (struct demangle_component *p,
 760                           enum gnu_v3_ctor_kinds kind,
 761                           struct demangle_component *name)
 762 {
 763   if (p == NULL
 764       || name == NULL
 765       || (int) kind < gnu_v3_complete_object_ctor
 766       || (int) kind > gnu_v3_object_ctor_group)
 767     return 0;
 768   p->type = DEMANGLE_COMPONENT_CTOR;
 769   p->u.s_ctor.kind = kind;
 770   p->u.s_ctor.name = name;
 771   return 1;
 772 }
 773
 774 /* Fill in a DEMANGLE_COMPONENT_DTOR.  */
 775
 776 CP_STATIC_IF_GLIBCPP_V3
 777 int
 778 cplus_demangle_fill_dtor (struct demangle_component *p,
 779                           enum gnu_v3_dtor_kinds kind,
 780                           struct demangle_component *name)
 781 {
 782   if (p == NULL
 783       || name == NULL
 784       || (int) kind < gnu_v3_deleting_dtor
 785       || (int) kind > gnu_v3_object_dtor_group)
 786     return 0;
 787   p->type = DEMANGLE_COMPONENT_DTOR;
 788   p->u.s_dtor.kind = kind;
 789   p->u.s_dtor.name = name;
 790   return 1;
 791 }
 792
 793 /* Add a new component.  */
 794
 795 static struct demangle_component *
 796 d_make_empty (struct d_info *di)
 797 {
 798   struct demangle_component *p;
 799
 800   if (di->next_comp >= di->num_comps)
 801     return NULL;
 802   p = &di->comps[di->next_comp];
 803   ++di->next_comp;
 804   return p;
 805 }
 806
 807 /* Add a new generic component.  */
 808
 809 static struct demangle_component *
 810 d_make_comp (struct d_info *di, enum demangle_component_type type,
 811              struct demangle_component *left,
 812              struct demangle_component *right)
 813 {
 814   struct demangle_component *p;
 815
 816   /* We check for errors here.  A typical error would be a NULL return
 817      from a subroutine.  We catch those here, and return NULL
 818      upward.  */
 819   switch (type)
 820     {
 821       /* These types require two parameters.  */
 822     case DEMANGLE_COMPONENT_QUAL_NAME:
 823     case DEMANGLE_COMPONENT_LOCAL_NAME:
 824     case DEMANGLE_COMPONENT_TYPED_NAME:
 825     case DEMANGLE_COMPONENT_TAGGED_NAME:
 826     case DEMANGLE_COMPONENT_TEMPLATE:
 827     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 828     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 829     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 830     case DEMANGLE_COMPONENT_UNARY:
 831     case DEMANGLE_COMPONENT_BINARY:
 832     case DEMANGLE_COMPONENT_BINARY_ARGS:
 833     case DEMANGLE_COMPONENT_TRINARY:
 834     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 835     case DEMANGLE_COMPONENT_LITERAL:
 836     case DEMANGLE_COMPONENT_LITERAL_NEG:
 837     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 838     case DEMANGLE_COMPONENT_VECTOR_TYPE:
 839     case DEMANGLE_COMPONENT_CLONE:
 840       if (left == NULL || right == NULL)
 841         return NULL;
 842       break;
 843
 844       /* These types only require one parameter.  */
 845     case DEMANGLE_COMPONENT_VTABLE:
 846     case DEMANGLE_COMPONENT_VTT:
 847     case DEMANGLE_COMPONENT_TYPEINFO:
 848     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 849     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 850     case DEMANGLE_COMPONENT_THUNK:
 851     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 852     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 853     case DEMANGLE_COMPONENT_JAVA_CLASS:
 854     case DEMANGLE_COMPONENT_GUARD:
 855     case DEMANGLE_COMPONENT_TLS_INIT:
 856     case DEMANGLE_COMPONENT_TLS_WRAPPER:
 857     case DEMANGLE_COMPONENT_REFTEMP:
 858     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 859     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
 860     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
 861     case DEMANGLE_COMPONENT_POINTER:
 862     case DEMANGLE_COMPONENT_REFERENCE:
 863     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 864     case DEMANGLE_COMPONENT_COMPLEX:
 865     case DEMANGLE_COMPONENT_IMAGINARY:
 866     case DEMANGLE_COMPONENT_VENDOR_TYPE:
 867     case DEMANGLE_COMPONENT_CAST:
 868     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 869     case DEMANGLE_COMPONENT_DECLTYPE:
 870     case DEMANGLE_COMPONENT_PACK_EXPANSION:
 871     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
 872     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
 873     case DEMANGLE_COMPONENT_NULLARY:
 874     case DEMANGLE_COMPONENT_TRINARY_ARG2:
 875       if (left == NULL)
 876         return NULL;
 877       break;
 878
 879       /* This needs a right parameter, but the left parameter can be
 880          empty.  */
 881     case DEMANGLE_COMPONENT_ARRAY_TYPE:
 882     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
 883       if (right == NULL)
 884         return NULL;
 885       break;
 886
 887       /* These are allowed to have no parameters--in some cases they
 888          will be filled in later.  */
 889     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 890     case DEMANGLE_COMPONENT_RESTRICT:
 891     case DEMANGLE_COMPONENT_VOLATILE:
 892     case DEMANGLE_COMPONENT_CONST:
 893     case DEMANGLE_COMPONENT_RESTRICT_THIS:
 894     case DEMANGLE_COMPONENT_VOLATILE_THIS:
 895     case DEMANGLE_COMPONENT_CONST_THIS:
 896     case DEMANGLE_COMPONENT_ARGLIST:
 897     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 898       break;
 899
 900       /* Other types should not be seen here.  */
 901     default:
 902       return NULL;
 903     }
 904
 905   p = d_make_empty (di);
 906   if (p != NULL)
 907     {
 908       p->type = type;
 909       p->u.s_binary.left = left;
 910       p->u.s_binary.right = right;
 911     }
 912   return p;
 913 }
 914
 915 /* Add a new demangle mangled name component.  */
 916
 917 static struct demangle_component *
 918 d_make_demangle_mangled_name (struct d_info *di, const char *s)
 919 {
 920   if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
 921     return d_make_name (di, s, strlen (s));
 922   d_advance (di, 2);
 923   return d_encoding (di, 0);
 924 }
 925
 926 /* Add a new name component.  */
 927
 928 static struct demangle_component *
 929 d_make_name (struct d_info *di, const char *s, int len)
 930 {
 931   struct demangle_component *p;
 932
 933   p = d_make_empty (di);
 934   if (! cplus_demangle_fill_name (p, s, len))
 935     return NULL;
 936   return p;
 937 }
 938
 939 /* Add a new builtin type component.  */
 940
 941 static struct demangle_component *
 942 d_make_builtin_type (struct d_info *di,
 943                      const struct demangle_builtin_type_info *type)
 944 {
 945   struct demangle_component *p;
 946
 947   if (type == NULL)
 948     return NULL;
 949   p = d_make_empty (di);
 950   if (p != NULL)
 951     {
 952       p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
 953       p->u.s_builtin.type = type;
 954     }
 955   return p;
 956 }
 957
 958 /* Add a new operator component.  */
 959
 960 static struct demangle_component *
 961 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
 962 {
 963   struct demangle_component *p;
 964
 965   p = d_make_empty (di);
 966   if (p != NULL)
 967     {
 968       p->type = DEMANGLE_COMPONENT_OPERATOR;
 969       p->u.s_operator.op = op;
 970     }
 971   return p;
 972 }
 973
 974 /* Add a new extended operator component.  */
 975
 976 static struct demangle_component *
 977 d_make_extended_operator (struct d_info *di, int args,
 978                           struct demangle_component *name)
 979 {
 980   struct demangle_component *p;
 981
 982   p = d_make_empty (di);
 983   if (! cplus_demangle_fill_extended_operator (p, args, name))
 984     return NULL;
 985   return p;
 986 }
 987
 988 static struct demangle_component *
 989 d_make_default_arg (struct d_info *di, int num,
 990                     struct demangle_component *sub)
 991 {
 992   struct demangle_component *p = d_make_empty (di);
 993   if (p)
 994     {
 995       p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
 996       p->u.s_unary_num.num = num;
 997       p->u.s_unary_num.sub = sub;
 998     }
 999   return p;
1000 }
1001
1002 /* Add a new constructor component.  */
1003
1004 static struct demangle_component *
1005 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
1006              struct demangle_component *name)
1007 {
1008   struct demangle_component *p;
1009
1010   p = d_make_empty (di);
1011   if (! cplus_demangle_fill_ctor (p, kind, name))
1012     return NULL;
1013   return p;
1014 }
1015
1016 /* Add a new destructor component.  */
1017
1018 static struct demangle_component *
1019 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
1020              struct demangle_component *name)
1021 {
1022   struct demangle_component *p;
1023
1024   p = d_make_empty (di);
1025   if (! cplus_demangle_fill_dtor (p, kind, name))
1026     return NULL;
1027   return p;
1028 }
1029
1030 /* Add a new template parameter.  */
1031
1032 static struct demangle_component *
1033 d_make_template_param (struct d_info *di, long i)
1034 {
1035   struct demangle_component *p;
1036
1037   p = d_make_empty (di);
1038   if (p != NULL)
1039     {
1040       p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
1041       p->u.s_number.number = i;
1042     }
1043   return p;
1044 }
1045
1046 /* Add a new function parameter.  */
1047
1048 static struct demangle_component *
1049 d_make_function_param (struct d_info *di, long i)
1050 {
1051   struct demangle_component *p;
1052
1053   p = d_make_empty (di);
1054   if (p != NULL)
1055     {
1056       p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1057       p->u.s_number.number = i;
1058     }
1059   return p;
1060 }
1061
1062 /* Add a new standard substitution component.  */
1063
1064 static struct demangle_component *
1065 d_make_sub (struct d_info *di, const char *name, int len)
1066 {
1067   struct demangle_component *p;
1068
1069   p = d_make_empty (di);
1070   if (p != NULL)
1071     {
1072       p->type = DEMANGLE_COMPONENT_SUB_STD;
1073       p->u.s_string.string = name;
1074       p->u.s_string.len = len;
1075     }
1076   return p;
1077 }
1078
1079 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1080
1081    TOP_LEVEL is non-zero when called at the top level.  */
1082
1083 CP_STATIC_IF_GLIBCPP_V3
1084 struct demangle_component *
1085 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1086 {
1087   struct demangle_component *p;
1088
1089   if (! d_check_char (di, '_')
1090       /* Allow missing _ if not at toplevel to work around a
1091          bug in G++ abi-version=2 mangling; see the comment in
1092          write_template_arg.  */
1093       && top_level)
1094     return NULL;
1095   if (! d_check_char (di, 'Z'))
1096     return NULL;
1097   p = d_encoding (di, top_level);
1098
1099   /* If at top level and parsing parameters, check for a clone
1100      suffix.  */
1101   if (top_level && (di->options & DMGL_PARAMS) != 0)
1102     while (d_peek_char (di) == '.'
1103            && (IS_LOWER (d_peek_next_char (di))
1104                || d_peek_next_char (di) == '_'
1105                || IS_DIGIT (d_peek_next_char (di))))
1106       p = d_clone_suffix (di, p);
1107
1108   return p;
1109 }
1110
1111 /* Return whether a function should have a return type.  The argument
1112    is the function name, which may be qualified in various ways.  The
1113    rules are that template functions have return types with some
1114    exceptions, function types which are not part of a function name
1115    mangling have return types with some exceptions, and non-template
1116    function names do not have return types.  The exceptions are that
1117    constructors, destructors, and conversion operators do not have
1118    return types.  */
1119
1120 static int
1121 has_return_type (struct demangle_component *dc)
1122 {
1123   if (dc == NULL)
1124     return 0;
1125   switch (dc->type)
1126     {
1127     default:
1128       return 0;
1129     case DEMANGLE_COMPONENT_TEMPLATE:
1130       return ! is_ctor_dtor_or_conversion (d_left (dc));
1131     case DEMANGLE_COMPONENT_RESTRICT_THIS:
1132     case DEMANGLE_COMPONENT_VOLATILE_THIS:
1133     case DEMANGLE_COMPONENT_CONST_THIS:
1134       return has_return_type (d_left (dc));
1135     }
1136 }
1137
1138 /* Return whether a name is a constructor, a destructor, or a
1139    conversion operator.  */
1140
1141 static int
1142 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1143 {
1144   if (dc == NULL)
1145     return 0;
1146   switch (dc->type)
1147     {
1148     default:
1149       return 0;
1150     case DEMANGLE_COMPONENT_QUAL_NAME:
1151     case DEMANGLE_COMPONENT_LOCAL_NAME:
1152       return is_ctor_dtor_or_conversion (d_right (dc));
1153     case DEMANGLE_COMPONENT_CTOR:
1154     case DEMANGLE_COMPONENT_DTOR:
1155     case DEMANGLE_COMPONENT_CAST:
1156       return 1;
1157     }
1158 }
1159
1160 /* <encoding> ::= <(function) name> <bare-function-type>
1161               ::= <(data) name>
1162               ::= <special-name>
1163
1164    TOP_LEVEL is non-zero when called at the top level, in which case
1165    if DMGL_PARAMS is not set we do not demangle the function
1166    parameters.  We only set this at the top level, because otherwise
1167    we would not correctly demangle names in local scopes.  */
1168
1169 static struct demangle_component *
1170 d_encoding (struct d_info *di, int top_level)
1171 {
1172   char peek = d_peek_char (di);
1173
1174   if (peek == 'G' || peek == 'T')
1175     return d_special_name (di);
1176   else
1177     {
1178       struct demangle_component *dc;
1179
1180       dc = d_name (di);
1181
1182       if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1183         {
1184           /* Strip off any initial CV-qualifiers, as they really apply
1185              to the `this' parameter, and they were not output by the
1186              v2 demangler without DMGL_PARAMS.  */
1187           while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1188                  || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1189                  || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
1190             dc = d_left (dc);
1191
1192           /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1193              there may be CV-qualifiers on its right argument which
1194              really apply here; this happens when parsing a class
1195              which is local to a function.  */
1196           if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1197             {
1198               struct demangle_component *dcr;
1199
1200               dcr = d_right (dc);
1201               while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1202                      || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1203                      || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
1204                 dcr = d_left (dcr);
1205               dc->u.s_binary.right = dcr;
1206             }
1207
1208           return dc;
1209         }
1210
1211       peek = d_peek_char (di);
1212       if (dc == NULL || peek == '\0' || peek == 'E')
1213         return dc;
1214       return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1215                           d_bare_function_type (di, has_return_type (dc)));
1216     }
1217 }
1218
1219 /* <tagged-name> ::= <name> B <source-name> */
1220
1221 static struct demangle_component *
1222 d_abi_tags (struct d_info *di, struct demangle_component *dc)
1223 {
1224   char peek;
1225   while (peek = d_peek_char (di),
1226          peek == 'B')
1227     {
1228       struct demangle_component *tag;
1229       d_advance (di, 1);
1230       tag = d_source_name (di);
1231       dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
1232     }
1233   return dc;
1234 }
1235
1236 /* <name> ::= <nested-name>
1237           ::= <unscoped-name>
1238           ::= <unscoped-template-name> <template-args>
1239           ::= <local-name>
1240
1241    <unscoped-name> ::= <unqualified-name>
1242                    ::= St <unqualified-name>
1243
1244    <unscoped-template-name> ::= <unscoped-name>
1245                             ::= <substitution>
1246 */
1247
1248 static struct demangle_component *
1249 d_name (struct d_info *di)
1250 {
1251   char peek = d_peek_char (di);
1252   struct demangle_component *dc;
1253
1254   switch (peek)
1255     {
1256     case 'N':
1257       return d_nested_name (di);
1258
1259     case 'Z':
1260       return d_local_name (di);
1261
1262     case 'L':
1263     case 'U':
1264       return d_unqualified_name (di);
1265
1266     case 'S':
1267       {
1268         int subst;
1269
1270         if (d_peek_next_char (di) != 't')
1271           {
1272             dc = d_substitution (di, 0);
1273             subst = 1;
1274           }
1275         else
1276           {
1277             d_advance (di, 2);
1278             dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1279                               d_make_name (di, "std", 3),
1280                               d_unqualified_name (di));
1281             di->expansion += 3;
1282             subst = 0;
1283           }
1284
1285         if (d_peek_char (di) != 'I')
1286           {
1287             /* The grammar does not permit this case to occur if we
1288                called d_substitution() above (i.e., subst == 1).  We
1289                don't bother to check.  */
1290           }
1291         else
1292           {
1293             /* This is <template-args>, which means that we just saw
1294                <unscoped-template-name>, which is a substitution
1295                candidate if we didn't just get it from a
1296                substitution.  */
1297             if (! subst)
1298               {
1299                 if (! d_add_substitution (di, dc))
1300                   return NULL;
1301               }
1302             dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1303                               d_template_args (di));
1304           }
1305
1306         return dc;
1307       }
1308
1309     default:
1310       dc = d_unqualified_name (di);
1311       if (d_peek_char (di) == 'I')
1312         {
1313           /* This is <template-args>, which means that we just saw
1314              <unscoped-template-name>, which is a substitution
1315              candidate.  */
1316           if (! d_add_substitution (di, dc))
1317             return NULL;
1318           dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1319                             d_template_args (di));
1320         }
1321       return dc;
1322     }
1323 }
1324
1325 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1326                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1327 */
1328
1329 static struct demangle_component *
1330 d_nested_name (struct d_info *di)
1331 {
1332   struct demangle_component *ret;
1333   struct demangle_component **pret;
1334
1335   if (! d_check_char (di, 'N'))
1336     return NULL;
1337
1338   pret = d_cv_qualifiers (di, &ret, 1);
1339   if (pret == NULL)
1340     return NULL;
1341
1342   *pret = d_prefix (di);
1343   if (*pret == NULL)
1344     return NULL;
1345
1346   if (! d_check_char (di, 'E'))
1347     return NULL;
1348
1349   return ret;
1350 }
1351
1352 /* <prefix> ::= <prefix> <unqualified-name>
1353             ::= <template-prefix> <template-args>
1354             ::= <template-param>
1355             ::= <decltype>
1356             ::=
1357             ::= <substitution>
1358
1359    <template-prefix> ::= <prefix> <(template) unqualified-name>
1360                      ::= <template-param>
1361                      ::= <substitution>
1362 */
1363
1364 static struct demangle_component *
1365 d_prefix (struct d_info *di)
1366 {
1367   struct demangle_component *ret = NULL;
1368
1369   while (1)
1370     {
1371       char peek;
1372       enum demangle_component_type comb_type;
1373       struct demangle_component *dc;
1374
1375       peek = d_peek_char (di);
1376       if (peek == '\0')
1377         return NULL;
1378
1379       /* The older code accepts a <local-name> here, but I don't see
1380          that in the grammar.  The older code does not accept a
1381          <template-param> here.  */
1382
1383       comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1384       if (peek == 'D')
1385         {
1386           char peek2 = d_peek_next_char (di);
1387           if (peek2 == 'T' || peek2 == 't')
1388             /* Decltype.  */
1389             dc = cplus_demangle_type (di);
1390           else
1391             /* Destructor name.  */
1392             dc = d_unqualified_name (di);
1393         }
1394       else if (IS_DIGIT (peek)
1395           || IS_LOWER (peek)
1396           || peek == 'C'
1397           || peek == 'U'
1398           || peek == 'L')
1399         dc = d_unqualified_name (di);
1400       else if (peek == 'S')
1401         dc = d_substitution (di, 1);
1402       else if (peek == 'I')
1403         {
1404           if (ret == NULL)
1405             return NULL;
1406           comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1407           dc = d_template_args (di);
1408         }
1409       else if (peek == 'T')
1410         dc = d_template_param (di);
1411       else if (peek == 'E')
1412         return ret;
1413       else if (peek == 'M')
1414         {
1415           /* Initializer scope for a lambda.  We don't need to represent
1416              this; the normal code will just treat the variable as a type
1417              scope, which gives appropriate output.  */
1418           if (ret == NULL)
1419             return NULL;
1420           d_advance (di, 1);
1421           continue;
1422         }
1423       else
1424         return NULL;
1425
1426       if (ret == NULL)
1427         ret = dc;
1428       else
1429         ret = d_make_comp (di, comb_type, ret, dc);
1430
1431       if (peek != 'S' && d_peek_char (di) != 'E')
1432         {
1433           if (! d_add_substitution (di, ret))
1434             return NULL;
1435         }
1436     }
1437 }
1438
1439 /* <unqualified-name> ::= <operator-name>
1440                       ::= <ctor-dtor-name>
1441                       ::= <source-name>
1442                       ::= <local-source-name>
1443
1444     <local-source-name> ::= L <source-name> <discriminator>
1445 */
1446
1447 static struct demangle_component *
1448 d_unqualified_name (struct d_info *di)
1449 {
1450   struct demangle_component *ret;
1451   char peek;
1452
1453   peek = d_peek_char (di);
1454   if (IS_DIGIT (peek))
1455     ret = d_source_name (di);
1456   else if (IS_LOWER (peek))
1457     {
1458       ret = d_operator_name (di);
1459       if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1460         {
1461           di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1462           if (!strcmp (ret->u.s_operator.op->code, "li"))
1463             ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
1464                                d_source_name (di));
1465         }
1466     }
1467   else if (peek == 'C' || peek == 'D')
1468     ret = d_ctor_dtor_name (di);
1469   else if (peek == 'L')
1470     {
1471       d_advance (di, 1);
1472
1473       ret = d_source_name (di);
1474       if (ret == NULL)
1475         return NULL;
1476       if (! d_discriminator (di))
1477         return NULL;
1478     }
1479   else if (peek == 'U')
1480     {
1481       switch (d_peek_next_char (di))
1482         {
1483         case 'l':
1484           ret = d_lambda (di);
1485           break;
1486         case 't':
1487           ret = d_unnamed_type (di);
1488           break;
1489         default:
1490           return NULL;
1491         }
1492     }
1493   else
1494     return NULL;
1495
1496   if (d_peek_char (di) == 'B')
1497     ret = d_abi_tags (di, ret);
1498   return ret;
1499 }
1500
1501 /* <source-name> ::= <(positive length) number> <identifier>  */
1502
1503 static struct demangle_component *
1504 d_source_name (struct d_info *di)
1505 {
1506   long len;
1507   struct demangle_component *ret;
1508
1509   len = d_number (di);
1510   if (len <= 0)
1511     return NULL;
1512   ret = d_identifier (di, len);
1513   di->last_name = ret;
1514   return ret;
1515 }
1516
1517 /* number ::= [n] <(non-negative decimal integer)>  */
1518
1519 static long
1520 d_number (struct d_info *di)
1521 {
1522   int negative;
1523   char peek;
1524   long ret;
1525
1526   negative = 0;
1527   peek = d_peek_char (di);
1528   if (peek == 'n')
1529     {
1530       negative = 1;
1531       d_advance (di, 1);
1532       peek = d_peek_char (di);
1533     }
1534
1535   ret = 0;
1536   while (1)
1537     {
1538       if (! IS_DIGIT (peek))
1539         {
1540           if (negative)
1541             ret = - ret;
1542           return ret;
1543         }
1544       ret = ret * 10 + peek - '0';
1545       d_advance (di, 1);
1546       peek = d_peek_char (di);
1547     }
1548 }
1549
1550 /* Like d_number, but returns a demangle_component.  */
1551
1552 static struct demangle_component *
1553 d_number_component (struct d_info *di)
1554 {
1555   struct demangle_component *ret = d_make_empty (di);
1556   if (ret)
1557     {
1558       ret->type = DEMANGLE_COMPONENT_NUMBER;
1559       ret->u.s_number.number = d_number (di);
1560     }
1561   return ret;
1562 }
1563
1564 /* identifier ::= <(unqualified source code identifier)>  */
1565
1566 static struct demangle_component *
1567 d_identifier (struct d_info *di, int len)
1568 {
1569   const char *name;
1570
1571   name = d_str (di);
1572
1573   if (di->send - name < len)
1574     return NULL;
1575
1576   d_advance (di, len);
1577
1578   /* A Java mangled name may have a trailing '$' if it is a C++
1579      keyword.  This '$' is not included in the length count.  We just
1580      ignore the '$'.  */
1581   if ((di->options & DMGL_JAVA) != 0
1582       && d_peek_char (di) == '$')
1583     d_advance (di, 1);
1584
1585   /* Look for something which looks like a gcc encoding of an
1586      anonymous namespace, and replace it with a more user friendly
1587      name.  */
1588   if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1589       && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1590                  ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1591     {
1592       const char *s;
1593
1594       s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1595       if ((*s == '.' || *s == '_' || *s == '$')
1596           && s[1] == 'N')
1597         {
1598           di->expansion -= len - sizeof "(anonymous namespace)";
1599           return d_make_name (di, "(anonymous namespace)",
1600                               sizeof "(anonymous namespace)" - 1);
1601         }
1602     }
1603
1604   return d_make_name (di, name, len);
1605 }
1606
1607 /* operator_name ::= many different two character encodings.
1608                  ::= cv <type>
1609                  ::= v <digit> <source-name>
1610
1611    This list is sorted for binary search.  */
1612
1613 #define NL(s) s, (sizeof s) - 1
1614
1615 CP_STATIC_IF_GLIBCPP_V3
1616 const struct demangle_operator_info cplus_demangle_operators[] =
1617 {
1618   { "aN", NL ("&="),        2 },
1619   { "aS", NL ("="),         2 },
1620   { "aa", NL ("&&"),        2 },
1621   { "ad", NL ("&"),         1 },
1622   { "an", NL ("&"),         2 },
1623   { "at", NL ("alignof "),   1 },
1624   { "az", NL ("alignof "),   1 },
1625   { "cc", NL ("const_cast"), 2 },
1626   { "cl", NL ("()"),        2 },
1627   { "cm", NL (","),         2 },
1628   { "co", NL ("~"),         1 },
1629   { "dV", NL ("/="),        2 },
1630   { "da", NL ("delete[] "), 1 },
1631   { "dc", NL ("dynamic_cast"), 2 },
1632   { "de", NL ("*"),         1 },
1633   { "dl", NL ("delete "),   1 },
1634   { "ds", NL (".*"),        2 },
1635   { "dt", NL ("."),         2 },
1636   { "dv", NL ("/"),         2 },
1637   { "eO", NL ("^="),        2 },
1638   { "eo", NL ("^"),         2 },
1639   { "eq", NL ("=="),        2 },
1640   { "ge", NL (">="),        2 },
1641   { "gs", NL ("::"),        1 },
1642   { "gt", NL (">"),         2 },
1643   { "ix", NL ("[]"),        2 },
1644   { "lS", NL ("<<="),       2 },
1645   { "le", NL ("<="),        2 },
1646   { "li", NL ("operator\"\" "), 1 },
1647   { "ls", NL ("<<"),        2 },
1648   { "lt", NL ("<"),         2 },
1649   { "mI", NL ("-="),        2 },
1650   { "mL", NL ("*="),        2 },
1651   { "mi", NL ("-"),         2 },
1652   { "ml", NL ("*"),         2 },
1653   { "mm", NL ("--"),        1 },
1654   { "na", NL ("new[]"),     3 },
1655   { "ne", NL ("!="),        2 },
1656   { "ng", NL ("-"),         1 },
1657   { "nt", NL ("!"),         1 },
1658   { "nw", NL ("new"),       3 },
1659   { "oR", NL ("|="),        2 },
1660   { "oo", NL ("||"),        2 },
1661   { "or", NL ("|"),         2 },
1662   { "pL", NL ("+="),        2 },
1663   { "pl", NL ("+"),         2 },
1664   { "pm", NL ("->*"),       2 },
1665   { "pp", NL ("++"),        1 },
1666   { "ps", NL ("+"),         1 },
1667   { "pt", NL ("->"),        2 },
1668   { "qu", NL ("?"),         3 },
1669   { "rM", NL ("%="),        2 },
1670   { "rS", NL (">>="),       2 },
1671   { "rc", NL ("reinterpret_cast"), 2 },
1672   { "rm", NL ("%"),         2 },
1673   { "rs", NL (">>"),        2 },
1674   { "sc", NL ("static_cast"), 2 },
1675   { "st", NL ("sizeof "),   1 },
1676   { "sz", NL ("sizeof "),   1 },
1677   { "tr", NL ("throw"),     0 },
1678   { "tw", NL ("throw "),    1 },
1679   { NULL, NULL, 0,          0 }
1680 };
1681
1682 static struct demangle_component *
1683 d_operator_name (struct d_info *di)
1684 {
1685   char c1;
1686   char c2;
1687
1688   c1 = d_next_char (di);
1689   c2 = d_next_char (di);
1690   if (c1 == 'v' && IS_DIGIT (c2))
1691     return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1692   else if (c1 == 'c' && c2 == 'v')
1693     return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
1694                         cplus_demangle_type (di), NULL);
1695   else
1696     {
1697       /* LOW is the inclusive lower bound.  */
1698       int low = 0;
1699       /* HIGH is the exclusive upper bound.  We subtract one to ignore
1700          the sentinel at the end of the array.  */
1701       int high = ((sizeof (cplus_demangle_operators)
1702                    / sizeof (cplus_demangle_operators[0]))
1703                   - 1);
1704
1705       while (1)
1706         {
1707           int i;
1708           const struct demangle_operator_info *p;
1709
1710           i = low + (high - low) / 2;
1711           p = cplus_demangle_operators + i;
1712
1713           if (c1 == p->code[0] && c2 == p->code[1])
1714             return d_make_operator (di, p);
1715
1716           if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1717             high = i;
1718           else
1719             low = i + 1;
1720           if (low == high)
1721             return NULL;
1722         }
1723     }
1724 }
1725
1726 static struct demangle_component *
1727 d_make_character (struct d_info *di, int c)
1728 {
1729   struct demangle_component *p;
1730   p = d_make_empty (di);
1731   if (p != NULL)
1732     {
1733       p->type = DEMANGLE_COMPONENT_CHARACTER;
1734       p->u.s_character.character = c;
1735     }
1736   return p;
1737 }
1738
1739 static struct demangle_component *
1740 d_java_resource (struct d_info *di)
1741 {
1742   struct demangle_component *p = NULL;
1743   struct demangle_component *next = NULL;
1744   long len, i;
1745   char c;
1746   const char *str;
1747
1748   len = d_number (di);
1749   if (len <= 1)
1750     return NULL;
1751
1752   /* Eat the leading '_'.  */
1753   if (d_next_char (di) != '_')
1754     return NULL;
1755   len--;
1756
1757   str = d_str (di);
1758   i = 0;
1759
1760   while (len > 0)
1761     {
1762       c = str[i];
1763       if (!c)
1764         return NULL;
1765
1766       /* Each chunk is either a '$' escape...  */
1767       if (c == '$')
1768         {
1769           i++;
1770           switch (str[i++])
1771             {
1772             case 'S':
1773               c = '/';
1774               break;
1775             case '_':
1776               c = '.';
1777               break;
1778             case '$':
1779               c = '$';
1780               break;
1781             default:
1782               return NULL;
1783             }
1784           next = d_make_character (di, c);
1785           d_advance (di, i);
1786           str = d_str (di);
1787           len -= i;
1788           i = 0;
1789           if (next == NULL)
1790             return NULL;
1791         }
1792       /* ... or a sequence of characters.  */
1793       else
1794         {
1795           while (i < len && str[i] && str[i] != '$')
1796             i++;
1797
1798           next = d_make_name (di, str, i);
1799           d_advance (di, i);
1800           str = d_str (di);
1801           len -= i;
1802           i = 0;
1803           if (next == NULL)
1804             return NULL;
1805         }
1806
1807       if (p == NULL)
1808         p = next;
1809       else
1810         {
1811           p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
1812           if (p == NULL)
1813             return NULL;
1814         }
1815     }
1816
1817   p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
1818
1819   return p;
1820 }
1821
1822 /* <special-name> ::= TV <type>
1823                   ::= TT <type>
1824                   ::= TI <type>
1825                   ::= TS <type>
1826                   ::= GV <(object) name>
1827                   ::= T <call-offset> <(base) encoding>
1828                   ::= Tc <call-offset> <call-offset> <(base) encoding>
1829    Also g++ extensions:
1830                   ::= TC <type> <(offset) number> _ <(base) type>
1831                   ::= TF <type>
1832                   ::= TJ <type>
1833                   ::= GR <name>
1834                   ::= GA <encoding>
1835                   ::= Gr <resource name>
1836                   ::= GTt <encoding>
1837                   ::= GTn <encoding>
1838 */
1839
1840 static struct demangle_component *
1841 d_special_name (struct d_info *di)
1842 {
1843   di->expansion += 20;
1844   if (d_check_char (di, 'T'))
1845     {
1846       switch (d_next_char (di))
1847         {
1848         case 'V':
1849           di->expansion -= 5;
1850           return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1851                               cplus_demangle_type (di), NULL);
1852         case 'T':
1853           di->expansion -= 10;
1854           return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1855                               cplus_demangle_type (di), NULL);
1856         case 'I':
1857           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1858                               cplus_demangle_type (di), NULL);
1859         case 'S':
1860           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1861                               cplus_demangle_type (di), NULL);
1862
1863         case 'h':
1864           if (! d_call_offset (di, 'h'))
1865             return NULL;
1866           return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1867                               d_encoding (di, 0), NULL);
1868
1869         case 'v':
1870           if (! d_call_offset (di, 'v'))
1871             return NULL;
1872           return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1873                               d_encoding (di, 0), NULL);
1874
1875         case 'c':
1876           if (! d_call_offset (di, '\0'))
1877             return NULL;
1878           if (! d_call_offset (di, '\0'))
1879             return NULL;
1880           return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1881                               d_encoding (di, 0), NULL);
1882
1883         case 'C':
1884           {
1885             struct demangle_component *derived_type;
1886             long offset;
1887             struct demangle_component *base_type;
1888
1889             derived_type = cplus_demangle_type (di);
1890             offset = d_number (di);
1891             if (offset < 0)
1892               return NULL;
1893             if (! d_check_char (di, '_'))
1894               return NULL;
1895             base_type = cplus_demangle_type (di);
1896             /* We don't display the offset.  FIXME: We should display
1897                it in verbose mode.  */
1898             di->expansion += 5;
1899             return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1900                                 base_type, derived_type);
1901           }
1902
1903         case 'F':
1904           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
1905                               cplus_demangle_type (di), NULL);
1906         case 'J':
1907           return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
1908                               cplus_demangle_type (di), NULL);
1909
1910         case 'H':
1911           return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
1912                               d_name (di), NULL);
1913
1914         case 'W':
1915           return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
1916                               d_name (di), NULL);
1917
1918         default:
1919           return NULL;
1920         }
1921     }
1922   else if (d_check_char (di, 'G'))
1923     {
1924       switch (d_next_char (di))
1925         {
1926         case 'V':
1927           return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
1928
1929         case 'R':
1930           {
1931             struct demangle_component *name = d_name (di);
1932             return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
1933                                 d_number_component (di));
1934           }
1935
1936         case 'A':
1937           return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
1938                               d_encoding (di, 0), NULL);
1939
1940         case 'T':
1941           switch (d_next_char (di))
1942             {
1943             case 'n':
1944               return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
1945                                   d_encoding (di, 0), NULL);
1946             default:
1947               /* ??? The proposal is that other letters (such as 'h') stand
1948                  for different variants of transaction cloning, such as
1949                  compiling directly for hardware transaction support.  But
1950                  they still should all be transactional clones of some sort
1951                  so go ahead and call them that.  */
1952             case 't':
1953               return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
1954                                   d_encoding (di, 0), NULL);
1955             }
1956
1957         case 'r':
1958           return d_java_resource (di);
1959
1960         default:
1961           return NULL;
1962         }
1963     }
1964   else
1965     return NULL;
1966 }
1967
1968 /* <call-offset> ::= h <nv-offset> _
1969                  ::= v <v-offset> _
1970
1971    <nv-offset> ::= <(offset) number>
1972
1973    <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1974
1975    The C parameter, if not '\0', is a character we just read which is
1976    the start of the <call-offset>.
1977
1978    We don't display the offset information anywhere.  FIXME: We should
1979    display it in verbose mode.  */
1980
1981 static int
1982 d_call_offset (struct d_info *di, int c)
1983 {
1984   if (c == '\0')
1985     c = d_next_char (di);
1986
1987   if (c == 'h')
1988     d_number (di);
1989   else if (c == 'v')
1990     {
1991       d_number (di);
1992       if (! d_check_char (di, '_'))
1993         return 0;
1994       d_number (di);
1995     }
1996   else
1997     return 0;
1998
1999   if (! d_check_char (di, '_'))
2000     return 0;
2001
2002   return 1;
2003 }
2004
2005 /* <ctor-dtor-name> ::= C1
2006                     ::= C2
2007                     ::= C3
2008                     ::= D0
2009                     ::= D1
2010                     ::= D2
2011 */
2012
2013 static struct demangle_component *
2014 d_ctor_dtor_name (struct d_info *di)
2015 {
2016   if (di->last_name != NULL)
2017     {
2018       if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
2019         di->expansion += di->last_name->u.s_name.len;
2020       else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
2021         di->expansion += di->last_name->u.s_string.len;
2022     }
2023   switch (d_peek_char (di))
2024     {
2025     case 'C':
2026       {
2027         enum gnu_v3_ctor_kinds kind;
2028
2029         switch (d_peek_next_char (di))
2030           {
2031           case '1':
2032             kind = gnu_v3_complete_object_ctor;
2033             break;
2034           case '2':
2035             kind = gnu_v3_base_object_ctor;
2036             break;
2037           case '3':
2038             kind = gnu_v3_complete_object_allocating_ctor;
2039             break;
2040           case '5':
2041             kind = gnu_v3_object_ctor_group;
2042             break;
2043           default:
2044             return NULL;
2045           }
2046         d_advance (di, 2);
2047         return d_make_ctor (di, kind, di->last_name);
2048       }
2049
2050     case 'D':
2051       {
2052         enum gnu_v3_dtor_kinds kind;
2053
2054         switch (d_peek_next_char (di))
2055           {
2056           case '0':
2057             kind = gnu_v3_deleting_dtor;
2058             break;
2059           case '1':
2060             kind = gnu_v3_complete_object_dtor;
2061             break;
2062           case '2':
2063             kind = gnu_v3_base_object_dtor;
2064             break;
2065           case '5':
2066             kind = gnu_v3_object_dtor_group;
2067             break;
2068           default:
2069             return NULL;
2070           }
2071         d_advance (di, 2);
2072         return d_make_dtor (di, kind, di->last_name);
2073       }
2074
2075     default:
2076       return NULL;
2077     }
2078 }
2079
2080 /* <type> ::= <builtin-type>
2081           ::= <function-type>
2082           ::= <class-enum-type>
2083           ::= <array-type>
2084           ::= <pointer-to-member-type>
2085           ::= <template-param>
2086           ::= <template-template-param> <template-args>
2087           ::= <substitution>
2088           ::= <CV-qualifiers> <type>
2089           ::= P <type>
2090           ::= R <type>
2091           ::= O <type> (C++0x)
2092           ::= C <type>
2093           ::= G <type>
2094           ::= U <source-name> <type>
2095
2096    <builtin-type> ::= various one letter codes
2097                   ::= u <source-name>
2098 */
2099
2100 CP_STATIC_IF_GLIBCPP_V3
2101 const struct demangle_builtin_type_info
2102 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
2103 {
2104   /* a */ { NL ("signed char"), NL ("signed char"),     D_PRINT_DEFAULT },
2105   /* b */ { NL ("bool"),        NL ("boolean"),         D_PRINT_BOOL },
2106   /* c */ { NL ("char"),        NL ("byte"),            D_PRINT_DEFAULT },
2107   /* d */ { NL ("double"),      NL ("double"),          D_PRINT_FLOAT },
2108   /* e */ { NL ("long double"), NL ("long double"),     D_PRINT_FLOAT },
2109   /* f */ { NL ("float"),       NL ("float"),           D_PRINT_FLOAT },
2110   /* g */ { NL ("__float128"),  NL ("__float128"),      D_PRINT_FLOAT },
2111   /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
2112   /* i */ { NL ("int"),         NL ("int"),             D_PRINT_INT },
2113   /* j */ { NL ("unsigned int"), NL ("unsigned"),       D_PRINT_UNSIGNED },
2114   /* k */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2115   /* l */ { NL ("long"),        NL ("long"),            D_PRINT_LONG },
2116   /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
2117   /* n */ { NL ("__int128"),    NL ("__int128"),        D_PRINT_DEFAULT },
2118   /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2119             D_PRINT_DEFAULT },
2120   /* p */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2121   /* q */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2122   /* r */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2123   /* s */ { NL ("short"),       NL ("short"),           D_PRINT_DEFAULT },
2124   /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
2125   /* u */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2126   /* v */ { NL ("void"),        NL ("void"),            D_PRINT_VOID },
2127   /* w */ { NL ("wchar_t"),     NL ("char"),            D_PRINT_DEFAULT },
2128   /* x */ { NL ("long long"),   NL ("long"),            D_PRINT_LONG_LONG },
2129   /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2130             D_PRINT_UNSIGNED_LONG_LONG },
2131   /* z */ { NL ("..."),         NL ("..."),             D_PRINT_DEFAULT },
2132   /* 26 */ { NL ("decimal32"),  NL ("decimal32"),       D_PRINT_DEFAULT },
2133   /* 27 */ { NL ("decimal64"),  NL ("decimal64"),       D_PRINT_DEFAULT },
2134   /* 28 */ { NL ("decimal128"), NL ("decimal128"),      D_PRINT_DEFAULT },
2135   /* 29 */ { NL ("half"),       NL ("half"),            D_PRINT_FLOAT },
2136   /* 30 */ { NL ("char16_t"),   NL ("char16_t"),        D_PRINT_DEFAULT },
2137   /* 31 */ { NL ("char32_t"),   NL ("char32_t"),        D_PRINT_DEFAULT },
2138   /* 32 */ { NL ("decltype(nullptr)"),  NL ("decltype(nullptr)"),
2139              D_PRINT_DEFAULT },
2140 };
2141
2142 CP_STATIC_IF_GLIBCPP_V3
2143 struct demangle_component *
2144 cplus_demangle_type (struct d_info *di)
2145 {
2146   char peek;
2147   struct demangle_component *ret;
2148   int can_subst;
2149
2150   /* The ABI specifies that when CV-qualifiers are used, the base type
2151      is substitutable, and the fully qualified type is substitutable,
2152      but the base type with a strict subset of the CV-qualifiers is
2153      not substitutable.  The natural recursive implementation of the
2154      CV-qualifiers would cause subsets to be substitutable, so instead
2155      we pull them all off now.
2156
2157      FIXME: The ABI says that order-insensitive vendor qualifiers
2158      should be handled in the same way, but we have no way to tell
2159      which vendor qualifiers are order-insensitive and which are
2160      order-sensitive.  So we just assume that they are all
2161      order-sensitive.  g++ 3.4 supports only one vendor qualifier,
2162      __vector, and it treats it as order-sensitive when mangling
2163      names.  */
2164
2165   peek = d_peek_char (di);
2166   if (peek == 'r' || peek == 'V' || peek == 'K')
2167     {
2168       struct demangle_component **pret;
2169
2170       pret = d_cv_qualifiers (di, &ret, 0);
2171       if (pret == NULL)
2172         return NULL;
2173       *pret = cplus_demangle_type (di);
2174       if (! *pret || ! d_add_substitution (di, ret))
2175         return NULL;
2176       return ret;
2177     }
2178
2179   can_subst = 1;
2180
2181   switch (peek)
2182     {
2183     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2184     case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
2185     case 'o':                               case 's': case 't':
2186     case 'v': case 'w': case 'x': case 'y': case 'z':
2187       ret = d_make_builtin_type (di,
2188                                  &cplus_demangle_builtin_types[peek - 'a']);
2189       di->expansion += ret->u.s_builtin.type->len;
2190       can_subst = 0;
2191       d_advance (di, 1);
2192       break;
2193
2194     case 'u':
2195       d_advance (di, 1);
2196       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2197                          d_source_name (di), NULL);
2198       break;
2199
2200     case 'F':
2201       ret = d_function_type (di);
2202       break;
2203
2204     case '0': case '1': case '2': case '3': case '4':
2205     case '5': case '6': case '7': case '8': case '9':
2206     case 'N':
2207     case 'Z':
2208       ret = d_class_enum_type (di);
2209       break;
2210
2211     case 'A':
2212       ret = d_array_type (di);
2213       break;
2214
2215     case 'M':
2216       ret = d_pointer_to_member_type (di);
2217       break;
2218
2219     case 'T':
2220       ret = d_template_param (di);
2221       if (d_peek_char (di) == 'I')
2222         {
2223           /* This is <template-template-param> <template-args>.  The
2224              <template-template-param> part is a substitution
2225              candidate.  */
2226           if (! d_add_substitution (di, ret))
2227             return NULL;
2228           ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2229                              d_template_args (di));
2230         }
2231       break;
2232
2233     case 'S':
2234       /* If this is a special substitution, then it is the start of
2235          <class-enum-type>.  */
2236       {
2237         char peek_next;
2238
2239         peek_next = d_peek_next_char (di);
2240         if (IS_DIGIT (peek_next)
2241             || peek_next == '_'
2242             || IS_UPPER (peek_next))
2243           {
2244             ret = d_substitution (di, 0);
2245             /* The substituted name may have been a template name and
2246                may be followed by tepmlate args.  */
2247             if (d_peek_char (di) == 'I')
2248               ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2249                                  d_template_args (di));
2250             else
2251               can_subst = 0;
2252           }
2253         else
2254           {
2255             ret = d_class_enum_type (di);
2256             /* If the substitution was a complete type, then it is not
2257                a new substitution candidate.  However, if the
2258                substitution was followed by template arguments, then
2259                the whole thing is a substitution candidate.  */
2260             if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2261               can_subst = 0;
2262           }
2263       }
2264       break;
2265
2266     case 'O':
2267       d_advance (di, 1);
2268       ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2269                          cplus_demangle_type (di), NULL);
2270       break;
2271
2272     case 'P':
2273       d_advance (di, 1);
2274       ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2275                          cplus_demangle_type (di), NULL);
2276       break;
2277
2278     case 'R':
2279       d_advance (di, 1);
2280       ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2281                          cplus_demangle_type (di), NULL);
2282       break;
2283
2284     case 'C':
2285       d_advance (di, 1);
2286       ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2287                          cplus_demangle_type (di), NULL);
2288       break;
2289
2290     case 'G':
2291       d_advance (di, 1);
2292       ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2293                          cplus_demangle_type (di), NULL);
2294       break;
2295
2296     case 'U':
2297       d_advance (di, 1);
2298       ret = d_source_name (di);
2299       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2300                          cplus_demangle_type (di), ret);
2301       break;
2302
2303     case 'D':
2304       can_subst = 0;
2305       d_advance (di, 1);
2306       peek = d_next_char (di);
2307       switch (peek)
2308         {
2309         case 'T':
2310         case 't':
2311           /* decltype (expression) */
2312           ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2313                              d_expression (di), NULL);
2314           if (ret && d_next_char (di) != 'E')
2315             ret = NULL;
2316           can_subst = 1;
2317           break;
2318
2319         case 'p':
2320           /* Pack expansion.  */
2321           ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2322                              cplus_demangle_type (di), NULL);
2323           can_subst = 1;
2324           break;
2325
2326         case 'a':
2327           /* auto */
2328           ret = d_make_name (di, "auto", 4);
2329           break;
2330
2331         case 'f':
2332           /* 32-bit decimal floating point */
2333           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2334           di->expansion += ret->u.s_builtin.type->len;
2335           break;
2336         case 'd':
2337           /* 64-bit DFP */
2338           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2339           di->expansion += ret->u.s_builtin.type->len;
2340           break;
2341         case 'e':
2342           /* 128-bit DFP */
2343           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2344           di->expansion += ret->u.s_builtin.type->len;
2345           break;
2346         case 'h':
2347           /* 16-bit half-precision FP */
2348           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2349           di->expansion += ret->u.s_builtin.type->len;
2350           break;
2351         case 's':
2352           /* char16_t */
2353           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2354           di->expansion += ret->u.s_builtin.type->len;
2355           break;
2356         case 'i':
2357           /* char32_t */
2358           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2359           di->expansion += ret->u.s_builtin.type->len;
2360           break;
2361
2362         case 'F':
2363           /* Fixed point types. DF<int bits><length><fract bits><sat>  */
2364           ret = d_make_empty (di);
2365           ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2366           if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2367             /* For demangling we don't care about the bits.  */
2368             d_number (di);
2369           ret->u.s_fixed.length = cplus_demangle_type (di);
2370           if (ret->u.s_fixed.length == NULL)
2371             return NULL;
2372           d_number (di);
2373           peek = d_next_char (di);
2374           ret->u.s_fixed.sat = (peek == 's');
2375           break;
2376
2377         case 'v':
2378           ret = d_vector_type (di);
2379           can_subst = 1;
2380           break;
2381
2382         case 'n':
2383           /* decltype(nullptr) */
2384           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2385           di->expansion += ret->u.s_builtin.type->len;
2386           break;
2387
2388         default:
2389           return NULL;
2390         }
2391       break;
2392
2393     default:
2394       return NULL;
2395     }
2396
2397   if (can_subst)
2398     {
2399       if (! d_add_substitution (di, ret))
2400         return NULL;
2401     }
2402
2403   return ret;
2404 }
2405
2406 /* <CV-qualifiers> ::= [r] [V] [K]  */
2407
2408 static struct demangle_component **
2409 d_cv_qualifiers (struct d_info *di,
2410                  struct demangle_component **pret, int member_fn)
2411 {
2412   struct demangle_component **pstart;
2413   char peek;
2414
2415   pstart = pret;
2416   peek = d_peek_char (di);
2417   while (peek == 'r' || peek == 'V' || peek == 'K')
2418     {
2419       enum demangle_component_type t;
2420
2421       d_advance (di, 1);
2422       if (peek == 'r')
2423         {
2424           t = (member_fn
2425                ? DEMANGLE_COMPONENT_RESTRICT_THIS
2426                : DEMANGLE_COMPONENT_RESTRICT);
2427           di->expansion += sizeof "restrict";
2428         }
2429       else if (peek == 'V')
2430         {
2431           t = (member_fn
2432                ? DEMANGLE_COMPONENT_VOLATILE_THIS
2433                : DEMANGLE_COMPONENT_VOLATILE);
2434           di->expansion += sizeof "volatile";
2435         }
2436       else
2437         {
2438           t = (member_fn
2439                ? DEMANGLE_COMPONENT_CONST_THIS
2440                : DEMANGLE_COMPONENT_CONST);
2441           di->expansion += sizeof "const";
2442         }
2443
2444       *pret = d_make_comp (di, t, NULL, NULL);
2445       if (*pret == NULL)
2446         return NULL;
2447       pret = &d_left (*pret);
2448
2449       peek = d_peek_char (di);
2450     }
2451
2452   if (!member_fn && peek == 'F')
2453     {
2454       while (pstart != pret)
2455         {
2456           switch ((*pstart)->type)
2457             {
2458             case DEMANGLE_COMPONENT_RESTRICT:
2459               (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
2460               break;
2461             case DEMANGLE_COMPONENT_VOLATILE:
2462               (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
2463               break;
2464             case DEMANGLE_COMPONENT_CONST:
2465               (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
2466               break;
2467             default:
2468               break;
2469             }
2470           pstart = &d_left (*pstart);
2471         }
2472     }
2473
2474   return pret;
2475 }
2476
2477 /* <function-type> ::= F [Y] <bare-function-type> E  */
2478
2479 static struct demangle_component *
2480 d_function_type (struct d_info *di)
2481 {
2482   struct demangle_component *ret;
2483
2484   if (! d_check_char (di, 'F'))
2485     return NULL;
2486   if (d_peek_char (di) == 'Y')
2487     {
2488       /* Function has C linkage.  We don't print this information.
2489          FIXME: We should print it in verbose mode.  */
2490       d_advance (di, 1);
2491     }
2492   ret = d_bare_function_type (di, 1);
2493   if (! d_check_char (di, 'E'))
2494     return NULL;
2495   return ret;
2496 }
2497
2498 /* <type>+ */
2499
2500 static struct demangle_component *
2501 d_parmlist (struct d_info *di)
2502 {
2503   struct demangle_component *tl;
2504   struct demangle_component **ptl;
2505
2506   tl = NULL;
2507   ptl = &tl;
2508   while (1)
2509     {
2510       struct demangle_component *type;
2511
2512       char peek = d_peek_char (di);
2513       if (peek == '\0' || peek == 'E' || peek == '.')
2514         break;
2515       type = cplus_demangle_type (di);
2516       if (type == NULL)
2517         return NULL;
2518       *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2519       if (*ptl == NULL)
2520         return NULL;
2521       ptl = &d_right (*ptl);
2522     }
2523
2524   /* There should be at least one parameter type besides the optional
2525      return type.  A function which takes no arguments will have a
2526      single parameter type void.  */
2527   if (tl == NULL)
2528     return NULL;
2529
2530   /* If we have a single parameter type void, omit it.  */
2531   if (d_right (tl) == NULL
2532       && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2533       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2534     {
2535       di->expansion -= d_left (tl)->u.s_builtin.type->len;
2536       d_left (tl) = NULL;
2537     }
2538
2539   return tl;
2540 }
2541
2542 /* <bare-function-type> ::= [J]<type>+  */
2543
2544 static struct demangle_component *
2545 d_bare_function_type (struct d_info *di, int has_return_type)
2546 {
2547   struct demangle_component *return_type;
2548   struct demangle_component *tl;
2549   char peek;
2550
2551   /* Detect special qualifier indicating that the first argument
2552      is the return type.  */
2553   peek = d_peek_char (di);
2554   if (peek == 'J')
2555     {
2556       d_advance (di, 1);
2557       has_return_type = 1;
2558     }
2559
2560   if (has_return_type)
2561     {
2562       return_type = cplus_demangle_type (di);
2563       if (return_type == NULL)
2564         return NULL;
2565     }
2566   else
2567     return_type = NULL;
2568
2569   tl = d_parmlist (di);
2570   if (tl == NULL)
2571     return NULL;
2572
2573   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2574                       return_type, tl);
2575 }
2576
2577 /* <class-enum-type> ::= <name>  */
2578
2579 static struct demangle_component *
2580 d_class_enum_type (struct d_info *di)
2581 {
2582   return d_name (di);
2583 }
2584
2585 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2586                 ::= A [<(dimension) expression>] _ <(element) type>
2587 */
2588
2589 static struct demangle_component *
2590 d_array_type (struct d_info *di)
2591 {
2592   char peek;
2593   struct demangle_component *dim;
2594
2595   if (! d_check_char (di, 'A'))
2596     return NULL;
2597
2598   peek = d_peek_char (di);
2599   if (peek == '_')
2600     dim = NULL;
2601   else if (IS_DIGIT (peek))
2602     {
2603       const char *s;
2604
2605       s = d_str (di);
2606       do
2607         {
2608           d_advance (di, 1);
2609           peek = d_peek_char (di);
2610         }
2611       while (IS_DIGIT (peek));
2612       dim = d_make_name (di, s, d_str (di) - s);
2613       if (dim == NULL)
2614         return NULL;
2615     }
2616   else
2617     {
2618       dim = d_expression (di);
2619       if (dim == NULL)
2620         return NULL;
2621     }
2622
2623   if (! d_check_char (di, '_'))
2624     return NULL;
2625
2626   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2627                       cplus_demangle_type (di));
2628 }
2629
2630 /* <vector-type> ::= Dv <number> _ <type>
2631                  ::= Dv _ <expression> _ <type> */
2632
2633 static struct demangle_component *
2634 d_vector_type (struct d_info *di)
2635 {
2636   char peek;
2637   struct demangle_component *dim;
2638
2639   peek = d_peek_char (di);
2640   if (peek == '_')
2641     {
2642       d_advance (di, 1);
2643       dim = d_expression (di);
2644     }
2645   else
2646     dim = d_number_component (di);
2647
2648   if (dim == NULL)
2649     return NULL;
2650
2651   if (! d_check_char (di, '_'))
2652     return NULL;
2653
2654   return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
2655                       cplus_demangle_type (di));
2656 }
2657
2658 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
2659
2660 static struct demangle_component *
2661 d_pointer_to_member_type (struct d_info *di)
2662 {
2663   struct demangle_component *cl;
2664   struct demangle_component *mem;
2665   struct demangle_component **pmem;
2666
2667   if (! d_check_char (di, 'M'))
2668     return NULL;
2669
2670   cl = cplus_demangle_type (di);
2671
2672   /* The ABI specifies that any type can be a substitution source, and
2673      that M is followed by two types, and that when a CV-qualified
2674      type is seen both the base type and the CV-qualified types are
2675      substitution sources.  The ABI also specifies that for a pointer
2676      to a CV-qualified member function, the qualifiers are attached to
2677      the second type.  Given the grammar, a plain reading of the ABI
2678      suggests that both the CV-qualified member function and the
2679      non-qualified member function are substitution sources.  However,
2680      g++ does not work that way.  g++ treats only the CV-qualified
2681      member function as a substitution source.  FIXME.  So to work
2682      with g++, we need to pull off the CV-qualifiers here, in order to
2683      avoid calling add_substitution() in cplus_demangle_type().  But
2684      for a CV-qualified member which is not a function, g++ does
2685      follow the ABI, so we need to handle that case here by calling
2686      d_add_substitution ourselves.  */
2687
2688   pmem = d_cv_qualifiers (di, &mem, 1);
2689   if (pmem == NULL)
2690     return NULL;
2691   *pmem = cplus_demangle_type (di);
2692   if (*pmem == NULL)
2693     return NULL;
2694
2695   if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
2696     {
2697       if (! d_add_substitution (di, mem))
2698         return NULL;
2699     }
2700
2701   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2702 }
2703
2704 /* <non-negative number> _ */
2705
2706 static long
2707 d_compact_number (struct d_info *di)
2708 {
2709   long num;
2710   if (d_peek_char (di) == '_')
2711     num = 0;
2712   else if (d_peek_char (di) == 'n')
2713     return -1;
2714   else
2715     num = d_number (di) + 1;
2716
2717   if (! d_check_char (di, '_'))
2718     return -1;
2719   return num;
2720 }
2721
2722 /* <template-param> ::= T_
2723                     ::= T <(parameter-2 non-negative) number> _
2724 */
2725
2726 static struct demangle_component *
2727 d_template_param (struct d_info *di)
2728 {
2729   long param;
2730
2731   if (! d_check_char (di, 'T'))
2732     return NULL;
2733
2734   param = d_compact_number (di);
2735   if (param < 0)
2736     return NULL;
2737
2738   ++di->did_subs;
2739
2740   return d_make_template_param (di, param);
2741 }
2742
2743 /* <template-args> ::= I <template-arg>+ E  */
2744
2745 static struct demangle_component *
2746 d_template_args (struct d_info *di)
2747 {
2748   struct demangle_component *hold_last_name;
2749   struct demangle_component *al;
2750   struct demangle_component **pal;
2751
2752   /* Preserve the last name we saw--don't let the template arguments
2753      clobber it, as that would give us the wrong name for a subsequent
2754      constructor or destructor.  */
2755   hold_last_name = di->last_name;
2756
2757   if (d_peek_char (di) != 'I'
2758       && d_peek_char (di) != 'J')
2759     return NULL;
2760   d_advance (di, 1);
2761
2762   if (d_peek_char (di) == 'E')
2763     {
2764       /* An argument pack can be empty.  */
2765       d_advance (di, 1);
2766       return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2767     }
2768
2769   al = NULL;
2770   pal = &al;
2771   while (1)
2772     {
2773       struct demangle_component *a;
2774
2775       a = d_template_arg (di);
2776       if (a == NULL)
2777         return NULL;
2778
2779       *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2780       if (*pal == NULL)
2781         return NULL;
2782       pal = &d_right (*pal);
2783
2784       if (d_peek_char (di) == 'E')
2785         {
2786           d_advance (di, 1);
2787           break;
2788         }
2789     }
2790
2791   di->last_name = hold_last_name;
2792
2793   return al;
2794 }
2795
2796 /* <template-arg> ::= <type>
2797                   ::= X <expression> E
2798                   ::= <expr-primary>
2799 */
2800
2801 static struct demangle_component *
2802 d_template_arg (struct d_info *di)
2803 {
2804   struct demangle_component *ret;
2805
2806   switch (d_peek_char (di))
2807     {
2808     case 'X':
2809       d_advance (di, 1);
2810       ret = d_expression (di);
2811       if (! d_check_char (di, 'E'))
2812         return NULL;
2813       return ret;
2814
2815     case 'L':
2816       return d_expr_primary (di);
2817
2818     case 'I':
2819     case 'J':
2820       /* An argument pack.  */
2821       return d_template_args (di);
2822
2823     default:
2824       return cplus_demangle_type (di);
2825     }
2826 }
2827
2828 /* Parse a sequence of expressions until we hit the terminator
2829    character.  */
2830
2831 static struct demangle_component *
2832 d_exprlist (struct d_info *di, char terminator)
2833 {
2834   struct demangle_component *list = NULL;
2835   struct demangle_component **p = &list;
2836
2837   if (d_peek_char (di) == terminator)
2838     {
2839       d_advance (di, 1);
2840       return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
2841     }
2842
2843   while (1)
2844     {
2845       struct demangle_component *arg = d_expression (di);
2846       if (arg == NULL)
2847         return NULL;
2848
2849       *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
2850       if (*p == NULL)
2851         return NULL;
2852       p = &d_right (*p);
2853
2854       if (d_peek_char (di) == terminator)
2855         {
2856           d_advance (di, 1);
2857           break;
2858         }
2859     }
2860
2861   return list;
2862 }
2863
2864 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
2865    dynamic_cast, static_cast or reinterpret_cast.  */
2866
2867 static int
2868 op_is_new_cast (struct demangle_component *op)
2869 {
2870   const char *code = op->u.s_operator.op->code;
2871   return (code[1] == 'c'
2872           && (code[0] == 's' || code[0] == 'd'
2873               || code[0] == 'c' || code[0] == 'r'));
2874 }
2875
2876 /* <expression> ::= <(unary) operator-name> <expression>
2877                 ::= <(binary) operator-name> <expression> <expression>
2878                 ::= <(trinary) operator-name> <expression> <expression> <expression>
2879                 ::= cl <expression>+ E
2880                 ::= st <type>
2881                 ::= <template-param>
2882                 ::= sr <type> <unqualified-name>
2883                 ::= sr <type> <unqualified-name> <template-args>
2884                 ::= <expr-primary>
2885 */
2886
2887 static struct demangle_component *
2888 d_expression (struct d_info *di)
2889 {
2890   char peek;
2891
2892   peek = d_peek_char (di);
2893   if (peek == 'L')
2894     return d_expr_primary (di);
2895   else if (peek == 'T')
2896     return d_template_param (di);
2897   else if (peek == 's' && d_peek_next_char (di) == 'r')
2898     {
2899       struct demangle_component *type;
2900       struct demangle_component *name;
2901
2902       d_advance (di, 2);
2903       type = cplus_demangle_type (di);
2904       name = d_unqualified_name (di);
2905       if (d_peek_char (di) != 'I')
2906         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2907       else
2908         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2909                             d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2910                                          d_template_args (di)));
2911     }
2912   else if (peek == 's' && d_peek_next_char (di) == 'p')
2913     {
2914       d_advance (di, 2);
2915       return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2916                           d_expression (di), NULL);
2917     }
2918   else if (peek == 'f' && d_peek_next_char (di) == 'p')
2919     {
2920       /* Function parameter used in a late-specified return type.  */
2921       int index;
2922       d_advance (di, 2);
2923       if (d_peek_char (di) == 'T')
2924         {
2925           /* 'this' parameter.  */
2926           d_advance (di, 1);
2927           index = 0;
2928         }
2929       else
2930         {
2931           index = d_compact_number (di) + 1;
2932           if (index == 0)
2933             return NULL;
2934         }
2935       return d_make_function_param (di, index);
2936     }
2937   else if (IS_DIGIT (peek)
2938            || (peek == 'o' && d_peek_next_char (di) == 'n'))
2939     {
2940       /* We can get an unqualified name as an expression in the case of
2941          a dependent function call, i.e. decltype(f(t)).  */
2942       struct demangle_component *name;
2943
2944       if (peek == 'o')
2945         /* operator-function-id, i.e. operator+(t).  */
2946         d_advance (di, 2);
2947
2948       name = d_unqualified_name (di);
2949       if (name == NULL)
2950         return NULL;
2951       if (d_peek_char (di) == 'I')
2952         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2953                             d_template_args (di));
2954       else
2955         return name;
2956     }
2957   else if ((peek == 'i' || peek == 't')
2958            && d_peek_next_char (di) == 'l')
2959     {
2960       /* Brace-enclosed initializer list, untyped or typed.  */
2961       struct demangle_component *type = NULL;
2962       if (peek == 't')
2963         type = cplus_demangle_type (di);
2964       d_advance (di, 2);
2965       return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
2966                           type, d_exprlist (di, 'E'));
2967     }
2968   else
2969     {
2970       struct demangle_component *op;
2971       const char *code = NULL;
2972       int args;
2973
2974       op = d_operator_name (di);
2975       if (op == NULL)
2976         return NULL;
2977
2978       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2979         {
2980           code = op->u.s_operator.op->code;
2981           di->expansion += op->u.s_operator.op->len - 2;
2982           if (strcmp (code, "st") == 0)
2983             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2984                                 cplus_demangle_type (di));
2985         }
2986
2987       switch (op->type)
2988         {
2989         default:
2990           return NULL;
2991         case DEMANGLE_COMPONENT_OPERATOR:
2992           args = op->u.s_operator.op->args;
2993           break;
2994         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2995           args = op->u.s_extended_operator.args;
2996           break;
2997         case DEMANGLE_COMPONENT_CAST:
2998           args = 1;
2999           break;
3000         }
3001
3002       switch (args)
3003         {
3004         case 0:
3005           return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3006
3007         case 1:
3008           {
3009             struct demangle_component *operand;
3010             int suffix = 0;
3011
3012             if (code && (code[0] == 'p' || code[0] == 'm')
3013                 && code[1] == code[0])
3014               /* pp_ and mm_ are the prefix variants.  */
3015               suffix = !d_check_char (di, '_');
3016
3017             if (op->type == DEMANGLE_COMPONENT_CAST
3018                 && d_check_char (di, '_'))
3019               operand = d_exprlist (di, 'E');
3020             else
3021               operand = d_expression (di);
3022
3023             if (suffix)
3024               /* Indicate the suffix variant for d_print_comp.  */
3025               return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3026                                   d_make_comp (di,
3027                                                DEMANGLE_COMPONENT_BINARY_ARGS,
3028                                                operand, operand));
3029             else
3030               return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3031                                   operand);
3032           }
3033         case 2:
3034           {
3035             struct demangle_component *left;
3036             struct demangle_component *right;
3037
3038             if (op_is_new_cast (op))
3039               left = cplus_demangle_type (di);
3040             else
3041               left = d_expression (di);
3042             if (!strcmp (code, "cl"))
3043               right = d_exprlist (di, 'E');
3044             else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3045               {
3046                 right = d_unqualified_name (di);
3047                 if (d_peek_char (di) == 'I')
3048                   right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3049                                        right, d_template_args (di));
3050               }
3051             else
3052               right = d_expression (di);
3053
3054             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3055                                 d_make_comp (di,
3056                                              DEMANGLE_COMPONENT_BINARY_ARGS,
3057                                              left, right));
3058           }
3059         case 3:
3060           {
3061             struct demangle_component *first;
3062             struct demangle_component *second;
3063             struct demangle_component *third;
3064
3065             if (!strcmp (code, "qu"))
3066               {
3067                 /* ?: expression.  */
3068                 first = d_expression (di);
3069                 second = d_expression (di);
3070                 third = d_expression (di);
3071               }
3072             else if (code[0] == 'n')
3073               {
3074                 /* new-expression.  */
3075                 if (code[1] != 'w' && code[1] != 'a')
3076                   return NULL;
3077                 first = d_exprlist (di, '_');
3078                 second = cplus_demangle_type (di);
3079                 if (d_peek_char (di) == 'E')
3080                   {
3081                     d_advance (di, 1);
3082                     third = NULL;
3083                   }
3084                 else if (d_peek_char (di) == 'p'
3085                          && d_peek_next_char (di) == 'i')
3086                   {
3087                     /* Parenthesized initializer.  */
3088                     d_advance (di, 2);
3089                     third = d_exprlist (di, 'E');
3090                   }
3091                 else if (d_peek_char (di) == 'i'
3092                          && d_peek_next_char (di) == 'l')
3093                   /* initializer-list.  */
3094                   third = d_expression (di);
3095                 else
3096                   return NULL;
3097               }
3098             else
3099               return NULL;
3100             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3101                                 d_make_comp (di,
3102                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
3103                                              first,
3104                                              d_make_comp (di,
3105                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
3106                                                           second, third)));
3107           }
3108         default:
3109           return NULL;
3110         }
3111     }
3112 }
3113
3114 /* <expr-primary> ::= L <type> <(value) number> E
3115                   ::= L <type> <(value) float> E
3116                   ::= L <mangled-name> E
3117 */
3118
3119 static struct demangle_component *
3120 d_expr_primary (struct d_info *di)
3121 {
3122   struct demangle_component *ret;
3123
3124   if (! d_check_char (di, 'L'))
3125     return NULL;
3126   if (d_peek_char (di) == '_'
3127       /* Workaround for G++ bug; see comment in write_template_arg.  */
3128       || d_peek_char (di) == 'Z')
3129     ret = cplus_demangle_mangled_name (di, 0);
3130   else
3131     {
3132       struct demangle_component *type;
3133       enum demangle_component_type t;
3134       const char *s;
3135
3136       type = cplus_demangle_type (di);
3137       if (type == NULL)
3138         return NULL;
3139
3140       /* If we have a type we know how to print, we aren't going to
3141          print the type name itself.  */
3142       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3143           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3144         di->expansion -= type->u.s_builtin.type->len;
3145
3146       /* Rather than try to interpret the literal value, we just
3147          collect it as a string.  Note that it's possible to have a
3148          floating point literal here.  The ABI specifies that the
3149          format of such literals is machine independent.  That's fine,
3150          but what's not fine is that versions of g++ up to 3.2 with
3151          -fabi-version=1 used upper case letters in the hex constant,
3152          and dumped out gcc's internal representation.  That makes it
3153          hard to tell where the constant ends, and hard to dump the
3154          constant in any readable form anyhow.  We don't attempt to
3155          handle these cases.  */
3156
3157       t = DEMANGLE_COMPONENT_LITERAL;
3158       if (d_peek_char (di) == 'n')
3159         {
3160           t = DEMANGLE_COMPONENT_LITERAL_NEG;
3161           d_advance (di, 1);
3162         }
3163       s = d_str (di);
3164       while (d_peek_char (di) != 'E')
3165         {
3166           if (d_peek_char (di) == '\0')
3167             return NULL;
3168           d_advance (di, 1);
3169         }
3170       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
3171     }
3172   if (! d_check_char (di, 'E'))
3173     return NULL;
3174   return ret;
3175 }
3176
3177 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3178                 ::= Z <(function) encoding> E s [<discriminator>]
3179                 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3180 */
3181
3182 static struct demangle_component *
3183 d_local_name (struct d_info *di)
3184 {
3185   struct demangle_component *function;
3186
3187   if (! d_check_char (di, 'Z'))
3188     return NULL;
3189
3190   function = d_encoding (di, 0);
3191
3192   if (! d_check_char (di, 'E'))
3193     return NULL;
3194
3195   if (d_peek_char (di) == 's')
3196     {
3197       d_advance (di, 1);
3198       if (! d_discriminator (di))
3199         return NULL;
3200       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
3201                           d_make_name (di, "string literal",
3202                                        sizeof "string literal" - 1));
3203     }
3204   else
3205     {
3206       struct demangle_component *name;
3207       int num = -1;
3208
3209       if (d_peek_char (di) == 'd')
3210         {
3211           /* Default argument scope: d <number> _.  */
3212           d_advance (di, 1);
3213           num = d_compact_number (di);
3214           if (num < 0)
3215             return NULL;
3216         }
3217
3218       name = d_name (di);
3219       if (name)
3220         switch (name->type)
3221           {
3222             /* Lambdas and unnamed types have internal discriminators.  */
3223           case DEMANGLE_COMPONENT_LAMBDA:
3224           case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3225             break;
3226           default:
3227             if (! d_discriminator (di))
3228               return NULL;
3229           }
3230       if (num >= 0)
3231         name = d_make_default_arg (di, num, name);
3232       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3233     }
3234 }
3235
3236 /* <discriminator> ::= _ <(non-negative) number>
3237
3238    We demangle the discriminator, but we don't print it out.  FIXME:
3239    We should print it out in verbose mode.  */
3240
3241 static int
3242 d_discriminator (struct d_info *di)
3243 {
3244   long discrim;
3245
3246   if (d_peek_char (di) != '_')
3247     return 1;
3248   d_advance (di, 1);
3249   discrim = d_number (di);
3250   if (discrim < 0)
3251     return 0;
3252   return 1;
3253 }
3254
3255 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3256
3257 static struct demangle_component *
3258 d_lambda (struct d_info *di)
3259 {
3260   struct demangle_component *tl;
3261   struct demangle_component *ret;
3262   int num;
3263
3264   if (! d_check_char (di, 'U'))
3265     return NULL;
3266   if (! d_check_char (di, 'l'))
3267     return NULL;
3268
3269   tl = d_parmlist (di);
3270   if (tl == NULL)
3271     return NULL;
3272
3273   if (! d_check_char (di, 'E'))
3274     return NULL;
3275
3276   num = d_compact_number (di);
3277   if (num < 0)
3278     return NULL;
3279
3280   ret = d_make_empty (di);
3281   if (ret)
3282     {
3283       ret->type = DEMANGLE_COMPONENT_LAMBDA;
3284       ret->u.s_unary_num.sub = tl;
3285       ret->u.s_unary_num.num = num;
3286     }
3287
3288   if (! d_add_substitution (di, ret))
3289     return NULL;
3290
3291   return ret;
3292 }
3293
3294 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3295
3296 static struct demangle_component *
3297 d_unnamed_type (struct d_info *di)
3298 {
3299   struct demangle_component *ret;
3300   long num;
3301
3302   if (! d_check_char (di, 'U'))
3303     return NULL;
3304   if (! d_check_char (di, 't'))
3305     return NULL;
3306
3307   num = d_compact_number (di);
3308   if (num < 0)
3309     return NULL;
3310
3311   ret = d_make_empty (di);
3312   if (ret)
3313     {
3314       ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3315       ret->u.s_number.number = num;
3316     }
3317
3318   if (! d_add_substitution (di, ret))
3319     return NULL;
3320
3321   return ret;
3322 }
3323
3324 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3325 */
3326
3327 static struct demangle_component *
3328 d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3329 {
3330   const char *suffix = d_str (di);
3331   const char *pend = suffix;
3332   struct demangle_component *n;
3333
3334   if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3335     {
3336       pend += 2;
3337       while (IS_LOWER (*pend) || *pend == '_')
3338         ++pend;
3339     }
3340   while (*pend == '.' && IS_DIGIT (pend[1]))
3341     {
3342       pend += 2;
3343       while (IS_DIGIT (*pend))
3344         ++pend;
3345     }
3346   d_advance (di, pend - suffix);
3347   n = d_make_name (di, suffix, pend - suffix);
3348   return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3349 }
3350
3351 /* Add a new substitution.  */
3352
3353 static int
3354 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3355 {
3356   if (dc == NULL)
3357     return 0;
3358   if (di->next_sub >= di->num_subs)
3359     return 0;
3360   di->subs[di->next_sub] = dc;
3361   ++di->next_sub;
3362   return 1;
3363 }
3364
3365 /* <substitution> ::= S <seq-id> _
3366                   ::= S_
3367                   ::= St
3368                   ::= Sa
3369                   ::= Sb
3370                   ::= Ss
3371                   ::= Si
3372                   ::= So
3373                   ::= Sd
3374
3375    If PREFIX is non-zero, then this type is being used as a prefix in
3376    a qualified name.  In this case, for the standard substitutions, we
3377    need to check whether we are being used as a prefix for a
3378    constructor or destructor, and return a full template name.
3379    Otherwise we will get something like std::iostream::~iostream()
3380    which does not correspond particularly well to any function which
3381    actually appears in the source.
3382 */
3383
3384 static const struct d_standard_sub_info standard_subs[] =
3385 {
3386   { 't', NL ("std"),
3387     NL ("std"),
3388     NULL, 0 },
3389   { 'a', NL ("std::allocator"),
3390     NL ("std::allocator"),
3391     NL ("allocator") },
3392   { 'b', NL ("std::basic_string"),
3393     NL ("std::basic_string"),
3394     NL ("basic_string") },
3395   { 's', NL ("std::string"),
3396     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3397     NL ("basic_string") },
3398   { 'i', NL ("std::istream"),
3399     NL ("std::basic_istream<char, std::char_traits<char> >"),
3400     NL ("basic_istream") },
3401   { 'o', NL ("std::ostream"),
3402     NL ("std::basic_ostream<char, std::char_traits<char> >"),
3403     NL ("basic_ostream") },
3404   { 'd', NL ("std::iostream"),
3405     NL ("std::basic_iostream<char, std::char_traits<char> >"),
3406     NL ("basic_iostream") }
3407 };
3408
3409 static struct demangle_component *
3410 d_substitution (struct d_info *di, int prefix)
3411 {
3412   char c;
3413
3414   if (! d_check_char (di, 'S'))
3415     return NULL;
3416
3417   c = d_next_char (di);
3418   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3419     {
3420       unsigned int id;
3421
3422       id = 0;
3423       if (c != '_')
3424         {
3425           do
3426             {
3427               unsigned int new_id;
3428
3429               if (IS_DIGIT (c))
3430                 new_id = id * 36 + c - '0';
3431               else if (IS_UPPER (c))
3432                 new_id = id * 36 + c - 'A' + 10;
3433               else
3434                 return NULL;
3435               if (new_id < id)
3436                 return NULL;
3437               id = new_id;
3438               c = d_next_char (di);
3439             }
3440           while (c != '_');
3441
3442           ++id;
3443         }
3444
3445       if (id >= (unsigned int) di->next_sub)
3446         return NULL;
3447
3448       ++di->did_subs;
3449
3450       return di->subs[id];
3451     }
3452   else
3453     {
3454       int verbose;
3455       const struct d_standard_sub_info *p;
3456       const struct d_standard_sub_info *pend;
3457
3458       verbose = (di->options & DMGL_VERBOSE) != 0;
3459       if (! verbose && prefix)
3460         {
3461           char peek;
3462
3463           peek = d_peek_char (di);
3464           if (peek == 'C' || peek == 'D')
3465             verbose = 1;
3466         }
3467
3468       pend = (&standard_subs[0]
3469               + sizeof standard_subs / sizeof standard_subs[0]);
3470       for (p = &standard_subs[0]; p < pend; ++p)
3471         {
3472           if (c == p->code)
3473             {
3474               const char *s;
3475               int len;
3476
3477               if (p->set_last_name != NULL)
3478                 di->last_name = d_make_sub (di, p->set_last_name,
3479                                             p->set_last_name_len);
3480               if (verbose)
3481                 {
3482                   s = p->full_expansion;
3483                   len = p->full_len;
3484                 }
3485               else
3486                 {
3487                   s = p->simple_expansion;
3488                   len = p->simple_len;
3489                 }
3490               di->expansion += len;
3491               return d_make_sub (di, s, len);
3492             }
3493         }
3494
3495       return NULL;
3496     }
3497 }
3498
3499 /* Initialize a growable string.  */
3500
3501 static void
3502 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3503 {
3504   dgs->buf = NULL;
3505   dgs->len = 0;
3506   dgs->alc = 0;
3507   dgs->allocation_failure = 0;
3508
3509   if (estimate > 0)
3510     d_growable_string_resize (dgs, estimate);
3511 }
3512
3513 /* Grow a growable string to a given size.  */
3514
3515 static inline void
3516 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3517 {
3518   size_t newalc;
3519   char *newbuf;
3520
3521   if (dgs->allocation_failure)
3522     return;
3523
3524   /* Start allocation at two bytes to avoid any possibility of confusion
3525      with the special value of 1 used as a return in *palc to indicate
3526      allocation failures.  */
3527   newalc = dgs->alc > 0 ? dgs->alc : 2;
3528   while (newalc < need)
3529     newalc <<= 1;
3530
3531   newbuf = (char *) realloc (dgs->buf, newalc);
3532   if (newbuf == NULL)
3533     {
3534       free (dgs->buf);
3535       dgs->buf = NULL;
3536       dgs->len = 0;
3537       dgs->alc = 0;
3538       dgs->allocation_failure = 1;
3539       return;
3540     }
3541   dgs->buf = newbuf;
3542   dgs->alc = newalc;
3543 }
3544
3545 /* Append a buffer to a growable string.  */
3546
3547 static inline void
3548 d_growable_string_append_buffer (struct d_growable_string *dgs,
3549                                  const char *s, size_t l)
3550 {
3551   size_t need;
3552
3553   need = dgs->len + l + 1;
3554   if (need > dgs->alc)
3555     d_growable_string_resize (dgs, need);
3556
3557   if (dgs->allocation_failure)
3558     return;
3559
3560   memcpy (dgs->buf + dgs->len, s, l);
3561   dgs->buf[dgs->len + l] = '\0';
3562   dgs->len += l;
3563 }
3564
3565 /* Bridge growable strings to the callback mechanism.  */
3566
3567 static void
3568 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3569 {
3570   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3571
3572   d_growable_string_append_buffer (dgs, s, l);
3573 }
3574
3575 /* Initialize a print information structure.  */
3576
3577 static void
3578 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
3579               void *opaque)
3580 {
3581   dpi->len = 0;
3582   dpi->last_char = '\0';
3583   dpi->templates = NULL;
3584   dpi->modifiers = NULL;
3585   dpi->pack_index = 0;
3586   dpi->flush_count = 0;
3587
3588   dpi->callback = callback;
3589   dpi->opaque = opaque;
3590
3591   dpi->demangle_failure = 0;
3592 }
3593
3594 /* Indicate that an error occurred during printing, and test for error.  */
3595
3596 static inline void
3597 d_print_error (struct d_print_info *dpi)
3598 {
3599   dpi->demangle_failure = 1;
3600 }
3601
3602 static inline int
3603 d_print_saw_error (struct d_print_info *dpi)
3604 {
3605   return dpi->demangle_failure != 0;
3606 }
3607
3608 /* Flush buffered characters to the callback.  */
3609
3610 static inline void
3611 d_print_flush (struct d_print_info *dpi)
3612 {
3613   dpi->buf[dpi->len] = '\0';
3614   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3615   dpi->len = 0;
3616   dpi->flush_count++;
3617 }
3618
3619 /* Append characters and buffers for printing.  */
3620
3621 static inline void
3622 d_append_char (struct d_print_info *dpi, char c)
3623 {
3624   if (dpi->len == sizeof (dpi->buf) - 1)
3625     d_print_flush (dpi);
3626
3627   dpi->buf[dpi->len++] = c;
3628   dpi->last_char = c;
3629 }
3630
3631 static inline void
3632 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3633 {
3634   size_t i;
3635
3636   for (i = 0; i < l; i++)
3637     d_append_char (dpi, s[i]);
3638 }
3639
3640 static inline void
3641 d_append_string (struct d_print_info *dpi, const char *s)
3642 {
3643   d_append_buffer (dpi, s, strlen (s));
3644 }
3645
3646 static inline void
3647 d_append_num (struct d_print_info *dpi, long l)
3648 {
3649   char buf[25];
3650   sprintf (buf,"%ld", l);
3651   d_append_string (dpi, buf);
3652 }
3653
3654 static inline char
3655 d_last_char (struct d_print_info *dpi)
3656 {
3657   return dpi->last_char;
3658 }
3659
3660 /* Turn components into a human readable string.  OPTIONS is the
3661    options bits passed to the demangler.  DC is the tree to print.
3662    CALLBACK is a function to call to flush demangled string segments
3663    as they fill the intermediate buffer, and OPAQUE is a generalized
3664    callback argument.  On success, this returns 1.  On failure,
3665    it returns 0, indicating a bad parse.  It does not use heap
3666    memory to build an output string, so cannot encounter memory
3667    allocation failure.  */
3668
3669 CP_STATIC_IF_GLIBCPP_V3
3670 int
3671 cplus_demangle_print_callback (int options,
3672                                const struct demangle_component *dc,
3673                                demangle_callbackref callback, void *opaque)
3674 {
3675   struct d_print_info dpi;
3676
3677   d_print_init (&dpi, callback, opaque);
3678
3679   d_print_comp (&dpi, options, dc);
3680
3681   d_print_flush (&dpi);
3682
3683   return ! d_print_saw_error (&dpi);
3684 }
3685
3686 /* Turn components into a human readable string.  OPTIONS is the
3687    options bits passed to the demangler.  DC is the tree to print.
3688    ESTIMATE is a guess at the length of the result.  This returns a
3689    string allocated by malloc, or NULL on error.  On success, this
3690    sets *PALC to the size of the allocated buffer.  On failure, this
3691    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3692    failure.  */
3693
3694 CP_STATIC_IF_GLIBCPP_V3
3695 char *
3696 cplus_demangle_print (int options, const struct demangle_component *dc,
3697                       int estimate, size_t *palc)
3698 {
3699   struct d_growable_string dgs;
3700
3701   d_growable_string_init (&dgs, estimate);
3702
3703   if (! cplus_demangle_print_callback (options, dc,
3704                                        d_growable_string_callback_adapter,
3705                                        &dgs))
3706     {
3707       free (dgs.buf);
3708       *palc = 0;
3709       return NULL;
3710     }
3711
3712   *palc = dgs.allocation_failure ? 1 : dgs.alc;
3713   return dgs.buf;
3714 }
3715
3716 /* Returns the I'th element of the template arglist ARGS, or NULL on
3717    failure.  */
3718
3719 static struct demangle_component *
3720 d_index_template_argument (struct demangle_component *args, int i)
3721 {
3722   struct demangle_component *a;
3723
3724   for (a = args;
3725        a != NULL;
3726        a = d_right (a))
3727     {
3728       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3729         return NULL;
3730       if (i <= 0)
3731         break;
3732       --i;
3733     }
3734   if (i != 0 || a == NULL)
3735     return NULL;
3736
3737   return d_left (a);
3738 }
3739
3740 /* Returns the template argument from the current context indicated by DC,
3741    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
3742
3743 static struct demangle_component *
3744 d_lookup_template_argument (struct d_print_info *dpi,
3745                             const struct demangle_component *dc)
3746 {
3747   if (dpi->templates == NULL)
3748     {
3749       d_print_error (dpi);
3750       return NULL;
3751     }
3752
3753   return d_index_template_argument
3754     (d_right (dpi->templates->template_decl),
3755      dc->u.s_number.number);
3756 }
3757
3758 /* Returns a template argument pack used in DC (any will do), or NULL.  */
3759
3760 static struct demangle_component *
3761 d_find_pack (struct d_print_info *dpi,
3762              const struct demangle_component *dc)
3763 {
3764   struct demangle_component *a;
3765   if (dc == NULL)
3766     return NULL;
3767
3768   switch (dc->type)
3769     {
3770     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3771       a = d_lookup_template_argument (dpi, dc);
3772       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3773         return a;
3774       return NULL;
3775
3776     case DEMANGLE_COMPONENT_PACK_EXPANSION:
3777       return NULL;
3778
3779     case DEMANGLE_COMPONENT_LAMBDA:
3780     case DEMANGLE_COMPONENT_NAME:
3781     case DEMANGLE_COMPONENT_TAGGED_NAME:
3782     case DEMANGLE_COMPONENT_OPERATOR:
3783     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3784     case DEMANGLE_COMPONENT_SUB_STD:
3785     case DEMANGLE_COMPONENT_CHARACTER:
3786     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3787     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3788       return NULL;
3789
3790     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3791       return d_find_pack (dpi, dc->u.s_extended_operator.name);
3792     case DEMANGLE_COMPONENT_CTOR:
3793       return d_find_pack (dpi, dc->u.s_ctor.name);
3794     case DEMANGLE_COMPONENT_DTOR:
3795       return d_find_pack (dpi, dc->u.s_dtor.name);
3796
3797     default:
3798       a = d_find_pack (dpi, d_left (dc));
3799       if (a)
3800         return a;
3801       return d_find_pack (dpi, d_right (dc));
3802     }
3803 }
3804
3805 /* Returns the length of the template argument pack DC.  */
3806
3807 static int
3808 d_pack_length (const struct demangle_component *dc)
3809 {
3810   int count = 0;
3811   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3812          && d_left (dc) != NULL)
3813     {
3814       ++count;
3815       dc = d_right (dc);
3816     }
3817   return count;
3818 }
3819
3820 /* DC is a component of a mangled expression.  Print it, wrapped in parens
3821    if needed.  */
3822
3823 static void
3824 d_print_subexpr (struct d_print_info *dpi, int options,
3825                  const struct demangle_component *dc)
3826 {
3827   int simple = 0;
3828   if (dc->type == DEMANGLE_COMPONENT_NAME
3829       || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
3830       || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
3831       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3832     simple = 1;
3833   if (!simple)
3834     d_append_char (dpi, '(');
3835   d_print_comp (dpi, options, dc);
3836   if (!simple)
3837     d_append_char (dpi, ')');
3838 }
3839
3840 /* Subroutine to handle components.  */
3841
3842 static void
3843 d_print_comp (struct d_print_info *dpi, int options,
3844               const struct demangle_component *dc)
3845 {
3846   /* Magic variable to let reference smashing skip over the next modifier
3847      without needing to modify *dc.  */
3848   const struct demangle_component *mod_inner = NULL;
3849
3850   if (dc == NULL)
3851     {
3852       d_print_error (dpi);
3853       return;
3854     }
3855   if (d_print_saw_error (dpi))
3856     return;
3857
3858   switch (dc->type)
3859     {
3860     case DEMANGLE_COMPONENT_NAME:
3861       if ((options & DMGL_JAVA) == 0)
3862         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3863       else
3864         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3865       return;
3866
3867     case DEMANGLE_COMPONENT_TAGGED_NAME:
3868       d_print_comp (dpi, options, d_left (dc));
3869       d_append_string (dpi, "[abi:");
3870       d_print_comp (dpi, options, d_right (dc));
3871       d_append_char (dpi, ']');
3872       return;
3873
3874     case DEMANGLE_COMPONENT_QUAL_NAME:
3875     case DEMANGLE_COMPONENT_LOCAL_NAME:
3876       d_print_comp (dpi, options, d_left (dc));
3877       if ((options & DMGL_JAVA) == 0)
3878         d_append_string (dpi, "::");
3879       else
3880         d_append_char (dpi, '.');
3881       {
3882         struct demangle_component *local_name = d_right (dc);
3883         if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3884           {
3885             d_append_string (dpi, "{default arg#");
3886             d_append_num (dpi, local_name->u.s_unary_num.num + 1);
3887             d_append_string (dpi, "}::");
3888             local_name = local_name->u.s_unary_num.sub;
3889           }
3890         d_print_comp (dpi, options, local_name);
3891       }
3892       return;
3893
3894     case DEMANGLE_COMPONENT_TYPED_NAME:
3895       {
3896         struct d_print_mod *hold_modifiers;
3897         struct demangle_component *typed_name;
3898         struct d_print_mod adpm[4];
3899         unsigned int i;
3900         struct d_print_template dpt;
3901
3902         /* Pass the name down to the type so that it can be printed in
3903            the right place for the type.  We also have to pass down
3904            any CV-qualifiers, which apply to the this parameter.  */
3905         hold_modifiers = dpi->modifiers;
3906         dpi->modifiers = 0;
3907         i = 0;
3908         typed_name = d_left (dc);
3909         while (typed_name != NULL)
3910           {
3911             if (i >= sizeof adpm / sizeof adpm[0])
3912               {
3913                 d_print_error (dpi);
3914                 return;
3915               }
3916
3917             adpm[i].next = dpi->modifiers;
3918             dpi->modifiers = &adpm[i];
3919             adpm[i].mod = typed_name;
3920             adpm[i].printed = 0;
3921             adpm[i].templates = dpi->templates;
3922             ++i;
3923
3924             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3925                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3926                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3927               break;
3928
3929             typed_name = d_left (typed_name);
3930           }
3931
3932         if (typed_name == NULL)
3933           {
3934             d_print_error (dpi);
3935             return;
3936           }
3937
3938         /* If typed_name is a template, then it applies to the
3939            function type as well.  */
3940         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3941           {
3942             dpt.next = dpi->templates;
3943             dpi->templates = &dpt;
3944             dpt.template_decl = typed_name;
3945           }
3946
3947         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3948            there may be CV-qualifiers on its right argument which
3949            really apply here; this happens when parsing a class which
3950            is local to a function.  */
3951         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3952           {
3953             struct demangle_component *local_name;
3954
3955             local_name = d_right (typed_name);
3956             if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3957               local_name = local_name->u.s_unary_num.sub;
3958             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3959                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3960                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3961               {
3962                 if (i >= sizeof adpm / sizeof adpm[0])
3963                   {
3964                     d_print_error (dpi);
3965                     return;
3966                   }
3967
3968                 adpm[i] = adpm[i - 1];
3969                 adpm[i].next = &adpm[i - 1];
3970                 dpi->modifiers = &adpm[i];
3971
3972                 adpm[i - 1].mod = local_name;
3973                 adpm[i - 1].printed = 0;
3974                 adpm[i - 1].templates = dpi->templates;
3975                 ++i;
3976
3977                 local_name = d_left (local_name);
3978               }
3979           }
3980
3981         d_print_comp (dpi, options, d_right (dc));
3982
3983         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3984           dpi->templates = dpt.next;
3985
3986         /* If the modifiers didn't get printed by the type, print them
3987            now.  */
3988         while (i > 0)
3989           {
3990             --i;
3991             if (! adpm[i].printed)
3992               {
3993                 d_append_char (dpi, ' ');
3994                 d_print_mod (dpi, options, adpm[i].mod);
3995               }
3996           }
3997
3998         dpi->modifiers = hold_modifiers;
3999
4000         return;
4001       }
4002
4003     case DEMANGLE_COMPONENT_TEMPLATE:
4004       {
4005         struct d_print_mod *hold_dpm;
4006         struct demangle_component *dcl;
4007
4008         /* Don't push modifiers into a template definition.  Doing so
4009            could give the wrong definition for a template argument.
4010            Instead, treat the template essentially as a name.  */
4011
4012         hold_dpm = dpi->modifiers;
4013         dpi->modifiers = NULL;
4014
4015         dcl = d_left (dc);
4016
4017         if ((options & DMGL_JAVA) != 0
4018             && dcl->type == DEMANGLE_COMPONENT_NAME
4019             && dcl->u.s_name.len == 6
4020             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
4021           {
4022             /* Special-case Java arrays, so that JArray<TYPE> appears
4023                instead as TYPE[].  */
4024
4025             d_print_comp (dpi, options, d_right (dc));
4026             d_append_string (dpi, "[]");
4027           }
4028         else
4029           {
4030             d_print_comp (dpi, options, dcl);
4031             if (d_last_char (dpi) == '<')
4032               d_append_char (dpi, ' ');
4033             d_append_char (dpi, '<');
4034             d_print_comp (dpi, options, d_right (dc));
4035             /* Avoid generating two consecutive '>' characters, to avoid
4036                the C++ syntactic ambiguity.  */
4037             if (d_last_char (dpi) == '>')
4038               d_append_char (dpi, ' ');
4039             d_append_char (dpi, '>');
4040           }
4041
4042         dpi->modifiers = hold_dpm;
4043
4044         return;
4045       }
4046
4047     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4048       {
4049         struct d_print_template *hold_dpt;
4050         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
4051
4052         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4053           a = d_index_template_argument (a, dpi->pack_index);
4054
4055         if (a == NULL)
4056           {
4057             d_print_error (dpi);
4058             return;
4059           }
4060
4061         /* While processing this parameter, we need to pop the list of
4062            templates.  This is because the template parameter may
4063            itself be a reference to a parameter of an outer
4064            template.  */
4065
4066         hold_dpt = dpi->templates;
4067         dpi->templates = hold_dpt->next;
4068
4069         d_print_comp (dpi, options, a);
4070
4071         dpi->templates = hold_dpt;
4072
4073         return;
4074       }
4075
4076     case DEMANGLE_COMPONENT_CTOR:
4077       d_print_comp (dpi, options, dc->u.s_ctor.name);
4078       return;
4079
4080     case DEMANGLE_COMPONENT_DTOR:
4081       d_append_char (dpi, '~');
4082       d_print_comp (dpi, options, dc->u.s_dtor.name);
4083       return;
4084
4085     case DEMANGLE_COMPONENT_VTABLE:
4086       d_append_string (dpi, "vtable for ");
4087       d_print_comp (dpi, options, d_left (dc));
4088       return;
4089
4090     case DEMANGLE_COMPONENT_VTT:
4091       d_append_string (dpi, "VTT for ");
4092       d_print_comp (dpi, options, d_left (dc));
4093       return;
4094
4095     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4096       d_append_string (dpi, "construction vtable for ");
4097       d_print_comp (dpi, options, d_left (dc));
4098       d_append_string (dpi, "-in-");
4099       d_print_comp (dpi, options, d_right (dc));
4100       return;
4101
4102     case DEMANGLE_COMPONENT_TYPEINFO:
4103       d_append_string (dpi, "typeinfo for ");
4104       d_print_comp (dpi, options, d_left (dc));
4105       return;
4106
4107     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4108       d_append_string (dpi, "typeinfo name for ");
4109       d_print_comp (dpi, options, d_left (dc));
4110       return;
4111
4112     case DEMANGLE_COMPONENT_TYPEINFO_FN:
4113       d_append_string (dpi, "typeinfo fn for ");
4114       d_print_comp (dpi, options, d_left (dc));
4115       return;
4116
4117     case DEMANGLE_COMPONENT_THUNK:
4118       d_append_string (dpi, "non-virtual thunk to ");
4119       d_print_comp (dpi, options, d_left (dc));
4120       return;
4121
4122     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4123       d_append_string (dpi, "virtual thunk to ");
4124       d_print_comp (dpi, options, d_left (dc));
4125       return;
4126
4127     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4128       d_append_string (dpi, "covariant return thunk to ");
4129       d_print_comp (dpi, options, d_left (dc));
4130       return;
4131
4132     case DEMANGLE_COMPONENT_JAVA_CLASS:
4133       d_append_string (dpi, "java Class for ");
4134       d_print_comp (dpi, options, d_left (dc));
4135       return;
4136
4137     case DEMANGLE_COMPONENT_GUARD:
4138       d_append_string (dpi, "guard variable for ");
4139       d_print_comp (dpi, options, d_left (dc));
4140       return;
4141
4142     case DEMANGLE_COMPONENT_TLS_INIT:
4143       d_append_string (dpi, "TLS init function for ");
4144       d_print_comp (dpi, options, d_left (dc));
4145       return;
4146
4147     case DEMANGLE_COMPONENT_TLS_WRAPPER:
4148       d_append_string (dpi, "TLS wrapper function for ");
4149       d_print_comp (dpi, options, d_left (dc));
4150       return;
4151
4152     case DEMANGLE_COMPONENT_REFTEMP:
4153       d_append_string (dpi, "reference temporary #");
4154       d_print_comp (dpi, options, d_right (dc));
4155       d_append_string (dpi, " for ");
4156       d_print_comp (dpi, options, d_left (dc));
4157       return;
4158
4159     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4160       d_append_string (dpi, "hidden alias for ");
4161       d_print_comp (dpi, options, d_left (dc));
4162       return;
4163
4164     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4165       d_append_string (dpi, "transaction clone for ");
4166       d_print_comp (dpi, options, d_left (dc));
4167       return;
4168
4169     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4170       d_append_string (dpi, "non-transaction clone for ");
4171       d_print_comp (dpi, options, d_left (dc));
4172       return;
4173
4174     case DEMANGLE_COMPONENT_SUB_STD:
4175       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
4176       return;
4177
4178     case DEMANGLE_COMPONENT_RESTRICT:
4179     case DEMANGLE_COMPONENT_VOLATILE:
4180     case DEMANGLE_COMPONENT_CONST:
4181       {
4182         struct d_print_mod *pdpm;
4183
4184         /* When printing arrays, it's possible to have cases where the
4185            same CV-qualifier gets pushed on the stack multiple times.
4186            We only need to print it once.  */
4187
4188         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
4189           {
4190             if (! pdpm->printed)
4191               {
4192                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
4193                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
4194                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
4195                   break;
4196                 if (pdpm->mod->type == dc->type)
4197                   {
4198                     d_print_comp (dpi, options, d_left (dc));
4199                     return;
4200                   }
4201               }
4202           }
4203       }
4204       goto modifier;
4205
4206     case DEMANGLE_COMPONENT_REFERENCE:
4207     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4208       {
4209         /* Handle reference smashing: & + && = &.  */
4210         const struct demangle_component *sub = d_left (dc);
4211         if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
4212           {
4213             struct demangle_component *a = d_lookup_template_argument (dpi, sub);
4214             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4215               a = d_index_template_argument (a, dpi->pack_index);
4216
4217             if (a == NULL)
4218               {
4219                 d_print_error (dpi);
4220                 return;
4221               }
4222
4223             sub = a;
4224           }
4225
4226         if (sub->type == DEMANGLE_COMPONENT_REFERENCE
4227             || sub->type == dc->type)
4228           dc = sub;
4229         else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
4230           mod_inner = d_left (sub);
4231       }
4232       /* Fall through.  */
4233
4234     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4235     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4236     case DEMANGLE_COMPONENT_CONST_THIS:
4237     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4238     case DEMANGLE_COMPONENT_POINTER:
4239     case DEMANGLE_COMPONENT_COMPLEX:
4240     case DEMANGLE_COMPONENT_IMAGINARY:
4241     modifier:
4242       {
4243         /* We keep a list of modifiers on the stack.  */
4244         struct d_print_mod dpm;
4245
4246         dpm.next = dpi->modifiers;
4247         dpi->modifiers = &dpm;
4248         dpm.mod = dc;
4249         dpm.printed = 0;
4250         dpm.templates = dpi->templates;
4251
4252         if (!mod_inner)
4253           mod_inner = d_left (dc);
4254
4255         d_print_comp (dpi, options, mod_inner);
4256
4257         /* If the modifier didn't get printed by the type, print it
4258            now.  */
4259         if (! dpm.printed)
4260           d_print_mod (dpi, options, dc);
4261
4262         dpi->modifiers = dpm.next;
4263
4264         return;
4265       }
4266
4267     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4268       if ((options & DMGL_JAVA) == 0)
4269         d_append_buffer (dpi, dc->u.s_builtin.type->name,
4270                          dc->u.s_builtin.type->len);
4271       else
4272         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
4273                          dc->u.s_builtin.type->java_len);
4274       return;
4275
4276     case DEMANGLE_COMPONENT_VENDOR_TYPE:
4277       d_print_comp (dpi, options, d_left (dc));
4278       return;
4279
4280     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4281       {
4282         if ((options & DMGL_RET_POSTFIX) != 0)
4283           d_print_function_type (dpi,
4284                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4285                                  dc, dpi->modifiers);
4286
4287         /* Print return type if present */
4288         if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
4289           d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4290                         d_left (dc));
4291         else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
4292           {
4293             struct d_print_mod dpm;
4294
4295             /* We must pass this type down as a modifier in order to
4296                print it in the right location.  */
4297             dpm.next = dpi->modifiers;
4298             dpi->modifiers = &dpm;
4299             dpm.mod = dc;
4300             dpm.printed = 0;
4301             dpm.templates = dpi->templates;
4302
4303             d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4304                           d_left (dc));
4305
4306             dpi->modifiers = dpm.next;
4307
4308             if (dpm.printed)
4309               return;
4310
4311             /* In standard prefix notation, there is a space between the
4312                return type and the function signature.  */
4313             if ((options & DMGL_RET_POSTFIX) == 0)
4314               d_append_char (dpi, ' ');
4315           }
4316
4317         if ((options & DMGL_RET_POSTFIX) == 0)
4318           d_print_function_type (dpi,
4319                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4320                                  dc, dpi->modifiers);
4321
4322         return;
4323       }
4324
4325     case DEMANGLE_COMPONENT_ARRAY_TYPE:
4326       {
4327         struct d_print_mod *hold_modifiers;
4328         struct d_print_mod adpm[4];
4329         unsigned int i;
4330         struct d_print_mod *pdpm;
4331
4332         /* We must pass this type down as a modifier in order to print
4333            multi-dimensional arrays correctly.  If the array itself is
4334            CV-qualified, we act as though the element type were
4335            CV-qualified.  We do this by copying the modifiers down
4336            rather than fiddling pointers, so that we don't wind up
4337            with a d_print_mod higher on the stack pointing into our
4338            stack frame after we return.  */
4339
4340         hold_modifiers = dpi->modifiers;
4341
4342         adpm[0].next = hold_modifiers;
4343         dpi->modifiers = &adpm[0];
4344         adpm[0].mod = dc;
4345         adpm[0].printed = 0;
4346         adpm[0].templates = dpi->templates;
4347
4348         i = 1;
4349         pdpm = hold_modifiers;
4350         while (pdpm != NULL
4351                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
4352                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
4353                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
4354           {
4355             if (! pdpm->printed)
4356               {
4357                 if (i >= sizeof adpm / sizeof adpm[0])
4358                   {
4359                     d_print_error (dpi);
4360                     return;
4361                   }
4362
4363                 adpm[i] = *pdpm;
4364                 adpm[i].next = dpi->modifiers;
4365                 dpi->modifiers = &adpm[i];
4366                 pdpm->printed = 1;
4367                 ++i;
4368               }
4369
4370             pdpm = pdpm->next;
4371           }
4372
4373         d_print_comp (dpi, options, d_right (dc));
4374
4375         dpi->modifiers = hold_modifiers;
4376
4377         if (adpm[0].printed)
4378           return;
4379
4380         while (i > 1)
4381           {
4382             --i;
4383             d_print_mod (dpi, options, adpm[i].mod);
4384           }
4385
4386         d_print_array_type (dpi, options, dc, dpi->modifiers);
4387
4388         return;
4389       }
4390
4391     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4392     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4393       {
4394         struct d_print_mod dpm;
4395
4396         dpm.next = dpi->modifiers;
4397         dpi->modifiers = &dpm;
4398         dpm.mod = dc;
4399         dpm.printed = 0;
4400         dpm.templates = dpi->templates;
4401
4402         d_print_comp (dpi, options, d_right (dc));
4403
4404         /* If the modifier didn't get printed by the type, print it
4405            now.  */
4406         if (! dpm.printed)
4407           d_print_mod (dpi, options, dc);
4408
4409         dpi->modifiers = dpm.next;
4410
4411         return;
4412       }
4413
4414     case DEMANGLE_COMPONENT_FIXED_TYPE:
4415       if (dc->u.s_fixed.sat)
4416         d_append_string (dpi, "_Sat ");
4417       /* Don't print "int _Accum".  */
4418       if (dc->u.s_fixed.length->u.s_builtin.type
4419           != &cplus_demangle_builtin_types['i'-'a'])
4420         {
4421           d_print_comp (dpi, options, dc->u.s_fixed.length);
4422           d_append_char (dpi, ' ');
4423         }
4424       if (dc->u.s_fixed.accum)
4425         d_append_string (dpi, "_Accum");
4426       else
4427         d_append_string (dpi, "_Fract");
4428       return;
4429
4430     case DEMANGLE_COMPONENT_ARGLIST:
4431     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4432       if (d_left (dc) != NULL)
4433         d_print_comp (dpi, options, d_left (dc));
4434       if (d_right (dc) != NULL)
4435         {
4436           size_t len;
4437           unsigned long int flush_count;
4438           /* Make sure ", " isn't flushed by d_append_string, otherwise
4439              dpi->len -= 2 wouldn't work.  */
4440           if (dpi->len >= sizeof (dpi->buf) - 2)
4441             d_print_flush (dpi);
4442           d_append_string (dpi, ", ");
4443           len = dpi->len;
4444           flush_count = dpi->flush_count;
4445           d_print_comp (dpi, options, d_right (dc));
4446           /* If that didn't print anything (which can happen with empty
4447              template argument packs), remove the comma and space.  */
4448           if (dpi->flush_count == flush_count && dpi->len == len)
4449             dpi->len -= 2;
4450         }
4451       return;
4452
4453     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4454       {
4455         struct demangle_component *type = d_left (dc);
4456         struct demangle_component *list = d_right (dc);
4457
4458         if (type)
4459           d_print_comp (dpi, options, type);
4460         d_append_char (dpi, '{');
4461         d_print_comp (dpi, options, list);
4462         d_append_char (dpi, '}');
4463       }
4464       return;
4465
4466     case DEMANGLE_COMPONENT_OPERATOR:
4467       {
4468         const struct demangle_operator_info *op = dc->u.s_operator.op;
4469         int len = op->len;
4470
4471         d_append_string (dpi, "operator");
4472         /* Add a space before new/delete.  */
4473         if (IS_LOWER (op->name[0]))
4474           d_append_char (dpi, ' ');
4475         /* Omit a trailing space.  */
4476         if (op->name[len-1] == ' ')
4477           --len;
4478         d_append_buffer (dpi, op->name, len);
4479         return;
4480       }
4481
4482     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4483       d_append_string (dpi, "operator ");
4484       d_print_comp (dpi, options, dc->u.s_extended_operator.name);
4485       return;
4486
4487     case DEMANGLE_COMPONENT_CAST:
4488       d_append_string (dpi, "operator ");
4489       d_print_cast (dpi, options, dc);
4490       return;
4491
4492     case DEMANGLE_COMPONENT_NULLARY:
4493       d_print_expr_op (dpi, options, d_left (dc));
4494       return;
4495
4496     case DEMANGLE_COMPONENT_UNARY:
4497       {
4498         struct demangle_component *op = d_left (dc);
4499         struct demangle_component *operand = d_right (dc);
4500         const char *code = NULL;
4501
4502         if (op->type == DEMANGLE_COMPONENT_OPERATOR)
4503           {
4504             code = op->u.s_operator.op->code;
4505             if (!strcmp (code, "ad"))
4506               {
4507                 /* Don't print the argument list for the address of a
4508                    function.  */
4509                 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
4510                     && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
4511                     && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4512                   operand = d_left (operand);
4513               }
4514             if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
4515               {
4516                 /* This indicates a suffix operator.  */
4517                 operand = d_left (operand);
4518                 d_print_subexpr (dpi, options, operand);
4519                 d_print_expr_op (dpi, options, op);
4520                 return;
4521               }
4522           }
4523
4524         if (op->type != DEMANGLE_COMPONENT_CAST)
4525           d_print_expr_op (dpi, options, op);
4526         else
4527           {
4528             d_append_char (dpi, '(');
4529             d_print_cast (dpi, options, op);
4530             d_append_char (dpi, ')');
4531           }
4532         if (code && !strcmp (code, "gs"))
4533           /* Avoid parens after '::'.  */
4534           d_print_comp (dpi, options, operand);
4535         else if (code && !strcmp (code, "st"))
4536           /* Always print parens for sizeof (type).  */
4537           {
4538             d_append_char (dpi, '(');
4539             d_print_comp (dpi, options, operand);
4540             d_append_char (dpi, ')');
4541           }
4542         else
4543           d_print_subexpr (dpi, options, operand);
4544       }
4545       return;
4546
4547     case DEMANGLE_COMPONENT_BINARY:
4548       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
4549         {
4550           d_print_error (dpi);
4551           return;
4552         }
4553
4554       if (op_is_new_cast (d_left (dc)))
4555         {
4556           d_print_expr_op (dpi, options, d_left (dc));
4557           d_append_char (dpi, '<');
4558           d_print_comp (dpi, options, d_left (d_right (dc)));
4559           d_append_string (dpi, ">(");
4560           d_print_comp (dpi, options, d_right (d_right (dc)));
4561           d_append_char (dpi, ')');
4562           return;
4563         }
4564
4565       /* We wrap an expression which uses the greater-than operator in
4566          an extra layer of parens so that it does not get confused
4567          with the '>' which ends the template parameters.  */
4568       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4569           && d_left (dc)->u.s_operator.op->len == 1
4570           && d_left (dc)->u.s_operator.op->name[0] == '>')
4571         d_append_char (dpi, '(');
4572
4573       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
4574           && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
4575         {
4576           /* Function call used in an expression should not have printed types
4577              of the function arguments.  Values of the function arguments still
4578              get printed below.  */
4579
4580           const struct demangle_component *func = d_left (d_right (dc));
4581
4582           if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
4583             d_print_error (dpi);
4584           d_print_subexpr (dpi, options, d_left (func));
4585         }
4586       else
4587         d_print_subexpr (dpi, options, d_left (d_right (dc)));
4588       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
4589         {
4590           d_append_char (dpi, '[');
4591           d_print_comp (dpi, options, d_right (d_right (dc)));
4592           d_append_char (dpi, ']');
4593         }
4594       else
4595         {
4596           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
4597             d_print_expr_op (dpi, options, d_left (dc));
4598           d_print_subexpr (dpi, options, d_right (d_right (dc)));
4599         }
4600
4601       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4602           && d_left (dc)->u.s_operator.op->len == 1
4603           && d_left (dc)->u.s_operator.op->name[0] == '>')
4604         d_append_char (dpi, ')');
4605
4606       return;
4607
4608     case DEMANGLE_COMPONENT_BINARY_ARGS:
4609       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
4610       d_print_error (dpi);
4611       return;
4612
4613     case DEMANGLE_COMPONENT_TRINARY:
4614       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
4615           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
4616         {
4617           d_print_error (dpi);
4618           return;
4619         }
4620       {
4621         struct demangle_component *op = d_left (dc);
4622         struct demangle_component *first = d_left (d_right (dc));
4623         struct demangle_component *second = d_left (d_right (d_right (dc)));
4624         struct demangle_component *third = d_right (d_right (d_right (dc)));
4625
4626         if (!strcmp (op->u.s_operator.op->code, "qu"))
4627           {
4628             d_print_subexpr (dpi, options, first);
4629             d_print_expr_op (dpi, options, op);
4630             d_print_subexpr (dpi, options, second);
4631             d_append_string (dpi, " : ");
4632             d_print_subexpr (dpi, options, third);
4633           }
4634         else
4635           {
4636             d_append_string (dpi, "new ");
4637             if (d_left (first) != NULL)
4638               {
4639                 d_print_subexpr (dpi, options, first);
4640                 d_append_char (dpi, ' ');
4641               }
4642             d_print_comp (dpi, options, second);
4643             if (third)
4644               d_print_subexpr (dpi, options, third);
4645           }
4646       }
4647       return;
4648
4649     case DEMANGLE_COMPONENT_TRINARY_ARG1:
4650     case DEMANGLE_COMPONENT_TRINARY_ARG2:
4651       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
4652       d_print_error (dpi);
4653       return;
4654
4655     case DEMANGLE_COMPONENT_LITERAL:
4656     case DEMANGLE_COMPONENT_LITERAL_NEG:
4657       {
4658         enum d_builtin_type_print tp;
4659
4660         /* For some builtin types, produce simpler output.  */
4661         tp = D_PRINT_DEFAULT;
4662         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
4663           {
4664             tp = d_left (dc)->u.s_builtin.type->print;
4665             switch (tp)
4666               {
4667               case D_PRINT_INT:
4668               case D_PRINT_UNSIGNED:
4669               case D_PRINT_LONG:
4670               case D_PRINT_UNSIGNED_LONG:
4671               case D_PRINT_LONG_LONG:
4672               case D_PRINT_UNSIGNED_LONG_LONG:
4673                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
4674                   {
4675                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4676                       d_append_char (dpi, '-');
4677                     d_print_comp (dpi, options, d_right (dc));
4678                     switch (tp)
4679                       {
4680                       default:
4681                         break;
4682                       case D_PRINT_UNSIGNED:
4683                         d_append_char (dpi, 'u');
4684                         break;
4685                       case D_PRINT_LONG:
4686                         d_append_char (dpi, 'l');
4687                         break;
4688                       case D_PRINT_UNSIGNED_LONG:
4689                         d_append_string (dpi, "ul");
4690                         break;
4691                       case D_PRINT_LONG_LONG:
4692                         d_append_string (dpi, "ll");
4693                         break;
4694                       case D_PRINT_UNSIGNED_LONG_LONG:
4695                         d_append_string (dpi, "ull");
4696                         break;
4697                       }
4698                     return;
4699                   }
4700                 break;
4701
4702               case D_PRINT_BOOL:
4703                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
4704                     && d_right (dc)->u.s_name.len == 1
4705                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
4706                   {
4707                     switch (d_right (dc)->u.s_name.s[0])
4708                       {
4709                       case '0':
4710                         d_append_string (dpi, "false");
4711                         return;
4712                       case '1':
4713                         d_append_string (dpi, "true");
4714                         return;
4715                       default:
4716                         break;
4717                       }
4718                   }
4719                 break;
4720
4721               default:
4722                 break;
4723               }
4724           }
4725
4726         d_append_char (dpi, '(');
4727         d_print_comp (dpi, options, d_left (dc));
4728         d_append_char (dpi, ')');
4729         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4730           d_append_char (dpi, '-');
4731         if (tp == D_PRINT_FLOAT)
4732           d_append_char (dpi, '[');
4733         d_print_comp (dpi, options, d_right (dc));
4734         if (tp == D_PRINT_FLOAT)
4735           d_append_char (dpi, ']');
4736       }
4737       return;
4738
4739     case DEMANGLE_COMPONENT_NUMBER:
4740       d_append_num (dpi, dc->u.s_number.number);
4741       return;
4742
4743     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4744       d_append_string (dpi, "java resource ");
4745       d_print_comp (dpi, options, d_left (dc));
4746       return;
4747
4748     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4749       d_print_comp (dpi, options, d_left (dc));
4750       d_print_comp (dpi, options, d_right (dc));
4751       return;
4752
4753     case DEMANGLE_COMPONENT_CHARACTER:
4754       d_append_char (dpi, dc->u.s_character.character);
4755       return;
4756
4757     case DEMANGLE_COMPONENT_DECLTYPE:
4758       d_append_string (dpi, "decltype (");
4759       d_print_comp (dpi, options, d_left (dc));
4760       d_append_char (dpi, ')');
4761       return;
4762
4763     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4764       {
4765         int len;
4766         int i;
4767         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4768         if (a == NULL)
4769           {
4770             /* d_find_pack won't find anything if the only packs involved
4771                in this expansion are function parameter packs; in that
4772                case, just print the pattern and "...".  */
4773             d_print_subexpr (dpi, options, d_left (dc));
4774             d_append_string (dpi, "...");
4775             return;
4776           }
4777
4778         len = d_pack_length (a);
4779         dc = d_left (dc);
4780         for (i = 0; i < len; ++i)
4781           {
4782             dpi->pack_index = i;
4783             d_print_comp (dpi, options, dc);
4784             if (i < len-1)
4785               d_append_string (dpi, ", ");
4786           }
4787       }
4788       return;
4789
4790     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4791       {
4792         long num = dc->u.s_number.number;
4793         if (num == 0)
4794           d_append_string (dpi, "this");
4795         else
4796           {
4797             d_append_string (dpi, "{parm#");
4798             d_append_num (dpi, num);
4799             d_append_char (dpi, '}');
4800           }
4801       }
4802       return;
4803
4804     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4805       d_append_string (dpi, "global constructors keyed to ");
4806       d_print_comp (dpi, options, dc->u.s_binary.left);
4807       return;
4808
4809     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4810       d_append_string (dpi, "global destructors keyed to ");
4811       d_print_comp (dpi, options, dc->u.s_binary.left);
4812       return;
4813
4814     case DEMANGLE_COMPONENT_LAMBDA:
4815       d_append_string (dpi, "{lambda(");
4816       d_print_comp (dpi, options, dc->u.s_unary_num.sub);
4817       d_append_string (dpi, ")#");
4818       d_append_num (dpi, dc->u.s_unary_num.num + 1);
4819       d_append_char (dpi, '}');
4820       return;
4821
4822     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4823       d_append_string (dpi, "{unnamed type#");
4824       d_append_num (dpi, dc->u.s_number.number + 1);
4825       d_append_char (dpi, '}');
4826       return;
4827
4828     case DEMANGLE_COMPONENT_CLONE:
4829       d_print_comp (dpi, options, d_left (dc));
4830       d_append_string (dpi, " [clone ");
4831       d_print_comp (dpi, options, d_right (dc));
4832       d_append_char (dpi, ']');
4833       return;
4834
4835     default:
4836       d_print_error (dpi);
4837       return;
4838     }
4839 }
4840
4841 /* Print a Java dentifier.  For Java we try to handle encoded extended
4842    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
4843    so we don't it for C++.  Characters are encoded as
4844    __U<hex-char>+_.  */
4845
4846 static void
4847 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4848 {
4849   const char *p;
4850   const char *end;
4851
4852   end = name + len;
4853   for (p = name; p < end; ++p)
4854     {
4855       if (end - p > 3
4856           && p[0] == '_'
4857           && p[1] == '_'
4858           && p[2] == 'U')
4859         {
4860           unsigned long c;
4861           const char *q;
4862
4863           c = 0;
4864           for (q = p + 3; q < end; ++q)
4865             {
4866               int dig;
4867
4868               if (IS_DIGIT (*q))
4869                 dig = *q - '0';
4870               else if (*q >= 'A' && *q <= 'F')
4871                 dig = *q - 'A' + 10;
4872               else if (*q >= 'a' && *q <= 'f')
4873                 dig = *q - 'a' + 10;
4874               else
4875                 break;
4876
4877               c = c * 16 + dig;
4878             }
4879           /* If the Unicode character is larger than 256, we don't try
4880              to deal with it here.  FIXME.  */
4881           if (q < end && *q == '_' && c < 256)
4882             {
4883               d_append_char (dpi, c);
4884               p = q;
4885               continue;
4886             }
4887         }
4888
4889       d_append_char (dpi, *p);
4890     }
4891 }
4892
4893 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
4894    qualifiers on this after printing a function.  */
4895
4896 static void
4897 d_print_mod_list (struct d_print_info *dpi, int options,
4898                   struct d_print_mod *mods, int suffix)
4899 {
4900   struct d_print_template *hold_dpt;
4901
4902   if (mods == NULL || d_print_saw_error (dpi))
4903     return;
4904
4905   if (mods->printed
4906       || (! suffix
4907           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4908               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4909               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4910     {
4911       d_print_mod_list (dpi, options, mods->next, suffix);
4912       return;
4913     }
4914
4915   mods->printed = 1;
4916
4917   hold_dpt = dpi->templates;
4918   dpi->templates = mods->templates;
4919
4920   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4921     {
4922       d_print_function_type (dpi, options, mods->mod, mods->next);
4923       dpi->templates = hold_dpt;
4924       return;
4925     }
4926   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4927     {
4928       d_print_array_type (dpi, options, mods->mod, mods->next);
4929       dpi->templates = hold_dpt;
4930       return;
4931     }
4932   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4933     {
4934       struct d_print_mod *hold_modifiers;
4935       struct demangle_component *dc;
4936
4937       /* When this is on the modifier stack, we have pulled any
4938          qualifiers off the right argument already.  Otherwise, we
4939          print it as usual, but don't let the left argument see any
4940          modifiers.  */
4941
4942       hold_modifiers = dpi->modifiers;
4943       dpi->modifiers = NULL;
4944       d_print_comp (dpi, options, d_left (mods->mod));
4945       dpi->modifiers = hold_modifiers;
4946
4947       if ((options & DMGL_JAVA) == 0)
4948         d_append_string (dpi, "::");
4949       else
4950         d_append_char (dpi, '.');
4951
4952       dc = d_right (mods->mod);
4953
4954       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4955         {
4956           d_append_string (dpi, "{default arg#");
4957           d_append_num (dpi, dc->u.s_unary_num.num + 1);
4958           d_append_string (dpi, "}::");
4959           dc = dc->u.s_unary_num.sub;
4960         }
4961
4962       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4963              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4964              || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4965         dc = d_left (dc);
4966
4967       d_print_comp (dpi, options, dc);
4968
4969       dpi->templates = hold_dpt;
4970       return;
4971     }
4972
4973   d_print_mod (dpi, options, mods->mod);
4974
4975   dpi->templates = hold_dpt;
4976
4977   d_print_mod_list (dpi, options, mods->next, suffix);
4978 }
4979
4980 /* Print a modifier.  */
4981
4982 static void
4983 d_print_mod (struct d_print_info *dpi, int options,
4984              const struct demangle_component *mod)
4985 {
4986   switch (mod->type)
4987     {
4988     case DEMANGLE_COMPONENT_RESTRICT:
4989     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4990       d_append_string (dpi, " restrict");
4991       return;
4992     case DEMANGLE_COMPONENT_VOLATILE:
4993     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4994       d_append_string (dpi, " volatile");
4995       return;
4996     case DEMANGLE_COMPONENT_CONST:
4997     case DEMANGLE_COMPONENT_CONST_THIS:
4998       d_append_string (dpi, " const");
4999       return;
5000     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5001       d_append_char (dpi, ' ');
5002       d_print_comp (dpi, options, d_right (mod));
5003       return;
5004     case DEMANGLE_COMPONENT_POINTER:
5005       /* There is no pointer symbol in Java.  */
5006       if ((options & DMGL_JAVA) == 0)
5007         d_append_char (dpi, '*');
5008       return;
5009     case DEMANGLE_COMPONENT_REFERENCE:
5010       d_append_char (dpi, '&');
5011       return;
5012     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5013       d_append_string (dpi, "&&");
5014       return;
5015     case DEMANGLE_COMPONENT_COMPLEX:
5016       d_append_string (dpi, "complex ");
5017       return;
5018     case DEMANGLE_COMPONENT_IMAGINARY:
5019       d_append_string (dpi, "imaginary ");
5020       return;
5021     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5022       if (d_last_char (dpi) != '(')
5023         d_append_char (dpi, ' ');
5024       d_print_comp (dpi, options, d_left (mod));
5025       d_append_string (dpi, "::*");
5026       return;
5027     case DEMANGLE_COMPONENT_TYPED_NAME:
5028       d_print_comp (dpi, options, d_left (mod));
5029       return;
5030     case DEMANGLE_COMPONENT_VECTOR_TYPE:
5031       d_append_string (dpi, " __vector(");
5032       d_print_comp (dpi, options, d_left (mod));
5033       d_append_char (dpi, ')');
5034       return;
5035
5036     default:
5037       /* Otherwise, we have something that won't go back on the
5038          modifier stack, so we can just print it.  */
5039       d_print_comp (dpi, options, mod);
5040       return;
5041     }
5042 }
5043
5044 /* Print a function type, except for the return type.  */
5045
5046 static void
5047 d_print_function_type (struct d_print_info *dpi, int options,
5048                        const struct demangle_component *dc,
5049                        struct d_print_mod *mods)
5050 {
5051   int need_paren;
5052   int need_space;
5053   struct d_print_mod *p;
5054   struct d_print_mod *hold_modifiers;
5055
5056   need_paren = 0;
5057   need_space = 0;
5058   for (p = mods; p != NULL; p = p->next)
5059     {
5060       if (p->printed)
5061         break;
5062
5063       switch (p->mod->type)
5064         {
5065         case DEMANGLE_COMPONENT_POINTER:
5066         case DEMANGLE_COMPONENT_REFERENCE:
5067         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5068           need_paren = 1;
5069           break;
5070         case DEMANGLE_COMPONENT_RESTRICT:
5071         case DEMANGLE_COMPONENT_VOLATILE:
5072         case DEMANGLE_COMPONENT_CONST:
5073         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5074         case DEMANGLE_COMPONENT_COMPLEX:
5075         case DEMANGLE_COMPONENT_IMAGINARY:
5076         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5077           need_space = 1;
5078           need_paren = 1;
5079           break;
5080         case DEMANGLE_COMPONENT_RESTRICT_THIS:
5081         case DEMANGLE_COMPONENT_VOLATILE_THIS:
5082         case DEMANGLE_COMPONENT_CONST_THIS:
5083           break;
5084         default:
5085           break;
5086         }
5087       if (need_paren)
5088         break;
5089     }
5090
5091   if (need_paren)
5092     {
5093       if (! need_space)
5094         {
5095           if (d_last_char (dpi) != '('
5096               && d_last_char (dpi) != '*')
5097             need_space = 1;
5098         }
5099       if (need_space && d_last_char (dpi) != ' ')
5100         d_append_char (dpi, ' ');
5101       d_append_char (dpi, '(');
5102     }
5103
5104   hold_modifiers = dpi->modifiers;
5105   dpi->modifiers = NULL;
5106
5107   d_print_mod_list (dpi, options, mods, 0);
5108
5109   if (need_paren)
5110     d_append_char (dpi, ')');
5111
5112   d_append_char (dpi, '(');
5113
5114   if (d_right (dc) != NULL)
5115     d_print_comp (dpi, options, d_right (dc));
5116
5117   d_append_char (dpi, ')');
5118
5119   d_print_mod_list (dpi, options, mods, 1);
5120
5121   dpi->modifiers = hold_modifiers;
5122 }
5123
5124 /* Print an array type, except for the element type.  */
5125
5126 static void
5127 d_print_array_type (struct d_print_info *dpi, int options,
5128                     const struct demangle_component *dc,
5129                     struct d_print_mod *mods)
5130 {
5131   int need_space;
5132
5133   need_space = 1;
5134   if (mods != NULL)
5135     {
5136       int need_paren;
5137       struct d_print_mod *p;
5138
5139       need_paren = 0;
5140       for (p = mods; p != NULL; p = p->next)
5141         {
5142           if (! p->printed)
5143             {
5144               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5145                 {
5146                   need_space = 0;
5147                   break;
5148                 }
5149               else
5150                 {
5151                   need_paren = 1;
5152                   need_space = 1;
5153                   break;
5154                 }
5155             }
5156         }
5157
5158       if (need_paren)
5159         d_append_string (dpi, " (");
5160
5161       d_print_mod_list (dpi, options, mods, 0);
5162
5163       if (need_paren)
5164         d_append_char (dpi, ')');
5165     }
5166
5167   if (need_space)
5168     d_append_char (dpi, ' ');
5169
5170   d_append_char (dpi, '[');
5171
5172   if (d_left (dc) != NULL)
5173     d_print_comp (dpi, options, d_left (dc));
5174
5175   d_append_char (dpi, ']');
5176 }
5177
5178 /* Print an operator in an expression.  */
5179
5180 static void
5181 d_print_expr_op (struct d_print_info *dpi, int options,
5182                  const struct demangle_component *dc)
5183 {
5184   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
5185     d_append_buffer (dpi, dc->u.s_operator.op->name,
5186                      dc->u.s_operator.op->len);
5187   else
5188     d_print_comp (dpi, options, dc);
5189 }
5190
5191 /* Print a cast.  */
5192
5193 static void
5194 d_print_cast (struct d_print_info *dpi, int options,
5195               const struct demangle_component *dc)
5196 {
5197   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
5198     d_print_comp (dpi, options, d_left (dc));
5199   else
5200     {
5201       struct d_print_mod *hold_dpm;
5202       struct d_print_template dpt;
5203
5204       /* It appears that for a templated cast operator, we need to put
5205          the template parameters in scope for the operator name, but
5206          not for the parameters.  The effect is that we need to handle
5207          the template printing here.  */
5208
5209       hold_dpm = dpi->modifiers;
5210       dpi->modifiers = NULL;
5211
5212       dpt.next = dpi->templates;
5213       dpi->templates = &dpt;
5214       dpt.template_decl = d_left (dc);
5215
5216       d_print_comp (dpi, options, d_left (d_left (dc)));
5217
5218       dpi->templates = dpt.next;
5219
5220       if (d_last_char (dpi) == '<')
5221         d_append_char (dpi, ' ');
5222       d_append_char (dpi, '<');
5223       d_print_comp (dpi, options, d_right (d_left (dc)));
5224       /* Avoid generating two consecutive '>' characters, to avoid
5225          the C++ syntactic ambiguity.  */
5226       if (d_last_char (dpi) == '>')
5227         d_append_char (dpi, ' ');
5228       d_append_char (dpi, '>');
5229
5230       dpi->modifiers = hold_dpm;
5231     }
5232 }
5233
5234 /* Initialize the information structure we use to pass around
5235    information.  */
5236
5237 CP_STATIC_IF_GLIBCPP_V3
5238 void
5239 cplus_demangle_init_info (const char *mangled, int options, size_t len,
5240                           struct d_info *di)
5241 {
5242   di->s = mangled;
5243   di->send = mangled + len;
5244   di->options = options;
5245
5246   di->n = mangled;
5247
5248   /* We can not need more components than twice the number of chars in
5249      the mangled string.  Most components correspond directly to
5250      chars, but the ARGLIST types are exceptions.  */
5251   di->num_comps = 2 * len;
5252   di->next_comp = 0;
5253
5254   /* Similarly, we can not need more substitutions than there are
5255      chars in the mangled string.  */
5256   di->num_subs = len;
5257   di->next_sub = 0;
5258   di->did_subs = 0;
5259
5260   di->last_name = NULL;
5261
5262   di->expansion = 0;
5263 }
5264
5265 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
5266    mangled name, return strings in repeated callback giving the demangled
5267    name.  OPTIONS is the usual libiberty demangler options.  On success,
5268    this returns 1.  On failure, returns 0.  */
5269
5270 static int
5271 d_demangle_callback (const char *mangled, int options,
5272                      demangle_callbackref callback, void *opaque)
5273 {
5274   enum
5275     {
5276       DCT_TYPE,
5277       DCT_MANGLED,
5278       DCT_GLOBAL_CTORS,
5279       DCT_GLOBAL_DTORS
5280     }
5281   type;
5282   struct d_info di;
5283   struct demangle_component *dc;
5284   int status;
5285
5286   if (mangled[0] == '_' && mangled[1] == 'Z')
5287     type = DCT_MANGLED;
5288   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
5289            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
5290            && (mangled[9] == 'D' || mangled[9] == 'I')
5291            && mangled[10] == '_')
5292     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
5293   else
5294     {
5295       if ((options & DMGL_TYPES) == 0)
5296         return 0;
5297       type = DCT_TYPE;
5298     }
5299
5300   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
5301
5302   {
5303 #ifdef CP_DYNAMIC_ARRAYS
5304     __extension__ struct demangle_component comps[di.num_comps];
5305     __extension__ struct demangle_component *subs[di.num_subs];
5306
5307     di.comps = comps;
5308     di.subs = subs;
5309 #else
5310     di.comps = alloca (di.num_comps * sizeof (*di.comps));
5311     di.subs = alloca (di.num_subs * sizeof (*di.subs));
5312 #endif
5313
5314     switch (type)
5315       {
5316       case DCT_TYPE:
5317         dc = cplus_demangle_type (&di);
5318         break;
5319       case DCT_MANGLED:
5320         dc = cplus_demangle_mangled_name (&di, 1);
5321         break;
5322       case DCT_GLOBAL_CTORS:
5323       case DCT_GLOBAL_DTORS:
5324         d_advance (&di, 11);
5325         dc = d_make_comp (&di,
5326                           (type == DCT_GLOBAL_CTORS
5327                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
5328                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
5329                           d_make_demangle_mangled_name (&di, d_str (&di)),
5330                           NULL);
5331         d_advance (&di, strlen (d_str (&di)));
5332         break;
5333       }
5334
5335     /* If DMGL_PARAMS is set, then if we didn't consume the entire
5336        mangled string, then we didn't successfully demangle it.  If
5337        DMGL_PARAMS is not set, we didn't look at the trailing
5338        parameters.  */
5339     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
5340       dc = NULL;
5341
5342 #ifdef CP_DEMANGLE_DEBUG
5343     d_dump (dc, 0);
5344 #endif
5345
5346     status = (dc != NULL)
5347              ? cplus_demangle_print_callback (options, dc, callback, opaque)
5348              : 0;
5349   }
5350
5351   return status;
5352 }
5353
5354 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
5355    name, return a buffer allocated with malloc holding the demangled
5356    name.  OPTIONS is the usual libiberty demangler options.  On
5357    success, this sets *PALC to the allocated size of the returned
5358    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
5359    a memory allocation failure, and returns NULL.  */
5360
5361 static char *
5362 d_demangle (const char *mangled, int options, size_t *palc)
5363 {
5364   struct d_growable_string dgs;
5365   int status;
5366
5367   d_growable_string_init (&dgs, 0);
5368
5369   status = d_demangle_callback (mangled, options,
5370                                 d_growable_string_callback_adapter, &dgs);
5371   if (status == 0)
5372     {
5373       free (dgs.buf);
5374       *palc = 0;
5375       return NULL;
5376     }
5377
5378   *palc = dgs.allocation_failure ? 1 : dgs.alc;
5379   return dgs.buf;
5380 }
5381
5382 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
5383
5384 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
5385
5386 /* ia64 ABI-mandated entry point in the C++ runtime library for
5387    performing demangling.  MANGLED_NAME is a NUL-terminated character
5388    string containing the name to be demangled.
5389
5390    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
5391    *LENGTH bytes, into which the demangled name is stored.  If
5392    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
5393    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
5394    is placed in a region of memory allocated with malloc.
5395
5396    If LENGTH is non-NULL, the length of the buffer containing the
5397    demangled name, is placed in *LENGTH.
5398
5399    The return value is a pointer to the start of the NUL-terminated
5400    demangled name, or NULL if the demangling fails.  The caller is
5401    responsible for deallocating this memory using free.
5402
5403    *STATUS is set to one of the following values:
5404       0: The demangling operation succeeded.
5405      -1: A memory allocation failure occurred.
5406      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5407      -3: One of the arguments is invalid.
5408
5409    The demangling is performed using the C++ ABI mangling rules, with
5410    GNU extensions.  */
5411
5412 char *
5413 __cxa_demangle (const char *mangled_name, char *output_buffer,
5414                 size_t *length, int *status)
5415 {
5416   char *demangled;
5417   size_t alc;
5418
5419   if (mangled_name == NULL)
5420     {
5421       if (status != NULL)
5422         *status = -3;
5423       return NULL;
5424     }
5425
5426   if (output_buffer != NULL && length == NULL)
5427     {
5428       if (status != NULL)
5429         *status = -3;
5430       return NULL;
5431     }
5432
5433   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
5434
5435   if (demangled == NULL)
5436     {
5437       if (status != NULL)
5438         {
5439           if (alc == 1)
5440             *status = -1;
5441           else
5442             *status = -2;
5443         }
5444       return NULL;
5445     }
5446
5447   if (output_buffer == NULL)
5448     {
5449       if (length != NULL)
5450         *length = alc;
5451     }
5452   else
5453     {
5454       if (strlen (demangled) < *length)
5455         {
5456           strcpy (output_buffer, demangled);
5457           free (demangled);
5458           demangled = output_buffer;
5459         }
5460       else
5461         {
5462           free (output_buffer);
5463           *length = alc;
5464         }
5465     }
5466
5467   if (status != NULL)
5468     *status = 0;
5469
5470   return demangled;
5471 }
5472
5473 extern int __gcclibcxx_demangle_callback (const char *,
5474                                           void (*)
5475                                             (const char *, size_t, void *),
5476                                           void *);
5477
5478 /* Alternative, allocationless entry point in the C++ runtime library
5479    for performing demangling.  MANGLED_NAME is a NUL-terminated character
5480    string containing the name to be demangled.
5481
5482    CALLBACK is a callback function, called with demangled string
5483    segments as demangling progresses; it is called at least once,
5484    but may be called more than once.  OPAQUE is a generalized pointer
5485    used as a callback argument.
5486
5487    The return code is one of the following values, equivalent to
5488    the STATUS values of __cxa_demangle() (excluding -1, since this
5489    function performs no memory allocations):
5490       0: The demangling operation succeeded.
5491      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5492      -3: One of the arguments is invalid.
5493
5494    The demangling is performed using the C++ ABI mangling rules, with
5495    GNU extensions.  */
5496
5497 int
5498 __gcclibcxx_demangle_callback (const char *mangled_name,
5499                                void (*callback) (const char *, size_t, void *),
5500                                void *opaque)
5501 {
5502   int status;
5503
5504   if (mangled_name == NULL || callback == NULL)
5505     return -3;
5506
5507   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
5508                                 callback, opaque);
5509   if (status == 0)
5510     return -2;
5511
5512   return 0;
5513 }
5514
5515 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5516
5517 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
5518    mangled name, return a buffer allocated with malloc holding the
5519    demangled name.  Otherwise, return NULL.  */
5520
5521 char *
5522 cplus_demangle_v3 (const char *mangled, int options)
5523 {
5524   size_t alc;
5525
5526   return d_demangle (mangled, options, &alc);
5527 }
5528
5529 int
5530 cplus_demangle_v3_callback (const char *mangled, int options,
5531                             demangle_callbackref callback, void *opaque)
5532 {
5533   return d_demangle_callback (mangled, options, callback, opaque);
5534 }
5535
5536 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
5537    conventions, but the output formatting is a little different.
5538    This instructs the C++ demangler not to emit pointer characters ("*"), to
5539    use Java's namespace separator symbol ("." instead of "::"), and to output
5540    JArray<TYPE> as TYPE[].  */
5541
5542 char *
5543 java_demangle_v3 (const char *mangled)
5544 {
5545   size_t alc;
5546
5547   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
5548 }
5549
5550 int
5551 java_demangle_v3_callback (const char *mangled,
5552                            demangle_callbackref callback, void *opaque)
5553 {
5554   return d_demangle_callback (mangled,
5555                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
5556                               callback, opaque);
5557 }
5558
5559 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5560
5561 #ifndef IN_GLIBCPP_V3
5562
5563 /* Demangle a string in order to find out whether it is a constructor
5564    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
5565    *DTOR_KIND appropriately.  */
5566
5567 static int
5568 is_ctor_or_dtor (const char *mangled,
5569                  enum gnu_v3_ctor_kinds *ctor_kind,
5570                  enum gnu_v3_dtor_kinds *dtor_kind)
5571 {
5572   struct d_info di;
5573   struct demangle_component *dc;
5574   int ret;
5575
5576   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
5577   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
5578
5579   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
5580
5581   {
5582 #ifdef CP_DYNAMIC_ARRAYS
5583     __extension__ struct demangle_component comps[di.num_comps];
5584     __extension__ struct demangle_component *subs[di.num_subs];
5585
5586     di.comps = comps;
5587     di.subs = subs;
5588 #else
5589     di.comps = alloca (di.num_comps * sizeof (*di.comps));
5590     di.subs = alloca (di.num_subs * sizeof (*di.subs));
5591 #endif
5592
5593     dc = cplus_demangle_mangled_name (&di, 1);
5594
5595     /* Note that because we did not pass DMGL_PARAMS, we don't expect
5596        to demangle the entire string.  */
5597
5598     ret = 0;
5599     while (dc != NULL)
5600       {
5601         switch (dc->type)
5602           {
5603           default:
5604             dc = NULL;
5605             break;
5606           case DEMANGLE_COMPONENT_TYPED_NAME:
5607           case DEMANGLE_COMPONENT_TEMPLATE:
5608           case DEMANGLE_COMPONENT_RESTRICT_THIS:
5609           case DEMANGLE_COMPONENT_VOLATILE_THIS:
5610           case DEMANGLE_COMPONENT_CONST_THIS:
5611             dc = d_left (dc);
5612             break;
5613           case DEMANGLE_COMPONENT_QUAL_NAME:
5614           case DEMANGLE_COMPONENT_LOCAL_NAME:
5615             dc = d_right (dc);
5616             break;
5617           case DEMANGLE_COMPONENT_CTOR:
5618             *ctor_kind = dc->u.s_ctor.kind;
5619             ret = 1;
5620             dc = NULL;
5621             break;
5622           case DEMANGLE_COMPONENT_DTOR:
5623             *dtor_kind = dc->u.s_dtor.kind;
5624             ret = 1;
5625             dc = NULL;
5626             break;
5627           }
5628       }
5629   }
5630
5631   return ret;
5632 }
5633
5634 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5635    name.  A non-zero return indicates the type of constructor.  */
5636
5637 enum gnu_v3_ctor_kinds
5638 is_gnu_v3_mangled_ctor (const char *name)
5639 {
5640   enum gnu_v3_ctor_kinds ctor_kind;
5641   enum gnu_v3_dtor_kinds dtor_kind;
5642
5643   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5644     return (enum gnu_v3_ctor_kinds) 0;
5645   return ctor_kind;
5646 }
5647
5648
5649 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5650    name.  A non-zero return indicates the type of destructor.  */
5651
5652 enum gnu_v3_dtor_kinds
5653 is_gnu_v3_mangled_dtor (const char *name)
5654 {
5655   enum gnu_v3_ctor_kinds ctor_kind;
5656   enum gnu_v3_dtor_kinds dtor_kind;
5657
5658   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5659     return (enum gnu_v3_dtor_kinds) 0;
5660   return dtor_kind;
5661 }
5662
5663 #endif /* IN_GLIBCPP_V3 */
5664
5665 #ifdef STANDALONE_DEMANGLER
5666
5667 #include "getopt.h"
5668 #include "dyn-string.h"
5669
5670 static void print_usage (FILE* fp, int exit_value);
5671
5672 #define IS_ALPHA(CHAR)                                                  \
5673   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
5674    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5675
5676 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
5677 #define is_mangled_char(CHAR)                                           \
5678   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
5679    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5680
5681 /* The name of this program, as invoked.  */
5682 const char* program_name;
5683
5684 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
5685
5686 static void
5687 print_usage (FILE* fp, int exit_value)
5688 {
5689   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
5690   fprintf (fp, "Options:\n");
5691   fprintf (fp, "  -h,--help       Display this message.\n");
5692   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
5693   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
5694   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
5695
5696   exit (exit_value);
5697 }
5698
5699 /* Option specification for getopt_long.  */
5700 static const struct option long_options[] =
5701 {
5702   { "help",      no_argument, NULL, 'h' },
5703   { "no-params", no_argument, NULL, 'p' },
5704   { "verbose",   no_argument, NULL, 'v' },
5705   { NULL,        no_argument, NULL, 0   },
5706 };
5707
5708 /* Main entry for a demangling filter executable.  It will demangle
5709    its command line arguments, if any.  If none are provided, it will
5710    filter stdin to stdout, replacing any recognized mangled C++ names
5711    with their demangled equivalents.  */
5712
5713 int
5714 main (int argc, char *argv[])
5715 {
5716   int i;
5717   int opt_char;
5718   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
5719
5720   /* Use the program name of this program, as invoked.  */
5721   program_name = argv[0];
5722
5723   /* Parse options.  */
5724   do
5725     {
5726       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
5727       switch (opt_char)
5728         {
5729         case '?':  /* Unrecognized option.  */
5730           print_usage (stderr, 1);
5731           break;
5732
5733         case 'h':
5734           print_usage (stdout, 0);
5735           break;
5736
5737         case 'p':
5738           options &= ~ DMGL_PARAMS;
5739           break;
5740
5741         case 'v':
5742           options |= DMGL_VERBOSE;
5743           break;
5744         }
5745     }
5746   while (opt_char != -1);
5747
5748   if (optind == argc)
5749     /* No command line arguments were provided.  Filter stdin.  */
5750     {
5751       dyn_string_t mangled = dyn_string_new (3);
5752       char *s;
5753
5754       /* Read all of input.  */
5755       while (!feof (stdin))
5756         {
5757           char c;
5758
5759           /* Pile characters into mangled until we hit one that can't
5760              occur in a mangled name.  */
5761           c = getchar ();
5762           while (!feof (stdin) && is_mangled_char (c))
5763             {
5764               dyn_string_append_char (mangled, c);
5765               if (feof (stdin))
5766                 break;
5767               c = getchar ();
5768             }
5769
5770           if (dyn_string_length (mangled) > 0)
5771             {
5772 #ifdef IN_GLIBCPP_V3
5773               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
5774 #else
5775               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5776 #endif
5777
5778               if (s != NULL)
5779                 {
5780                   fputs (s, stdout);
5781                   free (s);
5782                 }
5783               else
5784                 {
5785                   /* It might not have been a mangled name.  Print the
5786                      original text.  */
5787                   fputs (dyn_string_buf (mangled), stdout);
5788                 }
5789
5790               dyn_string_clear (mangled);
5791             }
5792
5793           /* If we haven't hit EOF yet, we've read one character that
5794              can't occur in a mangled name, so print it out.  */
5795           if (!feof (stdin))
5796             putchar (c);
5797         }
5798
5799       dyn_string_delete (mangled);
5800     }
5801   else
5802     /* Demangle command line arguments.  */
5803     {
5804       /* Loop over command line arguments.  */
5805       for (i = optind; i < argc; ++i)
5806         {
5807           char *s;
5808 #ifdef IN_GLIBCPP_V3
5809           int status;
5810 #endif
5811
5812           /* Attempt to demangle.  */
5813 #ifdef IN_GLIBCPP_V3
5814           s = __cxa_demangle (argv[i], NULL, NULL, &status);
5815 #else
5816           s = cplus_demangle_v3 (argv[i], options);
5817 #endif
5818
5819           /* If it worked, print the demangled name.  */
5820           if (s != NULL)
5821             {
5822               printf ("%s\n", s);
5823               free (s);
5824             }
5825           else
5826             {
5827 #ifdef IN_GLIBCPP_V3
5828               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5829 #else
5830               fprintf (stderr, "Failed: %s\n", argv[i]);
5831 #endif
5832             }
5833         }
5834     }
5835
5836   return 0;
5837 }
5838
5839 #endif /* STANDALONE_DEMANGLER */