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

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