contrib/gcc-8.0/libiberty/cp-demangle.c

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