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_NAME:
3484     case DEMANGLE_COMPONENT_OPERATOR:
3485     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3486     case DEMANGLE_COMPONENT_SUB_STD:
3487     case DEMANGLE_COMPONENT_CHARACTER:
3488     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3489       return NULL;
3490
3491     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3492       return d_find_pack (dpi, dc->u.s_extended_operator.name);
3493     case DEMANGLE_COMPONENT_CTOR:
3494       return d_find_pack (dpi, dc->u.s_ctor.name);
3495     case DEMANGLE_COMPONENT_DTOR:
3496       return d_find_pack (dpi, dc->u.s_dtor.name);
3497
3498     default:
3499       a = d_find_pack (dpi, d_left (dc));
3500       if (a)
3501         return a;
3502       return d_find_pack (dpi, d_right (dc));
3503     }
3504 }
3505
3506 /* Returns the length of the template argument pack DC.  */
3507
3508 static int
3509 d_pack_length (const struct demangle_component *dc)
3510 {
3511   int count = 0;
3512   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3513          && d_left (dc) != NULL)
3514     {
3515       ++count;
3516       dc = d_right (dc);
3517     }
3518   return count;
3519 }
3520
3521 /* DC is a component of a mangled expression.  Print it, wrapped in parens
3522    if needed.  */
3523
3524 static void
3525 d_print_subexpr (struct d_print_info *dpi,
3526                  const struct demangle_component *dc)
3527 {
3528   int simple = 0;
3529   if (dc->type == DEMANGLE_COMPONENT_NAME
3530       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3531     simple = 1;
3532   if (!simple)
3533     d_append_char (dpi, '(');
3534   d_print_comp (dpi, dc);
3535   if (!simple)
3536     d_append_char (dpi, ')');
3537 }
3538
3539 /* Subroutine to handle components.  */
3540
3541 static void
3542 d_print_comp (struct d_print_info *dpi,
3543               const struct demangle_component *dc)
3544 {
3545   if (dc == NULL)
3546     {
3547       d_print_error (dpi);
3548       return;
3549     }
3550   if (d_print_saw_error (dpi))
3551     return;
3552
3553   switch (dc->type)
3554     {
3555     case DEMANGLE_COMPONENT_NAME:
3556       if ((dpi->options & DMGL_JAVA) == 0)
3557         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3558       else
3559         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3560       return;
3561
3562     case DEMANGLE_COMPONENT_QUAL_NAME:
3563     case DEMANGLE_COMPONENT_LOCAL_NAME:
3564       d_print_comp (dpi, d_left (dc));
3565       if ((dpi->options & DMGL_JAVA) == 0)
3566         d_append_string (dpi, "::");
3567       else
3568         d_append_char (dpi, '.');
3569       d_print_comp (dpi, d_right (dc));
3570       return;
3571
3572     case DEMANGLE_COMPONENT_TYPED_NAME:
3573       {
3574         struct d_print_mod *hold_modifiers;
3575         struct demangle_component *typed_name;
3576         struct d_print_mod adpm[4];
3577         unsigned int i;
3578         struct d_print_template dpt;
3579
3580         /* Pass the name down to the type so that it can be printed in
3581            the right place for the type.  We also have to pass down
3582            any CV-qualifiers, which apply to the this parameter.  */
3583         hold_modifiers = dpi->modifiers;
3584         dpi->modifiers = 0;
3585         i = 0;
3586         typed_name = d_left (dc);
3587         while (typed_name != NULL)
3588           {
3589             if (i >= sizeof adpm / sizeof adpm[0])
3590               {
3591                 d_print_error (dpi);
3592                 return;
3593               }
3594
3595             adpm[i].next = dpi->modifiers;
3596             dpi->modifiers = &adpm[i];
3597             adpm[i].mod = typed_name;
3598             adpm[i].printed = 0;
3599             adpm[i].templates = dpi->templates;
3600             ++i;
3601
3602             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3603                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3604                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3605               break;
3606
3607             typed_name = d_left (typed_name);
3608           }
3609
3610         if (typed_name == NULL)
3611           {
3612             d_print_error (dpi);
3613             return;
3614           }
3615
3616         /* If typed_name is a template, then it applies to the
3617            function type as well.  */
3618         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3619           {
3620             dpt.next = dpi->templates;
3621             dpi->templates = &dpt;
3622             dpt.template_decl = typed_name;
3623           }
3624
3625         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3626            there may be CV-qualifiers on its right argument which
3627            really apply here; this happens when parsing a class which
3628            is local to a function.  */
3629         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3630           {
3631             struct demangle_component *local_name;
3632
3633             local_name = d_right (typed_name);
3634             if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3635               local_name = local_name->u.s_unary_num.sub;
3636             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3637                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3638                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3639               {
3640                 if (i >= sizeof adpm / sizeof adpm[0])
3641                   {
3642                     d_print_error (dpi);
3643                     return;
3644                   }
3645
3646                 adpm[i] = adpm[i - 1];
3647                 adpm[i].next = &adpm[i - 1];
3648                 dpi->modifiers = &adpm[i];
3649
3650                 adpm[i - 1].mod = local_name;
3651                 adpm[i - 1].printed = 0;
3652                 adpm[i - 1].templates = dpi->templates;
3653                 ++i;
3654
3655                 local_name = d_left (local_name);
3656               }
3657           }
3658
3659         d_print_comp (dpi, d_right (dc));
3660
3661         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3662           dpi->templates = dpt.next;
3663
3664         /* If the modifiers didn't get printed by the type, print them
3665            now.  */
3666         while (i > 0)
3667           {
3668             --i;
3669             if (! adpm[i].printed)
3670               {
3671                 d_append_char (dpi, ' ');
3672                 d_print_mod (dpi, adpm[i].mod);
3673               }
3674           }
3675
3676         dpi->modifiers = hold_modifiers;
3677
3678         return;
3679       }
3680
3681     case DEMANGLE_COMPONENT_TEMPLATE:
3682       {
3683         struct d_print_mod *hold_dpm;
3684         struct demangle_component *dcl;
3685
3686         /* Don't push modifiers into a template definition.  Doing so
3687            could give the wrong definition for a template argument.
3688            Instead, treat the template essentially as a name.  */
3689
3690         hold_dpm = dpi->modifiers;
3691         dpi->modifiers = NULL;
3692
3693         dcl = d_left (dc);
3694
3695         if ((dpi->options & DMGL_JAVA) != 0
3696             && dcl->type == DEMANGLE_COMPONENT_NAME
3697             && dcl->u.s_name.len == 6
3698             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3699           {
3700             /* Special-case Java arrays, so that JArray<TYPE> appears
3701                instead as TYPE[].  */
3702
3703             d_print_comp (dpi, d_right (dc));
3704             d_append_string (dpi, "[]");
3705           }
3706         else
3707           {
3708             d_print_comp (dpi, dcl);
3709             if (d_last_char (dpi) == '<')
3710               d_append_char (dpi, ' ');
3711             d_append_char (dpi, '<');
3712             d_print_comp (dpi, d_right (dc));
3713             /* Avoid generating two consecutive '>' characters, to avoid
3714                the C++ syntactic ambiguity.  */
3715             if (d_last_char (dpi) == '>')
3716               d_append_char (dpi, ' ');
3717             d_append_char (dpi, '>');
3718           }
3719
3720         dpi->modifiers = hold_dpm;
3721
3722         return;
3723       }
3724
3725     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3726       {
3727         struct d_print_template *hold_dpt;
3728         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3729
3730         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3731           a = d_index_template_argument (a, dpi->pack_index);
3732
3733         if (a == NULL)
3734           {
3735             d_print_error (dpi);
3736             return;
3737           }
3738
3739         /* While processing this parameter, we need to pop the list of
3740            templates.  This is because the template parameter may
3741            itself be a reference to a parameter of an outer
3742            template.  */
3743
3744         hold_dpt = dpi->templates;
3745         dpi->templates = hold_dpt->next;
3746
3747         d_print_comp (dpi, a);
3748
3749         dpi->templates = hold_dpt;
3750
3751         return;
3752       }
3753
3754     case DEMANGLE_COMPONENT_CTOR:
3755       d_print_comp (dpi, dc->u.s_ctor.name);
3756       return;
3757
3758     case DEMANGLE_COMPONENT_DTOR:
3759       d_append_char (dpi, '~');
3760       d_print_comp (dpi, dc->u.s_dtor.name);
3761       return;
3762
3763     case DEMANGLE_COMPONENT_VTABLE:
3764       d_append_string (dpi, "vtable for ");
3765       d_print_comp (dpi, d_left (dc));
3766       return;
3767
3768     case DEMANGLE_COMPONENT_VTT:
3769       d_append_string (dpi, "VTT for ");
3770       d_print_comp (dpi, d_left (dc));
3771       return;
3772
3773     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3774       d_append_string (dpi, "construction vtable for ");
3775       d_print_comp (dpi, d_left (dc));
3776       d_append_string (dpi, "-in-");
3777       d_print_comp (dpi, d_right (dc));
3778       return;
3779
3780     case DEMANGLE_COMPONENT_TYPEINFO:
3781       d_append_string (dpi, "typeinfo for ");
3782       d_print_comp (dpi, d_left (dc));
3783       return;
3784
3785     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3786       d_append_string (dpi, "typeinfo name for ");
3787       d_print_comp (dpi, d_left (dc));
3788       return;
3789
3790     case DEMANGLE_COMPONENT_TYPEINFO_FN:
3791       d_append_string (dpi, "typeinfo fn for ");
3792       d_print_comp (dpi, d_left (dc));
3793       return;
3794
3795     case DEMANGLE_COMPONENT_THUNK:
3796       d_append_string (dpi, "non-virtual thunk to ");
3797       d_print_comp (dpi, d_left (dc));
3798       return;
3799
3800     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3801       d_append_string (dpi, "virtual thunk to ");
3802       d_print_comp (dpi, d_left (dc));
3803       return;
3804
3805     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3806       d_append_string (dpi, "covariant return thunk to ");
3807       d_print_comp (dpi, d_left (dc));
3808       return;
3809
3810     case DEMANGLE_COMPONENT_JAVA_CLASS:
3811       d_append_string (dpi, "java Class for ");
3812       d_print_comp (dpi, d_left (dc));
3813       return;
3814
3815     case DEMANGLE_COMPONENT_GUARD:
3816       d_append_string (dpi, "guard variable for ");
3817       d_print_comp (dpi, d_left (dc));
3818       return;
3819
3820     case DEMANGLE_COMPONENT_REFTEMP:
3821       d_append_string (dpi, "reference temporary for ");
3822       d_print_comp (dpi, d_left (dc));
3823       return;
3824
3825     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3826       d_append_string (dpi, "hidden alias for ");
3827       d_print_comp (dpi, d_left (dc));
3828       return;
3829
3830     case DEMANGLE_COMPONENT_SUB_STD:
3831       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3832       return;
3833
3834     case DEMANGLE_COMPONENT_RESTRICT:
3835     case DEMANGLE_COMPONENT_VOLATILE:
3836     case DEMANGLE_COMPONENT_CONST:
3837       {
3838         struct d_print_mod *pdpm;
3839
3840         /* When printing arrays, it's possible to have cases where the
3841            same CV-qualifier gets pushed on the stack multiple times.
3842            We only need to print it once.  */
3843
3844         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3845           {
3846             if (! pdpm->printed)
3847               {
3848                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3849                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3850                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3851                   break;
3852                 if (pdpm->mod->type == dc->type)
3853                   {
3854                     d_print_comp (dpi, d_left (dc));
3855                     return;
3856                   }
3857               }
3858           }
3859       }
3860       /* Fall through.  */
3861     case DEMANGLE_COMPONENT_RESTRICT_THIS:
3862     case DEMANGLE_COMPONENT_VOLATILE_THIS:
3863     case DEMANGLE_COMPONENT_CONST_THIS:
3864     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3865     case DEMANGLE_COMPONENT_POINTER:
3866     case DEMANGLE_COMPONENT_REFERENCE:
3867     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3868     case DEMANGLE_COMPONENT_COMPLEX:
3869     case DEMANGLE_COMPONENT_IMAGINARY:
3870       {
3871         /* We keep a list of modifiers on the stack.  */
3872         struct d_print_mod dpm;
3873
3874         dpm.next = dpi->modifiers;
3875         dpi->modifiers = &dpm;
3876         dpm.mod = dc;
3877         dpm.printed = 0;
3878         dpm.templates = dpi->templates;
3879
3880         d_print_comp (dpi, d_left (dc));
3881
3882         /* If the modifier didn't get printed by the type, print it
3883            now.  */
3884         if (! dpm.printed)
3885           d_print_mod (dpi, dc);
3886
3887         dpi->modifiers = dpm.next;
3888
3889         return;
3890       }
3891
3892     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3893       if ((dpi->options & DMGL_JAVA) == 0)
3894         d_append_buffer (dpi, dc->u.s_builtin.type->name,
3895                          dc->u.s_builtin.type->len);
3896       else
3897         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3898                          dc->u.s_builtin.type->java_len);
3899       return;
3900
3901     case DEMANGLE_COMPONENT_VENDOR_TYPE:
3902       d_print_comp (dpi, d_left (dc));
3903       return;
3904
3905     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3906       {
3907         if ((dpi->options & DMGL_RET_POSTFIX) != 0)
3908           d_print_function_type (dpi, dc, dpi->modifiers);
3909
3910         /* Print return type if present */
3911         if (d_left (dc) != NULL)
3912           {
3913             struct d_print_mod dpm;
3914
3915             /* We must pass this type down as a modifier in order to
3916                print it in the right location.  */
3917             dpm.next = dpi->modifiers;
3918             dpi->modifiers = &dpm;
3919             dpm.mod = dc;
3920             dpm.printed = 0;
3921             dpm.templates = dpi->templates;
3922
3923             d_print_comp (dpi, d_left (dc));
3924
3925             dpi->modifiers = dpm.next;
3926
3927             if (dpm.printed)
3928               return;
3929
3930             /* In standard prefix notation, there is a space between the
3931                return type and the function signature.  */
3932             if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3933               d_append_char (dpi, ' ');
3934           }
3935
3936         if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3937           d_print_function_type (dpi, dc, dpi->modifiers);
3938
3939         return;
3940       }
3941
3942     case DEMANGLE_COMPONENT_ARRAY_TYPE:
3943       {
3944         struct d_print_mod *hold_modifiers;
3945         struct d_print_mod adpm[4];
3946         unsigned int i;
3947         struct d_print_mod *pdpm;
3948
3949         /* We must pass this type down as a modifier in order to print
3950            multi-dimensional arrays correctly.  If the array itself is
3951            CV-qualified, we act as though the element type were
3952            CV-qualified.  We do this by copying the modifiers down
3953            rather than fiddling pointers, so that we don't wind up
3954            with a d_print_mod higher on the stack pointing into our
3955            stack frame after we return.  */
3956
3957         hold_modifiers = dpi->modifiers;
3958
3959         adpm[0].next = hold_modifiers;
3960         dpi->modifiers = &adpm[0];
3961         adpm[0].mod = dc;
3962         adpm[0].printed = 0;
3963         adpm[0].templates = dpi->templates;
3964
3965         i = 1;
3966         pdpm = hold_modifiers;
3967         while (pdpm != NULL
3968                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3969                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3970                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3971           {
3972             if (! pdpm->printed)
3973               {
3974                 if (i >= sizeof adpm / sizeof adpm[0])
3975                   {
3976                     d_print_error (dpi);
3977                     return;
3978                   }
3979
3980                 adpm[i] = *pdpm;
3981                 adpm[i].next = dpi->modifiers;
3982                 dpi->modifiers = &adpm[i];
3983                 pdpm->printed = 1;
3984                 ++i;
3985               }
3986
3987             pdpm = pdpm->next;
3988           }
3989
3990         d_print_comp (dpi, d_right (dc));
3991
3992         dpi->modifiers = hold_modifiers;
3993
3994         if (adpm[0].printed)
3995           return;
3996
3997         while (i > 1)
3998           {
3999             --i;
4000             d_print_mod (dpi, adpm[i].mod);
4001           }
4002
4003         d_print_array_type (dpi, dc, dpi->modifiers);
4004
4005         return;
4006       }
4007
4008     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4009     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4010       {
4011         struct d_print_mod dpm;
4012
4013         dpm.next = dpi->modifiers;
4014         dpi->modifiers = &dpm;
4015         dpm.mod = dc;
4016         dpm.printed = 0;
4017         dpm.templates = dpi->templates;
4018
4019         d_print_comp (dpi, d_right (dc));
4020
4021         /* If the modifier didn't get printed by the type, print it
4022            now.  */
4023         if (! dpm.printed)
4024           d_print_mod (dpi, dc);
4025
4026         dpi->modifiers = dpm.next;
4027
4028         return;
4029       }
4030
4031     case DEMANGLE_COMPONENT_FIXED_TYPE:
4032       if (dc->u.s_fixed.sat)
4033         d_append_string (dpi, "_Sat ");
4034       /* Don't print "int _Accum".  */
4035       if (dc->u.s_fixed.length->u.s_builtin.type
4036           != &cplus_demangle_builtin_types['i'-'a'])
4037         {
4038           d_print_comp (dpi, dc->u.s_fixed.length);
4039           d_append_char (dpi, ' ');
4040         }
4041       if (dc->u.s_fixed.accum)
4042         d_append_string (dpi, "_Accum");
4043       else
4044         d_append_string (dpi, "_Fract");
4045       return;
4046
4047     case DEMANGLE_COMPONENT_ARGLIST:
4048     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4049       if (d_left (dc) != NULL)
4050         d_print_comp (dpi, d_left (dc));
4051       if (d_right (dc) != NULL)
4052         {
4053           size_t len;
4054           unsigned long int flush_count;
4055           /* Make sure ", " isn't flushed by d_append_string, otherwise
4056              dpi->len -= 2 wouldn't work.  */
4057           if (dpi->len >= sizeof (dpi->buf) - 2)
4058             d_print_flush (dpi);
4059           d_append_string (dpi, ", ");
4060           len = dpi->len;
4061           flush_count = dpi->flush_count;
4062           d_print_comp (dpi, d_right (dc));
4063           /* If that didn't print anything (which can happen with empty
4064              template argument packs), remove the comma and space.  */
4065           if (dpi->flush_count == flush_count && dpi->len == len)
4066             dpi->len -= 2;
4067         }
4068       return;
4069
4070     case DEMANGLE_COMPONENT_OPERATOR:
4071       {
4072         char c;
4073
4074         d_append_string (dpi, "operator");
4075         c = dc->u.s_operator.op->name[0];
4076         if (IS_LOWER (c))
4077           d_append_char (dpi, ' ');
4078         d_append_buffer (dpi, dc->u.s_operator.op->name,
4079                          dc->u.s_operator.op->len);
4080         return;
4081       }
4082
4083     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4084       d_append_string (dpi, "operator ");
4085       d_print_comp (dpi, dc->u.s_extended_operator.name);
4086       return;
4087
4088     case DEMANGLE_COMPONENT_CAST:
4089       d_append_string (dpi, "operator ");
4090       d_print_cast (dpi, dc);
4091       return;
4092
4093     case DEMANGLE_COMPONENT_UNARY:
4094       if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
4095         d_print_expr_op (dpi, d_left (dc));
4096       else
4097         {
4098           d_append_char (dpi, '(');
4099           d_print_cast (dpi, d_left (dc));
4100           d_append_char (dpi, ')');
4101         }
4102       d_print_subexpr (dpi, d_right (dc));
4103       return;
4104
4105     case DEMANGLE_COMPONENT_BINARY:
4106       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
4107         {
4108           d_print_error (dpi);
4109           return;
4110         }
4111
4112       /* We wrap an expression which uses the greater-than operator in
4113          an extra layer of parens so that it does not get confused
4114          with the '>' which ends the template parameters.  */
4115       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4116           && d_left (dc)->u.s_operator.op->len == 1
4117           && d_left (dc)->u.s_operator.op->name[0] == '>')
4118         d_append_char (dpi, '(');
4119
4120       d_print_subexpr (dpi, d_left (d_right (dc)));
4121       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
4122         {
4123           d_append_char (dpi, '[');
4124           d_print_comp (dpi, d_right (d_right (dc)));
4125           d_append_char (dpi, ']');
4126         }
4127       else
4128         {
4129           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
4130             d_print_expr_op (dpi, d_left (dc));
4131           d_print_subexpr (dpi, d_right (d_right (dc)));
4132         }
4133
4134       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4135           && d_left (dc)->u.s_operator.op->len == 1
4136           && d_left (dc)->u.s_operator.op->name[0] == '>')
4137         d_append_char (dpi, ')');
4138
4139       return;
4140
4141     case DEMANGLE_COMPONENT_BINARY_ARGS:
4142       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
4143       d_print_error (dpi);
4144       return;
4145
4146     case DEMANGLE_COMPONENT_TRINARY:
4147       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
4148           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
4149         {
4150           d_print_error (dpi);
4151           return;
4152         }
4153       d_print_subexpr (dpi, d_left (d_right (dc)));
4154       d_print_expr_op (dpi, d_left (dc));
4155       d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
4156       d_append_string (dpi, " : ");
4157       d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
4158       return;
4159
4160     case DEMANGLE_COMPONENT_TRINARY_ARG1:
4161     case DEMANGLE_COMPONENT_TRINARY_ARG2:
4162       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
4163       d_print_error (dpi);
4164       return;
4165
4166     case DEMANGLE_COMPONENT_LITERAL:
4167     case DEMANGLE_COMPONENT_LITERAL_NEG:
4168       {
4169         enum d_builtin_type_print tp;
4170
4171         /* For some builtin types, produce simpler output.  */
4172         tp = D_PRINT_DEFAULT;
4173         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
4174           {
4175             tp = d_left (dc)->u.s_builtin.type->print;
4176             switch (tp)
4177               {
4178               case D_PRINT_INT:
4179               case D_PRINT_UNSIGNED:
4180               case D_PRINT_LONG:
4181               case D_PRINT_UNSIGNED_LONG:
4182               case D_PRINT_LONG_LONG:
4183               case D_PRINT_UNSIGNED_LONG_LONG:
4184                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
4185                   {
4186                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4187                       d_append_char (dpi, '-');
4188                     d_print_comp (dpi, d_right (dc));
4189                     switch (tp)
4190                       {
4191                       default:
4192                         break;
4193                       case D_PRINT_UNSIGNED:
4194                         d_append_char (dpi, 'u');
4195                         break;
4196                       case D_PRINT_LONG:
4197                         d_append_char (dpi, 'l');
4198                         break;
4199                       case D_PRINT_UNSIGNED_LONG:
4200                         d_append_string (dpi, "ul");
4201                         break;
4202                       case D_PRINT_LONG_LONG:
4203                         d_append_string (dpi, "ll");
4204                         break;
4205                       case D_PRINT_UNSIGNED_LONG_LONG:
4206                         d_append_string (dpi, "ull");
4207                         break;
4208                       }
4209                     return;
4210                   }
4211                 break;
4212
4213               case D_PRINT_BOOL:
4214                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
4215                     && d_right (dc)->u.s_name.len == 1
4216                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
4217                   {
4218                     switch (d_right (dc)->u.s_name.s[0])
4219                       {
4220                       case '0':
4221                         d_append_string (dpi, "false");
4222                         return;
4223                       case '1':
4224                         d_append_string (dpi, "true");
4225                         return;
4226                       default:
4227                         break;
4228                       }
4229                   }
4230                 break;
4231
4232               default:
4233                 break;
4234               }
4235           }
4236
4237         d_append_char (dpi, '(');
4238         d_print_comp (dpi, d_left (dc));
4239         d_append_char (dpi, ')');
4240         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4241           d_append_char (dpi, '-');
4242         if (tp == D_PRINT_FLOAT)
4243           d_append_char (dpi, '[');
4244         d_print_comp (dpi, d_right (dc));
4245         if (tp == D_PRINT_FLOAT)
4246           d_append_char (dpi, ']');
4247       }
4248       return;
4249
4250     case DEMANGLE_COMPONENT_NUMBER:
4251       d_append_num (dpi, dc->u.s_number.number);
4252       return;
4253
4254     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4255       d_append_string (dpi, "java resource ");
4256       d_print_comp (dpi, d_left (dc));
4257       return;
4258
4259     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4260       d_print_comp (dpi, d_left (dc));
4261       d_print_comp (dpi, d_right (dc));
4262       return;
4263
4264     case DEMANGLE_COMPONENT_CHARACTER:
4265       d_append_char (dpi, dc->u.s_character.character);
4266       return;
4267
4268     case DEMANGLE_COMPONENT_DECLTYPE:
4269       d_append_string (dpi, "decltype (");
4270       d_print_comp (dpi, d_left (dc));
4271       d_append_char (dpi, ')');
4272       return;
4273
4274     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4275       {
4276         int len;
4277         int i;
4278         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4279         if (a == NULL)
4280           {
4281             /* d_find_pack won't find anything if the only packs involved
4282                in this expansion are function parameter packs; in that
4283                case, just print the pattern and "...".  */
4284             d_print_subexpr (dpi, d_left (dc));
4285             d_append_string (dpi, "...");
4286             return;
4287           }
4288
4289         len = d_pack_length (a);
4290         dc = d_left (dc);
4291         for (i = 0; i < len; ++i)
4292           {
4293             dpi->pack_index = i;
4294             d_print_comp (dpi, dc);
4295             if (i < len-1)
4296               d_append_string (dpi, ", ");
4297           }
4298       }
4299       return;
4300
4301     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4302       d_append_string (dpi, "{parm#");
4303       d_append_num (dpi, dc->u.s_number.number + 1);
4304       d_append_char (dpi, '}');
4305       return;
4306
4307     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4308       d_append_string (dpi, "global constructors keyed to ");
4309       d_print_comp (dpi, dc->u.s_binary.left);
4310       return;
4311
4312     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4313       d_append_string (dpi, "global destructors keyed to ");
4314       d_print_comp (dpi, dc->u.s_binary.left);
4315       return;
4316
4317     case DEMANGLE_COMPONENT_LAMBDA:
4318       d_append_string (dpi, "{lambda(");
4319       d_print_comp (dpi, dc->u.s_unary_num.sub);
4320       d_append_string (dpi, ")#");
4321       d_append_num (dpi, dc->u.s_unary_num.num + 1);
4322       d_append_char (dpi, '}');
4323       return;
4324
4325     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4326       d_append_string (dpi, "{unnamed type#");
4327       d_append_num (dpi, dc->u.s_number.number + 1);
4328       d_append_char (dpi, '}');
4329       return;
4330
4331     default:
4332       d_print_error (dpi);
4333       return;
4334     }
4335 }
4336
4337 /* Print a Java dentifier.  For Java we try to handle encoded extended
4338    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
4339    so we don't it for C++.  Characters are encoded as
4340    __U<hex-char>+_.  */
4341
4342 static void
4343 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4344 {
4345   const char *p;
4346   const char *end;
4347
4348   end = name + len;
4349   for (p = name; p < end; ++p)
4350     {
4351       if (end - p > 3
4352           && p[0] == '_'
4353           && p[1] == '_'
4354           && p[2] == 'U')
4355         {
4356           unsigned long c;
4357           const char *q;
4358
4359           c = 0;
4360           for (q = p + 3; q < end; ++q)
4361             {
4362               int dig;
4363
4364               if (IS_DIGIT (*q))
4365                 dig = *q - '0';
4366               else if (*q >= 'A' && *q <= 'F')
4367                 dig = *q - 'A' + 10;
4368               else if (*q >= 'a' && *q <= 'f')
4369                 dig = *q - 'a' + 10;
4370               else
4371                 break;
4372
4373               c = c * 16 + dig;
4374             }
4375           /* If the Unicode character is larger than 256, we don't try
4376              to deal with it here.  FIXME.  */
4377           if (q < end && *q == '_' && c < 256)
4378             {
4379               d_append_char (dpi, c);
4380               p = q;
4381               continue;
4382             }
4383         }
4384
4385       d_append_char (dpi, *p);
4386     }
4387 }
4388
4389 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
4390    qualifiers on this after printing a function.  */
4391
4392 static void
4393 d_print_mod_list (struct d_print_info *dpi,
4394                   struct d_print_mod *mods, int suffix)
4395 {
4396   struct d_print_template *hold_dpt;
4397
4398   if (mods == NULL || d_print_saw_error (dpi))
4399     return;
4400
4401   if (mods->printed
4402       || (! suffix
4403           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4404               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4405               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4406     {
4407       d_print_mod_list (dpi, mods->next, suffix);
4408       return;
4409     }
4410
4411   mods->printed = 1;
4412
4413   hold_dpt = dpi->templates;
4414   dpi->templates = mods->templates;
4415
4416   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4417     {
4418       d_print_function_type (dpi, mods->mod, mods->next);
4419       dpi->templates = hold_dpt;
4420       return;
4421     }
4422   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4423     {
4424       d_print_array_type (dpi, mods->mod, mods->next);
4425       dpi->templates = hold_dpt;
4426       return;
4427     }
4428   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4429     {
4430       struct d_print_mod *hold_modifiers;
4431       struct demangle_component *dc;
4432
4433       /* When this is on the modifier stack, we have pulled any
4434          qualifiers off the right argument already.  Otherwise, we
4435          print it as usual, but don't let the left argument see any
4436          modifiers.  */
4437
4438       hold_modifiers = dpi->modifiers;
4439       dpi->modifiers = NULL;
4440       d_print_comp (dpi, d_left (mods->mod));
4441       dpi->modifiers = hold_modifiers;
4442
4443       if ((dpi->options & DMGL_JAVA) == 0)
4444         d_append_string (dpi, "::");
4445       else
4446         d_append_char (dpi, '.');
4447
4448       dc = d_right (mods->mod);
4449
4450       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4451         {
4452           d_append_string (dpi, "{default arg#");
4453           d_append_num (dpi, dc->u.s_unary_num.num + 1);
4454           d_append_string (dpi, "}::");
4455           dc = dc->u.s_unary_num.sub;
4456         }
4457
4458       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4459              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4460              || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4461         dc = d_left (dc);
4462
4463       d_print_comp (dpi, dc);
4464
4465       dpi->templates = hold_dpt;
4466       return;
4467     }
4468
4469   d_print_mod (dpi, mods->mod);
4470
4471   dpi->templates = hold_dpt;
4472
4473   d_print_mod_list (dpi, mods->next, suffix);
4474 }
4475
4476 /* Print a modifier.  */
4477
4478 static void
4479 d_print_mod (struct d_print_info *dpi,
4480              const struct demangle_component *mod)
4481 {
4482   switch (mod->type)
4483     {
4484     case DEMANGLE_COMPONENT_RESTRICT:
4485     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4486       d_append_string (dpi, " restrict");
4487       return;
4488     case DEMANGLE_COMPONENT_VOLATILE:
4489     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4490       d_append_string (dpi, " volatile");
4491       return;
4492     case DEMANGLE_COMPONENT_CONST:
4493     case DEMANGLE_COMPONENT_CONST_THIS:
4494       d_append_string (dpi, " const");
4495       return;
4496     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4497       d_append_char (dpi, ' ');
4498       d_print_comp (dpi, d_right (mod));
4499       return;
4500     case DEMANGLE_COMPONENT_POINTER:
4501       /* There is no pointer symbol in Java.  */
4502       if ((dpi->options & DMGL_JAVA) == 0)
4503         d_append_char (dpi, '*');
4504       return;
4505     case DEMANGLE_COMPONENT_REFERENCE:
4506       d_append_char (dpi, '&');
4507       return;
4508     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4509       d_append_string (dpi, "&&");
4510       return;
4511     case DEMANGLE_COMPONENT_COMPLEX:
4512       d_append_string (dpi, "complex ");
4513       return;
4514     case DEMANGLE_COMPONENT_IMAGINARY:
4515       d_append_string (dpi, "imaginary ");
4516       return;
4517     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4518       if (d_last_char (dpi) != '(')
4519         d_append_char (dpi, ' ');
4520       d_print_comp (dpi, d_left (mod));
4521       d_append_string (dpi, "::*");
4522       return;
4523     case DEMANGLE_COMPONENT_TYPED_NAME:
4524       d_print_comp (dpi, d_left (mod));
4525       return;
4526     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4527       d_append_string (dpi, " __vector(");
4528       d_print_comp (dpi, d_left (mod));
4529       d_append_char (dpi, ')');
4530       return;
4531
4532     default:
4533       /* Otherwise, we have something that won't go back on the
4534          modifier stack, so we can just print it.  */
4535       d_print_comp (dpi, mod);
4536       return;
4537     }
4538 }
4539
4540 /* Print a function type, except for the return type.  */
4541
4542 static void
4543 d_print_function_type (struct d_print_info *dpi,
4544                        const struct demangle_component *dc,
4545                        struct d_print_mod *mods)
4546 {
4547   int need_paren;
4548   int saw_mod;
4549   int need_space;
4550   struct d_print_mod *p;
4551   struct d_print_mod *hold_modifiers;
4552
4553   need_paren = 0;
4554   saw_mod = 0;
4555   need_space = 0;
4556   for (p = mods; p != NULL; p = p->next)
4557     {
4558       if (p->printed)
4559         break;
4560
4561       saw_mod = 1;
4562       switch (p->mod->type)
4563         {
4564         case DEMANGLE_COMPONENT_POINTER:
4565         case DEMANGLE_COMPONENT_REFERENCE:
4566         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4567           need_paren = 1;
4568           break;
4569         case DEMANGLE_COMPONENT_RESTRICT:
4570         case DEMANGLE_COMPONENT_VOLATILE:
4571         case DEMANGLE_COMPONENT_CONST:
4572         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4573         case DEMANGLE_COMPONENT_COMPLEX:
4574         case DEMANGLE_COMPONENT_IMAGINARY:
4575         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4576           need_space = 1;
4577           need_paren = 1;
4578           break;
4579         case DEMANGLE_COMPONENT_RESTRICT_THIS:
4580         case DEMANGLE_COMPONENT_VOLATILE_THIS:
4581         case DEMANGLE_COMPONENT_CONST_THIS:
4582           break;
4583         default:
4584           break;
4585         }
4586       if (need_paren)
4587         break;
4588     }
4589
4590   if (d_left (dc) != NULL && ! saw_mod)
4591     need_paren = 1;
4592
4593   if (need_paren)
4594     {
4595       if (! need_space)
4596         {
4597           if (d_last_char (dpi) != '('
4598               && d_last_char (dpi) != '*')
4599             need_space = 1;
4600         }
4601       if (need_space && d_last_char (dpi) != ' ')
4602         d_append_char (dpi, ' ');
4603       d_append_char (dpi, '(');
4604     }
4605
4606   hold_modifiers = dpi->modifiers;
4607   dpi->modifiers = NULL;
4608
4609   d_print_mod_list (dpi, mods, 0);
4610
4611   if (need_paren)
4612     d_append_char (dpi, ')');
4613
4614   d_append_char (dpi, '(');
4615
4616   if (d_right (dc) != NULL)
4617     d_print_comp (dpi, d_right (dc));
4618
4619   d_append_char (dpi, ')');
4620
4621   d_print_mod_list (dpi, mods, 1);
4622
4623   dpi->modifiers = hold_modifiers;
4624 }
4625
4626 /* Print an array type, except for the element type.  */
4627
4628 static void
4629 d_print_array_type (struct d_print_info *dpi,
4630                     const struct demangle_component *dc,
4631                     struct d_print_mod *mods)
4632 {
4633   int need_space;
4634
4635   need_space = 1;
4636   if (mods != NULL)
4637     {
4638       int need_paren;
4639       struct d_print_mod *p;
4640
4641       need_paren = 0;
4642       for (p = mods; p != NULL; p = p->next)
4643         {
4644           if (! p->printed)
4645             {
4646               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4647                 {
4648                   need_space = 0;
4649                   break;
4650                 }
4651               else
4652                 {
4653                   need_paren = 1;
4654                   need_space = 1;
4655                   break;
4656                 }
4657             }
4658         }
4659
4660       if (need_paren)
4661         d_append_string (dpi, " (");
4662
4663       d_print_mod_list (dpi, mods, 0);
4664
4665       if (need_paren)
4666         d_append_char (dpi, ')');
4667     }
4668
4669   if (need_space)
4670     d_append_char (dpi, ' ');
4671
4672   d_append_char (dpi, '[');
4673
4674   if (d_left (dc) != NULL)
4675     d_print_comp (dpi, d_left (dc));
4676
4677   d_append_char (dpi, ']');
4678 }
4679
4680 /* Print an operator in an expression.  */
4681
4682 static void
4683 d_print_expr_op (struct d_print_info *dpi,
4684                  const struct demangle_component *dc)
4685 {
4686   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
4687     d_append_buffer (dpi, dc->u.s_operator.op->name,
4688                      dc->u.s_operator.op->len);
4689   else
4690     d_print_comp (dpi, dc);
4691 }
4692
4693 /* Print a cast.  */
4694
4695 static void
4696 d_print_cast (struct d_print_info *dpi,
4697               const struct demangle_component *dc)
4698 {
4699   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
4700     d_print_comp (dpi, d_left (dc));
4701   else
4702     {
4703       struct d_print_mod *hold_dpm;
4704       struct d_print_template dpt;
4705
4706       /* It appears that for a templated cast operator, we need to put
4707          the template parameters in scope for the operator name, but
4708          not for the parameters.  The effect is that we need to handle
4709          the template printing here.  */
4710
4711       hold_dpm = dpi->modifiers;
4712       dpi->modifiers = NULL;
4713
4714       dpt.next = dpi->templates;
4715       dpi->templates = &dpt;
4716       dpt.template_decl = d_left (dc);
4717
4718       d_print_comp (dpi, d_left (d_left (dc)));
4719
4720       dpi->templates = dpt.next;
4721
4722       if (d_last_char (dpi) == '<')
4723         d_append_char (dpi, ' ');
4724       d_append_char (dpi, '<');
4725       d_print_comp (dpi, d_right (d_left (dc)));
4726       /* Avoid generating two consecutive '>' characters, to avoid
4727          the C++ syntactic ambiguity.  */
4728       if (d_last_char (dpi) == '>')
4729         d_append_char (dpi, ' ');
4730       d_append_char (dpi, '>');
4731
4732       dpi->modifiers = hold_dpm;
4733     }
4734 }
4735
4736 /* Initialize the information structure we use to pass around
4737    information.  */
4738
4739 CP_STATIC_IF_GLIBCPP_V3
4740 void
4741 cplus_demangle_init_info (const char *mangled, int options, size_t len,
4742                           struct d_info *di)
4743 {
4744   di->s = mangled;
4745   di->send = mangled + len;
4746   di->options = options;
4747
4748   di->n = mangled;
4749
4750   /* We can not need more components than twice the number of chars in
4751      the mangled string.  Most components correspond directly to
4752      chars, but the ARGLIST types are exceptions.  */
4753   di->num_comps = 2 * len;
4754   di->next_comp = 0;
4755
4756   /* Similarly, we can not need more substitutions than there are
4757      chars in the mangled string.  */
4758   di->num_subs = len;
4759   di->next_sub = 0;
4760   di->did_subs = 0;
4761
4762   di->last_name = NULL;
4763
4764   di->expansion = 0;
4765 }
4766
4767 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
4768    mangled name, return strings in repeated callback giving the demangled
4769    name.  OPTIONS is the usual libiberty demangler options.  On success,
4770    this returns 1.  On failure, returns 0.  */
4771
4772 static int
4773 d_demangle_callback (const char *mangled, int options,
4774                      demangle_callbackref callback, void *opaque)
4775 {
4776   enum
4777     {
4778       DCT_TYPE,
4779       DCT_MANGLED,
4780       DCT_GLOBAL_CTORS,
4781       DCT_GLOBAL_DTORS
4782     }
4783   type;
4784   struct d_info di;
4785   struct demangle_component *dc;
4786   int status;
4787
4788   if (mangled[0] == '_' && mangled[1] == 'Z')
4789     type = DCT_MANGLED;
4790   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4791            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
4792            && (mangled[9] == 'D' || mangled[9] == 'I')
4793            && mangled[10] == '_')
4794     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
4795   else
4796     {
4797       if ((options & DMGL_TYPES) == 0)
4798         return 0;
4799       type = DCT_TYPE;
4800     }
4801
4802   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4803
4804   {
4805 #ifdef CP_DYNAMIC_ARRAYS
4806     __extension__ struct demangle_component comps[di.num_comps];
4807     __extension__ struct demangle_component *subs[di.num_subs];
4808
4809     di.comps = comps;
4810     di.subs = subs;
4811 #else
4812     di.comps = alloca (di.num_comps * sizeof (*di.comps));
4813     di.subs = alloca (di.num_subs * sizeof (*di.subs));
4814 #endif
4815
4816     switch (type)
4817       {
4818       case DCT_TYPE:
4819         dc = cplus_demangle_type (&di);
4820         break;
4821       case DCT_MANGLED:
4822         dc = cplus_demangle_mangled_name (&di, 1);
4823         break;
4824       case DCT_GLOBAL_CTORS:
4825       case DCT_GLOBAL_DTORS:
4826         d_advance (&di, 11);
4827         dc = d_make_comp (&di,
4828                           (type == DCT_GLOBAL_CTORS
4829                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
4830                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
4831                           d_make_name (&di, d_str (&di), strlen (d_str (&di))),
4832                           NULL);
4833         d_advance (&di, strlen (d_str (&di)));
4834         break;
4835       }
4836
4837     /* If DMGL_PARAMS is set, then if we didn't consume the entire
4838        mangled string, then we didn't successfully demangle it.  If
4839        DMGL_PARAMS is not set, we didn't look at the trailing
4840        parameters.  */
4841     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
4842       dc = NULL;
4843
4844 #ifdef CP_DEMANGLE_DEBUG
4845     d_dump (dc, 0);
4846 #endif
4847
4848     status = (dc != NULL)
4849              ? cplus_demangle_print_callback (options, dc, callback, opaque)
4850              : 0;
4851   }
4852
4853   return status;
4854 }
4855
4856 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
4857    name, return a buffer allocated with malloc holding the demangled
4858    name.  OPTIONS is the usual libiberty demangler options.  On
4859    success, this sets *PALC to the allocated size of the returned
4860    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
4861    a memory allocation failure, and returns NULL.  */
4862
4863 static char *
4864 d_demangle (const char *mangled, int options, size_t *palc)
4865 {
4866   struct d_growable_string dgs;
4867   int status;
4868
4869   d_growable_string_init (&dgs, 0);
4870
4871   status = d_demangle_callback (mangled, options,
4872                                 d_growable_string_callback_adapter, &dgs);
4873   if (status == 0)
4874     {
4875       free (dgs.buf);
4876       *palc = 0;
4877       return NULL;
4878     }
4879
4880   *palc = dgs.allocation_failure ? 1 : dgs.alc;
4881   return dgs.buf;
4882 }
4883
4884 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
4885
4886 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
4887
4888 /* ia64 ABI-mandated entry point in the C++ runtime library for
4889    performing demangling.  MANGLED_NAME is a NUL-terminated character
4890    string containing the name to be demangled.
4891
4892    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4893    *LENGTH bytes, into which the demangled name is stored.  If
4894    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4895    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4896    is placed in a region of memory allocated with malloc.
4897
4898    If LENGTH is non-NULL, the length of the buffer containing the
4899    demangled name, is placed in *LENGTH.
4900
4901    The return value is a pointer to the start of the NUL-terminated
4902    demangled name, or NULL if the demangling fails.  The caller is
4903    responsible for deallocating this memory using free.
4904
4905    *STATUS is set to one of the following values:
4906       0: The demangling operation succeeded.
4907      -1: A memory allocation failure occurred.
4908      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4909      -3: One of the arguments is invalid.
4910
4911    The demangling is performed using the C++ ABI mangling rules, with
4912    GNU extensions.  */
4913
4914 char *
4915 __cxa_demangle (const char *mangled_name, char *output_buffer,
4916                 size_t *length, int *status)
4917 {
4918   char *demangled;
4919   size_t alc;
4920
4921   if (mangled_name == NULL)
4922     {
4923       if (status != NULL)
4924         *status = -3;
4925       return NULL;
4926     }
4927
4928   if (output_buffer != NULL && length == NULL)
4929     {
4930       if (status != NULL)
4931         *status = -3;
4932       return NULL;
4933     }
4934
4935   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
4936
4937   if (demangled == NULL)
4938     {
4939       if (status != NULL)
4940         {
4941           if (alc == 1)
4942             *status = -1;
4943           else
4944             *status = -2;
4945         }
4946       return NULL;
4947     }
4948
4949   if (output_buffer == NULL)
4950     {
4951       if (length != NULL)
4952         *length = alc;
4953     }
4954   else
4955     {
4956       if (strlen (demangled) < *length)
4957         {
4958           strcpy (output_buffer, demangled);
4959           free (demangled);
4960           demangled = output_buffer;
4961         }
4962       else
4963         {
4964           free (output_buffer);
4965           *length = alc;
4966         }
4967     }
4968
4969   if (status != NULL)
4970     *status = 0;
4971
4972   return demangled;
4973 }
4974
4975 extern int __gcclibcxx_demangle_callback (const char *,
4976                                           void (*)
4977                                             (const char *, size_t, void *),
4978                                           void *);
4979
4980 /* Alternative, allocationless entry point in the C++ runtime library
4981    for performing demangling.  MANGLED_NAME is a NUL-terminated character
4982    string containing the name to be demangled.
4983
4984    CALLBACK is a callback function, called with demangled string
4985    segments as demangling progresses; it is called at least once,
4986    but may be called more than once.  OPAQUE is a generalized pointer
4987    used as a callback argument.
4988
4989    The return code is one of the following values, equivalent to
4990    the STATUS values of __cxa_demangle() (excluding -1, since this
4991    function performs no memory allocations):
4992       0: The demangling operation succeeded.
4993      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4994      -3: One of the arguments is invalid.
4995
4996    The demangling is performed using the C++ ABI mangling rules, with
4997    GNU extensions.  */
4998
4999 int
5000 __gcclibcxx_demangle_callback (const char *mangled_name,
5001                                void (*callback) (const char *, size_t, void *),
5002                                void *opaque)
5003 {
5004   int status;
5005
5006   if (mangled_name == NULL || callback == NULL)
5007     return -3;
5008
5009   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
5010                                 callback, opaque);
5011   if (status == 0)
5012     return -2;
5013
5014   return 0;
5015 }
5016
5017 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5018
5019 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
5020    mangled name, return a buffer allocated with malloc holding the
5021    demangled name.  Otherwise, return NULL.  */
5022
5023 char *
5024 cplus_demangle_v3 (const char *mangled, int options)
5025 {
5026   size_t alc;
5027
5028   return d_demangle (mangled, options, &alc);
5029 }
5030
5031 int
5032 cplus_demangle_v3_callback (const char *mangled, int options,
5033                             demangle_callbackref callback, void *opaque)
5034 {
5035   return d_demangle_callback (mangled, options, callback, opaque);
5036 }
5037
5038 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
5039    conventions, but the output formatting is a little different.
5040    This instructs the C++ demangler not to emit pointer characters ("*"), to
5041    use Java's namespace separator symbol ("." instead of "::"), and to output
5042    JArray<TYPE> as TYPE[].  */
5043
5044 char *
5045 java_demangle_v3 (const char *mangled)
5046 {
5047   size_t alc;
5048
5049   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
5050 }
5051
5052 int
5053 java_demangle_v3_callback (const char *mangled,
5054                            demangle_callbackref callback, void *opaque)
5055 {
5056   return d_demangle_callback (mangled,
5057                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
5058                               callback, opaque);
5059 }
5060
5061 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5062
5063 #ifndef IN_GLIBCPP_V3
5064
5065 /* Demangle a string in order to find out whether it is a constructor
5066    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
5067    *DTOR_KIND appropriately.  */
5068
5069 static int
5070 is_ctor_or_dtor (const char *mangled,
5071                  enum gnu_v3_ctor_kinds *ctor_kind,
5072                  enum gnu_v3_dtor_kinds *dtor_kind)
5073 {
5074   struct d_info di;
5075   struct demangle_component *dc;
5076   int ret;
5077
5078   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
5079   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
5080
5081   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
5082
5083   {
5084 #ifdef CP_DYNAMIC_ARRAYS
5085     __extension__ struct demangle_component comps[di.num_comps];
5086     __extension__ struct demangle_component *subs[di.num_subs];
5087
5088     di.comps = comps;
5089     di.subs = subs;
5090 #else
5091     di.comps = alloca (di.num_comps * sizeof (*di.comps));
5092     di.subs = alloca (di.num_subs * sizeof (*di.subs));
5093 #endif
5094
5095     dc = cplus_demangle_mangled_name (&di, 1);
5096
5097     /* Note that because we did not pass DMGL_PARAMS, we don't expect
5098        to demangle the entire string.  */
5099
5100     ret = 0;
5101     while (dc != NULL)
5102       {
5103         switch (dc->type)
5104           {
5105           default:
5106             dc = NULL;
5107             break;
5108           case DEMANGLE_COMPONENT_TYPED_NAME:
5109           case DEMANGLE_COMPONENT_TEMPLATE:
5110           case DEMANGLE_COMPONENT_RESTRICT_THIS:
5111           case DEMANGLE_COMPONENT_VOLATILE_THIS:
5112           case DEMANGLE_COMPONENT_CONST_THIS:
5113             dc = d_left (dc);
5114             break;
5115           case DEMANGLE_COMPONENT_QUAL_NAME:
5116           case DEMANGLE_COMPONENT_LOCAL_NAME:
5117             dc = d_right (dc);
5118             break;
5119           case DEMANGLE_COMPONENT_CTOR:
5120             *ctor_kind = dc->u.s_ctor.kind;
5121             ret = 1;
5122             dc = NULL;
5123             break;
5124           case DEMANGLE_COMPONENT_DTOR:
5125             *dtor_kind = dc->u.s_dtor.kind;
5126             ret = 1;
5127             dc = NULL;
5128             break;
5129           }
5130       }
5131   }
5132
5133   return ret;
5134 }
5135
5136 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5137    name.  A non-zero return indicates the type of constructor.  */
5138
5139 enum gnu_v3_ctor_kinds
5140 is_gnu_v3_mangled_ctor (const char *name)
5141 {
5142   enum gnu_v3_ctor_kinds ctor_kind;
5143   enum gnu_v3_dtor_kinds dtor_kind;
5144
5145   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5146     return (enum gnu_v3_ctor_kinds) 0;
5147   return ctor_kind;
5148 }
5149
5150
5151 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5152    name.  A non-zero return indicates the type of destructor.  */
5153
5154 enum gnu_v3_dtor_kinds
5155 is_gnu_v3_mangled_dtor (const char *name)
5156 {
5157   enum gnu_v3_ctor_kinds ctor_kind;
5158   enum gnu_v3_dtor_kinds dtor_kind;
5159
5160   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5161     return (enum gnu_v3_dtor_kinds) 0;
5162   return dtor_kind;
5163 }
5164
5165 #endif /* IN_GLIBCPP_V3 */
5166
5167 #ifdef STANDALONE_DEMANGLER
5168
5169 #include "getopt.h"
5170 #include "dyn-string.h"
5171
5172 static void print_usage (FILE* fp, int exit_value);
5173
5174 #define IS_ALPHA(CHAR)                                                  \
5175   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
5176    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5177
5178 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
5179 #define is_mangled_char(CHAR)                                           \
5180   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
5181    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5182
5183 /* The name of this program, as invoked.  */
5184 const char* program_name;
5185
5186 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
5187
5188 static void
5189 print_usage (FILE* fp, int exit_value)
5190 {
5191   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
5192   fprintf (fp, "Options:\n");
5193   fprintf (fp, "  -h,--help       Display this message.\n");
5194   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
5195   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
5196   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
5197
5198   exit (exit_value);
5199 }
5200
5201 /* Option specification for getopt_long.  */
5202 static const struct option long_options[] =
5203 {
5204   { "help",      no_argument, NULL, 'h' },
5205   { "no-params", no_argument, NULL, 'p' },
5206   { "verbose",   no_argument, NULL, 'v' },
5207   { NULL,        no_argument, NULL, 0   },
5208 };
5209
5210 /* Main entry for a demangling filter executable.  It will demangle
5211    its command line arguments, if any.  If none are provided, it will
5212    filter stdin to stdout, replacing any recognized mangled C++ names
5213    with their demangled equivalents.  */
5214
5215 int
5216 main (int argc, char *argv[])
5217 {
5218   int i;
5219   int opt_char;
5220   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
5221
5222   /* Use the program name of this program, as invoked.  */
5223   program_name = argv[0];
5224
5225   /* Parse options.  */
5226   do
5227     {
5228       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
5229       switch (opt_char)
5230         {
5231         case '?':  /* Unrecognized option.  */
5232           print_usage (stderr, 1);
5233           break;
5234
5235         case 'h':
5236           print_usage (stdout, 0);
5237           break;
5238
5239         case 'p':
5240           options &= ~ DMGL_PARAMS;
5241           break;
5242
5243         case 'v':
5244           options |= DMGL_VERBOSE;
5245           break;
5246         }
5247     }
5248   while (opt_char != -1);
5249
5250   if (optind == argc)
5251     /* No command line arguments were provided.  Filter stdin.  */
5252     {
5253       dyn_string_t mangled = dyn_string_new (3);
5254       char *s;
5255
5256       /* Read all of input.  */
5257       while (!feof (stdin))
5258         {
5259           char c;
5260
5261           /* Pile characters into mangled until we hit one that can't
5262              occur in a mangled name.  */
5263           c = getchar ();
5264           while (!feof (stdin) && is_mangled_char (c))
5265             {
5266               dyn_string_append_char (mangled, c);
5267               if (feof (stdin))
5268                 break;
5269               c = getchar ();
5270             }
5271
5272           if (dyn_string_length (mangled) > 0)
5273             {
5274 #ifdef IN_GLIBCPP_V3
5275               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
5276 #else
5277               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5278 #endif
5279
5280               if (s != NULL)
5281                 {
5282                   fputs (s, stdout);
5283                   free (s);
5284                 }
5285               else
5286                 {
5287                   /* It might not have been a mangled name.  Print the
5288                      original text.  */
5289                   fputs (dyn_string_buf (mangled), stdout);
5290                 }
5291
5292               dyn_string_clear (mangled);
5293             }
5294
5295           /* If we haven't hit EOF yet, we've read one character that
5296              can't occur in a mangled name, so print it out.  */
5297           if (!feof (stdin))
5298             putchar (c);
5299         }
5300
5301       dyn_string_delete (mangled);
5302     }
5303   else
5304     /* Demangle command line arguments.  */
5305     {
5306       /* Loop over command line arguments.  */
5307       for (i = optind; i < argc; ++i)
5308         {
5309           char *s;
5310 #ifdef IN_GLIBCPP_V3
5311           int status;
5312 #endif
5313
5314           /* Attempt to demangle.  */
5315 #ifdef IN_GLIBCPP_V3
5316           s = __cxa_demangle (argv[i], NULL, NULL, &status);
5317 #else
5318           s = cplus_demangle_v3 (argv[i], options);
5319 #endif
5320
5321           /* If it worked, print the demangled name.  */
5322           if (s != NULL)
5323             {
5324               printf ("%s\n", s);
5325               free (s);
5326             }
5327           else
5328             {
5329 #ifdef IN_GLIBCPP_V3
5330               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5331 #else
5332               fprintf (stderr, "Failed: %s\n", argv[i]);
5333 #endif
5334             }
5335         }
5336     }
5337
5338   return 0;
5339 }
5340
5341 #endif /* STANDALONE_DEMANGLER */