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