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