libiberty/cp-demangle.c

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