libiberty/cp-demangle.c

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