libiberty/cp-demangle.c

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