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       if (d_peek_char (di) == 'F')
2202         {
2203           /* cv-qualifiers before a function type apply to 'this',
2204              so avoid adding the unqualified function type to
2205              the substitution list.  */
2206           *pret = d_function_type (di);
2207         }
2208       else
2209         *pret = cplus_demangle_type (di);
2210       if (!*pret)
2211         return NULL;
2212       if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2213           || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
2214         {
2215           /* Move the ref-qualifier outside the cv-qualifiers so that
2216              they are printed in the right order.  */
2217           struct demangle_component *fn = d_left (*pret);
2218           d_left (*pret) = ret;
2219           ret = *pret;
2220           *pret = fn;
2221         }
2222       if (! d_add_substitution (di, ret))
2223         return NULL;
2224       return ret;
2225     }
2226
2227   can_subst = 1;
2228
2229   switch (peek)
2230     {
2231     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2232     case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
2233     case 'o':                               case 's': case 't':
2234     case 'v': case 'w': case 'x': case 'y': case 'z':
2235       ret = d_make_builtin_type (di,
2236                                  &cplus_demangle_builtin_types[peek - 'a']);
2237       di->expansion += ret->u.s_builtin.type->len;
2238       can_subst = 0;
2239       d_advance (di, 1);
2240       break;
2241
2242     case 'u':
2243       d_advance (di, 1);
2244       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2245                          d_source_name (di), NULL);
2246       break;
2247
2248     case 'F':
2249       ret = d_function_type (di);
2250       break;
2251
2252     case '0': case '1': case '2': case '3': case '4':
2253     case '5': case '6': case '7': case '8': case '9':
2254     case 'N':
2255     case 'Z':
2256       ret = d_class_enum_type (di);
2257       break;
2258
2259     case 'A':
2260       ret = d_array_type (di);
2261       break;
2262
2263     case 'M':
2264       ret = d_pointer_to_member_type (di);
2265       break;
2266
2267     case 'T':
2268       ret = d_template_param (di);
2269       if (d_peek_char (di) == 'I')
2270         {
2271           /* This is <template-template-param> <template-args>.  The
2272              <template-template-param> part is a substitution
2273              candidate.  */
2274           if (! d_add_substitution (di, ret))
2275             return NULL;
2276           ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2277                              d_template_args (di));
2278         }
2279       break;
2280
2281     case 'S':
2282       /* If this is a special substitution, then it is the start of
2283          <class-enum-type>.  */
2284       {
2285         char peek_next;
2286
2287         peek_next = d_peek_next_char (di);
2288         if (IS_DIGIT (peek_next)
2289             || peek_next == '_'
2290             || IS_UPPER (peek_next))
2291           {
2292             ret = d_substitution (di, 0);
2293             /* The substituted name may have been a template name and
2294                may be followed by tepmlate args.  */
2295             if (d_peek_char (di) == 'I')
2296               ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2297                                  d_template_args (di));
2298             else
2299               can_subst = 0;
2300           }
2301         else
2302           {
2303             ret = d_class_enum_type (di);
2304             /* If the substitution was a complete type, then it is not
2305                a new substitution candidate.  However, if the
2306                substitution was followed by template arguments, then
2307                the whole thing is a substitution candidate.  */
2308             if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2309               can_subst = 0;
2310           }
2311       }
2312       break;
2313
2314     case 'O':
2315       d_advance (di, 1);
2316       ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2317                          cplus_demangle_type (di), NULL);
2318       break;
2319
2320     case 'P':
2321       d_advance (di, 1);
2322       ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2323                          cplus_demangle_type (di), NULL);
2324       break;
2325
2326     case 'R':
2327       d_advance (di, 1);
2328       ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2329                          cplus_demangle_type (di), NULL);
2330       break;
2331
2332     case 'C':
2333       d_advance (di, 1);
2334       ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2335                          cplus_demangle_type (di), NULL);
2336       break;
2337
2338     case 'G':
2339       d_advance (di, 1);
2340       ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2341                          cplus_demangle_type (di), NULL);
2342       break;
2343
2344     case 'U':
2345       d_advance (di, 1);
2346       ret = d_source_name (di);
2347       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2348                          cplus_demangle_type (di), ret);
2349       break;
2350
2351     case 'D':
2352       can_subst = 0;
2353       d_advance (di, 1);
2354       peek = d_next_char (di);
2355       switch (peek)
2356         {
2357         case 'T':
2358         case 't':
2359           /* decltype (expression) */
2360           ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2361                              d_expression (di), NULL);
2362           if (ret && d_next_char (di) != 'E')
2363             ret = NULL;
2364           can_subst = 1;
2365           break;
2366
2367         case 'p':
2368           /* Pack expansion.  */
2369           ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2370                              cplus_demangle_type (di), NULL);
2371           can_subst = 1;
2372           break;
2373
2374         case 'a':
2375           /* auto */
2376           ret = d_make_name (di, "auto", 4);
2377           break;
2378
2379         case 'f':
2380           /* 32-bit decimal floating point */
2381           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2382           di->expansion += ret->u.s_builtin.type->len;
2383           break;
2384         case 'd':
2385           /* 64-bit DFP */
2386           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2387           di->expansion += ret->u.s_builtin.type->len;
2388           break;
2389         case 'e':
2390           /* 128-bit DFP */
2391           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2392           di->expansion += ret->u.s_builtin.type->len;
2393           break;
2394         case 'h':
2395           /* 16-bit half-precision FP */
2396           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2397           di->expansion += ret->u.s_builtin.type->len;
2398           break;
2399         case 's':
2400           /* char16_t */
2401           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2402           di->expansion += ret->u.s_builtin.type->len;
2403           break;
2404         case 'i':
2405           /* char32_t */
2406           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2407           di->expansion += ret->u.s_builtin.type->len;
2408           break;
2409
2410         case 'F':
2411           /* Fixed point types. DF<int bits><length><fract bits><sat>  */
2412           ret = d_make_empty (di);
2413           ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2414           if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2415             /* For demangling we don't care about the bits.  */
2416             d_number (di);
2417           ret->u.s_fixed.length = cplus_demangle_type (di);
2418           if (ret->u.s_fixed.length == NULL)
2419             return NULL;
2420           d_number (di);
2421           peek = d_next_char (di);
2422           ret->u.s_fixed.sat = (peek == 's');
2423           break;
2424
2425         case 'v':
2426           ret = d_vector_type (di);
2427           can_subst = 1;
2428           break;
2429
2430         case 'n':
2431           /* decltype(nullptr) */
2432           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2433           di->expansion += ret->u.s_builtin.type->len;
2434           break;
2435
2436         default:
2437           return NULL;
2438         }
2439       break;
2440
2441     default:
2442       return NULL;
2443     }
2444
2445   if (can_subst)
2446     {
2447       if (! d_add_substitution (di, ret))
2448         return NULL;
2449     }
2450
2451   return ret;
2452 }
2453
2454 /* <CV-qualifiers> ::= [r] [V] [K]  */
2455
2456 static struct demangle_component **
2457 d_cv_qualifiers (struct d_info *di,
2458                  struct demangle_component **pret, int member_fn)
2459 {
2460   struct demangle_component **pstart;
2461   char peek;
2462
2463   pstart = pret;
2464   peek = d_peek_char (di);
2465   while (peek == 'r' || peek == 'V' || peek == 'K')
2466     {
2467       enum demangle_component_type t;
2468
2469       d_advance (di, 1);
2470       if (peek == 'r')
2471         {
2472           t = (member_fn
2473                ? DEMANGLE_COMPONENT_RESTRICT_THIS
2474                : DEMANGLE_COMPONENT_RESTRICT);
2475           di->expansion += sizeof "restrict";
2476         }
2477       else if (peek == 'V')
2478         {
2479           t = (member_fn
2480                ? DEMANGLE_COMPONENT_VOLATILE_THIS
2481                : DEMANGLE_COMPONENT_VOLATILE);
2482           di->expansion += sizeof "volatile";
2483         }
2484       else
2485         {
2486           t = (member_fn
2487                ? DEMANGLE_COMPONENT_CONST_THIS
2488                : DEMANGLE_COMPONENT_CONST);
2489           di->expansion += sizeof "const";
2490         }
2491
2492       *pret = d_make_comp (di, t, NULL, NULL);
2493       if (*pret == NULL)
2494         return NULL;
2495       pret = &d_left (*pret);
2496
2497       peek = d_peek_char (di);
2498     }
2499
2500   if (!member_fn && peek == 'F')
2501     {
2502       while (pstart != pret)
2503         {
2504           switch ((*pstart)->type)
2505             {
2506             case DEMANGLE_COMPONENT_RESTRICT:
2507               (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
2508               break;
2509             case DEMANGLE_COMPONENT_VOLATILE:
2510               (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
2511               break;
2512             case DEMANGLE_COMPONENT_CONST:
2513               (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
2514               break;
2515             default:
2516               break;
2517             }
2518           pstart = &d_left (*pstart);
2519         }
2520     }
2521
2522   return pret;
2523 }
2524
2525 /* <ref-qualifier> ::= R
2526                    ::= O */
2527
2528 static struct demangle_component *
2529 d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2530 {
2531   struct demangle_component *ret = sub;
2532   char peek;
2533
2534   peek = d_peek_char (di);
2535   if (peek == 'R' || peek == 'O')
2536     {
2537       enum demangle_component_type t;
2538       if (peek == 'R')
2539         {
2540           t = DEMANGLE_COMPONENT_REFERENCE_THIS;
2541           di->expansion += sizeof "&";
2542         }
2543       else
2544         {
2545           t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
2546           di->expansion += sizeof "&&";
2547         }
2548       d_advance (di, 1);
2549
2550       ret = d_make_comp (di, t, ret, NULL);
2551     }
2552
2553   return ret;
2554 }
2555
2556 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E  */
2557
2558 static struct demangle_component *
2559 d_function_type (struct d_info *di)
2560 {
2561   struct demangle_component *ret;
2562
2563   if (! d_check_char (di, 'F'))
2564     return NULL;
2565   if (d_peek_char (di) == 'Y')
2566     {
2567       /* Function has C linkage.  We don't print this information.
2568          FIXME: We should print it in verbose mode.  */
2569       d_advance (di, 1);
2570     }
2571   ret = d_bare_function_type (di, 1);
2572   ret = d_ref_qualifier (di, ret);
2573
2574   if (! d_check_char (di, 'E'))
2575     return NULL;
2576   return ret;
2577 }
2578
2579 /* <type>+ */
2580
2581 static struct demangle_component *
2582 d_parmlist (struct d_info *di)
2583 {
2584   struct demangle_component *tl;
2585   struct demangle_component **ptl;
2586
2587   tl = NULL;
2588   ptl = &tl;
2589   while (1)
2590     {
2591       struct demangle_component *type;
2592
2593       char peek = d_peek_char (di);
2594       if (peek == '\0' || peek == 'E' || peek == '.')
2595         break;
2596       if ((peek == 'R' || peek == 'O')
2597           && d_peek_next_char (di) == 'E')
2598         /* Function ref-qualifier, not a ref prefix for a parameter type.  */
2599         break;
2600       type = cplus_demangle_type (di);
2601       if (type == NULL)
2602         return NULL;
2603       *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2604       if (*ptl == NULL)
2605         return NULL;
2606       ptl = &d_right (*ptl);
2607     }
2608
2609   /* There should be at least one parameter type besides the optional
2610      return type.  A function which takes no arguments will have a
2611      single parameter type void.  */
2612   if (tl == NULL)
2613     return NULL;
2614
2615   /* If we have a single parameter type void, omit it.  */
2616   if (d_right (tl) == NULL
2617       && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2618       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2619     {
2620       di->expansion -= d_left (tl)->u.s_builtin.type->len;
2621       d_left (tl) = NULL;
2622     }
2623
2624   return tl;
2625 }
2626
2627 /* <bare-function-type> ::= [J]<type>+  */
2628
2629 static struct demangle_component *
2630 d_bare_function_type (struct d_info *di, int has_return_type)
2631 {
2632   struct demangle_component *return_type;
2633   struct demangle_component *tl;
2634   char peek;
2635
2636   /* Detect special qualifier indicating that the first argument
2637      is the return type.  */
2638   peek = d_peek_char (di);
2639   if (peek == 'J')
2640     {
2641       d_advance (di, 1);
2642       has_return_type = 1;
2643     }
2644
2645   if (has_return_type)
2646     {
2647       return_type = cplus_demangle_type (di);
2648       if (return_type == NULL)
2649         return NULL;
2650     }
2651   else
2652     return_type = NULL;
2653
2654   tl = d_parmlist (di);
2655   if (tl == NULL)
2656     return NULL;
2657
2658   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2659                       return_type, tl);
2660 }
2661
2662 /* <class-enum-type> ::= <name>  */
2663
2664 static struct demangle_component *
2665 d_class_enum_type (struct d_info *di)
2666 {
2667   return d_name (di);
2668 }
2669
2670 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2671                 ::= A [<(dimension) expression>] _ <(element) type>
2672 */
2673
2674 static struct demangle_component *
2675 d_array_type (struct d_info *di)
2676 {
2677   char peek;
2678   struct demangle_component *dim;
2679
2680   if (! d_check_char (di, 'A'))
2681     return NULL;
2682
2683   peek = d_peek_char (di);
2684   if (peek == '_')
2685     dim = NULL;
2686   else if (IS_DIGIT (peek))
2687     {
2688       const char *s;
2689
2690       s = d_str (di);
2691       do
2692         {
2693           d_advance (di, 1);
2694           peek = d_peek_char (di);
2695         }
2696       while (IS_DIGIT (peek));
2697       dim = d_make_name (di, s, d_str (di) - s);
2698       if (dim == NULL)
2699         return NULL;
2700     }
2701   else
2702     {
2703       dim = d_expression (di);
2704       if (dim == NULL)
2705         return NULL;
2706     }
2707
2708   if (! d_check_char (di, '_'))
2709     return NULL;
2710
2711   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2712                       cplus_demangle_type (di));
2713 }
2714
2715 /* <vector-type> ::= Dv <number> _ <type>
2716                  ::= Dv _ <expression> _ <type> */
2717
2718 static struct demangle_component *
2719 d_vector_type (struct d_info *di)
2720 {
2721   char peek;
2722   struct demangle_component *dim;
2723
2724   peek = d_peek_char (di);
2725   if (peek == '_')
2726     {
2727       d_advance (di, 1);
2728       dim = d_expression (di);
2729     }
2730   else
2731     dim = d_number_component (di);
2732
2733   if (dim == NULL)
2734     return NULL;
2735
2736   if (! d_check_char (di, '_'))
2737     return NULL;
2738
2739   return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
2740                       cplus_demangle_type (di));
2741 }
2742
2743 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
2744
2745 static struct demangle_component *
2746 d_pointer_to_member_type (struct d_info *di)
2747 {
2748   struct demangle_component *cl;
2749   struct demangle_component *mem;
2750
2751   if (! d_check_char (di, 'M'))
2752     return NULL;
2753
2754   cl = cplus_demangle_type (di);
2755   if (cl == NULL)
2756     return NULL;
2757
2758   /* The ABI says, "The type of a non-static member function is considered
2759      to be different, for the purposes of substitution, from the type of a
2760      namespace-scope or static member function whose type appears
2761      similar. The types of two non-static member functions are considered
2762      to be different, for the purposes of substitution, if the functions
2763      are members of different classes. In other words, for the purposes of
2764      substitution, the class of which the function is a member is
2765      considered part of the type of function."
2766
2767      For a pointer to member function, this call to cplus_demangle_type
2768      will end up adding a (possibly qualified) non-member function type to
2769      the substitution table, which is not correct; however, the member
2770      function type will never be used in a substitution, so putting the
2771      wrong type in the substitution table is harmless.  */
2772
2773   mem = cplus_demangle_type (di);
2774   if (mem == NULL)
2775     return NULL;
2776
2777   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2778 }
2779
2780 /* <non-negative number> _ */
2781
2782 static long
2783 d_compact_number (struct d_info *di)
2784 {
2785   long num;
2786   if (d_peek_char (di) == '_')
2787     num = 0;
2788   else if (d_peek_char (di) == 'n')
2789     return -1;
2790   else
2791     num = d_number (di) + 1;
2792
2793   if (! d_check_char (di, '_'))
2794     return -1;
2795   return num;
2796 }
2797
2798 /* <template-param> ::= T_
2799                     ::= T <(parameter-2 non-negative) number> _
2800 */
2801
2802 static struct demangle_component *
2803 d_template_param (struct d_info *di)
2804 {
2805   long param;
2806
2807   if (! d_check_char (di, 'T'))
2808     return NULL;
2809
2810   param = d_compact_number (di);
2811   if (param < 0)
2812     return NULL;
2813
2814   ++di->did_subs;
2815
2816   return d_make_template_param (di, param);
2817 }
2818
2819 /* <template-args> ::= I <template-arg>+ E  */
2820
2821 static struct demangle_component *
2822 d_template_args (struct d_info *di)
2823 {
2824   struct demangle_component *hold_last_name;
2825   struct demangle_component *al;
2826   struct demangle_component **pal;
2827
2828   /* Preserve the last name we saw--don't let the template arguments
2829      clobber it, as that would give us the wrong name for a subsequent
2830      constructor or destructor.  */
2831   hold_last_name = di->last_name;
2832
2833   if (d_peek_char (di) != 'I'
2834       && d_peek_char (di) != 'J')
2835     return NULL;
2836   d_advance (di, 1);
2837
2838   if (d_peek_char (di) == 'E')
2839     {
2840       /* An argument pack can be empty.  */
2841       d_advance (di, 1);
2842       return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2843     }
2844
2845   al = NULL;
2846   pal = &al;
2847   while (1)
2848     {
2849       struct demangle_component *a;
2850
2851       a = d_template_arg (di);
2852       if (a == NULL)
2853         return NULL;
2854
2855       *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2856       if (*pal == NULL)
2857         return NULL;
2858       pal = &d_right (*pal);
2859
2860       if (d_peek_char (di) == 'E')
2861         {
2862           d_advance (di, 1);
2863           break;
2864         }
2865     }
2866
2867   di->last_name = hold_last_name;
2868
2869   return al;
2870 }
2871
2872 /* <template-arg> ::= <type>
2873                   ::= X <expression> E
2874                   ::= <expr-primary>
2875 */
2876
2877 static struct demangle_component *
2878 d_template_arg (struct d_info *di)
2879 {
2880   struct demangle_component *ret;
2881
2882   switch (d_peek_char (di))
2883     {
2884     case 'X':
2885       d_advance (di, 1);
2886       ret = d_expression (di);
2887       if (! d_check_char (di, 'E'))
2888         return NULL;
2889       return ret;
2890
2891     case 'L':
2892       return d_expr_primary (di);
2893
2894     case 'I':
2895     case 'J':
2896       /* An argument pack.  */
2897       return d_template_args (di);
2898
2899     default:
2900       return cplus_demangle_type (di);
2901     }
2902 }
2903
2904 /* Parse a sequence of expressions until we hit the terminator
2905    character.  */
2906
2907 static struct demangle_component *
2908 d_exprlist (struct d_info *di, char terminator)
2909 {
2910   struct demangle_component *list = NULL;
2911   struct demangle_component **p = &list;
2912
2913   if (d_peek_char (di) == terminator)
2914     {
2915       d_advance (di, 1);
2916       return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
2917     }
2918
2919   while (1)
2920     {
2921       struct demangle_component *arg = d_expression (di);
2922       if (arg == NULL)
2923         return NULL;
2924
2925       *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
2926       if (*p == NULL)
2927         return NULL;
2928       p = &d_right (*p);
2929
2930       if (d_peek_char (di) == terminator)
2931         {
2932           d_advance (di, 1);
2933           break;
2934         }
2935     }
2936
2937   return list;
2938 }
2939
2940 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
2941    dynamic_cast, static_cast or reinterpret_cast.  */
2942
2943 static int
2944 op_is_new_cast (struct demangle_component *op)
2945 {
2946   const char *code = op->u.s_operator.op->code;
2947   return (code[1] == 'c'
2948           && (code[0] == 's' || code[0] == 'd'
2949               || code[0] == 'c' || code[0] == 'r'));
2950 }
2951
2952 /* <expression> ::= <(unary) operator-name> <expression>
2953                 ::= <(binary) operator-name> <expression> <expression>
2954                 ::= <(trinary) operator-name> <expression> <expression> <expression>
2955                 ::= cl <expression>+ E
2956                 ::= st <type>
2957                 ::= <template-param>
2958                 ::= sr <type> <unqualified-name>
2959                 ::= sr <type> <unqualified-name> <template-args>
2960                 ::= <expr-primary>
2961 */
2962
2963 static struct demangle_component *
2964 d_expression (struct d_info *di)
2965 {
2966   char peek;
2967
2968   peek = d_peek_char (di);
2969   if (peek == 'L')
2970     return d_expr_primary (di);
2971   else if (peek == 'T')
2972     return d_template_param (di);
2973   else if (peek == 's' && d_peek_next_char (di) == 'r')
2974     {
2975       struct demangle_component *type;
2976       struct demangle_component *name;
2977
2978       d_advance (di, 2);
2979       type = cplus_demangle_type (di);
2980       name = d_unqualified_name (di);
2981       if (d_peek_char (di) != 'I')
2982         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2983       else
2984         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2985                             d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2986                                          d_template_args (di)));
2987     }
2988   else if (peek == 's' && d_peek_next_char (di) == 'p')
2989     {
2990       d_advance (di, 2);
2991       return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2992                           d_expression (di), NULL);
2993     }
2994   else if (peek == 'f' && d_peek_next_char (di) == 'p')
2995     {
2996       /* Function parameter used in a late-specified return type.  */
2997       int index;
2998       d_advance (di, 2);
2999       if (d_peek_char (di) == 'T')
3000         {
3001           /* 'this' parameter.  */
3002           d_advance (di, 1);
3003           index = 0;
3004         }
3005       else
3006         {
3007           index = d_compact_number (di) + 1;
3008           if (index == 0)
3009             return NULL;
3010         }
3011       return d_make_function_param (di, index);
3012     }
3013   else if (IS_DIGIT (peek)
3014            || (peek == 'o' && d_peek_next_char (di) == 'n'))
3015     {
3016       /* We can get an unqualified name as an expression in the case of
3017          a dependent function call, i.e. decltype(f(t)).  */
3018       struct demangle_component *name;
3019
3020       if (peek == 'o')
3021         /* operator-function-id, i.e. operator+(t).  */
3022         d_advance (di, 2);
3023
3024       name = d_unqualified_name (di);
3025       if (name == NULL)
3026         return NULL;
3027       if (d_peek_char (di) == 'I')
3028         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3029                             d_template_args (di));
3030       else
3031         return name;
3032     }
3033   else if ((peek == 'i' || peek == 't')
3034            && d_peek_next_char (di) == 'l')
3035     {
3036       /* Brace-enclosed initializer list, untyped or typed.  */
3037       struct demangle_component *type = NULL;
3038       if (peek == 't')
3039         type = cplus_demangle_type (di);
3040       d_advance (di, 2);
3041       return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
3042                           type, d_exprlist (di, 'E'));
3043     }
3044   else
3045     {
3046       struct demangle_component *op;
3047       const char *code = NULL;
3048       int args;
3049
3050       op = d_operator_name (di);
3051       if (op == NULL)
3052         return NULL;
3053
3054       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
3055         {
3056           code = op->u.s_operator.op->code;
3057           di->expansion += op->u.s_operator.op->len - 2;
3058           if (strcmp (code, "st") == 0)
3059             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3060                                 cplus_demangle_type (di));
3061         }
3062
3063       switch (op->type)
3064         {
3065         default:
3066           return NULL;
3067         case DEMANGLE_COMPONENT_OPERATOR:
3068           args = op->u.s_operator.op->args;
3069           break;
3070         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3071           args = op->u.s_extended_operator.args;
3072           break;
3073         case DEMANGLE_COMPONENT_CAST:
3074           args = 1;
3075           break;
3076         }
3077
3078       switch (args)
3079         {
3080         case 0:
3081           return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3082
3083         case 1:
3084           {
3085             struct demangle_component *operand;
3086             int suffix = 0;
3087
3088             if (code && (code[0] == 'p' || code[0] == 'm')
3089                 && code[1] == code[0])
3090               /* pp_ and mm_ are the prefix variants.  */
3091               suffix = !d_check_char (di, '_');
3092
3093             if (op->type == DEMANGLE_COMPONENT_CAST
3094                 && d_check_char (di, '_'))
3095               operand = d_exprlist (di, 'E');
3096             else
3097               operand = d_expression (di);
3098
3099             if (suffix)
3100               /* Indicate the suffix variant for d_print_comp.  */
3101               return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3102                                   d_make_comp (di,
3103                                                DEMANGLE_COMPONENT_BINARY_ARGS,
3104                                                operand, operand));
3105             else
3106               return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3107                                   operand);
3108           }
3109         case 2:
3110           {
3111             struct demangle_component *left;
3112             struct demangle_component *right;
3113
3114             if (op_is_new_cast (op))
3115               left = cplus_demangle_type (di);
3116             else
3117               left = d_expression (di);
3118             if (!strcmp (code, "cl"))
3119               right = d_exprlist (di, 'E');
3120             else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3121               {
3122                 right = d_unqualified_name (di);
3123                 if (d_peek_char (di) == 'I')
3124                   right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3125                                        right, d_template_args (di));
3126               }
3127             else
3128               right = d_expression (di);
3129
3130             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3131                                 d_make_comp (di,
3132                                              DEMANGLE_COMPONENT_BINARY_ARGS,
3133                                              left, right));
3134           }
3135         case 3:
3136           {
3137             struct demangle_component *first;
3138             struct demangle_component *second;
3139             struct demangle_component *third;
3140
3141             if (!strcmp (code, "qu"))
3142               {
3143                 /* ?: expression.  */
3144                 first = d_expression (di);
3145                 second = d_expression (di);
3146                 third = d_expression (di);
3147               }
3148             else if (code[0] == 'n')
3149               {
3150                 /* new-expression.  */
3151                 if (code[1] != 'w' && code[1] != 'a')
3152                   return NULL;
3153                 first = d_exprlist (di, '_');
3154                 second = cplus_demangle_type (di);
3155                 if (d_peek_char (di) == 'E')
3156                   {
3157                     d_advance (di, 1);
3158                     third = NULL;
3159                   }
3160                 else if (d_peek_char (di) == 'p'
3161                          && d_peek_next_char (di) == 'i')
3162                   {
3163                     /* Parenthesized initializer.  */
3164                     d_advance (di, 2);
3165                     third = d_exprlist (di, 'E');
3166                   }
3167                 else if (d_peek_char (di) == 'i'
3168                          && d_peek_next_char (di) == 'l')
3169                   /* initializer-list.  */
3170                   third = d_expression (di);
3171                 else
3172                   return NULL;
3173               }
3174             else
3175               return NULL;
3176             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3177                                 d_make_comp (di,
3178                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
3179                                              first,
3180                                              d_make_comp (di,
3181                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
3182                                                           second, third)));
3183           }
3184         default:
3185           return NULL;
3186         }
3187     }
3188 }
3189
3190 /* <expr-primary> ::= L <type> <(value) number> E
3191                   ::= L <type> <(value) float> E
3192                   ::= L <mangled-name> E
3193 */
3194
3195 static struct demangle_component *
3196 d_expr_primary (struct d_info *di)
3197 {
3198   struct demangle_component *ret;
3199
3200   if (! d_check_char (di, 'L'))
3201     return NULL;
3202   if (d_peek_char (di) == '_'
3203       /* Workaround for G++ bug; see comment in write_template_arg.  */
3204       || d_peek_char (di) == 'Z')
3205     ret = cplus_demangle_mangled_name (di, 0);
3206   else
3207     {
3208       struct demangle_component *type;
3209       enum demangle_component_type t;
3210       const char *s;
3211
3212       type = cplus_demangle_type (di);
3213       if (type == NULL)
3214         return NULL;
3215
3216       /* If we have a type we know how to print, we aren't going to
3217          print the type name itself.  */
3218       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3219           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3220         di->expansion -= type->u.s_builtin.type->len;
3221
3222       /* Rather than try to interpret the literal value, we just
3223          collect it as a string.  Note that it's possible to have a
3224          floating point literal here.  The ABI specifies that the
3225          format of such literals is machine independent.  That's fine,
3226          but what's not fine is that versions of g++ up to 3.2 with
3227          -fabi-version=1 used upper case letters in the hex constant,
3228          and dumped out gcc's internal representation.  That makes it
3229          hard to tell where the constant ends, and hard to dump the
3230          constant in any readable form anyhow.  We don't attempt to
3231          handle these cases.  */
3232
3233       t = DEMANGLE_COMPONENT_LITERAL;
3234       if (d_peek_char (di) == 'n')
3235         {
3236           t = DEMANGLE_COMPONENT_LITERAL_NEG;
3237           d_advance (di, 1);
3238         }
3239       s = d_str (di);
3240       while (d_peek_char (di) != 'E')
3241         {
3242           if (d_peek_char (di) == '\0')
3243             return NULL;
3244           d_advance (di, 1);
3245         }
3246       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
3247     }
3248   if (! d_check_char (di, 'E'))
3249     return NULL;
3250   return ret;
3251 }
3252
3253 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3254                 ::= Z <(function) encoding> E s [<discriminator>]
3255                 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3256 */
3257
3258 static struct demangle_component *
3259 d_local_name (struct d_info *di)
3260 {
3261   struct demangle_component *function;
3262
3263   if (! d_check_char (di, 'Z'))
3264     return NULL;
3265
3266   function = d_encoding (di, 0);
3267
3268   if (! d_check_char (di, 'E'))
3269     return NULL;
3270
3271   if (d_peek_char (di) == 's')
3272     {
3273       d_advance (di, 1);
3274       if (! d_discriminator (di))
3275         return NULL;
3276       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
3277                           d_make_name (di, "string literal",
3278                                        sizeof "string literal" - 1));
3279     }
3280   else
3281     {
3282       struct demangle_component *name;
3283       int num = -1;
3284
3285       if (d_peek_char (di) == 'd')
3286         {
3287           /* Default argument scope: d <number> _.  */
3288           d_advance (di, 1);
3289           num = d_compact_number (di);
3290           if (num < 0)
3291             return NULL;
3292         }
3293
3294       name = d_name (di);
3295       if (name)
3296         switch (name->type)
3297           {
3298             /* Lambdas and unnamed types have internal discriminators.  */
3299           case DEMANGLE_COMPONENT_LAMBDA:
3300           case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3301             break;
3302           default:
3303             if (! d_discriminator (di))
3304               return NULL;
3305           }
3306       if (num >= 0)
3307         name = d_make_default_arg (di, num, name);
3308       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3309     }
3310 }
3311
3312 /* <discriminator> ::= _ <(non-negative) number>
3313
3314    We demangle the discriminator, but we don't print it out.  FIXME:
3315    We should print it out in verbose mode.  */
3316
3317 static int
3318 d_discriminator (struct d_info *di)
3319 {
3320   long discrim;
3321
3322   if (d_peek_char (di) != '_')
3323     return 1;
3324   d_advance (di, 1);
3325   discrim = d_number (di);
3326   if (discrim < 0)
3327     return 0;
3328   return 1;
3329 }
3330
3331 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3332
3333 static struct demangle_component *
3334 d_lambda (struct d_info *di)
3335 {
3336   struct demangle_component *tl;
3337   struct demangle_component *ret;
3338   int num;
3339
3340   if (! d_check_char (di, 'U'))
3341     return NULL;
3342   if (! d_check_char (di, 'l'))
3343     return NULL;
3344
3345   tl = d_parmlist (di);
3346   if (tl == NULL)
3347     return NULL;
3348
3349   if (! d_check_char (di, 'E'))
3350     return NULL;
3351
3352   num = d_compact_number (di);
3353   if (num < 0)
3354     return NULL;
3355
3356   ret = d_make_empty (di);
3357   if (ret)
3358     {
3359       ret->type = DEMANGLE_COMPONENT_LAMBDA;
3360       ret->u.s_unary_num.sub = tl;
3361       ret->u.s_unary_num.num = num;
3362     }
3363
3364   if (! d_add_substitution (di, ret))
3365     return NULL;
3366
3367   return ret;
3368 }
3369
3370 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3371
3372 static struct demangle_component *
3373 d_unnamed_type (struct d_info *di)
3374 {
3375   struct demangle_component *ret;
3376   long num;
3377
3378   if (! d_check_char (di, 'U'))
3379     return NULL;
3380   if (! d_check_char (di, 't'))
3381     return NULL;
3382
3383   num = d_compact_number (di);
3384   if (num < 0)
3385     return NULL;
3386
3387   ret = d_make_empty (di);
3388   if (ret)
3389     {
3390       ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3391       ret->u.s_number.number = num;
3392     }
3393
3394   if (! d_add_substitution (di, ret))
3395     return NULL;
3396
3397   return ret;
3398 }
3399
3400 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3401 */
3402
3403 static struct demangle_component *
3404 d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3405 {
3406   const char *suffix = d_str (di);
3407   const char *pend = suffix;
3408   struct demangle_component *n;
3409
3410   if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3411     {
3412       pend += 2;
3413       while (IS_LOWER (*pend) || *pend == '_')
3414         ++pend;
3415     }
3416   while (*pend == '.' && IS_DIGIT (pend[1]))
3417     {
3418       pend += 2;
3419       while (IS_DIGIT (*pend))
3420         ++pend;
3421     }
3422   d_advance (di, pend - suffix);
3423   n = d_make_name (di, suffix, pend - suffix);
3424   return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3425 }
3426
3427 /* Add a new substitution.  */
3428
3429 static int
3430 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3431 {
3432   if (dc == NULL)
3433     return 0;
3434   if (di->next_sub >= di->num_subs)
3435     return 0;
3436   di->subs[di->next_sub] = dc;
3437   ++di->next_sub;
3438   return 1;
3439 }
3440
3441 /* <substitution> ::= S <seq-id> _
3442                   ::= S_
3443                   ::= St
3444                   ::= Sa
3445                   ::= Sb
3446                   ::= Ss
3447                   ::= Si
3448                   ::= So
3449                   ::= Sd
3450
3451    If PREFIX is non-zero, then this type is being used as a prefix in
3452    a qualified name.  In this case, for the standard substitutions, we
3453    need to check whether we are being used as a prefix for a
3454    constructor or destructor, and return a full template name.
3455    Otherwise we will get something like std::iostream::~iostream()
3456    which does not correspond particularly well to any function which
3457    actually appears in the source.
3458 */
3459
3460 static const struct d_standard_sub_info standard_subs[] =
3461 {
3462   { 't', NL ("std"),
3463     NL ("std"),
3464     NULL, 0 },
3465   { 'a', NL ("std::allocator"),
3466     NL ("std::allocator"),
3467     NL ("allocator") },
3468   { 'b', NL ("std::basic_string"),
3469     NL ("std::basic_string"),
3470     NL ("basic_string") },
3471   { 's', NL ("std::string"),
3472     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3473     NL ("basic_string") },
3474   { 'i', NL ("std::istream"),
3475     NL ("std::basic_istream<char, std::char_traits<char> >"),
3476     NL ("basic_istream") },
3477   { 'o', NL ("std::ostream"),
3478     NL ("std::basic_ostream<char, std::char_traits<char> >"),
3479     NL ("basic_ostream") },
3480   { 'd', NL ("std::iostream"),
3481     NL ("std::basic_iostream<char, std::char_traits<char> >"),
3482     NL ("basic_iostream") }
3483 };
3484
3485 static struct demangle_component *
3486 d_substitution (struct d_info *di, int prefix)
3487 {
3488   char c;
3489
3490   if (! d_check_char (di, 'S'))
3491     return NULL;
3492
3493   c = d_next_char (di);
3494   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3495     {
3496       unsigned int id;
3497
3498       id = 0;
3499       if (c != '_')
3500         {
3501           do
3502             {
3503               unsigned int new_id;
3504
3505               if (IS_DIGIT (c))
3506                 new_id = id * 36 + c - '0';
3507               else if (IS_UPPER (c))
3508                 new_id = id * 36 + c - 'A' + 10;
3509               else
3510                 return NULL;
3511               if (new_id < id)
3512                 return NULL;
3513               id = new_id;
3514               c = d_next_char (di);
3515             }
3516           while (c != '_');
3517
3518           ++id;
3519         }
3520
3521       if (id >= (unsigned int) di->next_sub)
3522         return NULL;
3523
3524       ++di->did_subs;
3525
3526       return di->subs[id];
3527     }
3528   else
3529     {
3530       int verbose;
3531       const struct d_standard_sub_info *p;
3532       const struct d_standard_sub_info *pend;
3533
3534       verbose = (di->options & DMGL_VERBOSE) != 0;
3535       if (! verbose && prefix)
3536         {
3537           char peek;
3538
3539           peek = d_peek_char (di);
3540           if (peek == 'C' || peek == 'D')
3541             verbose = 1;
3542         }
3543
3544       pend = (&standard_subs[0]
3545               + sizeof standard_subs / sizeof standard_subs[0]);
3546       for (p = &standard_subs[0]; p < pend; ++p)
3547         {
3548           if (c == p->code)
3549             {
3550               const char *s;
3551               int len;
3552
3553               if (p->set_last_name != NULL)
3554                 di->last_name = d_make_sub (di, p->set_last_name,
3555                                             p->set_last_name_len);
3556               if (verbose)
3557                 {
3558                   s = p->full_expansion;
3559                   len = p->full_len;
3560                 }
3561               else
3562                 {
3563                   s = p->simple_expansion;
3564                   len = p->simple_len;
3565                 }
3566               di->expansion += len;
3567               return d_make_sub (di, s, len);
3568             }
3569         }
3570
3571       return NULL;
3572     }
3573 }
3574
3575 /* Initialize a growable string.  */
3576
3577 static void
3578 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3579 {
3580   dgs->buf = NULL;
3581   dgs->len = 0;
3582   dgs->alc = 0;
3583   dgs->allocation_failure = 0;
3584
3585   if (estimate > 0)
3586     d_growable_string_resize (dgs, estimate);
3587 }
3588
3589 /* Grow a growable string to a given size.  */
3590
3591 static inline void
3592 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3593 {
3594   size_t newalc;
3595   char *newbuf;
3596
3597   if (dgs->allocation_failure)
3598     return;
3599
3600   /* Start allocation at two bytes to avoid any possibility of confusion
3601      with the special value of 1 used as a return in *palc to indicate
3602      allocation failures.  */
3603   newalc = dgs->alc > 0 ? dgs->alc : 2;
3604   while (newalc < need)
3605     newalc <<= 1;
3606
3607   newbuf = (char *) realloc (dgs->buf, newalc);
3608   if (newbuf == NULL)
3609     {
3610       free (dgs->buf);
3611       dgs->buf = NULL;
3612       dgs->len = 0;
3613       dgs->alc = 0;
3614       dgs->allocation_failure = 1;
3615       return;
3616     }
3617   dgs->buf = newbuf;
3618   dgs->alc = newalc;
3619 }
3620
3621 /* Append a buffer to a growable string.  */
3622
3623 static inline void
3624 d_growable_string_append_buffer (struct d_growable_string *dgs,
3625                                  const char *s, size_t l)
3626 {
3627   size_t need;
3628
3629   need = dgs->len + l + 1;
3630   if (need > dgs->alc)
3631     d_growable_string_resize (dgs, need);
3632
3633   if (dgs->allocation_failure)
3634     return;
3635
3636   memcpy (dgs->buf + dgs->len, s, l);
3637   dgs->buf[dgs->len + l] = '\0';
3638   dgs->len += l;
3639 }
3640
3641 /* Bridge growable strings to the callback mechanism.  */
3642
3643 static void
3644 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3645 {
3646   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3647
3648   d_growable_string_append_buffer (dgs, s, l);
3649 }
3650
3651 /* Initialize a print information structure.  */
3652
3653 static void
3654 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
3655               void *opaque)
3656 {
3657   dpi->len = 0;
3658   dpi->last_char = '\0';
3659   dpi->templates = NULL;
3660   dpi->modifiers = NULL;
3661   dpi->pack_index = 0;
3662   dpi->flush_count = 0;
3663
3664   dpi->callback = callback;
3665   dpi->opaque = opaque;
3666
3667   dpi->demangle_failure = 0;
3668 }
3669
3670 /* Indicate that an error occurred during printing, and test for error.  */
3671
3672 static inline void
3673 d_print_error (struct d_print_info *dpi)
3674 {
3675   dpi->demangle_failure = 1;
3676 }
3677
3678 static inline int
3679 d_print_saw_error (struct d_print_info *dpi)
3680 {
3681   return dpi->demangle_failure != 0;
3682 }
3683
3684 /* Flush buffered characters to the callback.  */
3685
3686 static inline void
3687 d_print_flush (struct d_print_info *dpi)
3688 {
3689   dpi->buf[dpi->len] = '\0';
3690   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3691   dpi->len = 0;
3692   dpi->flush_count++;
3693 }
3694
3695 /* Append characters and buffers for printing.  */
3696
3697 static inline void
3698 d_append_char (struct d_print_info *dpi, char c)
3699 {
3700   if (dpi->len == sizeof (dpi->buf) - 1)
3701     d_print_flush (dpi);
3702
3703   dpi->buf[dpi->len++] = c;
3704   dpi->last_char = c;
3705 }
3706
3707 static inline void
3708 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3709 {
3710   size_t i;
3711
3712   for (i = 0; i < l; i++)
3713     d_append_char (dpi, s[i]);
3714 }
3715
3716 static inline void
3717 d_append_string (struct d_print_info *dpi, const char *s)
3718 {
3719   d_append_buffer (dpi, s, strlen (s));
3720 }
3721
3722 static inline void
3723 d_append_num (struct d_print_info *dpi, long l)
3724 {
3725   char buf[25];
3726   sprintf (buf,"%ld", l);
3727   d_append_string (dpi, buf);
3728 }
3729
3730 static inline char
3731 d_last_char (struct d_print_info *dpi)
3732 {
3733   return dpi->last_char;
3734 }
3735
3736 /* Turn components into a human readable string.  OPTIONS is the
3737    options bits passed to the demangler.  DC is the tree to print.
3738    CALLBACK is a function to call to flush demangled string segments
3739    as they fill the intermediate buffer, and OPAQUE is a generalized
3740    callback argument.  On success, this returns 1.  On failure,
3741    it returns 0, indicating a bad parse.  It does not use heap
3742    memory to build an output string, so cannot encounter memory
3743    allocation failure.  */
3744
3745 CP_STATIC_IF_GLIBCPP_V3
3746 int
3747 cplus_demangle_print_callback (int options,
3748                                const struct demangle_component *dc,
3749                                demangle_callbackref callback, void *opaque)
3750 {
3751   struct d_print_info dpi;
3752
3753   d_print_init (&dpi, callback, opaque);
3754
3755   d_print_comp (&dpi, options, dc);
3756
3757   d_print_flush (&dpi);
3758
3759   return ! d_print_saw_error (&dpi);
3760 }
3761
3762 /* Turn components into a human readable string.  OPTIONS is the
3763    options bits passed to the demangler.  DC is the tree to print.
3764    ESTIMATE is a guess at the length of the result.  This returns a
3765    string allocated by malloc, or NULL on error.  On success, this
3766    sets *PALC to the size of the allocated buffer.  On failure, this
3767    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3768    failure.  */
3769
3770 CP_STATIC_IF_GLIBCPP_V3
3771 char *
3772 cplus_demangle_print (int options, const struct demangle_component *dc,
3773                       int estimate, size_t *palc)
3774 {
3775   struct d_growable_string dgs;
3776
3777   d_growable_string_init (&dgs, estimate);
3778
3779   if (! cplus_demangle_print_callback (options, dc,
3780                                        d_growable_string_callback_adapter,
3781                                        &dgs))
3782     {
3783       free (dgs.buf);
3784       *palc = 0;
3785       return NULL;
3786     }
3787
3788   *palc = dgs.allocation_failure ? 1 : dgs.alc;
3789   return dgs.buf;
3790 }
3791
3792 /* Returns the I'th element of the template arglist ARGS, or NULL on
3793    failure.  */
3794
3795 static struct demangle_component *
3796 d_index_template_argument (struct demangle_component *args, int i)
3797 {
3798   struct demangle_component *a;
3799
3800   for (a = args;
3801        a != NULL;
3802        a = d_right (a))
3803     {
3804       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3805         return NULL;
3806       if (i <= 0)
3807         break;
3808       --i;
3809     }
3810   if (i != 0 || a == NULL)
3811     return NULL;
3812
3813   return d_left (a);
3814 }
3815
3816 /* Returns the template argument from the current context indicated by DC,
3817    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
3818
3819 static struct demangle_component *
3820 d_lookup_template_argument (struct d_print_info *dpi,
3821                             const struct demangle_component *dc)
3822 {
3823   if (dpi->templates == NULL)
3824     {
3825       d_print_error (dpi);
3826       return NULL;
3827     }
3828
3829   return d_index_template_argument
3830     (d_right (dpi->templates->template_decl),
3831      dc->u.s_number.number);
3832 }
3833
3834 /* Returns a template argument pack used in DC (any will do), or NULL.  */
3835
3836 static struct demangle_component *
3837 d_find_pack (struct d_print_info *dpi,
3838              const struct demangle_component *dc)
3839 {
3840   struct demangle_component *a;
3841   if (dc == NULL)
3842     return NULL;
3843
3844   switch (dc->type)
3845     {
3846     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3847       a = d_lookup_template_argument (dpi, dc);
3848       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3849         return a;
3850       return NULL;
3851
3852     case DEMANGLE_COMPONENT_PACK_EXPANSION:
3853       return NULL;
3854
3855     case DEMANGLE_COMPONENT_LAMBDA:
3856     case DEMANGLE_COMPONENT_NAME:
3857     case DEMANGLE_COMPONENT_TAGGED_NAME:
3858     case DEMANGLE_COMPONENT_OPERATOR:
3859     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3860     case DEMANGLE_COMPONENT_SUB_STD:
3861     case DEMANGLE_COMPONENT_CHARACTER:
3862     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3863     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3864       return NULL;
3865
3866     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3867       return d_find_pack (dpi, dc->u.s_extended_operator.name);
3868     case DEMANGLE_COMPONENT_CTOR:
3869       return d_find_pack (dpi, dc->u.s_ctor.name);
3870     case DEMANGLE_COMPONENT_DTOR:
3871       return d_find_pack (dpi, dc->u.s_dtor.name);
3872
3873     default:
3874       a = d_find_pack (dpi, d_left (dc));
3875       if (a)
3876         return a;
3877       return d_find_pack (dpi, d_right (dc));
3878     }
3879 }
3880
3881 /* Returns the length of the template argument pack DC.  */
3882
3883 static int
3884 d_pack_length (const struct demangle_component *dc)
3885 {
3886   int count = 0;
3887   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3888          && d_left (dc) != NULL)
3889     {
3890       ++count;
3891       dc = d_right (dc);
3892     }
3893   return count;
3894 }
3895
3896 /* DC is a component of a mangled expression.  Print it, wrapped in parens
3897    if needed.  */
3898
3899 static void
3900 d_print_subexpr (struct d_print_info *dpi, int options,
3901                  const struct demangle_component *dc)
3902 {
3903   int simple = 0;
3904   if (dc->type == DEMANGLE_COMPONENT_NAME
3905       || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
3906       || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
3907       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3908     simple = 1;
3909   if (!simple)
3910     d_append_char (dpi, '(');
3911   d_print_comp (dpi, options, dc);
3912   if (!simple)
3913     d_append_char (dpi, ')');
3914 }
3915
3916 /* Subroutine to handle components.  */
3917
3918 static void
3919 d_print_comp (struct d_print_info *dpi, int options,
3920               const struct demangle_component *dc)
3921 {
3922   /* Magic variable to let reference smashing skip over the next modifier
3923      without needing to modify *dc.  */
3924   const struct demangle_component *mod_inner = NULL;
3925
3926   if (dc == NULL)
3927     {
3928       d_print_error (dpi);
3929       return;
3930     }
3931   if (d_print_saw_error (dpi))
3932     return;
3933
3934   switch (dc->type)
3935     {
3936     case DEMANGLE_COMPONENT_NAME:
3937       if ((options & DMGL_JAVA) == 0)
3938         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3939       else
3940         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3941       return;
3942
3943     case DEMANGLE_COMPONENT_TAGGED_NAME:
3944       d_print_comp (dpi, options, d_left (dc));
3945       d_append_string (dpi, "[abi:");
3946       d_print_comp (dpi, options, d_right (dc));
3947       d_append_char (dpi, ']');
3948       return;
3949
3950     case DEMANGLE_COMPONENT_QUAL_NAME:
3951     case DEMANGLE_COMPONENT_LOCAL_NAME:
3952       d_print_comp (dpi, options, d_left (dc));
3953       if ((options & DMGL_JAVA) == 0)
3954         d_append_string (dpi, "::");
3955       else
3956         d_append_char (dpi, '.');
3957       {
3958         struct demangle_component *local_name = d_right (dc);
3959         if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3960           {
3961             d_append_string (dpi, "{default arg#");
3962             d_append_num (dpi, local_name->u.s_unary_num.num + 1);
3963             d_append_string (dpi, "}::");
3964             local_name = local_name->u.s_unary_num.sub;
3965           }
3966         d_print_comp (dpi, options, local_name);
3967       }
3968       return;
3969
3970     case DEMANGLE_COMPONENT_TYPED_NAME:
3971       {
3972         struct d_print_mod *hold_modifiers;
3973         struct demangle_component *typed_name;
3974         struct d_print_mod adpm[4];
3975         unsigned int i;
3976         struct d_print_template dpt;
3977
3978         /* Pass the name down to the type so that it can be printed in
3979            the right place for the type.  We also have to pass down
3980            any CV-qualifiers, which apply to the this parameter.  */
3981         hold_modifiers = dpi->modifiers;
3982         dpi->modifiers = 0;
3983         i = 0;
3984         typed_name = d_left (dc);
3985         while (typed_name != NULL)
3986           {
3987             if (i >= sizeof adpm / sizeof adpm[0])
3988               {
3989                 d_print_error (dpi);
3990                 return;
3991               }
3992
3993             adpm[i].next = dpi->modifiers;
3994             dpi->modifiers = &adpm[i];
3995             adpm[i].mod = typed_name;
3996             adpm[i].printed = 0;
3997             adpm[i].templates = dpi->templates;
3998             ++i;
3999
4000             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
4001                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
4002                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS
4003                 && typed_name->type != DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
4004                 && typed_name->type != DEMANGLE_COMPONENT_REFERENCE_THIS)
4005               break;
4006
4007             typed_name = d_left (typed_name);
4008           }
4009
4010         if (typed_name == NULL)
4011           {
4012             d_print_error (dpi);
4013             return;
4014           }
4015
4016         /* If typed_name is a template, then it applies to the
4017            function type as well.  */
4018         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4019           {
4020             dpt.next = dpi->templates;
4021             dpi->templates = &dpt;
4022             dpt.template_decl = typed_name;
4023           }
4024
4025         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4026            there may be CV-qualifiers on its right argument which
4027            really apply here; this happens when parsing a class which
4028            is local to a function.  */
4029         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4030           {
4031             struct demangle_component *local_name;
4032
4033             local_name = d_right (typed_name);
4034             if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4035               local_name = local_name->u.s_unary_num.sub;
4036             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4037                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4038                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS
4039                    || local_name->type == DEMANGLE_COMPONENT_REFERENCE_THIS
4040                    || (local_name->type
4041                        == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))
4042               {
4043                 if (i >= sizeof adpm / sizeof adpm[0])
4044                   {
4045                     d_print_error (dpi);
4046                     return;
4047                   }
4048
4049                 adpm[i] = adpm[i - 1];
4050                 adpm[i].next = &adpm[i - 1];
4051                 dpi->modifiers = &adpm[i];
4052
4053                 adpm[i - 1].mod = local_name;
4054                 adpm[i - 1].printed = 0;
4055                 adpm[i - 1].templates = dpi->templates;
4056                 ++i;
4057
4058                 local_name = d_left (local_name);
4059               }
4060           }
4061
4062         d_print_comp (dpi, options, d_right (dc));
4063
4064         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4065           dpi->templates = dpt.next;
4066
4067         /* If the modifiers didn't get printed by the type, print them
4068            now.  */
4069         while (i > 0)
4070           {
4071             --i;
4072             if (! adpm[i].printed)
4073               {
4074                 d_append_char (dpi, ' ');
4075                 d_print_mod (dpi, options, adpm[i].mod);
4076               }
4077           }
4078
4079         dpi->modifiers = hold_modifiers;
4080
4081         return;
4082       }
4083
4084     case DEMANGLE_COMPONENT_TEMPLATE:
4085       {
4086         struct d_print_mod *hold_dpm;
4087         struct demangle_component *dcl;
4088
4089         /* Don't push modifiers into a template definition.  Doing so
4090            could give the wrong definition for a template argument.
4091            Instead, treat the template essentially as a name.  */
4092
4093         hold_dpm = dpi->modifiers;
4094         dpi->modifiers = NULL;
4095
4096         dcl = d_left (dc);
4097
4098         if ((options & DMGL_JAVA) != 0
4099             && dcl->type == DEMANGLE_COMPONENT_NAME
4100             && dcl->u.s_name.len == 6
4101             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
4102           {
4103             /* Special-case Java arrays, so that JArray<TYPE> appears
4104                instead as TYPE[].  */
4105
4106             d_print_comp (dpi, options, d_right (dc));
4107             d_append_string (dpi, "[]");
4108           }
4109         else
4110           {
4111             d_print_comp (dpi, options, dcl);
4112             if (d_last_char (dpi) == '<')
4113               d_append_char (dpi, ' ');
4114             d_append_char (dpi, '<');
4115             d_print_comp (dpi, options, d_right (dc));
4116             /* Avoid generating two consecutive '>' characters, to avoid
4117                the C++ syntactic ambiguity.  */
4118             if (d_last_char (dpi) == '>')
4119               d_append_char (dpi, ' ');
4120             d_append_char (dpi, '>');
4121           }
4122
4123         dpi->modifiers = hold_dpm;
4124
4125         return;
4126       }
4127
4128     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4129       {
4130         struct d_print_template *hold_dpt;
4131         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
4132
4133         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4134           a = d_index_template_argument (a, dpi->pack_index);
4135
4136         if (a == NULL)
4137           {
4138             d_print_error (dpi);
4139             return;
4140           }
4141
4142         /* While processing this parameter, we need to pop the list of
4143            templates.  This is because the template parameter may
4144            itself be a reference to a parameter of an outer
4145            template.  */
4146
4147         hold_dpt = dpi->templates;
4148         dpi->templates = hold_dpt->next;
4149
4150         d_print_comp (dpi, options, a);
4151
4152         dpi->templates = hold_dpt;
4153
4154         return;
4155       }
4156
4157     case DEMANGLE_COMPONENT_CTOR:
4158       d_print_comp (dpi, options, dc->u.s_ctor.name);
4159       return;
4160
4161     case DEMANGLE_COMPONENT_DTOR:
4162       d_append_char (dpi, '~');
4163       d_print_comp (dpi, options, dc->u.s_dtor.name);
4164       return;
4165
4166     case DEMANGLE_COMPONENT_VTABLE:
4167       d_append_string (dpi, "vtable for ");
4168       d_print_comp (dpi, options, d_left (dc));
4169       return;
4170
4171     case DEMANGLE_COMPONENT_VTT:
4172       d_append_string (dpi, "VTT for ");
4173       d_print_comp (dpi, options, d_left (dc));
4174       return;
4175
4176     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4177       d_append_string (dpi, "construction vtable for ");
4178       d_print_comp (dpi, options, d_left (dc));
4179       d_append_string (dpi, "-in-");
4180       d_print_comp (dpi, options, d_right (dc));
4181       return;
4182
4183     case DEMANGLE_COMPONENT_TYPEINFO:
4184       d_append_string (dpi, "typeinfo for ");
4185       d_print_comp (dpi, options, d_left (dc));
4186       return;
4187
4188     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4189       d_append_string (dpi, "typeinfo name for ");
4190       d_print_comp (dpi, options, d_left (dc));
4191       return;
4192
4193     case DEMANGLE_COMPONENT_TYPEINFO_FN:
4194       d_append_string (dpi, "typeinfo fn for ");
4195       d_print_comp (dpi, options, d_left (dc));
4196       return;
4197
4198     case DEMANGLE_COMPONENT_THUNK:
4199       d_append_string (dpi, "non-virtual thunk to ");
4200       d_print_comp (dpi, options, d_left (dc));
4201       return;
4202
4203     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4204       d_append_string (dpi, "virtual thunk to ");
4205       d_print_comp (dpi, options, d_left (dc));
4206       return;
4207
4208     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4209       d_append_string (dpi, "covariant return thunk to ");
4210       d_print_comp (dpi, options, d_left (dc));
4211       return;
4212
4213     case DEMANGLE_COMPONENT_JAVA_CLASS:
4214       d_append_string (dpi, "java Class for ");
4215       d_print_comp (dpi, options, d_left (dc));
4216       return;
4217
4218     case DEMANGLE_COMPONENT_GUARD:
4219       d_append_string (dpi, "guard variable for ");
4220       d_print_comp (dpi, options, d_left (dc));
4221       return;
4222
4223     case DEMANGLE_COMPONENT_TLS_INIT:
4224       d_append_string (dpi, "TLS init function for ");
4225       d_print_comp (dpi, options, d_left (dc));
4226       return;
4227
4228     case DEMANGLE_COMPONENT_TLS_WRAPPER:
4229       d_append_string (dpi, "TLS wrapper function for ");
4230       d_print_comp (dpi, options, d_left (dc));
4231       return;
4232
4233     case DEMANGLE_COMPONENT_REFTEMP:
4234       d_append_string (dpi, "reference temporary #");
4235       d_print_comp (dpi, options, d_right (dc));
4236       d_append_string (dpi, " for ");
4237       d_print_comp (dpi, options, d_left (dc));
4238       return;
4239
4240     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4241       d_append_string (dpi, "hidden alias for ");
4242       d_print_comp (dpi, options, d_left (dc));
4243       return;
4244
4245     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4246       d_append_string (dpi, "transaction clone for ");
4247       d_print_comp (dpi, options, d_left (dc));
4248       return;
4249
4250     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4251       d_append_string (dpi, "non-transaction clone for ");
4252       d_print_comp (dpi, options, d_left (dc));
4253       return;
4254
4255     case DEMANGLE_COMPONENT_SUB_STD:
4256       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
4257       return;
4258
4259     case DEMANGLE_COMPONENT_RESTRICT:
4260     case DEMANGLE_COMPONENT_VOLATILE:
4261     case DEMANGLE_COMPONENT_CONST:
4262       {
4263         struct d_print_mod *pdpm;
4264
4265         /* When printing arrays, it's possible to have cases where the
4266            same CV-qualifier gets pushed on the stack multiple times.
4267            We only need to print it once.  */
4268
4269         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
4270           {
4271             if (! pdpm->printed)
4272               {
4273                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
4274                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
4275                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
4276                   break;
4277                 if (pdpm->mod->type == dc->type)
4278                   {
4279                     d_print_comp (dpi, options, d_left (dc));
4280                     return;
4281                   }
4282               }
4283           }
4284       }
4285       goto modifier;
4286
4287     case DEMANGLE_COMPONENT_REFERENCE:
4288     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4289       {
4290         /* Handle reference smashing: & + && = &.  */
4291         const struct demangle_component *sub = d_left (dc);
4292         if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
4293           {
4294             struct demangle_component *a = d_lookup_template_argument (dpi, sub);
4295             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4296               a = d_index_template_argument (a, dpi->pack_index);
4297
4298             if (a == NULL)
4299               {
4300                 d_print_error (dpi);
4301                 return;
4302               }
4303
4304             sub = a;
4305           }
4306
4307         if (sub->type == DEMANGLE_COMPONENT_REFERENCE
4308             || sub->type == dc->type)
4309           dc = sub;
4310         else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
4311           mod_inner = d_left (sub);
4312       }
4313       /* Fall through.  */
4314
4315     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4316     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4317     case DEMANGLE_COMPONENT_CONST_THIS:
4318     case DEMANGLE_COMPONENT_REFERENCE_THIS:
4319     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
4320     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4321     case DEMANGLE_COMPONENT_POINTER:
4322     case DEMANGLE_COMPONENT_COMPLEX:
4323     case DEMANGLE_COMPONENT_IMAGINARY:
4324     modifier:
4325       {
4326         /* We keep a list of modifiers on the stack.  */
4327         struct d_print_mod dpm;
4328
4329         dpm.next = dpi->modifiers;
4330         dpi->modifiers = &dpm;
4331         dpm.mod = dc;
4332         dpm.printed = 0;
4333         dpm.templates = dpi->templates;
4334
4335         if (!mod_inner)
4336           mod_inner = d_left (dc);
4337
4338         d_print_comp (dpi, options, mod_inner);
4339
4340         /* If the modifier didn't get printed by the type, print it
4341            now.  */
4342         if (! dpm.printed)
4343           d_print_mod (dpi, options, dc);
4344
4345         dpi->modifiers = dpm.next;
4346
4347         return;
4348       }
4349
4350     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4351       if ((options & DMGL_JAVA) == 0)
4352         d_append_buffer (dpi, dc->u.s_builtin.type->name,
4353                          dc->u.s_builtin.type->len);
4354       else
4355         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
4356                          dc->u.s_builtin.type->java_len);
4357       return;
4358
4359     case DEMANGLE_COMPONENT_VENDOR_TYPE:
4360       d_print_comp (dpi, options, d_left (dc));
4361       return;
4362
4363     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4364       {
4365         if ((options & DMGL_RET_POSTFIX) != 0)
4366           d_print_function_type (dpi,
4367                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4368                                  dc, dpi->modifiers);
4369
4370         /* Print return type if present */
4371         if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
4372           d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4373                         d_left (dc));
4374         else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
4375           {
4376             struct d_print_mod dpm;
4377
4378             /* We must pass this type down as a modifier in order to
4379                print it in the right location.  */
4380             dpm.next = dpi->modifiers;
4381             dpi->modifiers = &dpm;
4382             dpm.mod = dc;
4383             dpm.printed = 0;
4384             dpm.templates = dpi->templates;
4385
4386             d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4387                           d_left (dc));
4388
4389             dpi->modifiers = dpm.next;
4390
4391             if (dpm.printed)
4392               return;
4393
4394             /* In standard prefix notation, there is a space between the
4395                return type and the function signature.  */
4396             if ((options & DMGL_RET_POSTFIX) == 0)
4397               d_append_char (dpi, ' ');
4398           }
4399
4400         if ((options & DMGL_RET_POSTFIX) == 0)
4401           d_print_function_type (dpi,
4402                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4403                                  dc, dpi->modifiers);
4404
4405         return;
4406       }
4407
4408     case DEMANGLE_COMPONENT_ARRAY_TYPE:
4409       {
4410         struct d_print_mod *hold_modifiers;
4411         struct d_print_mod adpm[4];
4412         unsigned int i;
4413         struct d_print_mod *pdpm;
4414
4415         /* We must pass this type down as a modifier in order to print
4416            multi-dimensional arrays correctly.  If the array itself is
4417            CV-qualified, we act as though the element type were
4418            CV-qualified.  We do this by copying the modifiers down
4419            rather than fiddling pointers, so that we don't wind up
4420            with a d_print_mod higher on the stack pointing into our
4421            stack frame after we return.  */
4422
4423         hold_modifiers = dpi->modifiers;
4424
4425         adpm[0].next = hold_modifiers;
4426         dpi->modifiers = &adpm[0];
4427         adpm[0].mod = dc;
4428         adpm[0].printed = 0;
4429         adpm[0].templates = dpi->templates;
4430
4431         i = 1;
4432         pdpm = hold_modifiers;
4433         while (pdpm != NULL
4434                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
4435                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
4436                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
4437           {
4438             if (! pdpm->printed)
4439               {
4440                 if (i >= sizeof adpm / sizeof adpm[0])
4441                   {
4442                     d_print_error (dpi);
4443                     return;
4444                   }
4445
4446                 adpm[i] = *pdpm;
4447                 adpm[i].next = dpi->modifiers;
4448                 dpi->modifiers = &adpm[i];
4449                 pdpm->printed = 1;
4450                 ++i;
4451               }
4452
4453             pdpm = pdpm->next;
4454           }
4455
4456         d_print_comp (dpi, options, d_right (dc));
4457
4458         dpi->modifiers = hold_modifiers;
4459
4460         if (adpm[0].printed)
4461           return;
4462
4463         while (i > 1)
4464           {
4465             --i;
4466             d_print_mod (dpi, options, adpm[i].mod);
4467           }
4468
4469         d_print_array_type (dpi, options, dc, dpi->modifiers);
4470
4471         return;
4472       }
4473
4474     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4475     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4476       {
4477         struct d_print_mod dpm;
4478
4479         dpm.next = dpi->modifiers;
4480         dpi->modifiers = &dpm;
4481         dpm.mod = dc;
4482         dpm.printed = 0;
4483         dpm.templates = dpi->templates;
4484
4485         d_print_comp (dpi, options, d_right (dc));
4486
4487         /* If the modifier didn't get printed by the type, print it
4488            now.  */
4489         if (! dpm.printed)
4490           d_print_mod (dpi, options, dc);
4491
4492         dpi->modifiers = dpm.next;
4493
4494         return;
4495       }
4496
4497     case DEMANGLE_COMPONENT_FIXED_TYPE:
4498       if (dc->u.s_fixed.sat)
4499         d_append_string (dpi, "_Sat ");
4500       /* Don't print "int _Accum".  */
4501       if (dc->u.s_fixed.length->u.s_builtin.type
4502           != &cplus_demangle_builtin_types['i'-'a'])
4503         {
4504           d_print_comp (dpi, options, dc->u.s_fixed.length);
4505           d_append_char (dpi, ' ');
4506         }
4507       if (dc->u.s_fixed.accum)
4508         d_append_string (dpi, "_Accum");
4509       else
4510         d_append_string (dpi, "_Fract");
4511       return;
4512
4513     case DEMANGLE_COMPONENT_ARGLIST:
4514     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4515       if (d_left (dc) != NULL)
4516         d_print_comp (dpi, options, d_left (dc));
4517       if (d_right (dc) != NULL)
4518         {
4519           size_t len;
4520           unsigned long int flush_count;
4521           /* Make sure ", " isn't flushed by d_append_string, otherwise
4522              dpi->len -= 2 wouldn't work.  */
4523           if (dpi->len >= sizeof (dpi->buf) - 2)
4524             d_print_flush (dpi);
4525           d_append_string (dpi, ", ");
4526           len = dpi->len;
4527           flush_count = dpi->flush_count;
4528           d_print_comp (dpi, options, d_right (dc));
4529           /* If that didn't print anything (which can happen with empty
4530              template argument packs), remove the comma and space.  */
4531           if (dpi->flush_count == flush_count && dpi->len == len)
4532             dpi->len -= 2;
4533         }
4534       return;
4535
4536     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4537       {
4538         struct demangle_component *type = d_left (dc);
4539         struct demangle_component *list = d_right (dc);
4540
4541         if (type)
4542           d_print_comp (dpi, options, type);
4543         d_append_char (dpi, '{');
4544         d_print_comp (dpi, options, list);
4545         d_append_char (dpi, '}');
4546       }
4547       return;
4548
4549     case DEMANGLE_COMPONENT_OPERATOR:
4550       {
4551         const struct demangle_operator_info *op = dc->u.s_operator.op;
4552         int len = op->len;
4553
4554         d_append_string (dpi, "operator");
4555         /* Add a space before new/delete.  */
4556         if (IS_LOWER (op->name[0]))
4557           d_append_char (dpi, ' ');
4558         /* Omit a trailing space.  */
4559         if (op->name[len-1] == ' ')
4560           --len;
4561         d_append_buffer (dpi, op->name, len);
4562         return;
4563       }
4564
4565     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4566       d_append_string (dpi, "operator ");
4567       d_print_comp (dpi, options, dc->u.s_extended_operator.name);
4568       return;
4569
4570     case DEMANGLE_COMPONENT_CAST:
4571       d_append_string (dpi, "operator ");
4572       d_print_cast (dpi, options, dc);
4573       return;
4574
4575     case DEMANGLE_COMPONENT_NULLARY:
4576       d_print_expr_op (dpi, options, d_left (dc));
4577       return;
4578
4579     case DEMANGLE_COMPONENT_UNARY:
4580       {
4581         struct demangle_component *op = d_left (dc);
4582         struct demangle_component *operand = d_right (dc);
4583         const char *code = NULL;
4584
4585         if (op->type == DEMANGLE_COMPONENT_OPERATOR)
4586           {
4587             code = op->u.s_operator.op->code;
4588             if (!strcmp (code, "ad"))
4589               {
4590                 /* Don't print the argument list for the address of a
4591                    function.  */
4592                 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
4593                     && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
4594                     && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4595                   operand = d_left (operand);
4596               }
4597             if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
4598               {
4599                 /* This indicates a suffix operator.  */
4600                 operand = d_left (operand);
4601                 d_print_subexpr (dpi, options, operand);
4602                 d_print_expr_op (dpi, options, op);
4603                 return;
4604               }
4605           }
4606
4607         if (op->type != DEMANGLE_COMPONENT_CAST)
4608           d_print_expr_op (dpi, options, op);
4609         else
4610           {
4611             d_append_char (dpi, '(');
4612             d_print_cast (dpi, options, op);
4613             d_append_char (dpi, ')');
4614           }
4615         if (code && !strcmp (code, "gs"))
4616           /* Avoid parens after '::'.  */
4617           d_print_comp (dpi, options, operand);
4618         else if (code && !strcmp (code, "st"))
4619           /* Always print parens for sizeof (type).  */
4620           {
4621             d_append_char (dpi, '(');
4622             d_print_comp (dpi, options, operand);
4623             d_append_char (dpi, ')');
4624           }
4625         else
4626           d_print_subexpr (dpi, options, operand);
4627       }
4628       return;
4629
4630     case DEMANGLE_COMPONENT_BINARY:
4631       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
4632         {
4633           d_print_error (dpi);
4634           return;
4635         }
4636
4637       if (op_is_new_cast (d_left (dc)))
4638         {
4639           d_print_expr_op (dpi, options, d_left (dc));
4640           d_append_char (dpi, '<');
4641           d_print_comp (dpi, options, d_left (d_right (dc)));
4642           d_append_string (dpi, ">(");
4643           d_print_comp (dpi, options, d_right (d_right (dc)));
4644           d_append_char (dpi, ')');
4645           return;
4646         }
4647
4648       /* We wrap an expression which uses the greater-than operator in
4649          an extra layer of parens so that it does not get confused
4650          with the '>' which ends the template parameters.  */
4651       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4652           && d_left (dc)->u.s_operator.op->len == 1
4653           && d_left (dc)->u.s_operator.op->name[0] == '>')
4654         d_append_char (dpi, '(');
4655
4656       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
4657           && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
4658         {
4659           /* Function call used in an expression should not have printed types
4660              of the function arguments.  Values of the function arguments still
4661              get printed below.  */
4662
4663           const struct demangle_component *func = d_left (d_right (dc));
4664
4665           if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
4666             d_print_error (dpi);
4667           d_print_subexpr (dpi, options, d_left (func));
4668         }
4669       else
4670         d_print_subexpr (dpi, options, d_left (d_right (dc)));
4671       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
4672         {
4673           d_append_char (dpi, '[');
4674           d_print_comp (dpi, options, d_right (d_right (dc)));
4675           d_append_char (dpi, ']');
4676         }
4677       else
4678         {
4679           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
4680             d_print_expr_op (dpi, options, d_left (dc));
4681           d_print_subexpr (dpi, options, d_right (d_right (dc)));
4682         }
4683
4684       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4685           && d_left (dc)->u.s_operator.op->len == 1
4686           && d_left (dc)->u.s_operator.op->name[0] == '>')
4687         d_append_char (dpi, ')');
4688
4689       return;
4690
4691     case DEMANGLE_COMPONENT_BINARY_ARGS:
4692       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
4693       d_print_error (dpi);
4694       return;
4695
4696     case DEMANGLE_COMPONENT_TRINARY:
4697       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
4698           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
4699         {
4700           d_print_error (dpi);
4701           return;
4702         }
4703       {
4704         struct demangle_component *op = d_left (dc);
4705         struct demangle_component *first = d_left (d_right (dc));
4706         struct demangle_component *second = d_left (d_right (d_right (dc)));
4707         struct demangle_component *third = d_right (d_right (d_right (dc)));
4708
4709         if (!strcmp (op->u.s_operator.op->code, "qu"))
4710           {
4711             d_print_subexpr (dpi, options, first);
4712             d_print_expr_op (dpi, options, op);
4713             d_print_subexpr (dpi, options, second);
4714             d_append_string (dpi, " : ");
4715             d_print_subexpr (dpi, options, third);
4716           }
4717         else
4718           {
4719             d_append_string (dpi, "new ");
4720             if (d_left (first) != NULL)
4721               {
4722                 d_print_subexpr (dpi, options, first);
4723                 d_append_char (dpi, ' ');
4724               }
4725             d_print_comp (dpi, options, second);
4726             if (third)
4727               d_print_subexpr (dpi, options, third);
4728           }
4729       }
4730       return;
4731
4732     case DEMANGLE_COMPONENT_TRINARY_ARG1:
4733     case DEMANGLE_COMPONENT_TRINARY_ARG2:
4734       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
4735       d_print_error (dpi);
4736       return;
4737
4738     case DEMANGLE_COMPONENT_LITERAL:
4739     case DEMANGLE_COMPONENT_LITERAL_NEG:
4740       {
4741         enum d_builtin_type_print tp;
4742
4743         /* For some builtin types, produce simpler output.  */
4744         tp = D_PRINT_DEFAULT;
4745         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
4746           {
4747             tp = d_left (dc)->u.s_builtin.type->print;
4748             switch (tp)
4749               {
4750               case D_PRINT_INT:
4751               case D_PRINT_UNSIGNED:
4752               case D_PRINT_LONG:
4753               case D_PRINT_UNSIGNED_LONG:
4754               case D_PRINT_LONG_LONG:
4755               case D_PRINT_UNSIGNED_LONG_LONG:
4756                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
4757                   {
4758                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4759                       d_append_char (dpi, '-');
4760                     d_print_comp (dpi, options, d_right (dc));
4761                     switch (tp)
4762                       {
4763                       default:
4764                         break;
4765                       case D_PRINT_UNSIGNED:
4766                         d_append_char (dpi, 'u');
4767                         break;
4768                       case D_PRINT_LONG:
4769                         d_append_char (dpi, 'l');
4770                         break;
4771                       case D_PRINT_UNSIGNED_LONG:
4772                         d_append_string (dpi, "ul");
4773                         break;
4774                       case D_PRINT_LONG_LONG:
4775                         d_append_string (dpi, "ll");
4776                         break;
4777                       case D_PRINT_UNSIGNED_LONG_LONG:
4778                         d_append_string (dpi, "ull");
4779                         break;
4780                       }
4781                     return;
4782                   }
4783                 break;
4784
4785               case D_PRINT_BOOL:
4786                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
4787                     && d_right (dc)->u.s_name.len == 1
4788                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
4789                   {
4790                     switch (d_right (dc)->u.s_name.s[0])
4791                       {
4792                       case '0':
4793                         d_append_string (dpi, "false");
4794                         return;
4795                       case '1':
4796                         d_append_string (dpi, "true");
4797                         return;
4798                       default:
4799                         break;
4800                       }
4801                   }
4802                 break;
4803
4804               default:
4805                 break;
4806               }
4807           }
4808
4809         d_append_char (dpi, '(');
4810         d_print_comp (dpi, options, d_left (dc));
4811         d_append_char (dpi, ')');
4812         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4813           d_append_char (dpi, '-');
4814         if (tp == D_PRINT_FLOAT)
4815           d_append_char (dpi, '[');
4816         d_print_comp (dpi, options, d_right (dc));
4817         if (tp == D_PRINT_FLOAT)
4818           d_append_char (dpi, ']');
4819       }
4820       return;
4821
4822     case DEMANGLE_COMPONENT_NUMBER:
4823       d_append_num (dpi, dc->u.s_number.number);
4824       return;
4825
4826     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4827       d_append_string (dpi, "java resource ");
4828       d_print_comp (dpi, options, d_left (dc));
4829       return;
4830
4831     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4832       d_print_comp (dpi, options, d_left (dc));
4833       d_print_comp (dpi, options, d_right (dc));
4834       return;
4835
4836     case DEMANGLE_COMPONENT_CHARACTER:
4837       d_append_char (dpi, dc->u.s_character.character);
4838       return;
4839
4840     case DEMANGLE_COMPONENT_DECLTYPE:
4841       d_append_string (dpi, "decltype (");
4842       d_print_comp (dpi, options, d_left (dc));
4843       d_append_char (dpi, ')');
4844       return;
4845
4846     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4847       {
4848         int len;
4849         int i;
4850         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4851         if (a == NULL)
4852           {
4853             /* d_find_pack won't find anything if the only packs involved
4854                in this expansion are function parameter packs; in that
4855                case, just print the pattern and "...".  */
4856             d_print_subexpr (dpi, options, d_left (dc));
4857             d_append_string (dpi, "...");
4858             return;
4859           }
4860
4861         len = d_pack_length (a);
4862         dc = d_left (dc);
4863         for (i = 0; i < len; ++i)
4864           {
4865             dpi->pack_index = i;
4866             d_print_comp (dpi, options, dc);
4867             if (i < len-1)
4868               d_append_string (dpi, ", ");
4869           }
4870       }
4871       return;
4872
4873     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4874       {
4875         long num = dc->u.s_number.number;
4876         if (num == 0)
4877           d_append_string (dpi, "this");
4878         else
4879           {
4880             d_append_string (dpi, "{parm#");
4881             d_append_num (dpi, num);
4882             d_append_char (dpi, '}');
4883           }
4884       }
4885       return;
4886
4887     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4888       d_append_string (dpi, "global constructors keyed to ");
4889       d_print_comp (dpi, options, dc->u.s_binary.left);
4890       return;
4891
4892     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4893       d_append_string (dpi, "global destructors keyed to ");
4894       d_print_comp (dpi, options, dc->u.s_binary.left);
4895       return;
4896
4897     case DEMANGLE_COMPONENT_LAMBDA:
4898       d_append_string (dpi, "{lambda(");
4899       d_print_comp (dpi, options, dc->u.s_unary_num.sub);
4900       d_append_string (dpi, ")#");
4901       d_append_num (dpi, dc->u.s_unary_num.num + 1);
4902       d_append_char (dpi, '}');
4903       return;
4904
4905     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4906       d_append_string (dpi, "{unnamed type#");
4907       d_append_num (dpi, dc->u.s_number.number + 1);
4908       d_append_char (dpi, '}');
4909       return;
4910
4911     case DEMANGLE_COMPONENT_CLONE:
4912       d_print_comp (dpi, options, d_left (dc));
4913       d_append_string (dpi, " [clone ");
4914       d_print_comp (dpi, options, d_right (dc));
4915       d_append_char (dpi, ']');
4916       return;
4917
4918     default:
4919       d_print_error (dpi);
4920       return;
4921     }
4922 }
4923
4924 /* Print a Java dentifier.  For Java we try to handle encoded extended
4925    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
4926    so we don't it for C++.  Characters are encoded as
4927    __U<hex-char>+_.  */
4928
4929 static void
4930 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4931 {
4932   const char *p;
4933   const char *end;
4934
4935   end = name + len;
4936   for (p = name; p < end; ++p)
4937     {
4938       if (end - p > 3
4939           && p[0] == '_'
4940           && p[1] == '_'
4941           && p[2] == 'U')
4942         {
4943           unsigned long c;
4944           const char *q;
4945
4946           c = 0;
4947           for (q = p + 3; q < end; ++q)
4948             {
4949               int dig;
4950
4951               if (IS_DIGIT (*q))
4952                 dig = *q - '0';
4953               else if (*q >= 'A' && *q <= 'F')
4954                 dig = *q - 'A' + 10;
4955               else if (*q >= 'a' && *q <= 'f')
4956                 dig = *q - 'a' + 10;
4957               else
4958                 break;
4959
4960               c = c * 16 + dig;
4961             }
4962           /* If the Unicode character is larger than 256, we don't try
4963              to deal with it here.  FIXME.  */
4964           if (q < end && *q == '_' && c < 256)
4965             {
4966               d_append_char (dpi, c);
4967               p = q;
4968               continue;
4969             }
4970         }
4971
4972       d_append_char (dpi, *p);
4973     }
4974 }
4975
4976 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
4977    qualifiers on this after printing a function.  */
4978
4979 static void
4980 d_print_mod_list (struct d_print_info *dpi, int options,
4981                   struct d_print_mod *mods, int suffix)
4982 {
4983   struct d_print_template *hold_dpt;
4984
4985   if (mods == NULL || d_print_saw_error (dpi))
4986     return;
4987
4988   if (mods->printed
4989       || (! suffix
4990           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4991               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4992               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS
4993               || mods->mod->type == DEMANGLE_COMPONENT_REFERENCE_THIS
4994               || (mods->mod->type
4995                   == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))))
4996     {
4997       d_print_mod_list (dpi, options, mods->next, suffix);
4998       return;
4999     }
5000
5001   mods->printed = 1;
5002
5003   hold_dpt = dpi->templates;
5004   dpi->templates = mods->templates;
5005
5006   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5007     {
5008       d_print_function_type (dpi, options, mods->mod, mods->next);
5009       dpi->templates = hold_dpt;
5010       return;
5011     }
5012   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5013     {
5014       d_print_array_type (dpi, options, mods->mod, mods->next);
5015       dpi->templates = hold_dpt;
5016       return;
5017     }
5018   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
5019     {
5020       struct d_print_mod *hold_modifiers;
5021       struct demangle_component *dc;
5022
5023       /* When this is on the modifier stack, we have pulled any
5024          qualifiers off the right argument already.  Otherwise, we
5025          print it as usual, but don't let the left argument see any
5026          modifiers.  */
5027
5028       hold_modifiers = dpi->modifiers;
5029       dpi->modifiers = NULL;
5030       d_print_comp (dpi, options, d_left (mods->mod));
5031       dpi->modifiers = hold_modifiers;
5032
5033       if ((options & DMGL_JAVA) == 0)
5034         d_append_string (dpi, "::");
5035       else
5036         d_append_char (dpi, '.');
5037
5038       dc = d_right (mods->mod);
5039
5040       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
5041         {
5042           d_append_string (dpi, "{default arg#");
5043           d_append_num (dpi, dc->u.s_unary_num.num + 1);
5044           d_append_string (dpi, "}::");
5045           dc = dc->u.s_unary_num.sub;
5046         }
5047
5048       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
5049              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
5050              || dc->type == DEMANGLE_COMPONENT_CONST_THIS
5051              || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
5052              || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
5053         dc = d_left (dc);
5054
5055       d_print_comp (dpi, options, dc);
5056
5057       dpi->templates = hold_dpt;
5058       return;
5059     }
5060
5061   d_print_mod (dpi, options, mods->mod);
5062
5063   dpi->templates = hold_dpt;
5064
5065   d_print_mod_list (dpi, options, mods->next, suffix);
5066 }
5067
5068 /* Print a modifier.  */
5069
5070 static void
5071 d_print_mod (struct d_print_info *dpi, int options,
5072              const struct demangle_component *mod)
5073 {
5074   switch (mod->type)
5075     {
5076     case DEMANGLE_COMPONENT_RESTRICT:
5077     case DEMANGLE_COMPONENT_RESTRICT_THIS:
5078       d_append_string (dpi, " restrict");
5079       return;
5080     case DEMANGLE_COMPONENT_VOLATILE:
5081     case DEMANGLE_COMPONENT_VOLATILE_THIS:
5082       d_append_string (dpi, " volatile");
5083       return;
5084     case DEMANGLE_COMPONENT_CONST:
5085     case DEMANGLE_COMPONENT_CONST_THIS:
5086       d_append_string (dpi, " const");
5087       return;
5088     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5089       d_append_char (dpi, ' ');
5090       d_print_comp (dpi, options, d_right (mod));
5091       return;
5092     case DEMANGLE_COMPONENT_POINTER:
5093       /* There is no pointer symbol in Java.  */
5094       if ((options & DMGL_JAVA) == 0)
5095         d_append_char (dpi, '*');
5096       return;
5097     case DEMANGLE_COMPONENT_REFERENCE_THIS:
5098       /* For the ref-qualifier, put a space before the &.  */
5099       d_append_char (dpi, ' ');
5100     case DEMANGLE_COMPONENT_REFERENCE:
5101       d_append_char (dpi, '&');
5102       return;
5103     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5104       d_append_char (dpi, ' ');
5105     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5106       d_append_string (dpi, "&&");
5107       return;
5108     case DEMANGLE_COMPONENT_COMPLEX:
5109       d_append_string (dpi, "complex ");
5110       return;
5111     case DEMANGLE_COMPONENT_IMAGINARY:
5112       d_append_string (dpi, "imaginary ");
5113       return;
5114     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5115       if (d_last_char (dpi) != '(')
5116         d_append_char (dpi, ' ');
5117       d_print_comp (dpi, options, d_left (mod));
5118       d_append_string (dpi, "::*");
5119       return;
5120     case DEMANGLE_COMPONENT_TYPED_NAME:
5121       d_print_comp (dpi, options, d_left (mod));
5122       return;
5123     case DEMANGLE_COMPONENT_VECTOR_TYPE:
5124       d_append_string (dpi, " __vector(");
5125       d_print_comp (dpi, options, d_left (mod));
5126       d_append_char (dpi, ')');
5127       return;
5128
5129     default:
5130       /* Otherwise, we have something that won't go back on the
5131          modifier stack, so we can just print it.  */
5132       d_print_comp (dpi, options, mod);
5133       return;
5134     }
5135 }
5136
5137 /* Print a function type, except for the return type.  */
5138
5139 static void
5140 d_print_function_type (struct d_print_info *dpi, int options,
5141                        const struct demangle_component *dc,
5142                        struct d_print_mod *mods)
5143 {
5144   int need_paren;
5145   int need_space;
5146   struct d_print_mod *p;
5147   struct d_print_mod *hold_modifiers;
5148
5149   need_paren = 0;
5150   need_space = 0;
5151   for (p = mods; p != NULL; p = p->next)
5152     {
5153       if (p->printed)
5154         break;
5155
5156       switch (p->mod->type)
5157         {
5158         case DEMANGLE_COMPONENT_POINTER:
5159         case DEMANGLE_COMPONENT_REFERENCE:
5160         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5161           need_paren = 1;
5162           break;
5163         case DEMANGLE_COMPONENT_RESTRICT:
5164         case DEMANGLE_COMPONENT_VOLATILE:
5165         case DEMANGLE_COMPONENT_CONST:
5166         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5167         case DEMANGLE_COMPONENT_COMPLEX:
5168         case DEMANGLE_COMPONENT_IMAGINARY:
5169         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5170           need_space = 1;
5171           need_paren = 1;
5172           break;
5173         case DEMANGLE_COMPONENT_RESTRICT_THIS:
5174         case DEMANGLE_COMPONENT_VOLATILE_THIS:
5175         case DEMANGLE_COMPONENT_CONST_THIS:
5176         case DEMANGLE_COMPONENT_REFERENCE_THIS:
5177         case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5178           break;
5179         default:
5180           break;
5181         }
5182       if (need_paren)
5183         break;
5184     }
5185
5186   if (need_paren)
5187     {
5188       if (! need_space)
5189         {
5190           if (d_last_char (dpi) != '('
5191               && d_last_char (dpi) != '*')
5192             need_space = 1;
5193         }
5194       if (need_space && d_last_char (dpi) != ' ')
5195         d_append_char (dpi, ' ');
5196       d_append_char (dpi, '(');
5197     }
5198
5199   hold_modifiers = dpi->modifiers;
5200   dpi->modifiers = NULL;
5201
5202   d_print_mod_list (dpi, options, mods, 0);
5203
5204   if (need_paren)
5205     d_append_char (dpi, ')');
5206
5207   d_append_char (dpi, '(');
5208
5209   if (d_right (dc) != NULL)
5210     d_print_comp (dpi, options, d_right (dc));
5211
5212   d_append_char (dpi, ')');
5213
5214   d_print_mod_list (dpi, options, mods, 1);
5215
5216   dpi->modifiers = hold_modifiers;
5217 }
5218
5219 /* Print an array type, except for the element type.  */
5220
5221 static void
5222 d_print_array_type (struct d_print_info *dpi, int options,
5223                     const struct demangle_component *dc,
5224                     struct d_print_mod *mods)
5225 {
5226   int need_space;
5227
5228   need_space = 1;
5229   if (mods != NULL)
5230     {
5231       int need_paren;
5232       struct d_print_mod *p;
5233
5234       need_paren = 0;
5235       for (p = mods; p != NULL; p = p->next)
5236         {
5237           if (! p->printed)
5238             {
5239               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5240                 {
5241                   need_space = 0;
5242                   break;
5243                 }
5244               else
5245                 {
5246                   need_paren = 1;
5247                   need_space = 1;
5248                   break;
5249                 }
5250             }
5251         }
5252
5253       if (need_paren)
5254         d_append_string (dpi, " (");
5255
5256       d_print_mod_list (dpi, options, mods, 0);
5257
5258       if (need_paren)
5259         d_append_char (dpi, ')');
5260     }
5261
5262   if (need_space)
5263     d_append_char (dpi, ' ');
5264
5265   d_append_char (dpi, '[');
5266
5267   if (d_left (dc) != NULL)
5268     d_print_comp (dpi, options, d_left (dc));
5269
5270   d_append_char (dpi, ']');
5271 }
5272
5273 /* Print an operator in an expression.  */
5274
5275 static void
5276 d_print_expr_op (struct d_print_info *dpi, int options,
5277                  const struct demangle_component *dc)
5278 {
5279   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
5280     d_append_buffer (dpi, dc->u.s_operator.op->name,
5281                      dc->u.s_operator.op->len);
5282   else
5283     d_print_comp (dpi, options, dc);
5284 }
5285
5286 /* Print a cast.  */
5287
5288 static void
5289 d_print_cast (struct d_print_info *dpi, int options,
5290               const struct demangle_component *dc)
5291 {
5292   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
5293     d_print_comp (dpi, options, d_left (dc));
5294   else
5295     {
5296       struct d_print_mod *hold_dpm;
5297       struct d_print_template dpt;
5298
5299       /* It appears that for a templated cast operator, we need to put
5300          the template parameters in scope for the operator name, but
5301          not for the parameters.  The effect is that we need to handle
5302          the template printing here.  */
5303
5304       hold_dpm = dpi->modifiers;
5305       dpi->modifiers = NULL;
5306
5307       dpt.next = dpi->templates;
5308       dpi->templates = &dpt;
5309       dpt.template_decl = d_left (dc);
5310
5311       d_print_comp (dpi, options, d_left (d_left (dc)));
5312
5313       dpi->templates = dpt.next;
5314
5315       if (d_last_char (dpi) == '<')
5316         d_append_char (dpi, ' ');
5317       d_append_char (dpi, '<');
5318       d_print_comp (dpi, options, d_right (d_left (dc)));
5319       /* Avoid generating two consecutive '>' characters, to avoid
5320          the C++ syntactic ambiguity.  */
5321       if (d_last_char (dpi) == '>')
5322         d_append_char (dpi, ' ');
5323       d_append_char (dpi, '>');
5324
5325       dpi->modifiers = hold_dpm;
5326     }
5327 }
5328
5329 /* Initialize the information structure we use to pass around
5330    information.  */
5331
5332 CP_STATIC_IF_GLIBCPP_V3
5333 void
5334 cplus_demangle_init_info (const char *mangled, int options, size_t len,
5335                           struct d_info *di)
5336 {
5337   di->s = mangled;
5338   di->send = mangled + len;
5339   di->options = options;
5340
5341   di->n = mangled;
5342
5343   /* We can not need more components than twice the number of chars in
5344      the mangled string.  Most components correspond directly to
5345      chars, but the ARGLIST types are exceptions.  */
5346   di->num_comps = 2 * len;
5347   di->next_comp = 0;
5348
5349   /* Similarly, we can not need more substitutions than there are
5350      chars in the mangled string.  */
5351   di->num_subs = len;
5352   di->next_sub = 0;
5353   di->did_subs = 0;
5354
5355   di->last_name = NULL;
5356
5357   di->expansion = 0;
5358 }
5359
5360 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
5361    mangled name, return strings in repeated callback giving the demangled
5362    name.  OPTIONS is the usual libiberty demangler options.  On success,
5363    this returns 1.  On failure, returns 0.  */
5364
5365 static int
5366 d_demangle_callback (const char *mangled, int options,
5367                      demangle_callbackref callback, void *opaque)
5368 {
5369   enum
5370     {
5371       DCT_TYPE,
5372       DCT_MANGLED,
5373       DCT_GLOBAL_CTORS,
5374       DCT_GLOBAL_DTORS
5375     }
5376   type;
5377   struct d_info di;
5378   struct demangle_component *dc;
5379   int status;
5380
5381   if (mangled[0] == '_' && mangled[1] == 'Z')
5382     type = DCT_MANGLED;
5383   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
5384            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
5385            && (mangled[9] == 'D' || mangled[9] == 'I')
5386            && mangled[10] == '_')
5387     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
5388   else
5389     {
5390       if ((options & DMGL_TYPES) == 0)
5391         return 0;
5392       type = DCT_TYPE;
5393     }
5394
5395   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
5396
5397   {
5398 #ifdef CP_DYNAMIC_ARRAYS
5399     __extension__ struct demangle_component comps[di.num_comps];
5400     __extension__ struct demangle_component *subs[di.num_subs];
5401
5402     di.comps = comps;
5403     di.subs = subs;
5404 #else
5405     di.comps = alloca (di.num_comps * sizeof (*di.comps));
5406     di.subs = alloca (di.num_subs * sizeof (*di.subs));
5407 #endif
5408
5409     switch (type)
5410       {
5411       case DCT_TYPE:
5412         dc = cplus_demangle_type (&di);
5413         break;
5414       case DCT_MANGLED:
5415         dc = cplus_demangle_mangled_name (&di, 1);
5416         break;
5417       case DCT_GLOBAL_CTORS:
5418       case DCT_GLOBAL_DTORS:
5419         d_advance (&di, 11);
5420         dc = d_make_comp (&di,
5421                           (type == DCT_GLOBAL_CTORS
5422                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
5423                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
5424                           d_make_demangle_mangled_name (&di, d_str (&di)),
5425                           NULL);
5426         d_advance (&di, strlen (d_str (&di)));
5427         break;
5428       }
5429
5430     /* If DMGL_PARAMS is set, then if we didn't consume the entire
5431        mangled string, then we didn't successfully demangle it.  If
5432        DMGL_PARAMS is not set, we didn't look at the trailing
5433        parameters.  */
5434     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
5435       dc = NULL;
5436
5437 #ifdef CP_DEMANGLE_DEBUG
5438     d_dump (dc, 0);
5439 #endif
5440
5441     status = (dc != NULL)
5442              ? cplus_demangle_print_callback (options, dc, callback, opaque)
5443              : 0;
5444   }
5445
5446   return status;
5447 }
5448
5449 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
5450    name, return a buffer allocated with malloc holding the demangled
5451    name.  OPTIONS is the usual libiberty demangler options.  On
5452    success, this sets *PALC to the allocated size of the returned
5453    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
5454    a memory allocation failure, and returns NULL.  */
5455
5456 static char *
5457 d_demangle (const char *mangled, int options, size_t *palc)
5458 {
5459   struct d_growable_string dgs;
5460   int status;
5461
5462   d_growable_string_init (&dgs, 0);
5463
5464   status = d_demangle_callback (mangled, options,
5465                                 d_growable_string_callback_adapter, &dgs);
5466   if (status == 0)
5467     {
5468       free (dgs.buf);
5469       *palc = 0;
5470       return NULL;
5471     }
5472
5473   *palc = dgs.allocation_failure ? 1 : dgs.alc;
5474   return dgs.buf;
5475 }
5476
5477 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
5478
5479 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
5480
5481 /* ia64 ABI-mandated entry point in the C++ runtime library for
5482    performing demangling.  MANGLED_NAME is a NUL-terminated character
5483    string containing the name to be demangled.
5484
5485    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
5486    *LENGTH bytes, into which the demangled name is stored.  If
5487    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
5488    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
5489    is placed in a region of memory allocated with malloc.
5490
5491    If LENGTH is non-NULL, the length of the buffer containing the
5492    demangled name, is placed in *LENGTH.
5493
5494    The return value is a pointer to the start of the NUL-terminated
5495    demangled name, or NULL if the demangling fails.  The caller is
5496    responsible for deallocating this memory using free.
5497
5498    *STATUS is set to one of the following values:
5499       0: The demangling operation succeeded.
5500      -1: A memory allocation failure occurred.
5501      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5502      -3: One of the arguments is invalid.
5503
5504    The demangling is performed using the C++ ABI mangling rules, with
5505    GNU extensions.  */
5506
5507 char *
5508 __cxa_demangle (const char *mangled_name, char *output_buffer,
5509                 size_t *length, int *status)
5510 {
5511   char *demangled;
5512   size_t alc;
5513
5514   if (mangled_name == NULL)
5515     {
5516       if (status != NULL)
5517         *status = -3;
5518       return NULL;
5519     }
5520
5521   if (output_buffer != NULL && length == NULL)
5522     {
5523       if (status != NULL)
5524         *status = -3;
5525       return NULL;
5526     }
5527
5528   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
5529
5530   if (demangled == NULL)
5531     {
5532       if (status != NULL)
5533         {
5534           if (alc == 1)
5535             *status = -1;
5536           else
5537             *status = -2;
5538         }
5539       return NULL;
5540     }
5541
5542   if (output_buffer == NULL)
5543     {
5544       if (length != NULL)
5545         *length = alc;
5546     }
5547   else
5548     {
5549       if (strlen (demangled) < *length)
5550         {
5551           strcpy (output_buffer, demangled);
5552           free (demangled);
5553           demangled = output_buffer;
5554         }
5555       else
5556         {
5557           free (output_buffer);
5558           *length = alc;
5559         }
5560     }
5561
5562   if (status != NULL)
5563     *status = 0;
5564
5565   return demangled;
5566 }
5567
5568 extern int __gcclibcxx_demangle_callback (const char *,
5569                                           void (*)
5570                                             (const char *, size_t, void *),
5571                                           void *);
5572
5573 /* Alternative, allocationless entry point in the C++ runtime library
5574    for performing demangling.  MANGLED_NAME is a NUL-terminated character
5575    string containing the name to be demangled.
5576
5577    CALLBACK is a callback function, called with demangled string
5578    segments as demangling progresses; it is called at least once,
5579    but may be called more than once.  OPAQUE is a generalized pointer
5580    used as a callback argument.
5581
5582    The return code is one of the following values, equivalent to
5583    the STATUS values of __cxa_demangle() (excluding -1, since this
5584    function performs no memory allocations):
5585       0: The demangling operation succeeded.
5586      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5587      -3: One of the arguments is invalid.
5588
5589    The demangling is performed using the C++ ABI mangling rules, with
5590    GNU extensions.  */
5591
5592 int
5593 __gcclibcxx_demangle_callback (const char *mangled_name,
5594                                void (*callback) (const char *, size_t, void *),
5595                                void *opaque)
5596 {
5597   int status;
5598
5599   if (mangled_name == NULL || callback == NULL)
5600     return -3;
5601
5602   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
5603                                 callback, opaque);
5604   if (status == 0)
5605     return -2;
5606
5607   return 0;
5608 }
5609
5610 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5611
5612 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
5613    mangled name, return a buffer allocated with malloc holding the
5614    demangled name.  Otherwise, return NULL.  */
5615
5616 char *
5617 cplus_demangle_v3 (const char *mangled, int options)
5618 {
5619   size_t alc;
5620
5621   return d_demangle (mangled, options, &alc);
5622 }
5623
5624 int
5625 cplus_demangle_v3_callback (const char *mangled, int options,
5626                             demangle_callbackref callback, void *opaque)
5627 {
5628   return d_demangle_callback (mangled, options, callback, opaque);
5629 }
5630
5631 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
5632    conventions, but the output formatting is a little different.
5633    This instructs the C++ demangler not to emit pointer characters ("*"), to
5634    use Java's namespace separator symbol ("." instead of "::"), and to output
5635    JArray<TYPE> as TYPE[].  */
5636
5637 char *
5638 java_demangle_v3 (const char *mangled)
5639 {
5640   size_t alc;
5641
5642   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
5643 }
5644
5645 int
5646 java_demangle_v3_callback (const char *mangled,
5647                            demangle_callbackref callback, void *opaque)
5648 {
5649   return d_demangle_callback (mangled,
5650                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
5651                               callback, opaque);
5652 }
5653
5654 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5655
5656 #ifndef IN_GLIBCPP_V3
5657
5658 /* Demangle a string in order to find out whether it is a constructor
5659    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
5660    *DTOR_KIND appropriately.  */
5661
5662 static int
5663 is_ctor_or_dtor (const char *mangled,
5664                  enum gnu_v3_ctor_kinds *ctor_kind,
5665                  enum gnu_v3_dtor_kinds *dtor_kind)
5666 {
5667   struct d_info di;
5668   struct demangle_component *dc;
5669   int ret;
5670
5671   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
5672   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
5673
5674   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
5675
5676   {
5677 #ifdef CP_DYNAMIC_ARRAYS
5678     __extension__ struct demangle_component comps[di.num_comps];
5679     __extension__ struct demangle_component *subs[di.num_subs];
5680
5681     di.comps = comps;
5682     di.subs = subs;
5683 #else
5684     di.comps = alloca (di.num_comps * sizeof (*di.comps));
5685     di.subs = alloca (di.num_subs * sizeof (*di.subs));
5686 #endif
5687
5688     dc = cplus_demangle_mangled_name (&di, 1);
5689
5690     /* Note that because we did not pass DMGL_PARAMS, we don't expect
5691        to demangle the entire string.  */
5692
5693     ret = 0;
5694     while (dc != NULL)
5695       {
5696         switch (dc->type)
5697           {
5698             /* These cannot appear on a constructor or destructor.  */
5699           case DEMANGLE_COMPONENT_RESTRICT_THIS:
5700           case DEMANGLE_COMPONENT_VOLATILE_THIS:
5701           case DEMANGLE_COMPONENT_CONST_THIS:
5702           case DEMANGLE_COMPONENT_REFERENCE_THIS:
5703           case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5704           default:
5705             dc = NULL;
5706             break;
5707           case DEMANGLE_COMPONENT_TYPED_NAME:
5708           case DEMANGLE_COMPONENT_TEMPLATE:
5709             dc = d_left (dc);
5710             break;
5711           case DEMANGLE_COMPONENT_QUAL_NAME:
5712           case DEMANGLE_COMPONENT_LOCAL_NAME:
5713             dc = d_right (dc);
5714             break;
5715           case DEMANGLE_COMPONENT_CTOR:
5716             *ctor_kind = dc->u.s_ctor.kind;
5717             ret = 1;
5718             dc = NULL;
5719             break;
5720           case DEMANGLE_COMPONENT_DTOR:
5721             *dtor_kind = dc->u.s_dtor.kind;
5722             ret = 1;
5723             dc = NULL;
5724             break;
5725           }
5726       }
5727   }
5728
5729   return ret;
5730 }
5731
5732 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5733    name.  A non-zero return indicates the type of constructor.  */
5734
5735 enum gnu_v3_ctor_kinds
5736 is_gnu_v3_mangled_ctor (const char *name)
5737 {
5738   enum gnu_v3_ctor_kinds ctor_kind;
5739   enum gnu_v3_dtor_kinds dtor_kind;
5740
5741   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5742     return (enum gnu_v3_ctor_kinds) 0;
5743   return ctor_kind;
5744 }
5745
5746
5747 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5748    name.  A non-zero return indicates the type of destructor.  */
5749
5750 enum gnu_v3_dtor_kinds
5751 is_gnu_v3_mangled_dtor (const char *name)
5752 {
5753   enum gnu_v3_ctor_kinds ctor_kind;
5754   enum gnu_v3_dtor_kinds dtor_kind;
5755
5756   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5757     return (enum gnu_v3_dtor_kinds) 0;
5758   return dtor_kind;
5759 }
5760
5761 #endif /* IN_GLIBCPP_V3 */
5762
5763 #ifdef STANDALONE_DEMANGLER
5764
5765 #include "getopt.h"
5766 #include "dyn-string.h"
5767
5768 static void print_usage (FILE* fp, int exit_value);
5769
5770 #define IS_ALPHA(CHAR)                                                  \
5771   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
5772    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5773
5774 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
5775 #define is_mangled_char(CHAR)                                           \
5776   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
5777    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5778
5779 /* The name of this program, as invoked.  */
5780 const char* program_name;
5781
5782 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
5783
5784 static void
5785 print_usage (FILE* fp, int exit_value)
5786 {
5787   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
5788   fprintf (fp, "Options:\n");
5789   fprintf (fp, "  -h,--help       Display this message.\n");
5790   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
5791   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
5792   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
5793
5794   exit (exit_value);
5795 }
5796
5797 /* Option specification for getopt_long.  */
5798 static const struct option long_options[] =
5799 {
5800   { "help",      no_argument, NULL, 'h' },
5801   { "no-params", no_argument, NULL, 'p' },
5802   { "verbose",   no_argument, NULL, 'v' },
5803   { NULL,        no_argument, NULL, 0   },
5804 };
5805
5806 /* Main entry for a demangling filter executable.  It will demangle
5807    its command line arguments, if any.  If none are provided, it will
5808    filter stdin to stdout, replacing any recognized mangled C++ names
5809    with their demangled equivalents.  */
5810
5811 int
5812 main (int argc, char *argv[])
5813 {
5814   int i;
5815   int opt_char;
5816   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
5817
5818   /* Use the program name of this program, as invoked.  */
5819   program_name = argv[0];
5820
5821   /* Parse options.  */
5822   do
5823     {
5824       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
5825       switch (opt_char)
5826         {
5827         case '?':  /* Unrecognized option.  */
5828           print_usage (stderr, 1);
5829           break;
5830
5831         case 'h':
5832           print_usage (stdout, 0);
5833           break;
5834
5835         case 'p':
5836           options &= ~ DMGL_PARAMS;
5837           break;
5838
5839         case 'v':
5840           options |= DMGL_VERBOSE;
5841           break;
5842         }
5843     }
5844   while (opt_char != -1);
5845
5846   if (optind == argc)
5847     /* No command line arguments were provided.  Filter stdin.  */
5848     {
5849       dyn_string_t mangled = dyn_string_new (3);
5850       char *s;
5851
5852       /* Read all of input.  */
5853       while (!feof (stdin))
5854         {
5855           char c;
5856
5857           /* Pile characters into mangled until we hit one that can't
5858              occur in a mangled name.  */
5859           c = getchar ();
5860           while (!feof (stdin) && is_mangled_char (c))
5861             {
5862               dyn_string_append_char (mangled, c);
5863               if (feof (stdin))
5864                 break;
5865               c = getchar ();
5866             }
5867
5868           if (dyn_string_length (mangled) > 0)
5869             {
5870 #ifdef IN_GLIBCPP_V3
5871               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
5872 #else
5873               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5874 #endif
5875
5876               if (s != NULL)
5877                 {
5878                   fputs (s, stdout);
5879                   free (s);
5880                 }
5881               else
5882                 {
5883                   /* It might not have been a mangled name.  Print the
5884                      original text.  */
5885                   fputs (dyn_string_buf (mangled), stdout);
5886                 }
5887
5888               dyn_string_clear (mangled);
5889             }
5890
5891           /* If we haven't hit EOF yet, we've read one character that
5892              can't occur in a mangled name, so print it out.  */
5893           if (!feof (stdin))
5894             putchar (c);
5895         }
5896
5897       dyn_string_delete (mangled);
5898     }
5899   else
5900     /* Demangle command line arguments.  */
5901     {
5902       /* Loop over command line arguments.  */
5903       for (i = optind; i < argc; ++i)
5904         {
5905           char *s;
5906 #ifdef IN_GLIBCPP_V3
5907           int status;
5908 #endif
5909
5910           /* Attempt to demangle.  */
5911 #ifdef IN_GLIBCPP_V3
5912           s = __cxa_demangle (argv[i], NULL, NULL, &status);
5913 #else
5914           s = cplus_demangle_v3 (argv[i], options);
5915 #endif
5916
5917           /* If it worked, print the demangled name.  */
5918           if (s != NULL)
5919             {
5920               printf ("%s\n", s);
5921               free (s);
5922             }
5923           else
5924             {
5925 #ifdef IN_GLIBCPP_V3
5926               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5927 #else
5928               fprintf (stderr, "Failed: %s\n", argv[i]);
5929 #endif
5930             }
5931         }
5932     }
5933
5934   return 0;
5935 }
5936
5937 #endif /* STANDALONE_DEMANGLER */