libiberty/cp-demangle.c

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