contrib/binutils-2.21/libiberty/cp-demangle.c

   1 /* Demangler for g++ V3 ABI.
   2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   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 enum { D_PRINT_BUFFER_LENGTH = 256 };
 279 struct d_print_info
 280 {
 281   /* The options passed to the demangler.  */
 282   int options;
 283   /* Fixed-length allocated buffer for demangled data, flushed to the
 284      callback with a NUL termination once full.  */
 285   char buf[D_PRINT_BUFFER_LENGTH];
 286   /* Current length of data in buffer.  */
 287   size_t len;
 288   /* The last character printed, saved individually so that it survives
 289      any buffer flush.  */
 290   char last_char;
 291   /* Callback function to handle demangled buffer flush.  */
 292   demangle_callbackref callback;
 293   /* Opaque callback argument.  */
 294   void *opaque;
 295   /* The current list of templates, if any.  */
 296   struct d_print_template *templates;
 297   /* The current list of modifiers (e.g., pointer, reference, etc.),
 298      if any.  */
 299   struct d_print_mod *modifiers;
 300   /* Set to 1 if we saw a demangling error.  */
 301   int demangle_failure;
 302   /* The current index into any template argument packs we are using
 303      for printing.  */
 304   int pack_index;
 305   /* Number of d_print_flush calls so far.  */
 306   unsigned long int flush_count;
 307 };
 308
 309 #ifdef CP_DEMANGLE_DEBUG
 310 static void d_dump (struct demangle_component *, int);
 311 #endif
 312
 313 static struct demangle_component *
 314 d_make_empty (struct d_info *);
 315
 316 static struct demangle_component *
 317 d_make_comp (struct d_info *, enum demangle_component_type,
 318              struct demangle_component *,
 319              struct demangle_component *);
 320
 321 static struct demangle_component *
 322 d_make_name (struct d_info *, const char *, int);
 323
 324 static struct demangle_component *
 325 d_make_builtin_type (struct d_info *,
 326                      const struct demangle_builtin_type_info *);
 327
 328 static struct demangle_component *
 329 d_make_operator (struct d_info *,
 330                  const struct demangle_operator_info *);
 331
 332 static struct demangle_component *
 333 d_make_extended_operator (struct d_info *, int,
 334                           struct demangle_component *);
 335
 336 static struct demangle_component *
 337 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
 338              struct demangle_component *);
 339
 340 static struct demangle_component *
 341 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
 342              struct demangle_component *);
 343
 344 static struct demangle_component *
 345 d_make_template_param (struct d_info *, long);
 346
 347 static struct demangle_component *
 348 d_make_sub (struct d_info *, const char *, int);
 349
 350 static int
 351 has_return_type (struct demangle_component *);
 352
 353 static int
 354 is_ctor_dtor_or_conversion (struct demangle_component *);
 355
 356 static struct demangle_component *d_encoding (struct d_info *, int);
 357
 358 static struct demangle_component *d_name (struct d_info *);
 359
 360 static struct demangle_component *d_nested_name (struct d_info *);
 361
 362 static struct demangle_component *d_prefix (struct d_info *);
 363
 364 static struct demangle_component *d_unqualified_name (struct d_info *);
 365
 366 static struct demangle_component *d_source_name (struct d_info *);
 367
 368 static long d_number (struct d_info *);
 369
 370 static struct demangle_component *d_identifier (struct d_info *, int);
 371
 372 static struct demangle_component *d_operator_name (struct d_info *);
 373
 374 static struct demangle_component *d_special_name (struct d_info *);
 375
 376 static int d_call_offset (struct d_info *, int);
 377
 378 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
 379
 380 static struct demangle_component **
 381 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
 382
 383 static struct demangle_component *
 384 d_function_type (struct d_info *);
 385
 386 static struct demangle_component *
 387 d_bare_function_type (struct d_info *, int);
 388
 389 static struct demangle_component *
 390 d_class_enum_type (struct d_info *);
 391
 392 static struct demangle_component *d_array_type (struct d_info *);
 393
 394 static struct demangle_component *d_vector_type (struct d_info *);
 395
 396 static struct demangle_component *
 397 d_pointer_to_member_type (struct d_info *);
 398
 399 static struct demangle_component *
 400 d_template_param (struct d_info *);
 401
 402 static struct demangle_component *d_template_args (struct d_info *);
 403
 404 static struct demangle_component *
 405 d_template_arg (struct d_info *);
 406
 407 static struct demangle_component *d_expression (struct d_info *);
 408
 409 static struct demangle_component *d_expr_primary (struct d_info *);
 410
 411 static struct demangle_component *d_local_name (struct d_info *);
 412
 413 static int d_discriminator (struct d_info *);
 414
 415 static struct demangle_component *d_lambda (struct d_info *);
 416
 417 static struct demangle_component *d_unnamed_type (struct d_info *);
 418
 419 static int
 420 d_add_substitution (struct d_info *, struct demangle_component *);
 421
 422 static struct demangle_component *d_substitution (struct d_info *, int);
 423
 424 static void d_growable_string_init (struct d_growable_string *, size_t);
 425
 426 static inline void
 427 d_growable_string_resize (struct d_growable_string *, size_t);
 428
 429 static inline void
 430 d_growable_string_append_buffer (struct d_growable_string *,
 431                                  const char *, size_t);
 432 static void
 433 d_growable_string_callback_adapter (const char *, size_t, void *);
 434
 435 static void
 436 d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
 437
 438 static inline void d_print_error (struct d_print_info *);
 439
 440 static inline int d_print_saw_error (struct d_print_info *);
 441
 442 static inline void d_print_flush (struct d_print_info *);
 443
 444 static inline void d_append_char (struct d_print_info *, char);
 445
 446 static inline void d_append_buffer (struct d_print_info *,
 447                                     const char *, size_t);
 448
 449 static inline void d_append_string (struct d_print_info *, const char *);
 450
 451 static inline char d_last_char (struct d_print_info *);
 452
 453 static void
 454 d_print_comp (struct d_print_info *, const struct demangle_component *);
 455
 456 static void
 457 d_print_java_identifier (struct d_print_info *, const char *, int);
 458
 459 static void
 460 d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
 461
 462 static void
 463 d_print_mod (struct d_print_info *, const struct demangle_component *);
 464
 465 static void
 466 d_print_function_type (struct d_print_info *,
 467                        const struct demangle_component *,
 468                        struct d_print_mod *);
 469
 470 static void
 471 d_print_array_type (struct d_print_info *,
 472                     const struct demangle_component *,
 473                     struct d_print_mod *);
 474
 475 static void
 476 d_print_expr_op (struct d_print_info *, const struct demangle_component *);
 477
 478 static void
 479 d_print_cast (struct d_print_info *, const struct demangle_component *);
 480
 481 static int d_demangle_callback (const char *, int,
 482                                 demangle_callbackref, void *);
 483 static char *d_demangle (const char *, int, size_t *);
 484
 485 #ifdef CP_DEMANGLE_DEBUG
 486
 487 static void
 488 d_dump (struct demangle_component *dc, int indent)
 489 {
 490   int i;
 491
 492   if (dc == NULL)
 493     {
 494       if (indent == 0)
 495         printf ("failed demangling\n");
 496       return;
 497     }
 498
 499   for (i = 0; i < indent; ++i)
 500     putchar (' ');
 501
 502   switch (dc->type)
 503     {
 504     case DEMANGLE_COMPONENT_NAME:
 505       printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
 506       return;
 507     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
 508       printf ("template parameter %ld\n", dc->u.s_number.number);
 509       return;
 510     case DEMANGLE_COMPONENT_CTOR:
 511       printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
 512       d_dump (dc->u.s_ctor.name, indent + 2);
 513       return;
 514     case DEMANGLE_COMPONENT_DTOR:
 515       printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
 516       d_dump (dc->u.s_dtor.name, indent + 2);
 517       return;
 518     case DEMANGLE_COMPONENT_SUB_STD:
 519       printf ("standard substitution %s\n", dc->u.s_string.string);
 520       return;
 521     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
 522       printf ("builtin type %s\n", dc->u.s_builtin.type->name);
 523       return;
 524     case DEMANGLE_COMPONENT_OPERATOR:
 525       printf ("operator %s\n", dc->u.s_operator.op->name);
 526       return;
 527     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 528       printf ("extended operator with %d args\n",
 529               dc->u.s_extended_operator.args);
 530       d_dump (dc->u.s_extended_operator.name, indent + 2);
 531       return;
 532
 533     case DEMANGLE_COMPONENT_QUAL_NAME:
 534       printf ("qualified name\n");
 535       break;
 536     case DEMANGLE_COMPONENT_LOCAL_NAME:
 537       printf ("local name\n");
 538       break;
 539     case DEMANGLE_COMPONENT_TYPED_NAME:
 540       printf ("typed name\n");
 541       break;
 542     case DEMANGLE_COMPONENT_TEMPLATE:
 543       printf ("template\n");
 544       break;
 545     case DEMANGLE_COMPONENT_VTABLE:
 546       printf ("vtable\n");
 547       break;
 548     case DEMANGLE_COMPONENT_VTT:
 549       printf ("VTT\n");
 550       break;
 551     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 552       printf ("construction vtable\n");
 553       break;
 554     case DEMANGLE_COMPONENT_TYPEINFO:
 555       printf ("typeinfo\n");
 556       break;
 557     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 558       printf ("typeinfo name\n");
 559       break;
 560     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 561       printf ("typeinfo function\n");
 562       break;
 563     case DEMANGLE_COMPONENT_THUNK:
 564       printf ("thunk\n");
 565       break;
 566     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 567       printf ("virtual thunk\n");
 568       break;
 569     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 570       printf ("covariant thunk\n");
 571       break;
 572     case DEMANGLE_COMPONENT_JAVA_CLASS:
 573       printf ("java class\n");
 574       break;
 575     case DEMANGLE_COMPONENT_GUARD:
 576       printf ("guard\n");
 577       break;
 578     case DEMANGLE_COMPONENT_REFTEMP:
 579       printf ("reference temporary\n");
 580       break;
 581     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 582       printf ("hidden alias\n");
 583       break;
 584     case DEMANGLE_COMPONENT_RESTRICT:
 585       printf ("restrict\n");
 586       break;
 587     case DEMANGLE_COMPONENT_VOLATILE:
 588       printf ("volatile\n");
 589       break;
 590     case DEMANGLE_COMPONENT_CONST:
 591       printf ("const\n");
 592       break;
 593     case DEMANGLE_COMPONENT_RESTRICT_THIS:
 594       printf ("restrict this\n");
 595       break;
 596     case DEMANGLE_COMPONENT_VOLATILE_THIS:
 597       printf ("volatile this\n");
 598       break;
 599     case DEMANGLE_COMPONENT_CONST_THIS:
 600       printf ("const this\n");
 601       break;
 602     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 603       printf ("vendor type qualifier\n");
 604       break;
 605     case DEMANGLE_COMPONENT_POINTER:
 606       printf ("pointer\n");
 607       break;
 608     case DEMANGLE_COMPONENT_REFERENCE:
 609       printf ("reference\n");
 610       break;
 611     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 612       printf ("rvalue reference\n");
 613       break;
 614     case DEMANGLE_COMPONENT_COMPLEX:
 615       printf ("complex\n");
 616       break;
 617     case DEMANGLE_COMPONENT_IMAGINARY:
 618       printf ("imaginary\n");
 619       break;
 620     case DEMANGLE_COMPONENT_VENDOR_TYPE:
 621       printf ("vendor type\n");
 622       break;
 623     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 624       printf ("function type\n");
 625       break;
 626     case DEMANGLE_COMPONENT_ARRAY_TYPE:
 627       printf ("array type\n");
 628       break;
 629     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 630       printf ("pointer to member type\n");
 631       break;
 632     case DEMANGLE_COMPONENT_FIXED_TYPE:
 633       printf ("fixed-point type\n");
 634       break;
 635     case DEMANGLE_COMPONENT_ARGLIST:
 636       printf ("argument list\n");
 637       break;
 638     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 639       printf ("template argument list\n");
 640       break;
 641     case DEMANGLE_COMPONENT_CAST:
 642       printf ("cast\n");
 643       break;
 644     case DEMANGLE_COMPONENT_UNARY:
 645       printf ("unary operator\n");
 646       break;
 647     case DEMANGLE_COMPONENT_BINARY:
 648       printf ("binary operator\n");
 649       break;
 650     case DEMANGLE_COMPONENT_BINARY_ARGS:
 651       printf ("binary operator arguments\n");
 652       break;
 653     case DEMANGLE_COMPONENT_TRINARY:
 654       printf ("trinary operator\n");
 655       break;
 656     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 657       printf ("trinary operator arguments 1\n");
 658       break;
 659     case DEMANGLE_COMPONENT_TRINARY_ARG2:
 660       printf ("trinary operator arguments 1\n");
 661       break;
 662     case DEMANGLE_COMPONENT_LITERAL:
 663       printf ("literal\n");
 664       break;
 665     case DEMANGLE_COMPONENT_LITERAL_NEG:
 666       printf ("negative literal\n");
 667       break;
 668     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 669       printf ("java resource\n");
 670       break;
 671     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 672       printf ("compound name\n");
 673       break;
 674     case DEMANGLE_COMPONENT_CHARACTER:
 675       printf ("character '%c'\n",  dc->u.s_character.character);
 676       return;
 677     case DEMANGLE_COMPONENT_DECLTYPE:
 678       printf ("decltype\n");
 679       break;
 680     case DEMANGLE_COMPONENT_PACK_EXPANSION:
 681       printf ("pack expansion\n");
 682       break;
 683     }
 684
 685   d_dump (d_left (dc), indent + 2);
 686   d_dump (d_right (dc), indent + 2);
 687 }
 688
 689 #endif /* CP_DEMANGLE_DEBUG */
 690
 691 /* Fill in a DEMANGLE_COMPONENT_NAME.  */
 692
 693 CP_STATIC_IF_GLIBCPP_V3
 694 int
 695 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
 696 {
 697   if (p == NULL || s == NULL || len == 0)
 698     return 0;
 699   p->type = DEMANGLE_COMPONENT_NAME;
 700   p->u.s_name.s = s;
 701   p->u.s_name.len = len;
 702   return 1;
 703 }
 704
 705 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
 706
 707 CP_STATIC_IF_GLIBCPP_V3
 708 int
 709 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
 710                                        struct demangle_component *name)
 711 {
 712   if (p == NULL || args < 0 || name == NULL)
 713     return 0;
 714   p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
 715   p->u.s_extended_operator.args = args;
 716   p->u.s_extended_operator.name = name;
 717   return 1;
 718 }
 719
 720 /* Fill in a DEMANGLE_COMPONENT_CTOR.  */
 721
 722 CP_STATIC_IF_GLIBCPP_V3
 723 int
 724 cplus_demangle_fill_ctor (struct demangle_component *p,
 725                           enum gnu_v3_ctor_kinds kind,
 726                           struct demangle_component *name)
 727 {
 728   if (p == NULL
 729       || name == NULL
 730       || (int) kind < gnu_v3_complete_object_ctor
 731       || (int) kind > gnu_v3_complete_object_allocating_ctor)
 732     return 0;
 733   p->type = DEMANGLE_COMPONENT_CTOR;
 734   p->u.s_ctor.kind = kind;
 735   p->u.s_ctor.name = name;
 736   return 1;
 737 }
 738
 739 /* Fill in a DEMANGLE_COMPONENT_DTOR.  */
 740
 741 CP_STATIC_IF_GLIBCPP_V3
 742 int
 743 cplus_demangle_fill_dtor (struct demangle_component *p,
 744                           enum gnu_v3_dtor_kinds kind,
 745                           struct demangle_component *name)
 746 {
 747   if (p == NULL
 748       || name == NULL
 749       || (int) kind < gnu_v3_deleting_dtor
 750       || (int) kind > gnu_v3_base_object_dtor)
 751     return 0;
 752   p->type = DEMANGLE_COMPONENT_DTOR;
 753   p->u.s_dtor.kind = kind;
 754   p->u.s_dtor.name = name;
 755   return 1;
 756 }
 757
 758 /* Add a new component.  */
 759
 760 static struct demangle_component *
 761 d_make_empty (struct d_info *di)
 762 {
 763   struct demangle_component *p;
 764
 765   if (di->next_comp >= di->num_comps)
 766     return NULL;
 767   p = &di->comps[di->next_comp];
 768   ++di->next_comp;
 769   return p;
 770 }
 771
 772 /* Add a new generic component.  */
 773
 774 static struct demangle_component *
 775 d_make_comp (struct d_info *di, enum demangle_component_type type,
 776              struct demangle_component *left,
 777              struct demangle_component *right)
 778 {
 779   struct demangle_component *p;
 780
 781   /* We check for errors here.  A typical error would be a NULL return
 782      from a subroutine.  We catch those here, and return NULL
 783      upward.  */
 784   switch (type)
 785     {
 786       /* These types require two parameters.  */
 787     case DEMANGLE_COMPONENT_QUAL_NAME:
 788     case DEMANGLE_COMPONENT_LOCAL_NAME:
 789     case DEMANGLE_COMPONENT_TYPED_NAME:
 790     case DEMANGLE_COMPONENT_TEMPLATE:
 791     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 792     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 793     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 794     case DEMANGLE_COMPONENT_UNARY:
 795     case DEMANGLE_COMPONENT_BINARY:
 796     case DEMANGLE_COMPONENT_BINARY_ARGS:
 797     case DEMANGLE_COMPONENT_TRINARY:
 798     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 799     case DEMANGLE_COMPONENT_TRINARY_ARG2:
 800     case DEMANGLE_COMPONENT_LITERAL:
 801     case DEMANGLE_COMPONENT_LITERAL_NEG:
 802     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 803     case DEMANGLE_COMPONENT_VECTOR_TYPE:
 804       if (left == NULL || right == NULL)
 805         return NULL;
 806       break;
 807
 808       /* These types only require one parameter.  */
 809     case DEMANGLE_COMPONENT_VTABLE:
 810     case DEMANGLE_COMPONENT_VTT:
 811     case DEMANGLE_COMPONENT_TYPEINFO:
 812     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 813     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 814     case DEMANGLE_COMPONENT_THUNK:
 815     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 816     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 817     case DEMANGLE_COMPONENT_JAVA_CLASS:
 818     case DEMANGLE_COMPONENT_GUARD:
 819     case DEMANGLE_COMPONENT_REFTEMP:
 820     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 821     case DEMANGLE_COMPONENT_POINTER:
 822     case DEMANGLE_COMPONENT_REFERENCE:
 823     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 824     case DEMANGLE_COMPONENT_COMPLEX:
 825     case DEMANGLE_COMPONENT_IMAGINARY:
 826     case DEMANGLE_COMPONENT_VENDOR_TYPE:
 827     case DEMANGLE_COMPONENT_CAST:
 828     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 829     case DEMANGLE_COMPONENT_DECLTYPE:
 830     case DEMANGLE_COMPONENT_PACK_EXPANSION:
 831     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
 832     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
 833       if (left == NULL)
 834         return NULL;
 835       break;
 836
 837       /* This needs a right parameter, but the left parameter can be
 838          empty.  */
 839     case DEMANGLE_COMPONENT_ARRAY_TYPE:
 840       if (right == NULL)
 841         return NULL;
 842       break;
 843
 844       /* These are allowed to have no parameters--in some cases they
 845          will be filled in later.  */
 846     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 847     case DEMANGLE_COMPONENT_RESTRICT:
 848     case DEMANGLE_COMPONENT_VOLATILE:
 849     case DEMANGLE_COMPONENT_CONST:
 850     case DEMANGLE_COMPONENT_RESTRICT_THIS:
 851     case DEMANGLE_COMPONENT_VOLATILE_THIS:
 852     case DEMANGLE_COMPONENT_CONST_THIS:
 853     case DEMANGLE_COMPONENT_ARGLIST:
 854     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 855       break;
 856
 857       /* Other types should not be seen here.  */
 858     default:
 859       return NULL;
 860     }
 861
 862   p = d_make_empty (di);
 863   if (p != NULL)
 864     {
 865       p->type = type;
 866       p->u.s_binary.left = left;
 867       p->u.s_binary.right = right;
 868     }
 869   return p;
 870 }
 871
 872 /* Add a new name component.  */
 873
 874 static struct demangle_component *
 875 d_make_name (struct d_info *di, const char *s, int len)
 876 {
 877   struct demangle_component *p;
 878
 879   p = d_make_empty (di);
 880   if (! cplus_demangle_fill_name (p, s, len))
 881     return NULL;
 882   return p;
 883 }
 884
 885 /* Add a new builtin type component.  */
 886
 887 static struct demangle_component *
 888 d_make_builtin_type (struct d_info *di,
 889                      const struct demangle_builtin_type_info *type)
 890 {
 891   struct demangle_component *p;
 892
 893   if (type == NULL)
 894     return NULL;
 895   p = d_make_empty (di);
 896   if (p != NULL)
 897     {
 898       p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
 899       p->u.s_builtin.type = type;
 900     }
 901   return p;
 902 }
 903
 904 /* Add a new operator component.  */
 905
 906 static struct demangle_component *
 907 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
 908 {
 909   struct demangle_component *p;
 910
 911   p = d_make_empty (di);
 912   if (p != NULL)
 913     {
 914       p->type = DEMANGLE_COMPONENT_OPERATOR;
 915       p->u.s_operator.op = op;
 916     }
 917   return p;
 918 }
 919
 920 /* Add a new extended operator component.  */
 921
 922 static struct demangle_component *
 923 d_make_extended_operator (struct d_info *di, int args,
 924                           struct demangle_component *name)
 925 {
 926   struct demangle_component *p;
 927
 928   p = d_make_empty (di);
 929   if (! cplus_demangle_fill_extended_operator (p, args, name))
 930     return NULL;
 931   return p;
 932 }
 933
 934 static struct demangle_component *
 935 d_make_default_arg (struct d_info *di, int num,
 936                     struct demangle_component *sub)
 937 {
 938   struct demangle_component *p = d_make_empty (di);
 939   if (p)
 940     {
 941       p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
 942       p->u.s_unary_num.num = num;
 943       p->u.s_unary_num.sub = sub;
 944     }
 945   return p;
 946 }
 947
 948 /* Add a new constructor component.  */
 949
 950 static struct demangle_component *
 951 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
 952              struct demangle_component *name)
 953 {
 954   struct demangle_component *p;
 955
 956   p = d_make_empty (di);
 957   if (! cplus_demangle_fill_ctor (p, kind, name))
 958     return NULL;
 959   return p;
 960 }
 961
 962 /* Add a new destructor component.  */
 963
 964 static struct demangle_component *
 965 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
 966              struct demangle_component *name)
 967 {
 968   struct demangle_component *p;
 969
 970   p = d_make_empty (di);
 971   if (! cplus_demangle_fill_dtor (p, kind, name))
 972     return NULL;
 973   return p;
 974 }
 975
 976 /* Add a new template parameter.  */
 977
 978 static struct demangle_component *
 979 d_make_template_param (struct d_info *di, long i)
 980 {
 981   struct demangle_component *p;
 982
 983   p = d_make_empty (di);
 984   if (p != NULL)
 985     {
 986       p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
 987       p->u.s_number.number = i;
 988     }
 989   return p;
 990 }
 991
 992 /* Add a new function parameter.  */
 993
 994 static struct demangle_component *
 995 d_make_function_param (struct d_info *di, long i)
 996 {
 997   struct demangle_component *p;
 998
 999   p = d_make_empty (di);
1000   if (p != NULL)
1001     {
1002       p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1003       p->u.s_number.number = i;
1004     }
1005   return p;
1006 }
1007
1008 /* Add a new standard substitution component.  */
1009
1010 static struct demangle_component *
1011 d_make_sub (struct d_info *di, const char *name, int len)
1012 {
1013   struct demangle_component *p;
1014
1015   p = d_make_empty (di);
1016   if (p != NULL)
1017     {
1018       p->type = DEMANGLE_COMPONENT_SUB_STD;
1019       p->u.s_string.string = name;
1020       p->u.s_string.len = len;
1021     }
1022   return p;
1023 }
1024
1025 /* <mangled-name> ::= _Z <encoding>
1026
1027    TOP_LEVEL is non-zero when called at the top level.  */
1028
1029 CP_STATIC_IF_GLIBCPP_V3
1030 struct demangle_component *
1031 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1032 {
1033   if (! d_check_char (di, '_')
1034       /* Allow missing _ if not at toplevel to work around a
1035          bug in G++ abi-version=2 mangling; see the comment in
1036          write_template_arg.  */
1037       && top_level)
1038     return NULL;
1039   if (! d_check_char (di, 'Z'))
1040     return NULL;
1041   return d_encoding (di, top_level);
1042 }
1043
1044 /* Return whether a function should have a return type.  The argument
1045    is the function name, which may be qualified in various ways.  The
1046    rules are that template functions have return types with some
1047    exceptions, function types which are not part of a function name
1048    mangling have return types with some exceptions, and non-template
1049    function names do not have return types.  The exceptions are that
1050    constructors, destructors, and conversion operators do not have
1051    return types.  */
1052
1053 static int
1054 has_return_type (struct demangle_component *dc)
1055 {
1056   if (dc == NULL)
1057     return 0;
1058   switch (dc->type)
1059     {
1060     default:
1061       return 0;
1062     case DEMANGLE_COMPONENT_TEMPLATE:
1063       return ! is_ctor_dtor_or_conversion (d_left (dc));
1064     case DEMANGLE_COMPONENT_RESTRICT_THIS:
1065     case DEMANGLE_COMPONENT_VOLATILE_THIS:
1066     case DEMANGLE_COMPONENT_CONST_THIS:
1067       return has_return_type (d_left (dc));
1068     }
1069 }
1070
1071 /* Return whether a name is a constructor, a destructor, or a
1072    conversion operator.  */
1073
1074 static int
1075 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1076 {
1077   if (dc == NULL)
1078     return 0;
1079   switch (dc->type)
1080     {
1081     default:
1082       return 0;
1083     case DEMANGLE_COMPONENT_QUAL_NAME:
1084     case DEMANGLE_COMPONENT_LOCAL_NAME:
1085       return is_ctor_dtor_or_conversion (d_right (dc));
1086     case DEMANGLE_COMPONENT_CTOR:
1087     case DEMANGLE_COMPONENT_DTOR:
1088     case DEMANGLE_COMPONENT_CAST:
1089       return 1;
1090     }
1091 }
1092
1093 /* <encoding> ::= <(function) name> <bare-function-type>
1094               ::= <(data) name>
1095               ::= <special-name>
1096
1097    TOP_LEVEL is non-zero when called at the top level, in which case
1098    if DMGL_PARAMS is not set we do not demangle the function
1099    parameters.  We only set this at the top level, because otherwise
1100    we would not correctly demangle names in local scopes.  */
1101
1102 static struct demangle_component *
1103 d_encoding (struct d_info *di, int top_level)
1104 {
1105   char peek = d_peek_char (di);
1106
1107   if (peek == 'G' || peek == 'T')
1108     return d_special_name (di);
1109   else
1110     {
1111       struct demangle_component *dc;
1112
1113       dc = d_name (di);
1114
1115       if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1116         {
1117           /* Strip off any initial CV-qualifiers, as they really apply
1118              to the `this' parameter, and they were not output by the
1119              v2 demangler without DMGL_PARAMS.  */
1120           while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1121                  || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1122                  || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
1123             dc = d_left (dc);
1124
1125           /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1126              there may be CV-qualifiers on its right argument which
1127              really apply here; this happens when parsing a class
1128              which is local to a function.  */
1129           if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1130             {
1131               struct demangle_component *dcr;
1132
1133               dcr = d_right (dc);
1134               while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1135                      || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1136                      || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
1137                 dcr = d_left (dcr);
1138               dc->u.s_binary.right = dcr;
1139             }
1140
1141           return dc;
1142         }
1143
1144       peek = d_peek_char (di);
1145       if (dc == NULL || peek == '\0' || peek == 'E')
1146         return dc;
1147       return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1148                           d_bare_function_type (di, has_return_type (dc)));
1149     }
1150 }
1151
1152 /* <name> ::= <nested-name>
1153           ::= <unscoped-name>
1154           ::= <unscoped-template-name> <template-args>
1155           ::= <local-name>
1156
1157    <unscoped-name> ::= <unqualified-name>
1158                    ::= St <unqualified-name>
1159
1160    <unscoped-template-name> ::= <unscoped-name>
1161                             ::= <substitution>
1162 */
1163
1164 static struct demangle_component *
1165 d_name (struct d_info *di)
1166 {
1167   char peek = d_peek_char (di);
1168   struct demangle_component *dc;
1169
1170   switch (peek)
1171     {
1172     case 'N':
1173       return d_nested_name (di);
1174
1175     case 'Z':
1176       return d_local_name (di);
1177
1178     case 'L':
1179     case 'U':
1180       return d_unqualified_name (di);
1181
1182     case 'S':
1183       {
1184         int subst;
1185
1186         if (d_peek_next_char (di) != 't')
1187           {
1188             dc = d_substitution (di, 0);
1189             subst = 1;
1190           }
1191         else
1192           {
1193             d_advance (di, 2);
1194             dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1195                               d_make_name (di, "std", 3),
1196                               d_unqualified_name (di));
1197             di->expansion += 3;
1198             subst = 0;
1199           }
1200
1201         if (d_peek_char (di) != 'I')
1202           {
1203             /* The grammar does not permit this case to occur if we
1204                called d_substitution() above (i.e., subst == 1).  We
1205                don't bother to check.  */
1206           }
1207         else
1208           {
1209             /* This is <template-args>, which means that we just saw
1210                <unscoped-template-name>, which is a substitution
1211                candidate if we didn't just get it from a
1212                substitution.  */
1213             if (! subst)
1214               {
1215                 if (! d_add_substitution (di, dc))
1216                   return NULL;
1217               }
1218             dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1219                               d_template_args (di));
1220           }
1221
1222         return dc;
1223       }
1224
1225     default:
1226       dc = d_unqualified_name (di);
1227       if (d_peek_char (di) == 'I')
1228         {
1229           /* This is <template-args>, which means that we just saw
1230              <unscoped-template-name>, which is a substitution
1231              candidate.  */
1232           if (! d_add_substitution (di, dc))
1233             return NULL;
1234           dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1235                             d_template_args (di));
1236         }
1237       return dc;
1238     }
1239 }
1240
1241 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1242                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1243 */
1244
1245 static struct demangle_component *
1246 d_nested_name (struct d_info *di)
1247 {
1248   struct demangle_component *ret;
1249   struct demangle_component **pret;
1250
1251   if (! d_check_char (di, 'N'))
1252     return NULL;
1253
1254   pret = d_cv_qualifiers (di, &ret, 1);
1255   if (pret == NULL)
1256     return NULL;
1257
1258   *pret = d_prefix (di);
1259   if (*pret == NULL)
1260     return NULL;
1261
1262   if (! d_check_char (di, 'E'))
1263     return NULL;
1264
1265   return ret;
1266 }
1267
1268 /* <prefix> ::= <prefix> <unqualified-name>
1269             ::= <template-prefix> <template-args>
1270             ::= <template-param>
1271             ::=
1272             ::= <substitution>
1273
1274    <template-prefix> ::= <prefix> <(template) unqualified-name>
1275                      ::= <template-param>
1276                      ::= <substitution>
1277 */
1278
1279 static struct demangle_component *
1280 d_prefix (struct d_info *di)
1281 {
1282   struct demangle_component *ret = NULL;
1283
1284   while (1)
1285     {
1286       char peek;
1287       enum demangle_component_type comb_type;
1288       struct demangle_component *dc;
1289
1290       peek = d_peek_char (di);
1291       if (peek == '\0')
1292         return NULL;
1293
1294       /* The older code accepts a <local-name> here, but I don't see
1295          that in the grammar.  The older code does not accept a
1296          <template-param> here.  */
1297
1298       comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1299       if (IS_DIGIT (peek)
1300           || IS_LOWER (peek)
1301           || peek == 'C'
1302           || peek == 'D'
1303           || peek == 'U'
1304           || peek == 'L')
1305         dc = d_unqualified_name (di);
1306       else if (peek == 'S')
1307         dc = d_substitution (di, 1);
1308       else if (peek == 'I')
1309         {
1310           if (ret == NULL)
1311             return NULL;
1312           comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1313           dc = d_template_args (di);
1314         }
1315       else if (peek == 'T')
1316         dc = d_template_param (di);
1317       else if (peek == 'E')
1318         return ret;
1319       else if (peek == 'M')
1320         {
1321           /* Initializer scope for a lambda.  We don't need to represent
1322              this; the normal code will just treat the variable as a type
1323              scope, which gives appropriate output.  */
1324           if (ret == NULL)
1325             return NULL;
1326           d_advance (di, 1);
1327           continue;
1328         }
1329       else
1330         return NULL;
1331
1332       if (ret == NULL)
1333         ret = dc;
1334       else
1335         ret = d_make_comp (di, comb_type, ret, dc);
1336
1337       if (peek != 'S' && d_peek_char (di) != 'E')
1338         {
1339           if (! d_add_substitution (di, ret))
1340             return NULL;
1341         }
1342     }
1343 }
1344
1345 /* <unqualified-name> ::= <operator-name>
1346                       ::= <ctor-dtor-name>
1347                       ::= <source-name>
1348                       ::= <local-source-name>
1349
1350     <local-source-name> ::= L <source-name> <discriminator>
1351 */
1352
1353 static struct demangle_component *
1354 d_unqualified_name (struct d_info *di)
1355 {
1356   char peek;
1357
1358   peek = d_peek_char (di);
1359   if (IS_DIGIT (peek))
1360     return d_source_name (di);
1361   else if (IS_LOWER (peek))
1362     {
1363       struct demangle_component *ret;
1364
1365       ret = d_operator_name (di);
1366       if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1367         di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1368       return ret;
1369     }
1370   else if (peek == 'C' || peek == 'D')
1371     return d_ctor_dtor_name (di);
1372   else if (peek == 'L')
1373     {
1374       struct demangle_component * ret;
1375
1376       d_advance (di, 1);
1377
1378       ret = d_source_name (di);
1379       if (ret == NULL)
1380         return NULL;
1381       if (! d_discriminator (di))
1382         return NULL;
1383       return ret;
1384     }
1385   else if (peek == 'U')
1386     {
1387       switch (d_peek_next_char (di))
1388         {
1389         case 'l':
1390           return d_lambda (di);
1391         case 't':
1392           return d_unnamed_type (di);
1393         default:
1394           return NULL;
1395         }
1396     }
1397   else
1398     return NULL;
1399 }
1400
1401 /* <source-name> ::= <(positive length) number> <identifier>  */
1402
1403 static struct demangle_component *
1404 d_source_name (struct d_info *di)
1405 {
1406   long len;
1407   struct demangle_component *ret;
1408
1409   len = d_number (di);
1410   if (len <= 0)
1411     return NULL;
1412   ret = d_identifier (di, len);
1413   di->last_name = ret;
1414   return ret;
1415 }
1416
1417 /* number ::= [n] <(non-negative decimal integer)>  */
1418
1419 static long
1420 d_number (struct d_info *di)
1421 {
1422   int negative;
1423   char peek;
1424   long ret;
1425
1426   negative = 0;
1427   peek = d_peek_char (di);
1428   if (peek == 'n')
1429     {
1430       negative = 1;
1431       d_advance (di, 1);
1432       peek = d_peek_char (di);
1433     }
1434
1435   ret = 0;
1436   while (1)
1437     {
1438       if (! IS_DIGIT (peek))
1439         {
1440           if (negative)
1441             ret = - ret;
1442           return ret;
1443         }
1444       ret = ret * 10 + peek - '0';
1445       d_advance (di, 1);
1446       peek = d_peek_char (di);
1447     }
1448 }
1449
1450 /* Like d_number, but returns a demangle_component.  */
1451
1452 static struct demangle_component *
1453 d_number_component (struct d_info *di)
1454 {
1455   struct demangle_component *ret = d_make_empty (di);
1456   if (ret)
1457     {
1458       ret->type = DEMANGLE_COMPONENT_NUMBER;
1459       ret->u.s_number.number = d_number (di);
1460     }
1461   return ret;
1462 }
1463
1464 /* identifier ::= <(unqualified source code identifier)>  */
1465
1466 static struct demangle_component *
1467 d_identifier (struct d_info *di, int len)
1468 {
1469   const char *name;
1470
1471   name = d_str (di);
1472
1473   if (di->send - name < len)
1474     return NULL;
1475
1476   d_advance (di, len);
1477
1478   /* A Java mangled name may have a trailing '$' if it is a C++
1479      keyword.  This '$' is not included in the length count.  We just
1480      ignore the '$'.  */
1481   if ((di->options & DMGL_JAVA) != 0
1482       && d_peek_char (di) == '$')
1483     d_advance (di, 1);
1484
1485   /* Look for something which looks like a gcc encoding of an
1486      anonymous namespace, and replace it with a more user friendly
1487      name.  */
1488   if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1489       && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1490                  ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1491     {
1492       const char *s;
1493
1494       s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1495       if ((*s == '.' || *s == '_' || *s == '$')
1496           && s[1] == 'N')
1497         {
1498           di->expansion -= len - sizeof "(anonymous namespace)";
1499           return d_make_name (di, "(anonymous namespace)",
1500                               sizeof "(anonymous namespace)" - 1);
1501         }
1502     }
1503
1504   return d_make_name (di, name, len);
1505 }
1506
1507 /* operator_name ::= many different two character encodings.
1508                  ::= cv <type>
1509                  ::= v <digit> <source-name>
1510 */
1511
1512 #define NL(s) s, (sizeof s) - 1
1513
1514 CP_STATIC_IF_GLIBCPP_V3
1515 const struct demangle_operator_info cplus_demangle_operators[] =
1516 {
1517   { "aN", NL ("&="),        2 },
1518   { "aS", NL ("="),         2 },
1519   { "aa", NL ("&&"),        2 },
1520   { "ad", NL ("&"),         1 },
1521   { "an", NL ("&"),         2 },
1522   { "cl", NL ("()"),        2 },
1523   { "cm", NL (","),         2 },
1524   { "co", NL ("~"),         1 },
1525   { "dV", NL ("/="),        2 },
1526   { "da", NL ("delete[]"),  1 },
1527   { "de", NL ("*"),         1 },
1528   { "dl", NL ("delete"),    1 },
1529   { "dt", NL ("."),         2 },
1530   { "dv", NL ("/"),         2 },
1531   { "eO", NL ("^="),        2 },
1532   { "eo", NL ("^"),         2 },
1533   { "eq", NL ("=="),        2 },
1534   { "ge", NL (">="),        2 },
1535   { "gt", NL (">"),         2 },
1536   { "ix", NL ("[]"),        2 },
1537   { "lS", NL ("<<="),       2 },
1538   { "le", NL ("<="),        2 },
1539   { "ls", NL ("<<"),        2 },
1540   { "lt", NL ("<"),         2 },
1541   { "mI", NL ("-="),        2 },
1542   { "mL", NL ("*="),        2 },
1543   { "mi", NL ("-"),         2 },
1544   { "ml", NL ("*"),         2 },
1545   { "mm", NL ("--"),        1 },
1546   { "na", NL ("new[]"),     1 },
1547   { "ne", NL ("!="),        2 },
1548   { "ng", NL ("-"),         1 },
1549   { "nt", NL ("!"),         1 },
1550   { "nw", NL ("new"),       1 },
1551   { "oR", NL ("|="),        2 },
1552   { "oo", NL ("||"),        2 },
1553   { "or", NL ("|"),         2 },
1554   { "pL", NL ("+="),        2 },
1555   { "pl", NL ("+"),         2 },
1556   { "pm", NL ("->*"),       2 },
1557   { "pp", NL ("++"),        1 },
1558   { "ps", NL ("+"),         1 },
1559   { "pt", NL ("->"),        2 },
1560   { "qu", NL ("?"),         3 },
1561   { "rM", NL ("%="),        2 },
1562   { "rS", NL (">>="),       2 },
1563   { "rm", NL ("%"),         2 },
1564   { "rs", NL (">>"),        2 },
1565   { "st", NL ("sizeof "),   1 },
1566   { "sz", NL ("sizeof "),   1 },
1567   { "at", NL ("alignof "),   1 },
1568   { "az", NL ("alignof "),   1 },
1569   { NULL, NULL, 0,          0 }
1570 };
1571
1572 static struct demangle_component *
1573 d_operator_name (struct d_info *di)
1574 {
1575   char c1;
1576   char c2;
1577
1578   c1 = d_next_char (di);
1579   c2 = d_next_char (di);
1580   if (c1 == 'v' && IS_DIGIT (c2))
1581     return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1582   else if (c1 == 'c' && c2 == 'v')
1583     return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
1584                         cplus_demangle_type (di), NULL);
1585   else
1586     {
1587       /* LOW is the inclusive lower bound.  */
1588       int low = 0;
1589       /* HIGH is the exclusive upper bound.  We subtract one to ignore
1590          the sentinel at the end of the array.  */
1591       int high = ((sizeof (cplus_demangle_operators)
1592                    / sizeof (cplus_demangle_operators[0]))
1593                   - 1);
1594
1595       while (1)
1596         {
1597           int i;
1598           const struct demangle_operator_info *p;
1599
1600           i = low + (high - low) / 2;
1601           p = cplus_demangle_operators + i;
1602
1603           if (c1 == p->code[0] && c2 == p->code[1])
1604             return d_make_operator (di, p);
1605
1606           if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1607             high = i;
1608           else
1609             low = i + 1;
1610           if (low == high)
1611             return NULL;
1612         }
1613     }
1614 }
1615
1616 static struct demangle_component *
1617 d_make_character (struct d_info *di, int c)
1618 {
1619   struct demangle_component *p;
1620   p = d_make_empty (di);
1621   if (p != NULL)
1622     {
1623       p->type = DEMANGLE_COMPONENT_CHARACTER;
1624       p->u.s_character.character = c;
1625     }
1626   return p;
1627 }
1628
1629 static struct demangle_component *
1630 d_java_resource (struct d_info *di)
1631 {
1632   struct demangle_component *p = NULL;
1633   struct demangle_component *next = NULL;
1634   long len, i;
1635   char c;
1636   const char *str;
1637
1638   len = d_number (di);
1639   if (len <= 1)
1640     return NULL;
1641
1642   /* Eat the leading '_'.  */
1643   if (d_next_char (di) != '_')
1644     return NULL;
1645   len--;
1646
1647   str = d_str (di);
1648   i = 0;
1649
1650   while (len > 0)
1651     {
1652       c = str[i];
1653       if (!c)
1654         return NULL;
1655
1656       /* Each chunk is either a '$' escape...  */
1657       if (c == '$')
1658         {
1659           i++;
1660           switch (str[i++])
1661             {
1662             case 'S':
1663               c = '/';
1664               break;
1665             case '_':
1666               c = '.';
1667               break;
1668             case '$':
1669               c = '$';
1670               break;
1671             default:
1672               return NULL;
1673             }
1674           next = d_make_character (di, c);
1675           d_advance (di, i);
1676           str = d_str (di);
1677           len -= i;
1678           i = 0;
1679           if (next == NULL)
1680             return NULL;
1681         }
1682       /* ... or a sequence of characters.  */
1683       else
1684         {
1685           while (i < len && str[i] && str[i] != '$')
1686             i++;
1687
1688           next = d_make_name (di, str, i);
1689           d_advance (di, i);
1690           str = d_str (di);
1691           len -= i;
1692           i = 0;
1693           if (next == NULL)
1694             return NULL;
1695         }
1696
1697       if (p == NULL)
1698         p = next;
1699       else
1700         {
1701           p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
1702           if (p == NULL)
1703             return NULL;
1704         }
1705     }
1706
1707   p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
1708
1709   return p;
1710 }
1711
1712 /* <special-name> ::= TV <type>
1713                   ::= TT <type>
1714                   ::= TI <type>
1715                   ::= TS <type>
1716                   ::= GV <(object) name>
1717                   ::= T <call-offset> <(base) encoding>
1718                   ::= Tc <call-offset> <call-offset> <(base) encoding>
1719    Also g++ extensions:
1720                   ::= TC <type> <(offset) number> _ <(base) type>
1721                   ::= TF <type>
1722                   ::= TJ <type>
1723                   ::= GR <name>
1724                   ::= GA <encoding>
1725                   ::= Gr <resource name>
1726 */
1727
1728 static struct demangle_component *
1729 d_special_name (struct d_info *di)
1730 {
1731   di->expansion += 20;
1732   if (d_check_char (di, 'T'))
1733     {
1734       switch (d_next_char (di))
1735         {
1736         case 'V':
1737           di->expansion -= 5;
1738           return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1739                               cplus_demangle_type (di), NULL);
1740         case 'T':
1741           di->expansion -= 10;
1742           return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1743                               cplus_demangle_type (di), NULL);
1744         case 'I':
1745           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1746                               cplus_demangle_type (di), NULL);
1747         case 'S':
1748           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1749                               cplus_demangle_type (di), NULL);
1750
1751         case 'h':
1752           if (! d_call_offset (di, 'h'))
1753             return NULL;
1754           return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1755                               d_encoding (di, 0), NULL);
1756
1757         case 'v':
1758           if (! d_call_offset (di, 'v'))
1759             return NULL;
1760           return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1761                               d_encoding (di, 0), NULL);
1762
1763         case 'c':
1764           if (! d_call_offset (di, '\0'))
1765             return NULL;
1766           if (! d_call_offset (di, '\0'))
1767             return NULL;
1768           return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1769                               d_encoding (di, 0), NULL);
1770
1771         case 'C':
1772           {
1773             struct demangle_component *derived_type;
1774             long offset;
1775             struct demangle_component *base_type;
1776
1777             derived_type = cplus_demangle_type (di);
1778             offset = d_number (di);
1779             if (offset < 0)
1780               return NULL;
1781             if (! d_check_char (di, '_'))
1782               return NULL;
1783             base_type = cplus_demangle_type (di);
1784             /* We don't display the offset.  FIXME: We should display
1785                it in verbose mode.  */
1786             di->expansion += 5;
1787             return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1788                                 base_type, derived_type);
1789           }
1790
1791         case 'F':
1792           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
1793                               cplus_demangle_type (di), NULL);
1794         case 'J':
1795           return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
1796                               cplus_demangle_type (di), NULL);
1797
1798         default:
1799           return NULL;
1800         }
1801     }
1802   else if (d_check_char (di, 'G'))
1803     {
1804       switch (d_next_char (di))
1805         {
1806         case 'V':
1807           return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
1808
1809         case 'R':
1810           return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
1811                               NULL);
1812
1813         case 'A':
1814           return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
1815                               d_encoding (di, 0), NULL);
1816
1817         case 'r':
1818           return d_java_resource (di);
1819
1820         default:
1821           return NULL;
1822         }
1823     }
1824   else
1825     return NULL;
1826 }
1827
1828 /* <call-offset> ::= h <nv-offset> _
1829                  ::= v <v-offset> _
1830
1831    <nv-offset> ::= <(offset) number>
1832
1833    <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1834
1835    The C parameter, if not '\0', is a character we just read which is
1836    the start of the <call-offset>.
1837
1838    We don't display the offset information anywhere.  FIXME: We should
1839    display it in verbose mode.  */
1840
1841 static int
1842 d_call_offset (struct d_info *di, int c)
1843 {
1844   if (c == '\0')
1845     c = d_next_char (di);
1846
1847   if (c == 'h')
1848     d_number (di);
1849   else if (c == 'v')
1850     {
1851       d_number (di);
1852       if (! d_check_char (di, '_'))
1853         return 0;
1854       d_number (di);
1855     }
1856   else
1857     return 0;
1858
1859   if (! d_check_char (di, '_'))
1860     return 0;
1861
1862   return 1;
1863 }
1864
1865 /* <ctor-dtor-name> ::= C1
1866                     ::= C2
1867                     ::= C3
1868                     ::= D0
1869                     ::= D1
1870                     ::= D2
1871 */
1872
1873 static struct demangle_component *
1874 d_ctor_dtor_name (struct d_info *di)
1875 {
1876   if (di->last_name != NULL)
1877     {
1878       if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
1879         di->expansion += di->last_name->u.s_name.len;
1880       else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
1881         di->expansion += di->last_name->u.s_string.len;
1882     }
1883   switch (d_peek_char (di))
1884     {
1885     case 'C':
1886       {
1887         enum gnu_v3_ctor_kinds kind;
1888
1889         switch (d_peek_next_char (di))
1890           {
1891           case '1':
1892             kind = gnu_v3_complete_object_ctor;
1893             break;
1894           case '2':
1895             kind = gnu_v3_base_object_ctor;
1896             break;
1897           case '3':
1898             kind = gnu_v3_complete_object_allocating_ctor;
1899             break;
1900           default:
1901             return NULL;
1902           }
1903         d_advance (di, 2);
1904         return d_make_ctor (di, kind, di->last_name);
1905       }
1906
1907     case 'D':
1908       {
1909         enum gnu_v3_dtor_kinds kind;
1910
1911         switch (d_peek_next_char (di))
1912           {
1913           case '0':
1914             kind = gnu_v3_deleting_dtor;
1915             break;
1916           case '1':
1917             kind = gnu_v3_complete_object_dtor;
1918             break;
1919           case '2':
1920             kind = gnu_v3_base_object_dtor;
1921             break;
1922           default:
1923             return NULL;
1924           }
1925         d_advance (di, 2);
1926         return d_make_dtor (di, kind, di->last_name);
1927       }
1928
1929     default:
1930       return NULL;
1931     }
1932 }
1933
1934 /* <type> ::= <builtin-type>
1935           ::= <function-type>
1936           ::= <class-enum-type>
1937           ::= <array-type>
1938           ::= <pointer-to-member-type>
1939           ::= <template-param>
1940           ::= <template-template-param> <template-args>
1941           ::= <substitution>
1942           ::= <CV-qualifiers> <type>
1943           ::= P <type>
1944           ::= R <type>
1945           ::= O <type> (C++0x)
1946           ::= C <type>
1947           ::= G <type>
1948           ::= U <source-name> <type>
1949
1950    <builtin-type> ::= various one letter codes
1951                   ::= u <source-name>
1952 */
1953
1954 CP_STATIC_IF_GLIBCPP_V3
1955 const struct demangle_builtin_type_info
1956 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
1957 {
1958   /* a */ { NL ("signed char"), NL ("signed char"),     D_PRINT_DEFAULT },
1959   /* b */ { NL ("bool"),        NL ("boolean"),         D_PRINT_BOOL },
1960   /* c */ { NL ("char"),        NL ("byte"),            D_PRINT_DEFAULT },
1961   /* d */ { NL ("double"),      NL ("double"),          D_PRINT_FLOAT },
1962   /* e */ { NL ("long double"), NL ("long double"),     D_PRINT_FLOAT },
1963   /* f */ { NL ("float"),       NL ("float"),           D_PRINT_FLOAT },
1964   /* g */ { NL ("__float128"),  NL ("__float128"),      D_PRINT_FLOAT },
1965   /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
1966   /* i */ { NL ("int"),         NL ("int"),             D_PRINT_INT },
1967   /* j */ { NL ("unsigned int"), NL ("unsigned"),       D_PRINT_UNSIGNED },
1968   /* k */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
1969   /* l */ { NL ("long"),        NL ("long"),            D_PRINT_LONG },
1970   /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
1971   /* n */ { NL ("__int128"),    NL ("__int128"),        D_PRINT_DEFAULT },
1972   /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
1973             D_PRINT_DEFAULT },
1974   /* p */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
1975   /* q */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
1976   /* r */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
1977   /* s */ { NL ("short"),       NL ("short"),           D_PRINT_DEFAULT },
1978   /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
1979   /* u */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
1980   /* v */ { NL ("void"),        NL ("void"),            D_PRINT_VOID },
1981   /* w */ { NL ("wchar_t"),     NL ("char"),            D_PRINT_DEFAULT },
1982   /* x */ { NL ("long long"),   NL ("long"),            D_PRINT_LONG_LONG },
1983   /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
1984             D_PRINT_UNSIGNED_LONG_LONG },
1985   /* z */ { NL ("..."),         NL ("..."),             D_PRINT_DEFAULT },
1986   /* 26 */ { NL ("decimal32"),  NL ("decimal32"),       D_PRINT_DEFAULT },
1987   /* 27 */ { NL ("decimal64"),  NL ("decimal64"),       D_PRINT_DEFAULT },
1988   /* 28 */ { NL ("decimal128"), NL ("decimal128"),      D_PRINT_DEFAULT },
1989   /* 29 */ { NL ("half"),       NL ("half"),            D_PRINT_FLOAT },
1990   /* 30 */ { NL ("char16_t"),   NL ("char16_t"),        D_PRINT_DEFAULT },
1991   /* 31 */ { NL ("char32_t"),   NL ("char32_t"),        D_PRINT_DEFAULT },
1992   /* 32 */ { NL ("decltype(nullptr)"),  NL ("decltype(nullptr)"),
1993              D_PRINT_DEFAULT },
1994 };
1995
1996 CP_STATIC_IF_GLIBCPP_V3
1997 struct demangle_component *
1998 cplus_demangle_type (struct d_info *di)
1999 {
2000   char peek;
2001   struct demangle_component *ret;
2002   int can_subst;
2003
2004   /* The ABI specifies that when CV-qualifiers are used, the base type
2005      is substitutable, and the fully qualified type is substitutable,
2006      but the base type with a strict subset of the CV-qualifiers is
2007      not substitutable.  The natural recursive implementation of the
2008      CV-qualifiers would cause subsets to be substitutable, so instead
2009      we pull them all off now.
2010
2011      FIXME: The ABI says that order-insensitive vendor qualifiers
2012      should be handled in the same way, but we have no way to tell
2013      which vendor qualifiers are order-insensitive and which are
2014      order-sensitive.  So we just assume that they are all
2015      order-sensitive.  g++ 3.4 supports only one vendor qualifier,
2016      __vector, and it treats it as order-sensitive when mangling
2017      names.  */
2018
2019   peek = d_peek_char (di);
2020   if (peek == 'r' || peek == 'V' || peek == 'K')
2021     {
2022       struct demangle_component **pret;
2023
2024       pret = d_cv_qualifiers (di, &ret, 0);
2025       if (pret == NULL)
2026         return NULL;
2027       *pret = cplus_demangle_type (di);
2028       if (! *pret || ! d_add_substitution (di, ret))
2029         return NULL;
2030       return ret;
2031     }
2032
2033   can_subst = 1;
2034
2035   switch (peek)
2036     {
2037     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2038     case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
2039     case 'o':                               case 's': case 't':
2040     case 'v': case 'w': case 'x': case 'y': case 'z':
2041       ret = d_make_builtin_type (di,
2042                                  &cplus_demangle_builtin_types[peek - 'a']);
2043       di->expansion += ret->u.s_builtin.type->len;
2044       can_subst = 0;
2045       d_advance (di, 1);
2046       break;
2047
2048     case 'u':
2049       d_advance (di, 1);
2050       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2051                          d_source_name (di), NULL);
2052       break;
2053
2054     case 'F':
2055       ret = d_function_type (di);
2056       break;
2057
2058     case '0': case '1': case '2': case '3': case '4':
2059     case '5': case '6': case '7': case '8': case '9':
2060     case 'N':
2061     case 'Z':
2062       ret = d_class_enum_type (di);
2063       break;
2064
2065     case 'A':
2066       ret = d_array_type (di);
2067       break;
2068
2069     case 'M':
2070       ret = d_pointer_to_member_type (di);
2071       break;
2072
2073     case 'T':
2074       ret = d_template_param (di);
2075       if (d_peek_char (di) == 'I')
2076         {
2077           /* This is <template-template-param> <template-args>.  The
2078              <template-template-param> part is a substitution
2079              candidate.  */
2080           if (! d_add_substitution (di, ret))
2081             return NULL;
2082           ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2083                              d_template_args (di));
2084         }
2085       break;
2086
2087     case 'S':
2088       /* If this is a special substitution, then it is the start of
2089          <class-enum-type>.  */
2090       {
2091         char peek_next;
2092
2093         peek_next = d_peek_next_char (di);
2094         if (IS_DIGIT (peek_next)
2095             || peek_next == '_'
2096             || IS_UPPER (peek_next))
2097           {
2098             ret = d_substitution (di, 0);
2099             /* The substituted name may have been a template name and
2100                may be followed by tepmlate args.  */
2101             if (d_peek_char (di) == 'I')
2102               ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2103                                  d_template_args (di));
2104             else
2105               can_subst = 0;
2106           }
2107         else
2108           {
2109             ret = d_class_enum_type (di);
2110             /* If the substitution was a complete type, then it is not
2111                a new substitution candidate.  However, if the
2112                substitution was followed by template arguments, then
2113                the whole thing is a substitution candidate.  */
2114             if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2115               can_subst = 0;
2116           }
2117       }
2118       break;
2119
2120     case 'O':
2121       d_advance (di, 1);
2122       ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2123                          cplus_demangle_type (di), NULL);
2124       break;
2125
2126     case 'P':
2127       d_advance (di, 1);
2128       ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2129                          cplus_demangle_type (di), NULL);
2130       break;
2131
2132     case 'R':
2133       d_advance (di, 1);
2134       ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2135                          cplus_demangle_type (di), NULL);
2136       break;
2137
2138     case 'C':
2139       d_advance (di, 1);
2140       ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2141                          cplus_demangle_type (di), NULL);
2142       break;
2143
2144     case 'G':
2145       d_advance (di, 1);
2146       ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2147                          cplus_demangle_type (di), NULL);
2148       break;
2149
2150     case 'U':
2151       d_advance (di, 1);
2152       ret = d_source_name (di);
2153       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2154                          cplus_demangle_type (di), ret);
2155       break;
2156
2157     case 'D':
2158       can_subst = 0;
2159       d_advance (di, 1);
2160       peek = d_next_char (di);
2161       switch (peek)
2162         {
2163         case 'T':
2164         case 't':
2165           /* decltype (expression) */
2166           ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2167                              d_expression (di), NULL);
2168           if (ret && d_next_char (di) != 'E')
2169             ret = NULL;
2170           break;
2171
2172         case 'p':
2173           /* Pack expansion.  */
2174           ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2175                              cplus_demangle_type (di), NULL);
2176           break;
2177
2178         case 'f':
2179           /* 32-bit decimal floating point */
2180           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2181           di->expansion += ret->u.s_builtin.type->len;
2182           break;
2183         case 'd':
2184           /* 64-bit DFP */
2185           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2186           di->expansion += ret->u.s_builtin.type->len;
2187           break;
2188         case 'e':
2189           /* 128-bit DFP */
2190           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2191           di->expansion += ret->u.s_builtin.type->len;
2192           break;
2193         case 'h':
2194           /* 16-bit half-precision FP */
2195           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2196           di->expansion += ret->u.s_builtin.type->len;
2197           break;
2198         case 's':
2199           /* char16_t */
2200           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2201           di->expansion += ret->u.s_builtin.type->len;
2202           break;
2203         case 'i':
2204           /* char32_t */
2205           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2206           di->expansion += ret->u.s_builtin.type->len;
2207           break;
2208
2209         case 'F':
2210           /* Fixed point types. DF<int bits><length><fract bits><sat>  */
2211           ret = d_make_empty (di);
2212           ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2213           if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2214             /* For demangling we don't care about the bits.  */
2215             d_number (di);
2216           ret->u.s_fixed.length = cplus_demangle_type (di);
2217           if (ret->u.s_fixed.length == NULL)
2218             return NULL;
2219           d_number (di);
2220           peek = d_next_char (di);
2221           ret->u.s_fixed.sat = (peek == 's');
2222           break;
2223
2224         case 'v':
2225           ret = d_vector_type (di);
2226           break;
2227
2228         case 'n':
2229           /* decltype(nullptr) */
2230           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2231           di->expansion += ret->u.s_builtin.type->len;
2232           break;
2233
2234         default:
2235           return NULL;
2236         }
2237       break;
2238
2239     default:
2240       return NULL;
2241     }
2242
2243   if (can_subst)
2244     {
2245       if (! d_add_substitution (di, ret))
2246         return NULL;
2247     }
2248
2249   return ret;
2250 }
2251
2252 /* <CV-qualifiers> ::= [r] [V] [K]  */
2253
2254 static struct demangle_component **
2255 d_cv_qualifiers (struct d_info *di,
2256                  struct demangle_component **pret, int member_fn)
2257 {
2258   char peek;
2259
2260   peek = d_peek_char (di);
2261   while (peek == 'r' || peek == 'V' || peek == 'K')
2262     {
2263       enum demangle_component_type t;
2264
2265       d_advance (di, 1);
2266       if (peek == 'r')
2267         {
2268           t = (member_fn
2269                ? DEMANGLE_COMPONENT_RESTRICT_THIS
2270                : DEMANGLE_COMPONENT_RESTRICT);
2271           di->expansion += sizeof "restrict";
2272         }
2273       else if (peek == 'V')
2274         {
2275           t = (member_fn
2276                ? DEMANGLE_COMPONENT_VOLATILE_THIS
2277                : DEMANGLE_COMPONENT_VOLATILE);
2278           di->expansion += sizeof "volatile";
2279         }
2280       else
2281         {
2282           t = (member_fn
2283                ? DEMANGLE_COMPONENT_CONST_THIS
2284                : DEMANGLE_COMPONENT_CONST);
2285           di->expansion += sizeof "const";
2286         }
2287
2288       *pret = d_make_comp (di, t, NULL, NULL);
2289       if (*pret == NULL)
2290         return NULL;
2291       pret = &d_left (*pret);
2292
2293       peek = d_peek_char (di);
2294     }
2295
2296   return pret;
2297 }
2298
2299 /* <function-type> ::= F [Y] <bare-function-type> E  */
2300
2301 static struct demangle_component *
2302 d_function_type (struct d_info *di)
2303 {
2304   struct demangle_component *ret;
2305
2306   if (! d_check_char (di, 'F'))
2307     return NULL;
2308   if (d_peek_char (di) == 'Y')
2309     {
2310       /* Function has C linkage.  We don't print this information.
2311          FIXME: We should print it in verbose mode.  */
2312       d_advance (di, 1);
2313     }
2314   ret = d_bare_function_type (di, 1);
2315   if (! d_check_char (di, 'E'))
2316     return NULL;
2317   return ret;
2318 }
2319
2320 /* <type>+ */
2321
2322 static struct demangle_component *
2323 d_parmlist (struct d_info *di)
2324 {
2325   struct demangle_component *tl;
2326   struct demangle_component **ptl;
2327
2328   tl = NULL;
2329   ptl = &tl;
2330   while (1)
2331     {
2332       struct demangle_component *type;
2333
2334       char peek = d_peek_char (di);
2335       if (peek == '\0' || peek == 'E')
2336         break;
2337       type = cplus_demangle_type (di);
2338       if (type == NULL)
2339         return NULL;
2340       *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2341       if (*ptl == NULL)
2342         return NULL;
2343       ptl = &d_right (*ptl);
2344     }
2345
2346   /* There should be at least one parameter type besides the optional
2347      return type.  A function which takes no arguments will have a
2348      single parameter type void.  */
2349   if (tl == NULL)
2350     return NULL;
2351
2352   /* If we have a single parameter type void, omit it.  */
2353   if (d_right (tl) == NULL
2354       && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2355       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2356     {
2357       di->expansion -= d_left (tl)->u.s_builtin.type->len;
2358       d_left (tl) = NULL;
2359     }
2360
2361   return tl;
2362 }
2363
2364 /* <bare-function-type> ::= [J]<type>+  */
2365
2366 static struct demangle_component *
2367 d_bare_function_type (struct d_info *di, int has_return_type)
2368 {
2369   struct demangle_component *return_type;
2370   struct demangle_component *tl;
2371   char peek;
2372
2373   /* Detect special qualifier indicating that the first argument
2374      is the return type.  */
2375   peek = d_peek_char (di);
2376   if (peek == 'J')
2377     {
2378       d_advance (di, 1);
2379       has_return_type = 1;
2380     }
2381
2382   if (has_return_type)
2383     {
2384       return_type = cplus_demangle_type (di);
2385       if (return_type == NULL)
2386         return NULL;
2387     }
2388   else
2389     return_type = NULL;
2390
2391   tl = d_parmlist (di);
2392   if (tl == NULL)
2393     return NULL;
2394
2395   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2396                       return_type, tl);
2397 }
2398
2399 /* <class-enum-type> ::= <name>  */
2400
2401 static struct demangle_component *
2402 d_class_enum_type (struct d_info *di)
2403 {
2404   return d_name (di);
2405 }
2406
2407 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2408                 ::= A [<(dimension) expression>] _ <(element) type>
2409 */
2410
2411 static struct demangle_component *
2412 d_array_type (struct d_info *di)
2413 {
2414   char peek;
2415   struct demangle_component *dim;
2416
2417   if (! d_check_char (di, 'A'))
2418     return NULL;
2419
2420   peek = d_peek_char (di);
2421   if (peek == '_')
2422     dim = NULL;
2423   else if (IS_DIGIT (peek))
2424     {
2425       const char *s;
2426
2427       s = d_str (di);
2428       do
2429         {
2430           d_advance (di, 1);
2431           peek = d_peek_char (di);
2432         }
2433       while (IS_DIGIT (peek));
2434       dim = d_make_name (di, s, d_str (di) - s);
2435       if (dim == NULL)
2436         return NULL;
2437     }
2438   else
2439     {
2440       dim = d_expression (di);
2441       if (dim == NULL)
2442         return NULL;
2443     }
2444
2445   if (! d_check_char (di, '_'))
2446     return NULL;
2447
2448   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2449                       cplus_demangle_type (di));
2450 }
2451
2452 /* <vector-type> ::= Dv <number> _ <type>
2453                  ::= Dv _ <expression> _ <type> */
2454
2455 static struct demangle_component *
2456 d_vector_type (struct d_info *di)
2457 {
2458   char peek;
2459   struct demangle_component *dim;
2460
2461   peek = d_peek_char (di);
2462   if (peek == '_')
2463     {
2464       d_advance (di, 1);
2465       dim = d_expression (di);
2466     }
2467   else
2468     dim = d_number_component (di);
2469
2470   if (dim == NULL)
2471     return NULL;
2472
2473   if (! d_check_char (di, '_'))
2474     return NULL;
2475
2476   return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
2477                       cplus_demangle_type (di));
2478 }
2479
2480 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
2481
2482 static struct demangle_component *
2483 d_pointer_to_member_type (struct d_info *di)
2484 {
2485   struct demangle_component *cl;
2486   struct demangle_component *mem;
2487   struct demangle_component **pmem;
2488
2489   if (! d_check_char (di, 'M'))
2490     return NULL;
2491
2492   cl = cplus_demangle_type (di);
2493
2494   /* The ABI specifies that any type can be a substitution source, and
2495      that M is followed by two types, and that when a CV-qualified
2496      type is seen both the base type and the CV-qualified types are
2497      substitution sources.  The ABI also specifies that for a pointer
2498      to a CV-qualified member function, the qualifiers are attached to
2499      the second type.  Given the grammar, a plain reading of the ABI
2500      suggests that both the CV-qualified member function and the
2501      non-qualified member function are substitution sources.  However,
2502      g++ does not work that way.  g++ treats only the CV-qualified
2503      member function as a substitution source.  FIXME.  So to work
2504      with g++, we need to pull off the CV-qualifiers here, in order to
2505      avoid calling add_substitution() in cplus_demangle_type().  But
2506      for a CV-qualified member which is not a function, g++ does
2507      follow the ABI, so we need to handle that case here by calling
2508      d_add_substitution ourselves.  */
2509
2510   pmem = d_cv_qualifiers (di, &mem, 1);
2511   if (pmem == NULL)
2512     return NULL;
2513   *pmem = cplus_demangle_type (di);
2514   if (*pmem == NULL)
2515     return NULL;
2516
2517   if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
2518     {
2519       if (! d_add_substitution (di, mem))
2520         return NULL;
2521     }
2522
2523   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2524 }
2525
2526 /* <non-negative number> _ */
2527
2528 static long
2529 d_compact_number (struct d_info *di)
2530 {
2531   long num;
2532   if (d_peek_char (di) == '_')
2533     num = 0;
2534   else if (d_peek_char (di) == 'n')
2535     return -1;
2536   else
2537     num = d_number (di) + 1;
2538
2539   if (! d_check_char (di, '_'))
2540     return -1;
2541   return num;
2542 }
2543
2544 /* <template-param> ::= T_
2545                     ::= T <(parameter-2 non-negative) number> _
2546 */
2547
2548 static struct demangle_component *
2549 d_template_param (struct d_info *di)
2550 {
2551   long param;
2552
2553   if (! d_check_char (di, 'T'))
2554     return NULL;
2555
2556   param = d_compact_number (di);
2557   if (param < 0)
2558     return NULL;
2559
2560   ++di->did_subs;
2561
2562   return d_make_template_param (di, param);
2563 }
2564
2565 /* <template-args> ::= I <template-arg>+ E  */
2566
2567 static struct demangle_component *
2568 d_template_args (struct d_info *di)
2569 {
2570   struct demangle_component *hold_last_name;
2571   struct demangle_component *al;
2572   struct demangle_component **pal;
2573
2574   /* Preserve the last name we saw--don't let the template arguments
2575      clobber it, as that would give us the wrong name for a subsequent
2576      constructor or destructor.  */
2577   hold_last_name = di->last_name;
2578
2579   if (! d_check_char (di, 'I'))
2580     return NULL;
2581
2582   if (d_peek_char (di) == 'E')
2583     {
2584       /* An argument pack can be empty.  */
2585       d_advance (di, 1);
2586       return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2587     }
2588
2589   al = NULL;
2590   pal = &al;
2591   while (1)
2592     {
2593       struct demangle_component *a;
2594
2595       a = d_template_arg (di);
2596       if (a == NULL)
2597         return NULL;
2598
2599       *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2600       if (*pal == NULL)
2601         return NULL;
2602       pal = &d_right (*pal);
2603
2604       if (d_peek_char (di) == 'E')
2605         {
2606           d_advance (di, 1);
2607           break;
2608         }
2609     }
2610
2611   di->last_name = hold_last_name;
2612
2613   return al;
2614 }
2615
2616 /* <template-arg> ::= <type>
2617                   ::= X <expression> E
2618                   ::= <expr-primary>
2619 */
2620
2621 static struct demangle_component *
2622 d_template_arg (struct d_info *di)
2623 {
2624   struct demangle_component *ret;
2625
2626   switch (d_peek_char (di))
2627     {
2628     case 'X':
2629       d_advance (di, 1);
2630       ret = d_expression (di);
2631       if (! d_check_char (di, 'E'))
2632         return NULL;
2633       return ret;
2634
2635     case 'L':
2636       return d_expr_primary (di);
2637
2638     case 'I':
2639       /* An argument pack.  */
2640       return d_template_args (di);
2641
2642     default:
2643       return cplus_demangle_type (di);
2644     }
2645 }
2646
2647 /* Subroutine of <expression> ::= cl <expression>+ E */
2648
2649 static struct demangle_component *
2650 d_exprlist (struct d_info *di)
2651 {
2652   struct demangle_component *list = NULL;
2653   struct demangle_component **p = &list;
2654
2655   if (d_peek_char (di) == 'E')
2656     {
2657       d_advance (di, 1);
2658       return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
2659     }
2660
2661   while (1)
2662     {
2663       struct demangle_component *arg = d_expression (di);
2664       if (arg == NULL)
2665         return NULL;
2666
2667       *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
2668       if (*p == NULL)
2669         return NULL;
2670       p = &d_right (*p);
2671
2672       if (d_peek_char (di) == 'E')
2673         {
2674           d_advance (di, 1);
2675           break;
2676         }
2677     }
2678
2679   return list;
2680 }
2681
2682 /* <expression> ::= <(unary) operator-name> <expression>
2683                 ::= <(binary) operator-name> <expression> <expression>
2684                 ::= <(trinary) operator-name> <expression> <expression> <expression>
2685                 ::= cl <expression>+ E
2686                 ::= st <type>
2687                 ::= <template-param>
2688                 ::= sr <type> <unqualified-name>
2689                 ::= sr <type> <unqualified-name> <template-args>
2690                 ::= <expr-primary>
2691 */
2692
2693 static struct demangle_component *
2694 d_expression (struct d_info *di)
2695 {
2696   char peek;
2697
2698   peek = d_peek_char (di);
2699   if (peek == 'L')
2700     return d_expr_primary (di);
2701   else if (peek == 'T')
2702     return d_template_param (di);
2703   else if (peek == 's' && d_peek_next_char (di) == 'r')
2704     {
2705       struct demangle_component *type;
2706       struct demangle_component *name;
2707
2708       d_advance (di, 2);
2709       type = cplus_demangle_type (di);
2710       name = d_unqualified_name (di);
2711       if (d_peek_char (di) != 'I')
2712         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2713       else
2714         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2715                             d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2716                                          d_template_args (di)));
2717     }
2718   else if (peek == 's' && d_peek_next_char (di) == 'p')
2719     {
2720       d_advance (di, 2);
2721       return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2722                           d_expression (di), NULL);
2723     }
2724   else if (peek == 'f' && d_peek_next_char (di) == 'p')
2725     {
2726       /* Function parameter used in a late-specified return type.  */
2727       int index;
2728       d_advance (di, 2);
2729       index = d_compact_number (di);
2730       if (index < 0)
2731         return NULL;
2732
2733       return d_make_function_param (di, index);
2734     }
2735   else if (IS_DIGIT (peek)
2736            || (peek == 'o' && d_peek_next_char (di) == 'n'))
2737     {
2738       /* We can get an unqualified name as an expression in the case of
2739          a dependent function call, i.e. decltype(f(t)).  */
2740       struct demangle_component *name;
2741
2742       if (peek == 'o')
2743         /* operator-function-id, i.e. operator+(t).  */
2744         d_advance (di, 2);
2745
2746       name = d_unqualified_name (di);
2747       if (name == NULL)
2748         return NULL;
2749       if (d_peek_char (di) == 'I')
2750         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2751                             d_template_args (di));
2752       else
2753         return name;
2754     }
2755   else
2756     {
2757       struct demangle_component *op;
2758       int args;
2759
2760       op = d_operator_name (di);
2761       if (op == NULL)
2762         return NULL;
2763
2764       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2765         di->expansion += op->u.s_operator.op->len - 2;
2766
2767       if (op->type == DEMANGLE_COMPONENT_OPERATOR
2768           && strcmp (op->u.s_operator.op->code, "st") == 0)
2769         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2770                             cplus_demangle_type (di));
2771
2772       switch (op->type)
2773         {
2774         default:
2775           return NULL;
2776         case DEMANGLE_COMPONENT_OPERATOR:
2777           args = op->u.s_operator.op->args;
2778           break;
2779         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2780           args = op->u.s_extended_operator.args;
2781           break;
2782         case DEMANGLE_COMPONENT_CAST:
2783           args = 1;
2784           break;
2785         }
2786
2787       switch (args)
2788         {
2789         case 1:
2790           {
2791             struct demangle_component *operand;
2792             if (op->type == DEMANGLE_COMPONENT_CAST
2793                 && d_check_char (di, '_'))
2794               operand = d_exprlist (di);
2795             else
2796               operand = d_expression (di);
2797             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2798                                 operand);
2799           }
2800         case 2:
2801           {
2802             struct demangle_component *left;
2803             struct demangle_component *right;
2804             const char *code = op->u.s_operator.op->code;
2805
2806             left = d_expression (di);
2807             if (!strcmp (code, "cl"))
2808               right = d_exprlist (di);
2809             else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
2810               {
2811                 right = d_unqualified_name (di);
2812                 if (d_peek_char (di) == 'I')
2813                   right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
2814                                        right, d_template_args (di));
2815               }
2816             else
2817               right = d_expression (di);
2818
2819             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2820                                 d_make_comp (di,
2821                                              DEMANGLE_COMPONENT_BINARY_ARGS,
2822                                              left, right));
2823           }
2824         case 3:
2825           {
2826             struct demangle_component *first;
2827             struct demangle_component *second;
2828
2829             first = d_expression (di);
2830             second = d_expression (di);
2831             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2832                                 d_make_comp (di,
2833                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
2834                                              first,
2835                                              d_make_comp (di,
2836                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
2837                                                           second,
2838                                                           d_expression (di))));
2839           }
2840         default:
2841           return NULL;
2842         }
2843     }
2844 }
2845
2846 /* <expr-primary> ::= L <type> <(value) number> E
2847                   ::= L <type> <(value) float> E
2848                   ::= L <mangled-name> E
2849 */
2850
2851 static struct demangle_component *
2852 d_expr_primary (struct d_info *di)
2853 {
2854   struct demangle_component *ret;
2855
2856   if (! d_check_char (di, 'L'))
2857     return NULL;
2858   if (d_peek_char (di) == '_'
2859       /* Workaround for G++ bug; see comment in write_template_arg.  */
2860       || d_peek_char (di) == 'Z')
2861     ret = cplus_demangle_mangled_name (di, 0);
2862   else
2863     {
2864       struct demangle_component *type;
2865       enum demangle_component_type t;
2866       const char *s;
2867
2868       type = cplus_demangle_type (di);
2869       if (type == NULL)
2870         return NULL;
2871
2872       /* If we have a type we know how to print, we aren't going to
2873          print the type name itself.  */
2874       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2875           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2876         di->expansion -= type->u.s_builtin.type->len;
2877
2878       /* Rather than try to interpret the literal value, we just
2879          collect it as a string.  Note that it's possible to have a
2880          floating point literal here.  The ABI specifies that the
2881          format of such literals is machine independent.  That's fine,
2882          but what's not fine is that versions of g++ up to 3.2 with
2883          -fabi-version=1 used upper case letters in the hex constant,
2884          and dumped out gcc's internal representation.  That makes it
2885          hard to tell where the constant ends, and hard to dump the
2886          constant in any readable form anyhow.  We don't attempt to
2887          handle these cases.  */
2888
2889       t = DEMANGLE_COMPONENT_LITERAL;
2890       if (d_peek_char (di) == 'n')
2891         {
2892           t = DEMANGLE_COMPONENT_LITERAL_NEG;
2893           d_advance (di, 1);
2894         }
2895       s = d_str (di);
2896       while (d_peek_char (di) != 'E')
2897         {
2898           if (d_peek_char (di) == '\0')
2899             return NULL;
2900           d_advance (di, 1);
2901         }
2902       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2903     }
2904   if (! d_check_char (di, 'E'))
2905     return NULL;
2906   return ret;
2907 }
2908
2909 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2910                 ::= Z <(function) encoding> E s [<discriminator>]
2911 */
2912
2913 static struct demangle_component *
2914 d_local_name (struct d_info *di)
2915 {
2916   struct demangle_component *function;
2917
2918   if (! d_check_char (di, 'Z'))
2919     return NULL;
2920
2921   function = d_encoding (di, 0);
2922
2923   if (! d_check_char (di, 'E'))
2924     return NULL;
2925
2926   if (d_peek_char (di) == 's')
2927     {
2928       d_advance (di, 1);
2929       if (! d_discriminator (di))
2930         return NULL;
2931       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2932                           d_make_name (di, "string literal",
2933                                        sizeof "string literal" - 1));
2934     }
2935   else
2936     {
2937       struct demangle_component *name;
2938       int num = -1;
2939
2940       if (d_peek_char (di) == 'd')
2941         {
2942           /* Default argument scope: d <number> _.  */
2943           d_advance (di, 1);
2944           num = d_compact_number (di);
2945           if (num < 0)
2946             return NULL;
2947         }
2948
2949       name = d_name (di);
2950       if (name)
2951         switch (name->type)
2952           {
2953             /* Lambdas and unnamed types have internal discriminators.  */
2954           case DEMANGLE_COMPONENT_LAMBDA:
2955           case DEMANGLE_COMPONENT_UNNAMED_TYPE:
2956             break;
2957           default:
2958             if (! d_discriminator (di))
2959               return NULL;
2960           }
2961       if (num >= 0)
2962         name = d_make_default_arg (di, num, name);
2963       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2964     }
2965 }
2966
2967 /* <discriminator> ::= _ <(non-negative) number>
2968
2969    We demangle the discriminator, but we don't print it out.  FIXME:
2970    We should print it out in verbose mode.  */
2971
2972 static int
2973 d_discriminator (struct d_info *di)
2974 {
2975   long discrim;
2976
2977   if (d_peek_char (di) != '_')
2978     return 1;
2979   d_advance (di, 1);
2980   discrim = d_number (di);
2981   if (discrim < 0)
2982     return 0;
2983   return 1;
2984 }
2985
2986 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
2987
2988 static struct demangle_component *
2989 d_lambda (struct d_info *di)
2990 {
2991   struct demangle_component *tl;
2992   struct demangle_component *ret;
2993   int num;
2994
2995   if (! d_check_char (di, 'U'))
2996     return NULL;
2997   if (! d_check_char (di, 'l'))
2998     return NULL;
2999
3000   tl = d_parmlist (di);
3001   if (tl == NULL)
3002     return NULL;
3003
3004   if (! d_check_char (di, 'E'))
3005     return NULL;
3006
3007   num = d_compact_number (di);
3008   if (num < 0)
3009     return NULL;
3010
3011   ret = d_make_empty (di);
3012   if (ret)
3013     {
3014       ret->type = DEMANGLE_COMPONENT_LAMBDA;
3015       ret->u.s_unary_num.sub = tl;
3016       ret->u.s_unary_num.num = num;
3017     }
3018
3019   if (! d_add_substitution (di, ret))
3020     return NULL;
3021
3022   return ret;
3023 }
3024
3025 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3026
3027 static struct demangle_component *
3028 d_unnamed_type (struct d_info *di)
3029 {
3030   struct demangle_component *ret;
3031   long num;
3032
3033   if (! d_check_char (di, 'U'))
3034     return NULL;
3035   if (! d_check_char (di, 't'))
3036     return NULL;
3037
3038   num = d_compact_number (di);
3039   if (num < 0)
3040     return NULL;
3041
3042   ret = d_make_empty (di);
3043   if (ret)
3044     {
3045       ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3046       ret->u.s_number.number = num;
3047     }
3048
3049   if (! d_add_substitution (di, ret))
3050     return NULL;
3051
3052   return ret;
3053 }
3054
3055 /* Add a new substitution.  */
3056
3057 static int
3058 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3059 {
3060   if (dc == NULL)
3061     return 0;
3062   if (di->next_sub >= di->num_subs)
3063     return 0;
3064   di->subs[di->next_sub] = dc;
3065   ++di->next_sub;
3066   return 1;
3067 }
3068
3069 /* <substitution> ::= S <seq-id> _
3070                   ::= S_
3071                   ::= St
3072                   ::= Sa
3073                   ::= Sb
3074                   ::= Ss
3075                   ::= Si
3076                   ::= So
3077                   ::= Sd
3078
3079    If PREFIX is non-zero, then this type is being used as a prefix in
3080    a qualified name.  In this case, for the standard substitutions, we
3081    need to check whether we are being used as a prefix for a
3082    constructor or destructor, and return a full template name.
3083    Otherwise we will get something like std::iostream::~iostream()
3084    which does not correspond particularly well to any function which
3085    actually appears in the source.
3086 */
3087
3088 static const struct d_standard_sub_info standard_subs[] =
3089 {
3090   { 't', NL ("std"),
3091     NL ("std"),
3092     NULL, 0 },
3093   { 'a', NL ("std::allocator"),
3094     NL ("std::allocator"),
3095     NL ("allocator") },
3096   { 'b', NL ("std::basic_string"),
3097     NL ("std::basic_string"),
3098     NL ("basic_string") },
3099   { 's', NL ("std::string"),
3100     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3101     NL ("basic_string") },
3102   { 'i', NL ("std::istream"),
3103     NL ("std::basic_istream<char, std::char_traits<char> >"),
3104     NL ("basic_istream") },
3105   { 'o', NL ("std::ostream"),
3106     NL ("std::basic_ostream<char, std::char_traits<char> >"),
3107     NL ("basic_ostream") },
3108   { 'd', NL ("std::iostream"),
3109     NL ("std::basic_iostream<char, std::char_traits<char> >"),
3110     NL ("basic_iostream") }
3111 };
3112
3113 static struct demangle_component *
3114 d_substitution (struct d_info *di, int prefix)
3115 {
3116   char c;
3117
3118   if (! d_check_char (di, 'S'))
3119     return NULL;
3120
3121   c = d_next_char (di);
3122   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3123     {
3124       unsigned int id;
3125
3126       id = 0;
3127       if (c != '_')
3128         {
3129           do
3130             {
3131               unsigned int new_id;
3132
3133               if (IS_DIGIT (c))
3134                 new_id = id * 36 + c - '0';
3135               else if (IS_UPPER (c))
3136                 new_id = id * 36 + c - 'A' + 10;
3137               else
3138                 return NULL;
3139               if (new_id < id)
3140                 return NULL;
3141               id = new_id;
3142               c = d_next_char (di);
3143             }
3144           while (c != '_');
3145
3146           ++id;
3147         }
3148
3149       if (id >= (unsigned int) di->next_sub)
3150         return NULL;
3151
3152       ++di->did_subs;
3153
3154       return di->subs[id];
3155     }
3156   else
3157     {
3158       int verbose;
3159       const struct d_standard_sub_info *p;
3160       const struct d_standard_sub_info *pend;
3161
3162       verbose = (di->options & DMGL_VERBOSE) != 0;
3163       if (! verbose && prefix)
3164         {
3165           char peek;
3166
3167           peek = d_peek_char (di);
3168           if (peek == 'C' || peek == 'D')
3169             verbose = 1;
3170         }
3171
3172       pend = (&standard_subs[0]
3173               + sizeof standard_subs / sizeof standard_subs[0]);
3174       for (p = &standard_subs[0]; p < pend; ++p)
3175         {
3176           if (c == p->code)
3177             {
3178               const char *s;
3179               int len;
3180
3181               if (p->set_last_name != NULL)
3182                 di->last_name = d_make_sub (di, p->set_last_name,
3183                                             p->set_last_name_len);
3184               if (verbose)
3185                 {
3186                   s = p->full_expansion;
3187                   len = p->full_len;
3188                 }
3189               else
3190                 {
3191                   s = p->simple_expansion;
3192                   len = p->simple_len;
3193                 }
3194               di->expansion += len;
3195               return d_make_sub (di, s, len);
3196             }
3197         }
3198
3199       return NULL;
3200     }
3201 }
3202
3203 /* Initialize a growable string.  */
3204
3205 static void
3206 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3207 {
3208   dgs->buf = NULL;
3209   dgs->len = 0;
3210   dgs->alc = 0;
3211   dgs->allocation_failure = 0;
3212
3213   if (estimate > 0)
3214     d_growable_string_resize (dgs, estimate);
3215 }
3216
3217 /* Grow a growable string to a given size.  */
3218
3219 static inline void
3220 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3221 {
3222   size_t newalc;
3223   char *newbuf;
3224
3225   if (dgs->allocation_failure)
3226     return;
3227
3228   /* Start allocation at two bytes to avoid any possibility of confusion
3229      with the special value of 1 used as a return in *palc to indicate
3230      allocation failures.  */
3231   newalc = dgs->alc > 0 ? dgs->alc : 2;
3232   while (newalc < need)
3233     newalc <<= 1;
3234
3235   newbuf = (char *) realloc (dgs->buf, newalc);
3236   if (newbuf == NULL)
3237     {
3238       free (dgs->buf);
3239       dgs->buf = NULL;
3240       dgs->len = 0;
3241       dgs->alc = 0;
3242       dgs->allocation_failure = 1;
3243       return;
3244     }
3245   dgs->buf = newbuf;
3246   dgs->alc = newalc;
3247 }
3248
3249 /* Append a buffer to a growable string.  */
3250
3251 static inline void
3252 d_growable_string_append_buffer (struct d_growable_string *dgs,
3253                                  const char *s, size_t l)
3254 {
3255   size_t need;
3256
3257   need = dgs->len + l + 1;
3258   if (need > dgs->alc)
3259     d_growable_string_resize (dgs, need);
3260
3261   if (dgs->allocation_failure)
3262     return;
3263
3264   memcpy (dgs->buf + dgs->len, s, l);
3265   dgs->buf[dgs->len + l] = '\0';
3266   dgs->len += l;
3267 }
3268
3269 /* Bridge growable strings to the callback mechanism.  */
3270
3271 static void
3272 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3273 {
3274   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3275
3276   d_growable_string_append_buffer (dgs, s, l);
3277 }
3278
3279 /* Initialize a print information structure.  */
3280
3281 static void
3282 d_print_init (struct d_print_info *dpi, int options,
3283               demangle_callbackref callback, void *opaque)
3284 {
3285   dpi->options = options;
3286   dpi->len = 0;
3287   dpi->last_char = '\0';
3288   dpi->templates = NULL;
3289   dpi->modifiers = NULL;
3290   dpi->flush_count = 0;
3291
3292   dpi->callback = callback;
3293   dpi->opaque = opaque;
3294
3295   dpi->demangle_failure = 0;
3296 }
3297
3298 /* Indicate that an error occurred during printing, and test for error.  */
3299
3300 static inline void
3301 d_print_error (struct d_print_info *dpi)
3302 {
3303   dpi->demangle_failure = 1;
3304 }
3305
3306 static inline int
3307 d_print_saw_error (struct d_print_info *dpi)
3308 {
3309   return dpi->demangle_failure != 0;
3310 }
3311
3312 /* Flush buffered characters to the callback.  */
3313
3314 static inline void
3315 d_print_flush (struct d_print_info *dpi)
3316 {
3317   dpi->buf[dpi->len] = '\0';
3318   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3319   dpi->len = 0;
3320   dpi->flush_count++;
3321 }
3322
3323 /* Append characters and buffers for printing.  */
3324
3325 static inline void
3326 d_append_char (struct d_print_info *dpi, char c)
3327 {
3328   if (dpi->len == sizeof (dpi->buf) - 1)
3329     d_print_flush (dpi);
3330
3331   dpi->buf[dpi->len++] = c;
3332   dpi->last_char = c;
3333 }
3334
3335 static inline void
3336 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3337 {
3338   size_t i;
3339
3340   for (i = 0; i < l; i++)
3341     d_append_char (dpi, s[i]);
3342 }
3343
3344 static inline void
3345 d_append_string (struct d_print_info *dpi, const char *s)
3346 {
3347   d_append_buffer (dpi, s, strlen (s));
3348 }
3349
3350 static inline void
3351 d_append_num (struct d_print_info *dpi, long l)
3352 {
3353   char buf[25];
3354   sprintf (buf,"%ld", l);
3355   d_append_string (dpi, buf);
3356 }
3357
3358 static inline char
3359 d_last_char (struct d_print_info *dpi)
3360 {
3361   return dpi->last_char;
3362 }
3363
3364 /* Turn components into a human readable string.  OPTIONS is the
3365    options bits passed to the demangler.  DC is the tree to print.
3366    CALLBACK is a function to call to flush demangled string segments
3367    as they fill the intermediate buffer, and OPAQUE is a generalized
3368    callback argument.  On success, this returns 1.  On failure,
3369    it returns 0, indicating a bad parse.  It does not use heap
3370    memory to build an output string, so cannot encounter memory
3371    allocation failure.  */
3372
3373 CP_STATIC_IF_GLIBCPP_V3
3374 int
3375 cplus_demangle_print_callback (int options,
3376                                const struct demangle_component *dc,
3377                                demangle_callbackref callback, void *opaque)
3378 {
3379   struct d_print_info dpi;
3380
3381   d_print_init (&dpi, options, callback, opaque);
3382
3383   d_print_comp (&dpi, dc);
3384
3385   d_print_flush (&dpi);
3386
3387   return ! d_print_saw_error (&dpi);
3388 }
3389
3390 /* Turn components into a human readable string.  OPTIONS is the
3391    options bits passed to the demangler.  DC is the tree to print.
3392    ESTIMATE is a guess at the length of the result.  This returns a
3393    string allocated by malloc, or NULL on error.  On success, this
3394    sets *PALC to the size of the allocated buffer.  On failure, this
3395    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3396    failure.  */
3397
3398 CP_STATIC_IF_GLIBCPP_V3
3399 char *
3400 cplus_demangle_print (int options, const struct demangle_component *dc,
3401                       int estimate, size_t *palc)
3402 {
3403   struct d_growable_string dgs;
3404
3405   d_growable_string_init (&dgs, estimate);
3406
3407   if (! cplus_demangle_print_callback (options, dc,
3408                                        d_growable_string_callback_adapter,
3409                                        &dgs))
3410     {
3411       free (dgs.buf);
3412       *palc = 0;
3413       return NULL;
3414     }
3415
3416   *palc = dgs.allocation_failure ? 1 : dgs.alc;
3417   return dgs.buf;
3418 }
3419
3420 /* Returns the I'th element of the template arglist ARGS, or NULL on
3421    failure.  */
3422
3423 static struct demangle_component *
3424 d_index_template_argument (struct demangle_component *args, int i)
3425 {
3426   struct demangle_component *a;
3427
3428   for (a = args;
3429        a != NULL;
3430        a = d_right (a))
3431     {
3432       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3433         return NULL;
3434       if (i <= 0)
3435         break;
3436       --i;
3437     }
3438   if (i != 0 || a == NULL)
3439     return NULL;
3440
3441   return d_left (a);
3442 }
3443
3444 /* Returns the template argument from the current context indicated by DC,
3445    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
3446
3447 static struct demangle_component *
3448 d_lookup_template_argument (struct d_print_info *dpi,
3449                             const struct demangle_component *dc)
3450 {
3451   if (dpi->templates == NULL)
3452     {
3453       d_print_error (dpi);
3454       return NULL;
3455     }
3456
3457   return d_index_template_argument
3458     (d_right (dpi->templates->template_decl),
3459      dc->u.s_number.number);
3460 }
3461
3462 /* Returns a template argument pack used in DC (any will do), or NULL.  */
3463
3464 static struct demangle_component *
3465 d_find_pack (struct d_print_info *dpi,
3466              const struct demangle_component *dc)
3467 {
3468   struct demangle_component *a;
3469   if (dc == NULL)
3470     return NULL;
3471
3472   switch (dc->type)
3473     {
3474     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3475       a = d_lookup_template_argument (dpi, dc);
3476       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3477         return a;
3478       return NULL;
3479
3480     case DEMANGLE_COMPONENT_PACK_EXPANSION:
3481       return NULL;
3482
3483     case DEMANGLE_COMPONENT_LAMBDA:
3484     case DEMANGLE_COMPONENT_NAME:
3485     case DEMANGLE_COMPONENT_OPERATOR:
3486     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3487     case DEMANGLE_COMPONENT_SUB_STD:
3488     case DEMANGLE_COMPONENT_CHARACTER:
3489     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3490       return NULL;
3491
3492     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3493       return d_find_pack (dpi, dc->u.s_extended_operator.name);
3494     case DEMANGLE_COMPONENT_CTOR:
3495       return d_find_pack (dpi, dc->u.s_ctor.name);
3496     case DEMANGLE_COMPONENT_DTOR:
3497       return d_find_pack (dpi, dc->u.s_dtor.name);
3498
3499     default:
3500       a = d_find_pack (dpi, d_left (dc));
3501       if (a)
3502         return a;
3503       return d_find_pack (dpi, d_right (dc));
3504     }
3505 }
3506
3507 /* Returns the length of the template argument pack DC.  */
3508
3509 static int
3510 d_pack_length (const struct demangle_component *dc)
3511 {
3512   int count = 0;
3513   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3514          && d_left (dc) != NULL)
3515     {
3516       ++count;
3517       dc = d_right (dc);
3518     }
3519   return count;
3520 }
3521
3522 /* DC is a component of a mangled expression.  Print it, wrapped in parens
3523    if needed.  */
3524
3525 static void
3526 d_print_subexpr (struct d_print_info *dpi,
3527                  const struct demangle_component *dc)
3528 {
3529   int simple = 0;
3530   if (dc->type == DEMANGLE_COMPONENT_NAME
3531       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3532     simple = 1;
3533   if (!simple)
3534     d_append_char (dpi, '(');
3535   d_print_comp (dpi, dc);
3536   if (!simple)
3537     d_append_char (dpi, ')');
3538 }
3539
3540 /* Subroutine to handle components.  */
3541
3542 static void
3543 d_print_comp (struct d_print_info *dpi,
3544               const struct demangle_component *dc)
3545 {
3546   if (dc == NULL)
3547     {
3548       d_print_error (dpi);
3549       return;
3550     }
3551   if (d_print_saw_error (dpi))
3552     return;
3553
3554   switch (dc->type)
3555     {
3556     case DEMANGLE_COMPONENT_NAME:
3557       if ((dpi->options & DMGL_JAVA) == 0)
3558         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3559       else
3560         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3561       return;
3562
3563     case DEMANGLE_COMPONENT_QUAL_NAME:
3564     case DEMANGLE_COMPONENT_LOCAL_NAME:
3565       d_print_comp (dpi, d_left (dc));
3566       if ((dpi->options & DMGL_JAVA) == 0)
3567         d_append_string (dpi, "::");
3568       else
3569         d_append_char (dpi, '.');
3570       d_print_comp (dpi, d_right (dc));
3571       return;
3572
3573     case DEMANGLE_COMPONENT_TYPED_NAME:
3574       {
3575         struct d_print_mod *hold_modifiers;
3576         struct demangle_component *typed_name;
3577         struct d_print_mod adpm[4];
3578         unsigned int i;
3579         struct d_print_template dpt;
3580
3581         /* Pass the name down to the type so that it can be printed in
3582            the right place for the type.  We also have to pass down
3583            any CV-qualifiers, which apply to the this parameter.  */
3584         hold_modifiers = dpi->modifiers;
3585         dpi->modifiers = 0;
3586         i = 0;
3587         typed_name = d_left (dc);
3588         while (typed_name != NULL)
3589           {
3590             if (i >= sizeof adpm / sizeof adpm[0])
3591               {
3592                 d_print_error (dpi);
3593                 return;
3594               }
3595
3596             adpm[i].next = dpi->modifiers;
3597             dpi->modifiers = &adpm[i];
3598             adpm[i].mod = typed_name;
3599             adpm[i].printed = 0;
3600             adpm[i].templates = dpi->templates;
3601             ++i;
3602
3603             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3604                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3605                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3606               break;
3607
3608             typed_name = d_left (typed_name);
3609           }
3610
3611         if (typed_name == NULL)
3612           {
3613             d_print_error (dpi);
3614             return;
3615           }
3616
3617         /* If typed_name is a template, then it applies to the
3618            function type as well.  */
3619         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3620           {
3621             dpt.next = dpi->templates;
3622             dpi->templates = &dpt;
3623             dpt.template_decl = typed_name;
3624           }
3625
3626         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3627            there may be CV-qualifiers on its right argument which
3628            really apply here; this happens when parsing a class which
3629            is local to a function.  */
3630         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3631           {
3632             struct demangle_component *local_name;
3633
3634             local_name = d_right (typed_name);
3635             if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3636               local_name = local_name->u.s_unary_num.sub;
3637             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3638                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3639                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3640               {
3641                 if (i >= sizeof adpm / sizeof adpm[0])
3642                   {
3643                     d_print_error (dpi);
3644                     return;
3645                   }
3646
3647                 adpm[i] = adpm[i - 1];
3648                 adpm[i].next = &adpm[i - 1];
3649                 dpi->modifiers = &adpm[i];
3650
3651                 adpm[i - 1].mod = local_name;
3652                 adpm[i - 1].printed = 0;
3653                 adpm[i - 1].templates = dpi->templates;
3654                 ++i;
3655
3656                 local_name = d_left (local_name);
3657               }
3658           }
3659
3660         d_print_comp (dpi, d_right (dc));
3661
3662         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3663           dpi->templates = dpt.next;
3664
3665         /* If the modifiers didn't get printed by the type, print them
3666            now.  */
3667         while (i > 0)
3668           {
3669             --i;
3670             if (! adpm[i].printed)
3671               {
3672                 d_append_char (dpi, ' ');
3673                 d_print_mod (dpi, adpm[i].mod);
3674               }
3675           }
3676
3677         dpi->modifiers = hold_modifiers;
3678
3679         return;
3680       }
3681
3682     case DEMANGLE_COMPONENT_TEMPLATE:
3683       {
3684         struct d_print_mod *hold_dpm;
3685         struct demangle_component *dcl;
3686
3687         /* Don't push modifiers into a template definition.  Doing so
3688            could give the wrong definition for a template argument.
3689            Instead, treat the template essentially as a name.  */
3690
3691         hold_dpm = dpi->modifiers;
3692         dpi->modifiers = NULL;
3693
3694         dcl = d_left (dc);
3695
3696         if ((dpi->options & DMGL_JAVA) != 0
3697             && dcl->type == DEMANGLE_COMPONENT_NAME
3698             && dcl->u.s_name.len == 6
3699             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3700           {
3701             /* Special-case Java arrays, so that JArray<TYPE> appears
3702                instead as TYPE[].  */
3703
3704             d_print_comp (dpi, d_right (dc));
3705             d_append_string (dpi, "[]");
3706           }
3707         else
3708           {
3709             d_print_comp (dpi, dcl);
3710             if (d_last_char (dpi) == '<')
3711               d_append_char (dpi, ' ');
3712             d_append_char (dpi, '<');
3713             d_print_comp (dpi, d_right (dc));
3714             /* Avoid generating two consecutive '>' characters, to avoid
3715                the C++ syntactic ambiguity.  */
3716             if (d_last_char (dpi) == '>')
3717               d_append_char (dpi, ' ');
3718             d_append_char (dpi, '>');
3719           }
3720
3721         dpi->modifiers = hold_dpm;
3722
3723         return;
3724       }
3725
3726     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3727       {
3728         struct d_print_template *hold_dpt;
3729         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3730
3731         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3732           a = d_index_template_argument (a, dpi->pack_index);
3733
3734         if (a == NULL)
3735           {
3736             d_print_error (dpi);
3737             return;
3738           }
3739
3740         /* While processing this parameter, we need to pop the list of
3741            templates.  This is because the template parameter may
3742            itself be a reference to a parameter of an outer
3743            template.  */
3744
3745         hold_dpt = dpi->templates;
3746         dpi->templates = hold_dpt->next;
3747
3748         d_print_comp (dpi, a);
3749
3750         dpi->templates = hold_dpt;
3751
3752         return;
3753       }
3754
3755     case DEMANGLE_COMPONENT_CTOR:
3756       d_print_comp (dpi, dc->u.s_ctor.name);
3757       return;
3758
3759     case DEMANGLE_COMPONENT_DTOR:
3760       d_append_char (dpi, '~');
3761       d_print_comp (dpi, dc->u.s_dtor.name);
3762       return;
3763
3764     case DEMANGLE_COMPONENT_VTABLE:
3765       d_append_string (dpi, "vtable for ");
3766       d_print_comp (dpi, d_left (dc));
3767       return;
3768
3769     case DEMANGLE_COMPONENT_VTT:
3770       d_append_string (dpi, "VTT for ");
3771       d_print_comp (dpi, d_left (dc));
3772       return;
3773
3774     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3775       d_append_string (dpi, "construction vtable for ");
3776       d_print_comp (dpi, d_left (dc));
3777       d_append_string (dpi, "-in-");
3778       d_print_comp (dpi, d_right (dc));
3779       return;
3780
3781     case DEMANGLE_COMPONENT_TYPEINFO:
3782       d_append_string (dpi, "typeinfo for ");
3783       d_print_comp (dpi, d_left (dc));
3784       return;
3785
3786     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3787       d_append_string (dpi, "typeinfo name for ");
3788       d_print_comp (dpi, d_left (dc));
3789       return;
3790
3791     case DEMANGLE_COMPONENT_TYPEINFO_FN:
3792       d_append_string (dpi, "typeinfo fn for ");
3793       d_print_comp (dpi, d_left (dc));
3794       return;
3795
3796     case DEMANGLE_COMPONENT_THUNK:
3797       d_append_string (dpi, "non-virtual thunk to ");
3798       d_print_comp (dpi, d_left (dc));
3799       return;
3800
3801     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3802       d_append_string (dpi, "virtual thunk to ");
3803       d_print_comp (dpi, d_left (dc));
3804       return;
3805
3806     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3807       d_append_string (dpi, "covariant return thunk to ");
3808       d_print_comp (dpi, d_left (dc));
3809       return;
3810
3811     case DEMANGLE_COMPONENT_JAVA_CLASS:
3812       d_append_string (dpi, "java Class for ");
3813       d_print_comp (dpi, d_left (dc));
3814       return;
3815
3816     case DEMANGLE_COMPONENT_GUARD:
3817       d_append_string (dpi, "guard variable for ");
3818       d_print_comp (dpi, d_left (dc));
3819       return;
3820
3821     case DEMANGLE_COMPONENT_REFTEMP:
3822       d_append_string (dpi, "reference temporary for ");
3823       d_print_comp (dpi, d_left (dc));
3824       return;
3825
3826     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3827       d_append_string (dpi, "hidden alias for ");
3828       d_print_comp (dpi, d_left (dc));
3829       return;
3830
3831     case DEMANGLE_COMPONENT_SUB_STD:
3832       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3833       return;
3834
3835     case DEMANGLE_COMPONENT_RESTRICT:
3836     case DEMANGLE_COMPONENT_VOLATILE:
3837     case DEMANGLE_COMPONENT_CONST:
3838       {
3839         struct d_print_mod *pdpm;
3840
3841         /* When printing arrays, it's possible to have cases where the
3842            same CV-qualifier gets pushed on the stack multiple times.
3843            We only need to print it once.  */
3844
3845         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3846           {
3847             if (! pdpm->printed)
3848               {
3849                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3850                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3851                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3852                   break;
3853                 if (pdpm->mod->type == dc->type)
3854                   {
3855                     d_print_comp (dpi, d_left (dc));
3856                     return;
3857                   }
3858               }
3859           }
3860       }
3861       /* Fall through.  */
3862     case DEMANGLE_COMPONENT_RESTRICT_THIS:
3863     case DEMANGLE_COMPONENT_VOLATILE_THIS:
3864     case DEMANGLE_COMPONENT_CONST_THIS:
3865     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3866     case DEMANGLE_COMPONENT_POINTER:
3867     case DEMANGLE_COMPONENT_REFERENCE:
3868     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3869     case DEMANGLE_COMPONENT_COMPLEX:
3870     case DEMANGLE_COMPONENT_IMAGINARY:
3871       {
3872         /* We keep a list of modifiers on the stack.  */
3873         struct d_print_mod dpm;
3874
3875         dpm.next = dpi->modifiers;
3876         dpi->modifiers = &dpm;
3877         dpm.mod = dc;
3878         dpm.printed = 0;
3879         dpm.templates = dpi->templates;
3880
3881         d_print_comp (dpi, d_left (dc));
3882
3883         /* If the modifier didn't get printed by the type, print it
3884            now.  */
3885         if (! dpm.printed)
3886           d_print_mod (dpi, dc);
3887
3888         dpi->modifiers = dpm.next;
3889
3890         return;
3891       }
3892
3893     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3894       if ((dpi->options & DMGL_JAVA) == 0)
3895         d_append_buffer (dpi, dc->u.s_builtin.type->name,
3896                          dc->u.s_builtin.type->len);
3897       else
3898         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3899                          dc->u.s_builtin.type->java_len);
3900       return;
3901
3902     case DEMANGLE_COMPONENT_VENDOR_TYPE:
3903       d_print_comp (dpi, d_left (dc));
3904       return;
3905
3906     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3907       {
3908         if ((dpi->options & DMGL_RET_POSTFIX) != 0)
3909           d_print_function_type (dpi, dc, dpi->modifiers);
3910
3911         /* Print return type if present */
3912         if (d_left (dc) != NULL)
3913           {
3914             struct d_print_mod dpm;
3915
3916             /* We must pass this type down as a modifier in order to
3917                print it in the right location.  */
3918             dpm.next = dpi->modifiers;
3919             dpi->modifiers = &dpm;
3920             dpm.mod = dc;
3921             dpm.printed = 0;
3922             dpm.templates = dpi->templates;
3923
3924             d_print_comp (dpi, d_left (dc));
3925
3926             dpi->modifiers = dpm.next;
3927
3928             if (dpm.printed)
3929               return;
3930
3931             /* In standard prefix notation, there is a space between the
3932                return type and the function signature.  */
3933             if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3934               d_append_char (dpi, ' ');
3935           }
3936
3937         if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3938           d_print_function_type (dpi, dc, dpi->modifiers);
3939
3940         return;
3941       }
3942
3943     case DEMANGLE_COMPONENT_ARRAY_TYPE:
3944       {
3945         struct d_print_mod *hold_modifiers;
3946         struct d_print_mod adpm[4];
3947         unsigned int i;
3948         struct d_print_mod *pdpm;
3949
3950         /* We must pass this type down as a modifier in order to print
3951            multi-dimensional arrays correctly.  If the array itself is
3952            CV-qualified, we act as though the element type were
3953            CV-qualified.  We do this by copying the modifiers down
3954            rather than fiddling pointers, so that we don't wind up
3955            with a d_print_mod higher on the stack pointing into our
3956            stack frame after we return.  */
3957
3958         hold_modifiers = dpi->modifiers;
3959
3960         adpm[0].next = hold_modifiers;
3961         dpi->modifiers = &adpm[0];
3962         adpm[0].mod = dc;
3963         adpm[0].printed = 0;
3964         adpm[0].templates = dpi->templates;
3965
3966         i = 1;
3967         pdpm = hold_modifiers;
3968         while (pdpm != NULL
3969                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3970                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3971                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3972           {
3973             if (! pdpm->printed)
3974               {
3975                 if (i >= sizeof adpm / sizeof adpm[0])
3976                   {
3977                     d_print_error (dpi);
3978                     return;
3979                   }
3980
3981                 adpm[i] = *pdpm;
3982                 adpm[i].next = dpi->modifiers;
3983                 dpi->modifiers = &adpm[i];
3984                 pdpm->printed = 1;
3985                 ++i;
3986               }
3987
3988             pdpm = pdpm->next;
3989           }
3990
3991         d_print_comp (dpi, d_right (dc));
3992
3993         dpi->modifiers = hold_modifiers;
3994
3995         if (adpm[0].printed)
3996           return;
3997
3998         while (i > 1)
3999           {
4000             --i;
4001             d_print_mod (dpi, adpm[i].mod);
4002           }
4003
4004         d_print_array_type (dpi, dc, dpi->modifiers);
4005
4006         return;
4007       }
4008
4009     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4010     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4011       {
4012         struct d_print_mod dpm;
4013
4014         dpm.next = dpi->modifiers;
4015         dpi->modifiers = &dpm;
4016         dpm.mod = dc;
4017         dpm.printed = 0;
4018         dpm.templates = dpi->templates;
4019
4020         d_print_comp (dpi, d_right (dc));
4021
4022         /* If the modifier didn't get printed by the type, print it
4023            now.  */
4024         if (! dpm.printed)
4025           d_print_mod (dpi, dc);
4026
4027         dpi->modifiers = dpm.next;
4028
4029         return;
4030       }
4031
4032     case DEMANGLE_COMPONENT_FIXED_TYPE:
4033       if (dc->u.s_fixed.sat)
4034         d_append_string (dpi, "_Sat ");
4035       /* Don't print "int _Accum".  */
4036       if (dc->u.s_fixed.length->u.s_builtin.type
4037           != &cplus_demangle_builtin_types['i'-'a'])
4038         {
4039           d_print_comp (dpi, dc->u.s_fixed.length);
4040           d_append_char (dpi, ' ');
4041         }
4042       if (dc->u.s_fixed.accum)
4043         d_append_string (dpi, "_Accum");
4044       else
4045         d_append_string (dpi, "_Fract");
4046       return;
4047
4048     case DEMANGLE_COMPONENT_ARGLIST:
4049     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4050       if (d_left (dc) != NULL)
4051         d_print_comp (dpi, d_left (dc));
4052       if (d_right (dc) != NULL)
4053         {
4054           size_t len;
4055           unsigned long int flush_count;
4056           /* Make sure ", " isn't flushed by d_append_string, otherwise
4057              dpi->len -= 2 wouldn't work.  */
4058           if (dpi->len >= sizeof (dpi->buf) - 2)
4059             d_print_flush (dpi);
4060           d_append_string (dpi, ", ");
4061           len = dpi->len;
4062           flush_count = dpi->flush_count;
4063           d_print_comp (dpi, d_right (dc));
4064           /* If that didn't print anything (which can happen with empty
4065              template argument packs), remove the comma and space.  */
4066           if (dpi->flush_count == flush_count && dpi->len == len)
4067             dpi->len -= 2;
4068         }
4069       return;
4070
4071     case DEMANGLE_COMPONENT_OPERATOR:
4072       {
4073         char c;
4074
4075         d_append_string (dpi, "operator");
4076         c = dc->u.s_operator.op->name[0];
4077         if (IS_LOWER (c))
4078           d_append_char (dpi, ' ');
4079         d_append_buffer (dpi, dc->u.s_operator.op->name,
4080                          dc->u.s_operator.op->len);
4081         return;
4082       }
4083
4084     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4085       d_append_string (dpi, "operator ");
4086       d_print_comp (dpi, dc->u.s_extended_operator.name);
4087       return;
4088
4089     case DEMANGLE_COMPONENT_CAST:
4090       d_append_string (dpi, "operator ");
4091       d_print_cast (dpi, dc);
4092       return;
4093
4094     case DEMANGLE_COMPONENT_UNARY:
4095       if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
4096         d_print_expr_op (dpi, d_left (dc));
4097       else
4098         {
4099           d_append_char (dpi, '(');
4100           d_print_cast (dpi, d_left (dc));
4101           d_append_char (dpi, ')');
4102         }
4103       d_print_subexpr (dpi, d_right (dc));
4104       return;
4105
4106     case DEMANGLE_COMPONENT_BINARY:
4107       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
4108         {
4109           d_print_error (dpi);
4110           return;
4111         }
4112
4113       /* We wrap an expression which uses the greater-than operator in
4114          an extra layer of parens so that it does not get confused
4115          with the '>' which ends the template parameters.  */
4116       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4117           && d_left (dc)->u.s_operator.op->len == 1
4118           && d_left (dc)->u.s_operator.op->name[0] == '>')
4119         d_append_char (dpi, '(');
4120
4121       d_print_subexpr (dpi, d_left (d_right (dc)));
4122       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
4123         {
4124           d_append_char (dpi, '[');
4125           d_print_comp (dpi, d_right (d_right (dc)));
4126           d_append_char (dpi, ']');
4127         }
4128       else
4129         {
4130           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
4131             d_print_expr_op (dpi, d_left (dc));
4132           d_print_subexpr (dpi, d_right (d_right (dc)));
4133         }
4134
4135       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4136           && d_left (dc)->u.s_operator.op->len == 1
4137           && d_left (dc)->u.s_operator.op->name[0] == '>')
4138         d_append_char (dpi, ')');
4139
4140       return;
4141
4142     case DEMANGLE_COMPONENT_BINARY_ARGS:
4143       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
4144       d_print_error (dpi);
4145       return;
4146
4147     case DEMANGLE_COMPONENT_TRINARY:
4148       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
4149           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
4150         {
4151           d_print_error (dpi);
4152           return;
4153         }
4154       d_print_subexpr (dpi, d_left (d_right (dc)));
4155       d_print_expr_op (dpi, d_left (dc));
4156       d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
4157       d_append_string (dpi, " : ");
4158       d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
4159       return;
4160
4161     case DEMANGLE_COMPONENT_TRINARY_ARG1:
4162     case DEMANGLE_COMPONENT_TRINARY_ARG2:
4163       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
4164       d_print_error (dpi);
4165       return;
4166
4167     case DEMANGLE_COMPONENT_LITERAL:
4168     case DEMANGLE_COMPONENT_LITERAL_NEG:
4169       {
4170         enum d_builtin_type_print tp;
4171
4172         /* For some builtin types, produce simpler output.  */
4173         tp = D_PRINT_DEFAULT;
4174         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
4175           {
4176             tp = d_left (dc)->u.s_builtin.type->print;
4177             switch (tp)
4178               {
4179               case D_PRINT_INT:
4180               case D_PRINT_UNSIGNED:
4181               case D_PRINT_LONG:
4182               case D_PRINT_UNSIGNED_LONG:
4183               case D_PRINT_LONG_LONG:
4184               case D_PRINT_UNSIGNED_LONG_LONG:
4185                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
4186                   {
4187                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4188                       d_append_char (dpi, '-');
4189                     d_print_comp (dpi, d_right (dc));
4190                     switch (tp)
4191                       {
4192                       default:
4193                         break;
4194                       case D_PRINT_UNSIGNED:
4195                         d_append_char (dpi, 'u');
4196                         break;
4197                       case D_PRINT_LONG:
4198                         d_append_char (dpi, 'l');
4199                         break;
4200                       case D_PRINT_UNSIGNED_LONG:
4201                         d_append_string (dpi, "ul");
4202                         break;
4203                       case D_PRINT_LONG_LONG:
4204                         d_append_string (dpi, "ll");
4205                         break;
4206                       case D_PRINT_UNSIGNED_LONG_LONG:
4207                         d_append_string (dpi, "ull");
4208                         break;
4209                       }
4210                     return;
4211                   }
4212                 break;
4213
4214               case D_PRINT_BOOL:
4215                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
4216                     && d_right (dc)->u.s_name.len == 1
4217                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
4218                   {
4219                     switch (d_right (dc)->u.s_name.s[0])
4220                       {
4221                       case '0':
4222                         d_append_string (dpi, "false");
4223                         return;
4224                       case '1':
4225                         d_append_string (dpi, "true");
4226                         return;
4227                       default:
4228                         break;
4229                       }
4230                   }
4231                 break;
4232
4233               default:
4234                 break;
4235               }
4236           }
4237
4238         d_append_char (dpi, '(');
4239         d_print_comp (dpi, d_left (dc));
4240         d_append_char (dpi, ')');
4241         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4242           d_append_char (dpi, '-');
4243         if (tp == D_PRINT_FLOAT)
4244           d_append_char (dpi, '[');
4245         d_print_comp (dpi, d_right (dc));
4246         if (tp == D_PRINT_FLOAT)
4247           d_append_char (dpi, ']');
4248       }
4249       return;
4250
4251     case DEMANGLE_COMPONENT_NUMBER:
4252       d_append_num (dpi, dc->u.s_number.number);
4253       return;
4254
4255     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4256       d_append_string (dpi, "java resource ");
4257       d_print_comp (dpi, d_left (dc));
4258       return;
4259
4260     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4261       d_print_comp (dpi, d_left (dc));
4262       d_print_comp (dpi, d_right (dc));
4263       return;
4264
4265     case DEMANGLE_COMPONENT_CHARACTER:
4266       d_append_char (dpi, dc->u.s_character.character);
4267       return;
4268
4269     case DEMANGLE_COMPONENT_DECLTYPE:
4270       d_append_string (dpi, "decltype (");
4271       d_print_comp (dpi, d_left (dc));
4272       d_append_char (dpi, ')');
4273       return;
4274
4275     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4276       {
4277         int len;
4278         int i;
4279         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4280         if (a == NULL)
4281           {
4282             /* d_find_pack won't find anything if the only packs involved
4283                in this expansion are function parameter packs; in that
4284                case, just print the pattern and "...".  */
4285             d_print_subexpr (dpi, d_left (dc));
4286             d_append_string (dpi, "...");
4287             return;
4288           }
4289
4290         len = d_pack_length (a);
4291         dc = d_left (dc);
4292         for (i = 0; i < len; ++i)
4293           {
4294             dpi->pack_index = i;
4295             d_print_comp (dpi, dc);
4296             if (i < len-1)
4297               d_append_string (dpi, ", ");
4298           }
4299       }
4300       return;
4301
4302     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4303       d_append_string (dpi, "{parm#");
4304       d_append_num (dpi, dc->u.s_number.number + 1);
4305       d_append_char (dpi, '}');
4306       return;
4307
4308     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4309       d_append_string (dpi, "global constructors keyed to ");
4310       d_print_comp (dpi, dc->u.s_binary.left);
4311       return;
4312
4313     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4314       d_append_string (dpi, "global destructors keyed to ");
4315       d_print_comp (dpi, dc->u.s_binary.left);
4316       return;
4317
4318     case DEMANGLE_COMPONENT_LAMBDA:
4319       d_append_string (dpi, "{lambda(");
4320       d_print_comp (dpi, dc->u.s_unary_num.sub);
4321       d_append_string (dpi, ")#");
4322       d_append_num (dpi, dc->u.s_unary_num.num + 1);
4323       d_append_char (dpi, '}');
4324       return;
4325
4326     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4327       d_append_string (dpi, "{unnamed type#");
4328       d_append_num (dpi, dc->u.s_number.number + 1);
4329       d_append_char (dpi, '}');
4330       return;
4331
4332     default:
4333       d_print_error (dpi);
4334       return;
4335     }
4336 }
4337
4338 /* Print a Java dentifier.  For Java we try to handle encoded extended
4339    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
4340    so we don't it for C++.  Characters are encoded as
4341    __U<hex-char>+_.  */
4342
4343 static void
4344 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4345 {
4346   const char *p;
4347   const char *end;
4348
4349   end = name + len;
4350   for (p = name; p < end; ++p)
4351     {
4352       if (end - p > 3
4353           && p[0] == '_'
4354           && p[1] == '_'
4355           && p[2] == 'U')
4356         {
4357           unsigned long c;
4358           const char *q;
4359
4360           c = 0;
4361           for (q = p + 3; q < end; ++q)
4362             {
4363               int dig;
4364
4365               if (IS_DIGIT (*q))
4366                 dig = *q - '0';
4367               else if (*q >= 'A' && *q <= 'F')
4368                 dig = *q - 'A' + 10;
4369               else if (*q >= 'a' && *q <= 'f')
4370                 dig = *q - 'a' + 10;
4371               else
4372                 break;
4373
4374               c = c * 16 + dig;
4375             }
4376           /* If the Unicode character is larger than 256, we don't try
4377              to deal with it here.  FIXME.  */
4378           if (q < end && *q == '_' && c < 256)
4379             {
4380               d_append_char (dpi, c);
4381               p = q;
4382               continue;
4383             }
4384         }
4385
4386       d_append_char (dpi, *p);
4387     }
4388 }
4389
4390 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
4391    qualifiers on this after printing a function.  */
4392
4393 static void
4394 d_print_mod_list (struct d_print_info *dpi,
4395                   struct d_print_mod *mods, int suffix)
4396 {
4397   struct d_print_template *hold_dpt;
4398
4399   if (mods == NULL || d_print_saw_error (dpi))
4400     return;
4401
4402   if (mods->printed
4403       || (! suffix
4404           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4405               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4406               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4407     {
4408       d_print_mod_list (dpi, mods->next, suffix);
4409       return;
4410     }
4411
4412   mods->printed = 1;
4413
4414   hold_dpt = dpi->templates;
4415   dpi->templates = mods->templates;
4416
4417   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4418     {
4419       d_print_function_type (dpi, mods->mod, mods->next);
4420       dpi->templates = hold_dpt;
4421       return;
4422     }
4423   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4424     {
4425       d_print_array_type (dpi, mods->mod, mods->next);
4426       dpi->templates = hold_dpt;
4427       return;
4428     }
4429   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4430     {
4431       struct d_print_mod *hold_modifiers;
4432       struct demangle_component *dc;
4433
4434       /* When this is on the modifier stack, we have pulled any
4435          qualifiers off the right argument already.  Otherwise, we
4436          print it as usual, but don't let the left argument see any
4437          modifiers.  */
4438
4439       hold_modifiers = dpi->modifiers;
4440       dpi->modifiers = NULL;
4441       d_print_comp (dpi, d_left (mods->mod));
4442       dpi->modifiers = hold_modifiers;
4443
4444       if ((dpi->options & DMGL_JAVA) == 0)
4445         d_append_string (dpi, "::");
4446       else
4447         d_append_char (dpi, '.');
4448
4449       dc = d_right (mods->mod);
4450
4451       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4452         {
4453           d_append_string (dpi, "{default arg#");
4454           d_append_num (dpi, dc->u.s_unary_num.num + 1);
4455           d_append_string (dpi, "}::");
4456           dc = dc->u.s_unary_num.sub;
4457         }
4458
4459       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4460              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4461              || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4462         dc = d_left (dc);
4463
4464       d_print_comp (dpi, dc);
4465
4466       dpi->templates = hold_dpt;
4467       return;
4468     }
4469
4470   d_print_mod (dpi, mods->mod);
4471
4472   dpi->templates = hold_dpt;
4473
4474   d_print_mod_list (dpi, mods->next, suffix);
4475 }
4476
4477 /* Print a modifier.  */
4478
4479 static void
4480 d_print_mod (struct d_print_info *dpi,
4481              const struct demangle_component *mod)
4482 {
4483   switch (mod->type)
4484     {
4485     case DEMANGLE_COMPONENT_RESTRICT:
4486     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4487       d_append_string (dpi, " restrict");
4488       return;
4489     case DEMANGLE_COMPONENT_VOLATILE:
4490     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4491       d_append_string (dpi, " volatile");
4492       return;
4493     case DEMANGLE_COMPONENT_CONST:
4494     case DEMANGLE_COMPONENT_CONST_THIS:
4495       d_append_string (dpi, " const");
4496       return;
4497     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4498       d_append_char (dpi, ' ');
4499       d_print_comp (dpi, d_right (mod));
4500       return;
4501     case DEMANGLE_COMPONENT_POINTER:
4502       /* There is no pointer symbol in Java.  */
4503       if ((dpi->options & DMGL_JAVA) == 0)
4504         d_append_char (dpi, '*');
4505       return;
4506     case DEMANGLE_COMPONENT_REFERENCE:
4507       d_append_char (dpi, '&');
4508       return;
4509     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4510       d_append_string (dpi, "&&");
4511       return;
4512     case DEMANGLE_COMPONENT_COMPLEX:
4513       d_append_string (dpi, "complex ");
4514       return;
4515     case DEMANGLE_COMPONENT_IMAGINARY:
4516       d_append_string (dpi, "imaginary ");
4517       return;
4518     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4519       if (d_last_char (dpi) != '(')
4520         d_append_char (dpi, ' ');
4521       d_print_comp (dpi, d_left (mod));
4522       d_append_string (dpi, "::*");
4523       return;
4524     case DEMANGLE_COMPONENT_TYPED_NAME:
4525       d_print_comp (dpi, d_left (mod));
4526       return;
4527     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4528       d_append_string (dpi, " __vector(");
4529       d_print_comp (dpi, d_left (mod));
4530       d_append_char (dpi, ')');
4531       return;
4532
4533     default:
4534       /* Otherwise, we have something that won't go back on the
4535          modifier stack, so we can just print it.  */
4536       d_print_comp (dpi, mod);
4537       return;
4538     }
4539 }
4540
4541 /* Print a function type, except for the return type.  */
4542
4543 static void
4544 d_print_function_type (struct d_print_info *dpi,
4545                        const struct demangle_component *dc,
4546                        struct d_print_mod *mods)
4547 {
4548   int need_paren;
4549   int need_space;
4550   struct d_print_mod *p;
4551   struct d_print_mod *hold_modifiers;
4552
4553   need_paren = 0;
4554   need_space = 0;
4555   for (p = mods; p != NULL; p = p->next)
4556     {
4557       if (p->printed)
4558         break;
4559
4560       switch (p->mod->type)
4561         {
4562         case DEMANGLE_COMPONENT_POINTER:
4563         case DEMANGLE_COMPONENT_REFERENCE:
4564         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4565           need_paren = 1;
4566           break;
4567         case DEMANGLE_COMPONENT_RESTRICT:
4568         case DEMANGLE_COMPONENT_VOLATILE:
4569         case DEMANGLE_COMPONENT_CONST:
4570         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4571         case DEMANGLE_COMPONENT_COMPLEX:
4572         case DEMANGLE_COMPONENT_IMAGINARY:
4573         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4574           need_space = 1;
4575           need_paren = 1;
4576           break;
4577         case DEMANGLE_COMPONENT_RESTRICT_THIS:
4578         case DEMANGLE_COMPONENT_VOLATILE_THIS:
4579         case DEMANGLE_COMPONENT_CONST_THIS:
4580           break;
4581         default:
4582           break;
4583         }
4584       if (need_paren)
4585         break;
4586     }
4587
4588   if (need_paren)
4589     {
4590       if (! need_space)
4591         {
4592           if (d_last_char (dpi) != '('
4593               && d_last_char (dpi) != '*')
4594             need_space = 1;
4595         }
4596       if (need_space && d_last_char (dpi) != ' ')
4597         d_append_char (dpi, ' ');
4598       d_append_char (dpi, '(');
4599     }
4600
4601   hold_modifiers = dpi->modifiers;
4602   dpi->modifiers = NULL;
4603
4604   d_print_mod_list (dpi, mods, 0);
4605
4606   if (need_paren)
4607     d_append_char (dpi, ')');
4608
4609   d_append_char (dpi, '(');
4610
4611   if (d_right (dc) != NULL)
4612     d_print_comp (dpi, d_right (dc));
4613
4614   d_append_char (dpi, ')');
4615
4616   d_print_mod_list (dpi, mods, 1);
4617
4618   dpi->modifiers = hold_modifiers;
4619 }
4620
4621 /* Print an array type, except for the element type.  */
4622
4623 static void
4624 d_print_array_type (struct d_print_info *dpi,
4625                     const struct demangle_component *dc,
4626                     struct d_print_mod *mods)
4627 {
4628   int need_space;
4629
4630   need_space = 1;
4631   if (mods != NULL)
4632     {
4633       int need_paren;
4634       struct d_print_mod *p;
4635
4636       need_paren = 0;
4637       for (p = mods; p != NULL; p = p->next)
4638         {
4639           if (! p->printed)
4640             {
4641               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4642                 {
4643                   need_space = 0;
4644                   break;
4645                 }
4646               else
4647                 {
4648                   need_paren = 1;
4649                   need_space = 1;
4650                   break;
4651                 }
4652             }
4653         }
4654
4655       if (need_paren)
4656         d_append_string (dpi, " (");
4657
4658       d_print_mod_list (dpi, mods, 0);
4659
4660       if (need_paren)
4661         d_append_char (dpi, ')');
4662     }
4663
4664   if (need_space)
4665     d_append_char (dpi, ' ');
4666
4667   d_append_char (dpi, '[');
4668
4669   if (d_left (dc) != NULL)
4670     d_print_comp (dpi, d_left (dc));
4671
4672   d_append_char (dpi, ']');
4673 }
4674
4675 /* Print an operator in an expression.  */
4676
4677 static void
4678 d_print_expr_op (struct d_print_info *dpi,
4679                  const struct demangle_component *dc)
4680 {
4681   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
4682     d_append_buffer (dpi, dc->u.s_operator.op->name,
4683                      dc->u.s_operator.op->len);
4684   else
4685     d_print_comp (dpi, dc);
4686 }
4687
4688 /* Print a cast.  */
4689
4690 static void
4691 d_print_cast (struct d_print_info *dpi,
4692               const struct demangle_component *dc)
4693 {
4694   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
4695     d_print_comp (dpi, d_left (dc));
4696   else
4697     {
4698       struct d_print_mod *hold_dpm;
4699       struct d_print_template dpt;
4700
4701       /* It appears that for a templated cast operator, we need to put
4702          the template parameters in scope for the operator name, but
4703          not for the parameters.  The effect is that we need to handle
4704          the template printing here.  */
4705
4706       hold_dpm = dpi->modifiers;
4707       dpi->modifiers = NULL;
4708
4709       dpt.next = dpi->templates;
4710       dpi->templates = &dpt;
4711       dpt.template_decl = d_left (dc);
4712
4713       d_print_comp (dpi, d_left (d_left (dc)));
4714
4715       dpi->templates = dpt.next;
4716
4717       if (d_last_char (dpi) == '<')
4718         d_append_char (dpi, ' ');
4719       d_append_char (dpi, '<');
4720       d_print_comp (dpi, d_right (d_left (dc)));
4721       /* Avoid generating two consecutive '>' characters, to avoid
4722          the C++ syntactic ambiguity.  */
4723       if (d_last_char (dpi) == '>')
4724         d_append_char (dpi, ' ');
4725       d_append_char (dpi, '>');
4726
4727       dpi->modifiers = hold_dpm;
4728     }
4729 }
4730
4731 /* Initialize the information structure we use to pass around
4732    information.  */
4733
4734 CP_STATIC_IF_GLIBCPP_V3
4735 void
4736 cplus_demangle_init_info (const char *mangled, int options, size_t len,
4737                           struct d_info *di)
4738 {
4739   di->s = mangled;
4740   di->send = mangled + len;
4741   di->options = options;
4742
4743   di->n = mangled;
4744
4745   /* We can not need more components than twice the number of chars in
4746      the mangled string.  Most components correspond directly to
4747      chars, but the ARGLIST types are exceptions.  */
4748   di->num_comps = 2 * len;
4749   di->next_comp = 0;
4750
4751   /* Similarly, we can not need more substitutions than there are
4752      chars in the mangled string.  */
4753   di->num_subs = len;
4754   di->next_sub = 0;
4755   di->did_subs = 0;
4756
4757   di->last_name = NULL;
4758
4759   di->expansion = 0;
4760 }
4761
4762 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
4763    mangled name, return strings in repeated callback giving the demangled
4764    name.  OPTIONS is the usual libiberty demangler options.  On success,
4765    this returns 1.  On failure, returns 0.  */
4766
4767 static int
4768 d_demangle_callback (const char *mangled, int options,
4769                      demangle_callbackref callback, void *opaque)
4770 {
4771   enum
4772     {
4773       DCT_TYPE,
4774       DCT_MANGLED,
4775       DCT_GLOBAL_CTORS,
4776       DCT_GLOBAL_DTORS
4777     }
4778   type;
4779   struct d_info di;
4780   struct demangle_component *dc;
4781   int status;
4782
4783   if (mangled[0] == '_' && mangled[1] == 'Z')
4784     type = DCT_MANGLED;
4785   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4786            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
4787            && (mangled[9] == 'D' || mangled[9] == 'I')
4788            && mangled[10] == '_')
4789     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
4790   else
4791     {
4792       if ((options & DMGL_TYPES) == 0)
4793         return 0;
4794       type = DCT_TYPE;
4795     }
4796
4797   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4798
4799   {
4800 #ifdef CP_DYNAMIC_ARRAYS
4801     __extension__ struct demangle_component comps[di.num_comps];
4802     __extension__ struct demangle_component *subs[di.num_subs];
4803
4804     di.comps = comps;
4805     di.subs = subs;
4806 #else
4807     di.comps = alloca (di.num_comps * sizeof (*di.comps));
4808     di.subs = alloca (di.num_subs * sizeof (*di.subs));
4809 #endif
4810
4811     switch (type)
4812       {
4813       case DCT_TYPE:
4814         dc = cplus_demangle_type (&di);
4815         break;
4816       case DCT_MANGLED:
4817         dc = cplus_demangle_mangled_name (&di, 1);
4818         break;
4819       case DCT_GLOBAL_CTORS:
4820       case DCT_GLOBAL_DTORS:
4821         d_advance (&di, 11);
4822         dc = d_make_comp (&di,
4823                           (type == DCT_GLOBAL_CTORS
4824                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
4825                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
4826                           d_make_name (&di, d_str (&di), strlen (d_str (&di))),
4827                           NULL);
4828         d_advance (&di, strlen (d_str (&di)));
4829         break;
4830       }
4831
4832     /* If DMGL_PARAMS is set, then if we didn't consume the entire
4833        mangled string, then we didn't successfully demangle it.  If
4834        DMGL_PARAMS is not set, we didn't look at the trailing
4835        parameters.  */
4836     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
4837       dc = NULL;
4838
4839 #ifdef CP_DEMANGLE_DEBUG
4840     d_dump (dc, 0);
4841 #endif
4842
4843     status = (dc != NULL)
4844              ? cplus_demangle_print_callback (options, dc, callback, opaque)
4845              : 0;
4846   }
4847
4848   return status;
4849 }
4850
4851 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
4852    name, return a buffer allocated with malloc holding the demangled
4853    name.  OPTIONS is the usual libiberty demangler options.  On
4854    success, this sets *PALC to the allocated size of the returned
4855    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
4856    a memory allocation failure, and returns NULL.  */
4857
4858 static char *
4859 d_demangle (const char *mangled, int options, size_t *palc)
4860 {
4861   struct d_growable_string dgs;
4862   int status;
4863
4864   d_growable_string_init (&dgs, 0);
4865
4866   status = d_demangle_callback (mangled, options,
4867                                 d_growable_string_callback_adapter, &dgs);
4868   if (status == 0)
4869     {
4870       free (dgs.buf);
4871       *palc = 0;
4872       return NULL;
4873     }
4874
4875   *palc = dgs.allocation_failure ? 1 : dgs.alc;
4876   return dgs.buf;
4877 }
4878
4879 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
4880
4881 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
4882
4883 /* ia64 ABI-mandated entry point in the C++ runtime library for
4884    performing demangling.  MANGLED_NAME is a NUL-terminated character
4885    string containing the name to be demangled.
4886
4887    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4888    *LENGTH bytes, into which the demangled name is stored.  If
4889    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4890    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4891    is placed in a region of memory allocated with malloc.
4892
4893    If LENGTH is non-NULL, the length of the buffer containing the
4894    demangled name, is placed in *LENGTH.
4895
4896    The return value is a pointer to the start of the NUL-terminated
4897    demangled name, or NULL if the demangling fails.  The caller is
4898    responsible for deallocating this memory using free.
4899
4900    *STATUS is set to one of the following values:
4901       0: The demangling operation succeeded.
4902      -1: A memory allocation failure occurred.
4903      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4904      -3: One of the arguments is invalid.
4905
4906    The demangling is performed using the C++ ABI mangling rules, with
4907    GNU extensions.  */
4908
4909 char *
4910 __cxa_demangle (const char *mangled_name, char *output_buffer,
4911                 size_t *length, int *status)
4912 {
4913   char *demangled;
4914   size_t alc;
4915
4916   if (mangled_name == NULL)
4917     {
4918       if (status != NULL)
4919         *status = -3;
4920       return NULL;
4921     }
4922
4923   if (output_buffer != NULL && length == NULL)
4924     {
4925       if (status != NULL)
4926         *status = -3;
4927       return NULL;
4928     }
4929
4930   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
4931
4932   if (demangled == NULL)
4933     {
4934       if (status != NULL)
4935         {
4936           if (alc == 1)
4937             *status = -1;
4938           else
4939             *status = -2;
4940         }
4941       return NULL;
4942     }
4943
4944   if (output_buffer == NULL)
4945     {
4946       if (length != NULL)
4947         *length = alc;
4948     }
4949   else
4950     {
4951       if (strlen (demangled) < *length)
4952         {
4953           strcpy (output_buffer, demangled);
4954           free (demangled);
4955           demangled = output_buffer;
4956         }
4957       else
4958         {
4959           free (output_buffer);
4960           *length = alc;
4961         }
4962     }
4963
4964   if (status != NULL)
4965     *status = 0;
4966
4967   return demangled;
4968 }
4969
4970 extern int __gcclibcxx_demangle_callback (const char *,
4971                                           void (*)
4972                                             (const char *, size_t, void *),
4973                                           void *);
4974
4975 /* Alternative, allocationless entry point in the C++ runtime library
4976    for performing demangling.  MANGLED_NAME is a NUL-terminated character
4977    string containing the name to be demangled.
4978
4979    CALLBACK is a callback function, called with demangled string
4980    segments as demangling progresses; it is called at least once,
4981    but may be called more than once.  OPAQUE is a generalized pointer
4982    used as a callback argument.
4983
4984    The return code is one of the following values, equivalent to
4985    the STATUS values of __cxa_demangle() (excluding -1, since this
4986    function performs no memory allocations):
4987       0: The demangling operation succeeded.
4988      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4989      -3: One of the arguments is invalid.
4990
4991    The demangling is performed using the C++ ABI mangling rules, with
4992    GNU extensions.  */
4993
4994 int
4995 __gcclibcxx_demangle_callback (const char *mangled_name,
4996                                void (*callback) (const char *, size_t, void *),
4997                                void *opaque)
4998 {
4999   int status;
5000
5001   if (mangled_name == NULL || callback == NULL)
5002     return -3;
5003
5004   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
5005                                 callback, opaque);
5006   if (status == 0)
5007     return -2;
5008
5009   return 0;
5010 }
5011
5012 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5013
5014 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
5015    mangled name, return a buffer allocated with malloc holding the
5016    demangled name.  Otherwise, return NULL.  */
5017
5018 char *
5019 cplus_demangle_v3 (const char *mangled, int options)
5020 {
5021   size_t alc;
5022
5023   return d_demangle (mangled, options, &alc);
5024 }
5025
5026 int
5027 cplus_demangle_v3_callback (const char *mangled, int options,
5028                             demangle_callbackref callback, void *opaque)
5029 {
5030   return d_demangle_callback (mangled, options, callback, opaque);
5031 }
5032
5033 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
5034    conventions, but the output formatting is a little different.
5035    This instructs the C++ demangler not to emit pointer characters ("*"), to
5036    use Java's namespace separator symbol ("." instead of "::"), and to output
5037    JArray<TYPE> as TYPE[].  */
5038
5039 char *
5040 java_demangle_v3 (const char *mangled)
5041 {
5042   size_t alc;
5043
5044   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
5045 }
5046
5047 int
5048 java_demangle_v3_callback (const char *mangled,
5049                            demangle_callbackref callback, void *opaque)
5050 {
5051   return d_demangle_callback (mangled,
5052                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
5053                               callback, opaque);
5054 }
5055
5056 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5057
5058 #ifndef IN_GLIBCPP_V3
5059
5060 /* Demangle a string in order to find out whether it is a constructor
5061    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
5062    *DTOR_KIND appropriately.  */
5063
5064 static int
5065 is_ctor_or_dtor (const char *mangled,
5066                  enum gnu_v3_ctor_kinds *ctor_kind,
5067                  enum gnu_v3_dtor_kinds *dtor_kind)
5068 {
5069   struct d_info di;
5070   struct demangle_component *dc;
5071   int ret;
5072
5073   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
5074   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
5075
5076   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
5077
5078   {
5079 #ifdef CP_DYNAMIC_ARRAYS
5080     __extension__ struct demangle_component comps[di.num_comps];
5081     __extension__ struct demangle_component *subs[di.num_subs];
5082
5083     di.comps = comps;
5084     di.subs = subs;
5085 #else
5086     di.comps = alloca (di.num_comps * sizeof (*di.comps));
5087     di.subs = alloca (di.num_subs * sizeof (*di.subs));
5088 #endif
5089
5090     dc = cplus_demangle_mangled_name (&di, 1);
5091
5092     /* Note that because we did not pass DMGL_PARAMS, we don't expect
5093        to demangle the entire string.  */
5094
5095     ret = 0;
5096     while (dc != NULL)
5097       {
5098         switch (dc->type)
5099           {
5100           default:
5101             dc = NULL;
5102             break;
5103           case DEMANGLE_COMPONENT_TYPED_NAME:
5104           case DEMANGLE_COMPONENT_TEMPLATE:
5105           case DEMANGLE_COMPONENT_RESTRICT_THIS:
5106           case DEMANGLE_COMPONENT_VOLATILE_THIS:
5107           case DEMANGLE_COMPONENT_CONST_THIS:
5108             dc = d_left (dc);
5109             break;
5110           case DEMANGLE_COMPONENT_QUAL_NAME:
5111           case DEMANGLE_COMPONENT_LOCAL_NAME:
5112             dc = d_right (dc);
5113             break;
5114           case DEMANGLE_COMPONENT_CTOR:
5115             *ctor_kind = dc->u.s_ctor.kind;
5116             ret = 1;
5117             dc = NULL;
5118             break;
5119           case DEMANGLE_COMPONENT_DTOR:
5120             *dtor_kind = dc->u.s_dtor.kind;
5121             ret = 1;
5122             dc = NULL;
5123             break;
5124           }
5125       }
5126   }
5127
5128   return ret;
5129 }
5130
5131 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5132    name.  A non-zero return indicates the type of constructor.  */
5133
5134 enum gnu_v3_ctor_kinds
5135 is_gnu_v3_mangled_ctor (const char *name)
5136 {
5137   enum gnu_v3_ctor_kinds ctor_kind;
5138   enum gnu_v3_dtor_kinds dtor_kind;
5139
5140   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5141     return (enum gnu_v3_ctor_kinds) 0;
5142   return ctor_kind;
5143 }
5144
5145
5146 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5147    name.  A non-zero return indicates the type of destructor.  */
5148
5149 enum gnu_v3_dtor_kinds
5150 is_gnu_v3_mangled_dtor (const char *name)
5151 {
5152   enum gnu_v3_ctor_kinds ctor_kind;
5153   enum gnu_v3_dtor_kinds dtor_kind;
5154
5155   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5156     return (enum gnu_v3_dtor_kinds) 0;
5157   return dtor_kind;
5158 }
5159
5160 #endif /* IN_GLIBCPP_V3 */
5161
5162 #ifdef STANDALONE_DEMANGLER
5163
5164 #include "getopt.h"
5165 #include "dyn-string.h"
5166
5167 static void print_usage (FILE* fp, int exit_value);
5168
5169 #define IS_ALPHA(CHAR)                                                  \
5170   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
5171    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5172
5173 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
5174 #define is_mangled_char(CHAR)                                           \
5175   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
5176    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5177
5178 /* The name of this program, as invoked.  */
5179 const char* program_name;
5180
5181 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
5182
5183 static void
5184 print_usage (FILE* fp, int exit_value)
5185 {
5186   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
5187   fprintf (fp, "Options:\n");
5188   fprintf (fp, "  -h,--help       Display this message.\n");
5189   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
5190   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
5191   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
5192
5193   exit (exit_value);
5194 }
5195
5196 /* Option specification for getopt_long.  */
5197 static const struct option long_options[] =
5198 {
5199   { "help",      no_argument, NULL, 'h' },
5200   { "no-params", no_argument, NULL, 'p' },
5201   { "verbose",   no_argument, NULL, 'v' },
5202   { NULL,        no_argument, NULL, 0   },
5203 };
5204
5205 /* Main entry for a demangling filter executable.  It will demangle
5206    its command line arguments, if any.  If none are provided, it will
5207    filter stdin to stdout, replacing any recognized mangled C++ names
5208    with their demangled equivalents.  */
5209
5210 int
5211 main (int argc, char *argv[])
5212 {
5213   int i;
5214   int opt_char;
5215   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
5216
5217   /* Use the program name of this program, as invoked.  */
5218   program_name = argv[0];
5219
5220   /* Parse options.  */
5221   do
5222     {
5223       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
5224       switch (opt_char)
5225         {
5226         case '?':  /* Unrecognized option.  */
5227           print_usage (stderr, 1);
5228           break;
5229
5230         case 'h':
5231           print_usage (stdout, 0);
5232           break;
5233
5234         case 'p':
5235           options &= ~ DMGL_PARAMS;
5236           break;
5237
5238         case 'v':
5239           options |= DMGL_VERBOSE;
5240           break;
5241         }
5242     }
5243   while (opt_char != -1);
5244
5245   if (optind == argc)
5246     /* No command line arguments were provided.  Filter stdin.  */
5247     {
5248       dyn_string_t mangled = dyn_string_new (3);
5249       char *s;
5250
5251       /* Read all of input.  */
5252       while (!feof (stdin))
5253         {
5254           char c;
5255
5256           /* Pile characters into mangled until we hit one that can't
5257              occur in a mangled name.  */
5258           c = getchar ();
5259           while (!feof (stdin) && is_mangled_char (c))
5260             {
5261               dyn_string_append_char (mangled, c);
5262               if (feof (stdin))
5263                 break;
5264               c = getchar ();
5265             }
5266
5267           if (dyn_string_length (mangled) > 0)
5268             {
5269 #ifdef IN_GLIBCPP_V3
5270               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
5271 #else
5272               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5273 #endif
5274
5275               if (s != NULL)
5276                 {
5277                   fputs (s, stdout);
5278                   free (s);
5279                 }
5280               else
5281                 {
5282                   /* It might not have been a mangled name.  Print the
5283                      original text.  */
5284                   fputs (dyn_string_buf (mangled), stdout);
5285                 }
5286
5287               dyn_string_clear (mangled);
5288             }
5289
5290           /* If we haven't hit EOF yet, we've read one character that
5291              can't occur in a mangled name, so print it out.  */
5292           if (!feof (stdin))
5293             putchar (c);
5294         }
5295
5296       dyn_string_delete (mangled);
5297     }
5298   else
5299     /* Demangle command line arguments.  */
5300     {
5301       /* Loop over command line arguments.  */
5302       for (i = optind; i < argc; ++i)
5303         {
5304           char *s;
5305 #ifdef IN_GLIBCPP_V3
5306           int status;
5307 #endif
5308
5309           /* Attempt to demangle.  */
5310 #ifdef IN_GLIBCPP_V3
5311           s = __cxa_demangle (argv[i], NULL, NULL, &status);
5312 #else
5313           s = cplus_demangle_v3 (argv[i], options);
5314 #endif
5315
5316           /* If it worked, print the demangled name.  */
5317           if (s != NULL)
5318             {
5319               printf ("%s\n", s);
5320               free (s);
5321             }
5322           else
5323             {
5324 #ifdef IN_GLIBCPP_V3
5325               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5326 #else
5327               fprintf (stderr, "Failed: %s\n", argv[i]);
5328 #endif
5329             }
5330         }
5331     }
5332
5333   return 0;
5334 }
5335
5336 #endif /* STANDALONE_DEMANGLER */