libiberty/cp-demangle.c

   1 /* Demangler for g++ V3 ABI.
   2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor <ian@wasabisystems.com>.
   5
   6    This file is part of the libiberty library, which is part of GCC.
   7
   8    This file is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    In addition to the permissions in the GNU General Public License, the
  14    Free Software Foundation gives you unlimited permission to link the
  15    compiled version of this file into combinations with other programs,
  16    and to distribute those combinations without any restriction coming
  17    from the use of this file.  (The General Public License restrictions
  18    do apply in other respects; for example, they cover modification of
  19    the file, and distribution when not linked into a combined
  20    executable.)
  21
  22    This program is distributed in the hope that it will be useful,
  23    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25    GNU General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program; if not, write to the Free Software
  29    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  30 */
  31
  32 /* This code implements a demangler for the g++ V3 ABI.  The ABI is
  33    described on this web page:
  34        http://www.codesourcery.com/cxx-abi/abi.html#mangling
  35
  36    This code was written while looking at the demangler written by
  37    Alex Samuel <samuel@codesourcery.com>.
  38
  39    This code first pulls the mangled name apart into a list of
  40    components, and then walks the list generating the demangled
  41    name.
  42
  43    This file will normally define the following functions, q.v.:
  44       char *cplus_demangle_v3(const char *mangled, int options)
  45       char *java_demangle_v3(const char *mangled)
  46       int cplus_demangle_v3_callback(const char *mangled, int options,
  47                                      demangle_callbackref callback)
  48       int java_demangle_v3_callback(const char *mangled,
  49                                     demangle_callbackref callback)
  50       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
  51       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
  52
  53    Also, the interface to the component list is public, and defined in
  54    demangle.h.  The interface consists of these types, which are
  55    defined in demangle.h:
  56       enum demangle_component_type
  57       struct demangle_component
  58       demangle_callbackref
  59    and these functions defined in this file:
  60       cplus_demangle_fill_name
  61       cplus_demangle_fill_extended_operator
  62       cplus_demangle_fill_ctor
  63       cplus_demangle_fill_dtor
  64       cplus_demangle_print
  65       cplus_demangle_print_callback
  66    and other functions defined in the file cp-demint.c.
  67
  68    This file also defines some other functions and variables which are
  69    only to be used by the file cp-demint.c.
  70
  71    Preprocessor macros you can define while compiling this file:
  72
  73    IN_LIBGCC2
  74       If defined, this file defines the following functions, q.v.:
  75          char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
  76                                int *status)
  77          int __gcclibcxx_demangle_callback (const char *,
  78                                             void (*)
  79                                               (const char *, size_t, void *),
  80                                             void *)
  81       instead of cplus_demangle_v3[_callback]() and
  82       java_demangle_v3[_callback]().
  83
  84    IN_GLIBCPP_V3
  85       If defined, this file defines only __cxa_demangle() and
  86       __gcclibcxx_demangle_callback(), and no other publically visible
  87       functions or variables.
  88
  89    STANDALONE_DEMANGLER
  90       If defined, this file defines a main() function which demangles
  91       any arguments, or, if none, demangles stdin.
  92
  93    CP_DEMANGLE_DEBUG
  94       If defined, turns on debugging mode, which prints information on
  95       stdout about the mangled string.  This is not generally useful.
  96 */
  97
  98 #if defined (_AIX) && !defined (__GNUC__)
  99  #pragma alloca
 100 #endif
 101
 102 #ifdef HAVE_CONFIG_H
 103 #include "config.h"
 104 #endif
 105
 106 #include <stdio.h>
 107
 108 #ifdef HAVE_STDLIB_H
 109 #include <stdlib.h>
 110 #endif
 111 #ifdef HAVE_STRING_H
 112 #include <string.h>
 113 #endif
 114
 115 #ifdef HAVE_ALLOCA_H
 116 # include <alloca.h>
 117 #else
 118 # ifndef alloca
 119 #  ifdef __GNUC__
 120 #   define alloca __builtin_alloca
 121 #  else
 122 extern char *alloca ();
 123 #  endif /* __GNUC__ */
 124 # endif /* alloca */
 125 #endif /* HAVE_ALLOCA_H */
 126
 127 #include "ansidecl.h"
 128 #include "libiberty.h"
 129 #include "demangle.h"
 130 #include "cp-demangle.h"
 131
 132 /* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
 133    also rename them via #define to avoid compiler errors when the
 134    static definition conflicts with the extern declaration in a header
 135    file.  */
 136 #ifdef IN_GLIBCPP_V3
 137
 138 #define CP_STATIC_IF_GLIBCPP_V3 static
 139
 140 #define cplus_demangle_fill_name d_fill_name
 141 static int d_fill_name (struct demangle_component *, const char *, int);
 142
 143 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
 144 static int
 145 d_fill_extended_operator (struct demangle_component *, int,
 146                           struct demangle_component *);
 147
 148 #define cplus_demangle_fill_ctor d_fill_ctor
 149 static int
 150 d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
 151              struct demangle_component *);
 152
 153 #define cplus_demangle_fill_dtor d_fill_dtor
 154 static int
 155 d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
 156              struct demangle_component *);
 157
 158 #define cplus_demangle_mangled_name d_mangled_name
 159 static struct demangle_component *d_mangled_name (struct d_info *, int);
 160
 161 #define cplus_demangle_type d_type
 162 static struct demangle_component *d_type (struct d_info *);
 163
 164 #define cplus_demangle_print d_print
 165 static char *d_print (int, const struct demangle_component *, int, size_t *);
 166
 167 #define cplus_demangle_print_callback d_print_callback
 168 static int d_print_callback (int, const struct demangle_component *,
 169                              demangle_callbackref, void *);
 170
 171 #define cplus_demangle_init_info d_init_info
 172 static void d_init_info (const char *, int, size_t, struct d_info *);
 173
 174 #else /* ! defined(IN_GLIBCPP_V3) */
 175 #define CP_STATIC_IF_GLIBCPP_V3
 176 #endif /* ! defined(IN_GLIBCPP_V3) */
 177
 178 /* See if the compiler supports dynamic arrays.  */
 179
 180 #ifdef __GNUC__
 181 #define CP_DYNAMIC_ARRAYS
 182 #else
 183 #ifdef __STDC__
 184 #ifdef __STDC_VERSION__
 185 #if __STDC_VERSION__ >= 199901L
 186 #define CP_DYNAMIC_ARRAYS
 187 #endif /* __STDC__VERSION >= 199901L */
 188 #endif /* defined (__STDC_VERSION__) */
 189 #endif /* defined (__STDC__) */
 190 #endif /* ! defined (__GNUC__) */
 191
 192 /* We avoid pulling in the ctype tables, to prevent pulling in
 193    additional unresolved symbols when this code is used in a library.
 194    FIXME: Is this really a valid reason?  This comes from the original
 195    V3 demangler code.
 196
 197    As of this writing this file has the following undefined references
 198    when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
 199    strcat, strlen.  */
 200
 201 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
 202 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
 203 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
 204
 205 /* The prefix prepended by GCC to an identifier represnting the
 206    anonymous namespace.  */
 207 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
 208 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
 209   (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
 210
 211 /* Information we keep for the standard substitutions.  */
 212
 213 struct d_standard_sub_info
 214 {
 215   /* The code for this substitution.  */
 216   char code;
 217   /* The simple string it expands to.  */
 218   const char *simple_expansion;
 219   /* The length of the simple expansion.  */
 220   int simple_len;
 221   /* The results of a full, verbose, expansion.  This is used when
 222      qualifying a constructor/destructor, or when in verbose mode.  */
 223   const char *full_expansion;
 224   /* The length of the full expansion.  */
 225   int full_len;
 226   /* What to set the last_name field of d_info to; NULL if we should
 227      not set it.  This is only relevant when qualifying a
 228      constructor/destructor.  */
 229   const char *set_last_name;
 230   /* The length of set_last_name.  */
 231   int set_last_name_len;
 232 };
 233
 234 /* Accessors for subtrees of struct demangle_component.  */
 235
 236 #define d_left(dc) ((dc)->u.s_binary.left)
 237 #define d_right(dc) ((dc)->u.s_binary.right)
 238
 239 /* A list of templates.  This is used while printing.  */
 240
 241 struct d_print_template
 242 {
 243   /* Next template on the list.  */
 244   struct d_print_template *next;
 245   /* This template.  */
 246   const struct demangle_component *template_decl;
 247 };
 248
 249 /* A list of type modifiers.  This is used while printing.  */
 250
 251 struct d_print_mod
 252 {
 253   /* Next modifier on the list.  These are in the reverse of the order
 254      in which they appeared in the mangled string.  */
 255   struct d_print_mod *next;
 256   /* The modifier.  */
 257   const struct demangle_component *mod;
 258   /* Whether this modifier was printed.  */
 259   int printed;
 260   /* The list of templates which applies to this modifier.  */
 261   struct d_print_template *templates;
 262 };
 263
 264 /* We use these structures to hold information during printing.  */
 265
 266 struct d_growable_string
 267 {
 268   /* Buffer holding the result.  */
 269   char *buf;
 270   /* Current length of data in buffer.  */
 271   size_t len;
 272   /* Allocated size of buffer.  */
 273   size_t alc;
 274   /* Set to 1 if we had a memory allocation failure.  */
 275   int allocation_failure;
 276 };
 277
 278 enum { D_PRINT_BUFFER_LENGTH = 256 };
 279 struct d_print_info
 280 {
 281   /* 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       index = d_compact_number (di);
2742       if (index < 0)
2743         return NULL;
2744
2745       return d_make_function_param (di, index);
2746     }
2747   else if (IS_DIGIT (peek)
2748            || (peek == 'o' && d_peek_next_char (di) == 'n'))
2749     {
2750       /* We can get an unqualified name as an expression in the case of
2751          a dependent function call, i.e. decltype(f(t)).  */
2752       struct demangle_component *name;
2753
2754       if (peek == 'o')
2755         /* operator-function-id, i.e. operator+(t).  */
2756         d_advance (di, 2);
2757
2758       name = d_unqualified_name (di);
2759       if (name == NULL)
2760         return NULL;
2761       if (d_peek_char (di) == 'I')
2762         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2763                             d_template_args (di));
2764       else
2765         return name;
2766     }
2767   else
2768     {
2769       struct demangle_component *op;
2770       int args;
2771
2772       op = d_operator_name (di);
2773       if (op == NULL)
2774         return NULL;
2775
2776       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2777         di->expansion += op->u.s_operator.op->len - 2;
2778
2779       if (op->type == DEMANGLE_COMPONENT_OPERATOR
2780           && strcmp (op->u.s_operator.op->code, "st") == 0)
2781         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2782                             cplus_demangle_type (di));
2783
2784       switch (op->type)
2785         {
2786         default:
2787           return NULL;
2788         case DEMANGLE_COMPONENT_OPERATOR:
2789           args = op->u.s_operator.op->args;
2790           break;
2791         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2792           args = op->u.s_extended_operator.args;
2793           break;
2794         case DEMANGLE_COMPONENT_CAST:
2795           args = 1;
2796           break;
2797         }
2798
2799       switch (args)
2800         {
2801         case 1:
2802           {
2803             struct demangle_component *operand;
2804             if (op->type == DEMANGLE_COMPONENT_CAST
2805                 && d_check_char (di, '_'))
2806               operand = d_exprlist (di);
2807             else
2808               operand = d_expression (di);
2809             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2810                                 operand);
2811           }
2812         case 2:
2813           {
2814             struct demangle_component *left;
2815             struct demangle_component *right;
2816             const char *code = op->u.s_operator.op->code;
2817
2818             left = d_expression (di);
2819             if (!strcmp (code, "cl"))
2820               right = d_exprlist (di);
2821             else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
2822               {
2823                 right = d_unqualified_name (di);
2824                 if (d_peek_char (di) == 'I')
2825                   right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
2826                                        right, d_template_args (di));
2827               }
2828             else
2829               right = d_expression (di);
2830
2831             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2832                                 d_make_comp (di,
2833                                              DEMANGLE_COMPONENT_BINARY_ARGS,
2834                                              left, right));
2835           }
2836         case 3:
2837           {
2838             struct demangle_component *first;
2839             struct demangle_component *second;
2840
2841             first = d_expression (di);
2842             second = d_expression (di);
2843             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2844                                 d_make_comp (di,
2845                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
2846                                              first,
2847                                              d_make_comp (di,
2848                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
2849                                                           second,
2850                                                           d_expression (di))));
2851           }
2852         default:
2853           return NULL;
2854         }
2855     }
2856 }
2857
2858 /* <expr-primary> ::= L <type> <(value) number> E
2859                   ::= L <type> <(value) float> E
2860                   ::= L <mangled-name> E
2861 */
2862
2863 static struct demangle_component *
2864 d_expr_primary (struct d_info *di)
2865 {
2866   struct demangle_component *ret;
2867
2868   if (! d_check_char (di, 'L'))
2869     return NULL;
2870   if (d_peek_char (di) == '_'
2871       /* Workaround for G++ bug; see comment in write_template_arg.  */
2872       || d_peek_char (di) == 'Z')
2873     ret = cplus_demangle_mangled_name (di, 0);
2874   else
2875     {
2876       struct demangle_component *type;
2877       enum demangle_component_type t;
2878       const char *s;
2879
2880       type = cplus_demangle_type (di);
2881       if (type == NULL)
2882         return NULL;
2883
2884       /* If we have a type we know how to print, we aren't going to
2885          print the type name itself.  */
2886       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2887           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2888         di->expansion -= type->u.s_builtin.type->len;
2889
2890       /* Rather than try to interpret the literal value, we just
2891          collect it as a string.  Note that it's possible to have a
2892          floating point literal here.  The ABI specifies that the
2893          format of such literals is machine independent.  That's fine,
2894          but what's not fine is that versions of g++ up to 3.2 with
2895          -fabi-version=1 used upper case letters in the hex constant,
2896          and dumped out gcc's internal representation.  That makes it
2897          hard to tell where the constant ends, and hard to dump the
2898          constant in any readable form anyhow.  We don't attempt to
2899          handle these cases.  */
2900
2901       t = DEMANGLE_COMPONENT_LITERAL;
2902       if (d_peek_char (di) == 'n')
2903         {
2904           t = DEMANGLE_COMPONENT_LITERAL_NEG;
2905           d_advance (di, 1);
2906         }
2907       s = d_str (di);
2908       while (d_peek_char (di) != 'E')
2909         {
2910           if (d_peek_char (di) == '\0')
2911             return NULL;
2912           d_advance (di, 1);
2913         }
2914       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2915     }
2916   if (! d_check_char (di, 'E'))
2917     return NULL;
2918   return ret;
2919 }
2920
2921 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2922                 ::= Z <(function) encoding> E s [<discriminator>]
2923 */
2924
2925 static struct demangle_component *
2926 d_local_name (struct d_info *di)
2927 {
2928   struct demangle_component *function;
2929
2930   if (! d_check_char (di, 'Z'))
2931     return NULL;
2932
2933   function = d_encoding (di, 0);
2934
2935   if (! d_check_char (di, 'E'))
2936     return NULL;
2937
2938   if (d_peek_char (di) == 's')
2939     {
2940       d_advance (di, 1);
2941       if (! d_discriminator (di))
2942         return NULL;
2943       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2944                           d_make_name (di, "string literal",
2945                                        sizeof "string literal" - 1));
2946     }
2947   else
2948     {
2949       struct demangle_component *name;
2950       int num = -1;
2951
2952       if (d_peek_char (di) == 'd')
2953         {
2954           /* Default argument scope: d <number> _.  */
2955           d_advance (di, 1);
2956           num = d_compact_number (di);
2957           if (num < 0)
2958             return NULL;
2959         }
2960
2961       name = d_name (di);
2962       if (name)
2963         switch (name->type)
2964           {
2965             /* Lambdas and unnamed types have internal discriminators.  */
2966           case DEMANGLE_COMPONENT_LAMBDA:
2967           case DEMANGLE_COMPONENT_UNNAMED_TYPE:
2968             break;
2969           default:
2970             if (! d_discriminator (di))
2971               return NULL;
2972           }
2973       if (num >= 0)
2974         name = d_make_default_arg (di, num, name);
2975       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2976     }
2977 }
2978
2979 /* <discriminator> ::= _ <(non-negative) number>
2980
2981    We demangle the discriminator, but we don't print it out.  FIXME:
2982    We should print it out in verbose mode.  */
2983
2984 static int
2985 d_discriminator (struct d_info *di)
2986 {
2987   long discrim;
2988
2989   if (d_peek_char (di) != '_')
2990     return 1;
2991   d_advance (di, 1);
2992   discrim = d_number (di);
2993   if (discrim < 0)
2994     return 0;
2995   return 1;
2996 }
2997
2998 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
2999
3000 static struct demangle_component *
3001 d_lambda (struct d_info *di)
3002 {
3003   struct demangle_component *tl;
3004   struct demangle_component *ret;
3005   int num;
3006
3007   if (! d_check_char (di, 'U'))
3008     return NULL;
3009   if (! d_check_char (di, 'l'))
3010     return NULL;
3011
3012   tl = d_parmlist (di);
3013   if (tl == NULL)
3014     return NULL;
3015
3016   if (! d_check_char (di, 'E'))
3017     return NULL;
3018
3019   num = d_compact_number (di);
3020   if (num < 0)
3021     return NULL;
3022
3023   ret = d_make_empty (di);
3024   if (ret)
3025     {
3026       ret->type = DEMANGLE_COMPONENT_LAMBDA;
3027       ret->u.s_unary_num.sub = tl;
3028       ret->u.s_unary_num.num = num;
3029     }
3030
3031   if (! d_add_substitution (di, ret))
3032     return NULL;
3033
3034   return ret;
3035 }
3036
3037 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3038
3039 static struct demangle_component *
3040 d_unnamed_type (struct d_info *di)
3041 {
3042   struct demangle_component *ret;
3043   long num;
3044
3045   if (! d_check_char (di, 'U'))
3046     return NULL;
3047   if (! d_check_char (di, 't'))
3048     return NULL;
3049
3050   num = d_compact_number (di);
3051   if (num < 0)
3052     return NULL;
3053
3054   ret = d_make_empty (di);
3055   if (ret)
3056     {
3057       ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3058       ret->u.s_number.number = num;
3059     }
3060
3061   if (! d_add_substitution (di, ret))
3062     return NULL;
3063
3064   return ret;
3065 }
3066
3067 /* Add a new substitution.  */
3068
3069 static int
3070 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3071 {
3072   if (dc == NULL)
3073     return 0;
3074   if (di->next_sub >= di->num_subs)
3075     return 0;
3076   di->subs[di->next_sub] = dc;
3077   ++di->next_sub;
3078   return 1;
3079 }
3080
3081 /* <substitution> ::= S <seq-id> _
3082                   ::= S_
3083                   ::= St
3084                   ::= Sa
3085                   ::= Sb
3086                   ::= Ss
3087                   ::= Si
3088                   ::= So
3089                   ::= Sd
3090
3091    If PREFIX is non-zero, then this type is being used as a prefix in
3092    a qualified name.  In this case, for the standard substitutions, we
3093    need to check whether we are being used as a prefix for a
3094    constructor or destructor, and return a full template name.
3095    Otherwise we will get something like std::iostream::~iostream()
3096    which does not correspond particularly well to any function which
3097    actually appears in the source.
3098 */
3099
3100 static const struct d_standard_sub_info standard_subs[] =
3101 {
3102   { 't', NL ("std"),
3103     NL ("std"),
3104     NULL, 0 },
3105   { 'a', NL ("std::allocator"),
3106     NL ("std::allocator"),
3107     NL ("allocator") },
3108   { 'b', NL ("std::basic_string"),
3109     NL ("std::basic_string"),
3110     NL ("basic_string") },
3111   { 's', NL ("std::string"),
3112     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3113     NL ("basic_string") },
3114   { 'i', NL ("std::istream"),
3115     NL ("std::basic_istream<char, std::char_traits<char> >"),
3116     NL ("basic_istream") },
3117   { 'o', NL ("std::ostream"),
3118     NL ("std::basic_ostream<char, std::char_traits<char> >"),
3119     NL ("basic_ostream") },
3120   { 'd', NL ("std::iostream"),
3121     NL ("std::basic_iostream<char, std::char_traits<char> >"),
3122     NL ("basic_iostream") }
3123 };
3124
3125 static struct demangle_component *
3126 d_substitution (struct d_info *di, int prefix)
3127 {
3128   char c;
3129
3130   if (! d_check_char (di, 'S'))
3131     return NULL;
3132
3133   c = d_next_char (di);
3134   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3135     {
3136       unsigned int id;
3137
3138       id = 0;
3139       if (c != '_')
3140         {
3141           do
3142             {
3143               unsigned int new_id;
3144
3145               if (IS_DIGIT (c))
3146                 new_id = id * 36 + c - '0';
3147               else if (IS_UPPER (c))
3148                 new_id = id * 36 + c - 'A' + 10;
3149               else
3150                 return NULL;
3151               if (new_id < id)
3152                 return NULL;
3153               id = new_id;
3154               c = d_next_char (di);
3155             }
3156           while (c != '_');
3157
3158           ++id;
3159         }
3160
3161       if (id >= (unsigned int) di->next_sub)
3162         return NULL;
3163
3164       ++di->did_subs;
3165
3166       return di->subs[id];
3167     }
3168   else
3169     {
3170       int verbose;
3171       const struct d_standard_sub_info *p;
3172       const struct d_standard_sub_info *pend;
3173
3174       verbose = (di->options & DMGL_VERBOSE) != 0;
3175       if (! verbose && prefix)
3176         {
3177           char peek;
3178
3179           peek = d_peek_char (di);
3180           if (peek == 'C' || peek == 'D')
3181             verbose = 1;
3182         }
3183
3184       pend = (&standard_subs[0]
3185               + sizeof standard_subs / sizeof standard_subs[0]);
3186       for (p = &standard_subs[0]; p < pend; ++p)
3187         {
3188           if (c == p->code)
3189             {
3190               const char *s;
3191               int len;
3192
3193               if (p->set_last_name != NULL)
3194                 di->last_name = d_make_sub (di, p->set_last_name,
3195                                             p->set_last_name_len);
3196               if (verbose)
3197                 {
3198                   s = p->full_expansion;
3199                   len = p->full_len;
3200                 }
3201               else
3202                 {
3203                   s = p->simple_expansion;
3204                   len = p->simple_len;
3205                 }
3206               di->expansion += len;
3207               return d_make_sub (di, s, len);
3208             }
3209         }
3210
3211       return NULL;
3212     }
3213 }
3214
3215 /* Initialize a growable string.  */
3216
3217 static void
3218 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3219 {
3220   dgs->buf = NULL;
3221   dgs->len = 0;
3222   dgs->alc = 0;
3223   dgs->allocation_failure = 0;
3224
3225   if (estimate > 0)
3226     d_growable_string_resize (dgs, estimate);
3227 }
3228
3229 /* Grow a growable string to a given size.  */
3230
3231 static inline void
3232 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3233 {
3234   size_t newalc;
3235   char *newbuf;
3236
3237   if (dgs->allocation_failure)
3238     return;
3239
3240   /* Start allocation at two bytes to avoid any possibility of confusion
3241      with the special value of 1 used as a return in *palc to indicate
3242      allocation failures.  */
3243   newalc = dgs->alc > 0 ? dgs->alc : 2;
3244   while (newalc < need)
3245     newalc <<= 1;
3246
3247   newbuf = (char *) realloc (dgs->buf, newalc);
3248   if (newbuf == NULL)
3249     {
3250       free (dgs->buf);
3251       dgs->buf = NULL;
3252       dgs->len = 0;
3253       dgs->alc = 0;
3254       dgs->allocation_failure = 1;
3255       return;
3256     }
3257   dgs->buf = newbuf;
3258   dgs->alc = newalc;
3259 }
3260
3261 /* Append a buffer to a growable string.  */
3262
3263 static inline void
3264 d_growable_string_append_buffer (struct d_growable_string *dgs,
3265                                  const char *s, size_t l)
3266 {
3267   size_t need;
3268
3269   need = dgs->len + l + 1;
3270   if (need > dgs->alc)
3271     d_growable_string_resize (dgs, need);
3272
3273   if (dgs->allocation_failure)
3274     return;
3275
3276   memcpy (dgs->buf + dgs->len, s, l);
3277   dgs->buf[dgs->len + l] = '\0';
3278   dgs->len += l;
3279 }
3280
3281 /* Bridge growable strings to the callback mechanism.  */
3282
3283 static void
3284 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3285 {
3286   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3287
3288   d_growable_string_append_buffer (dgs, s, l);
3289 }
3290
3291 /* Initialize a print information structure.  */
3292
3293 static void
3294 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
3295               void *opaque)
3296 {
3297   dpi->len = 0;
3298   dpi->last_char = '\0';
3299   dpi->templates = NULL;
3300   dpi->modifiers = NULL;
3301   dpi->flush_count = 0;
3302
3303   dpi->callback = callback;
3304   dpi->opaque = opaque;
3305
3306   dpi->demangle_failure = 0;
3307 }
3308
3309 /* Indicate that an error occurred during printing, and test for error.  */
3310
3311 static inline void
3312 d_print_error (struct d_print_info *dpi)
3313 {
3314   dpi->demangle_failure = 1;
3315 }
3316
3317 static inline int
3318 d_print_saw_error (struct d_print_info *dpi)
3319 {
3320   return dpi->demangle_failure != 0;
3321 }
3322
3323 /* Flush buffered characters to the callback.  */
3324
3325 static inline void
3326 d_print_flush (struct d_print_info *dpi)
3327 {
3328   dpi->buf[dpi->len] = '\0';
3329   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3330   dpi->len = 0;
3331   dpi->flush_count++;
3332 }
3333
3334 /* Append characters and buffers for printing.  */
3335
3336 static inline void
3337 d_append_char (struct d_print_info *dpi, char c)
3338 {
3339   if (dpi->len == sizeof (dpi->buf) - 1)
3340     d_print_flush (dpi);
3341
3342   dpi->buf[dpi->len++] = c;
3343   dpi->last_char = c;
3344 }
3345
3346 static inline void
3347 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3348 {
3349   size_t i;
3350
3351   for (i = 0; i < l; i++)
3352     d_append_char (dpi, s[i]);
3353 }
3354
3355 static inline void
3356 d_append_string (struct d_print_info *dpi, const char *s)
3357 {
3358   d_append_buffer (dpi, s, strlen (s));
3359 }
3360
3361 static inline void
3362 d_append_num (struct d_print_info *dpi, long l)
3363 {
3364   char buf[25];
3365   sprintf (buf,"%ld", l);
3366   d_append_string (dpi, buf);
3367 }
3368
3369 static inline char
3370 d_last_char (struct d_print_info *dpi)
3371 {
3372   return dpi->last_char;
3373 }
3374
3375 /* Turn components into a human readable string.  OPTIONS is the
3376    options bits passed to the demangler.  DC is the tree to print.
3377    CALLBACK is a function to call to flush demangled string segments
3378    as they fill the intermediate buffer, and OPAQUE is a generalized
3379    callback argument.  On success, this returns 1.  On failure,
3380    it returns 0, indicating a bad parse.  It does not use heap
3381    memory to build an output string, so cannot encounter memory
3382    allocation failure.  */
3383
3384 CP_STATIC_IF_GLIBCPP_V3
3385 int
3386 cplus_demangle_print_callback (int options,
3387                                const struct demangle_component *dc,
3388                                demangle_callbackref callback, void *opaque)
3389 {
3390   struct d_print_info dpi;
3391
3392   d_print_init (&dpi, callback, opaque);
3393
3394   d_print_comp (&dpi, options, dc);
3395
3396   d_print_flush (&dpi);
3397
3398   return ! d_print_saw_error (&dpi);
3399 }
3400
3401 /* Turn components into a human readable string.  OPTIONS is the
3402    options bits passed to the demangler.  DC is the tree to print.
3403    ESTIMATE is a guess at the length of the result.  This returns a
3404    string allocated by malloc, or NULL on error.  On success, this
3405    sets *PALC to the size of the allocated buffer.  On failure, this
3406    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3407    failure.  */
3408
3409 CP_STATIC_IF_GLIBCPP_V3
3410 char *
3411 cplus_demangle_print (int options, const struct demangle_component *dc,
3412                       int estimate, size_t *palc)
3413 {
3414   struct d_growable_string dgs;
3415
3416   d_growable_string_init (&dgs, estimate);
3417
3418   if (! cplus_demangle_print_callback (options, dc,
3419                                        d_growable_string_callback_adapter,
3420                                        &dgs))
3421     {
3422       free (dgs.buf);
3423       *palc = 0;
3424       return NULL;
3425     }
3426
3427   *palc = dgs.allocation_failure ? 1 : dgs.alc;
3428   return dgs.buf;
3429 }
3430
3431 /* Returns the I'th element of the template arglist ARGS, or NULL on
3432    failure.  */
3433
3434 static struct demangle_component *
3435 d_index_template_argument (struct demangle_component *args, int i)
3436 {
3437   struct demangle_component *a;
3438
3439   for (a = args;
3440        a != NULL;
3441        a = d_right (a))
3442     {
3443       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3444         return NULL;
3445       if (i <= 0)
3446         break;
3447       --i;
3448     }
3449   if (i != 0 || a == NULL)
3450     return NULL;
3451
3452   return d_left (a);
3453 }
3454
3455 /* Returns the template argument from the current context indicated by DC,
3456    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
3457
3458 static struct demangle_component *
3459 d_lookup_template_argument (struct d_print_info *dpi,
3460                             const struct demangle_component *dc)
3461 {
3462   if (dpi->templates == NULL)
3463     {
3464       d_print_error (dpi);
3465       return NULL;
3466     }
3467
3468   return d_index_template_argument
3469     (d_right (dpi->templates->template_decl),
3470      dc->u.s_number.number);
3471 }
3472
3473 /* Returns a template argument pack used in DC (any will do), or NULL.  */
3474
3475 static struct demangle_component *
3476 d_find_pack (struct d_print_info *dpi,
3477              const struct demangle_component *dc)
3478 {
3479   struct demangle_component *a;
3480   if (dc == NULL)
3481     return NULL;
3482
3483   switch (dc->type)
3484     {
3485     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3486       a = d_lookup_template_argument (dpi, dc);
3487       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3488         return a;
3489       return NULL;
3490
3491     case DEMANGLE_COMPONENT_PACK_EXPANSION:
3492       return NULL;
3493
3494     case DEMANGLE_COMPONENT_LAMBDA:
3495     case DEMANGLE_COMPONENT_NAME:
3496     case DEMANGLE_COMPONENT_OPERATOR:
3497     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3498     case DEMANGLE_COMPONENT_SUB_STD:
3499     case DEMANGLE_COMPONENT_CHARACTER:
3500     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3501       return NULL;
3502
3503     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3504       return d_find_pack (dpi, dc->u.s_extended_operator.name);
3505     case DEMANGLE_COMPONENT_CTOR:
3506       return d_find_pack (dpi, dc->u.s_ctor.name);
3507     case DEMANGLE_COMPONENT_DTOR:
3508       return d_find_pack (dpi, dc->u.s_dtor.name);
3509
3510     default:
3511       a = d_find_pack (dpi, d_left (dc));
3512       if (a)
3513         return a;
3514       return d_find_pack (dpi, d_right (dc));
3515     }
3516 }
3517
3518 /* Returns the length of the template argument pack DC.  */
3519
3520 static int
3521 d_pack_length (const struct demangle_component *dc)
3522 {
3523   int count = 0;
3524   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3525          && d_left (dc) != NULL)
3526     {
3527       ++count;
3528       dc = d_right (dc);
3529     }
3530   return count;
3531 }
3532
3533 /* DC is a component of a mangled expression.  Print it, wrapped in parens
3534    if needed.  */
3535
3536 static void
3537 d_print_subexpr (struct d_print_info *dpi, int options,
3538                  const struct demangle_component *dc)
3539 {
3540   int simple = 0;
3541   if (dc->type == DEMANGLE_COMPONENT_NAME
3542       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3543     simple = 1;
3544   if (!simple)
3545     d_append_char (dpi, '(');
3546   d_print_comp (dpi, options, dc);
3547   if (!simple)
3548     d_append_char (dpi, ')');
3549 }
3550
3551 /* Subroutine to handle components.  */
3552
3553 static void
3554 d_print_comp (struct d_print_info *dpi, int options,
3555               const struct demangle_component *dc)
3556 {
3557   /* Magic variable to let reference smashing skip over the next modifier
3558      without needing to modify *dc.  */
3559   const struct demangle_component *mod_inner = NULL;
3560
3561   if (dc == NULL)
3562     {
3563       d_print_error (dpi);
3564       return;
3565     }
3566   if (d_print_saw_error (dpi))
3567     return;
3568
3569   switch (dc->type)
3570     {
3571     case DEMANGLE_COMPONENT_NAME:
3572       if ((options & DMGL_JAVA) == 0)
3573         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3574       else
3575         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3576       return;
3577
3578     case DEMANGLE_COMPONENT_QUAL_NAME:
3579     case DEMANGLE_COMPONENT_LOCAL_NAME:
3580       d_print_comp (dpi, options, d_left (dc));
3581       if ((options & DMGL_JAVA) == 0)
3582         d_append_string (dpi, "::");
3583       else
3584         d_append_char (dpi, '.');
3585       d_print_comp (dpi, options, d_right (dc));
3586       return;
3587
3588     case DEMANGLE_COMPONENT_TYPED_NAME:
3589       {
3590         struct d_print_mod *hold_modifiers;
3591         struct demangle_component *typed_name;
3592         struct d_print_mod adpm[4];
3593         unsigned int i;
3594         struct d_print_template dpt;
3595
3596         /* Pass the name down to the type so that it can be printed in
3597            the right place for the type.  We also have to pass down
3598            any CV-qualifiers, which apply to the this parameter.  */
3599         hold_modifiers = dpi->modifiers;
3600         dpi->modifiers = 0;
3601         i = 0;
3602         typed_name = d_left (dc);
3603         while (typed_name != NULL)
3604           {
3605             if (i >= sizeof adpm / sizeof adpm[0])
3606               {
3607                 d_print_error (dpi);
3608                 return;
3609               }
3610
3611             adpm[i].next = dpi->modifiers;
3612             dpi->modifiers = &adpm[i];
3613             adpm[i].mod = typed_name;
3614             adpm[i].printed = 0;
3615             adpm[i].templates = dpi->templates;
3616             ++i;
3617
3618             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3619                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3620                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3621               break;
3622
3623             typed_name = d_left (typed_name);
3624           }
3625
3626         if (typed_name == NULL)
3627           {
3628             d_print_error (dpi);
3629             return;
3630           }
3631
3632         /* If typed_name is a template, then it applies to the
3633            function type as well.  */
3634         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3635           {
3636             dpt.next = dpi->templates;
3637             dpi->templates = &dpt;
3638             dpt.template_decl = typed_name;
3639           }
3640
3641         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3642            there may be CV-qualifiers on its right argument which
3643            really apply here; this happens when parsing a class which
3644            is local to a function.  */
3645         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3646           {
3647             struct demangle_component *local_name;
3648
3649             local_name = d_right (typed_name);
3650             if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3651               local_name = local_name->u.s_unary_num.sub;
3652             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3653                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3654                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3655               {
3656                 if (i >= sizeof adpm / sizeof adpm[0])
3657                   {
3658                     d_print_error (dpi);
3659                     return;
3660                   }
3661
3662                 adpm[i] = adpm[i - 1];
3663                 adpm[i].next = &adpm[i - 1];
3664                 dpi->modifiers = &adpm[i];
3665
3666                 adpm[i - 1].mod = local_name;
3667                 adpm[i - 1].printed = 0;
3668                 adpm[i - 1].templates = dpi->templates;
3669                 ++i;
3670
3671                 local_name = d_left (local_name);
3672               }
3673           }
3674
3675         d_print_comp (dpi, options, d_right (dc));
3676
3677         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3678           dpi->templates = dpt.next;
3679
3680         /* If the modifiers didn't get printed by the type, print them
3681            now.  */
3682         while (i > 0)
3683           {
3684             --i;
3685             if (! adpm[i].printed)
3686               {
3687                 d_append_char (dpi, ' ');
3688                 d_print_mod (dpi, options, adpm[i].mod);
3689               }
3690           }
3691
3692         dpi->modifiers = hold_modifiers;
3693
3694         return;
3695       }
3696
3697     case DEMANGLE_COMPONENT_TEMPLATE:
3698       {
3699         struct d_print_mod *hold_dpm;
3700         struct demangle_component *dcl;
3701
3702         /* Don't push modifiers into a template definition.  Doing so
3703            could give the wrong definition for a template argument.
3704            Instead, treat the template essentially as a name.  */
3705
3706         hold_dpm = dpi->modifiers;
3707         dpi->modifiers = NULL;
3708
3709         dcl = d_left (dc);
3710
3711         if ((options & DMGL_JAVA) != 0
3712             && dcl->type == DEMANGLE_COMPONENT_NAME
3713             && dcl->u.s_name.len == 6
3714             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3715           {
3716             /* Special-case Java arrays, so that JArray<TYPE> appears
3717                instead as TYPE[].  */
3718
3719             d_print_comp (dpi, options, d_right (dc));
3720             d_append_string (dpi, "[]");
3721           }
3722         else
3723           {
3724             d_print_comp (dpi, options, dcl);
3725             if (d_last_char (dpi) == '<')
3726               d_append_char (dpi, ' ');
3727             d_append_char (dpi, '<');
3728             d_print_comp (dpi, options, d_right (dc));
3729             /* Avoid generating two consecutive '>' characters, to avoid
3730                the C++ syntactic ambiguity.  */
3731             if (d_last_char (dpi) == '>')
3732               d_append_char (dpi, ' ');
3733             d_append_char (dpi, '>');
3734           }
3735
3736         dpi->modifiers = hold_dpm;
3737
3738         return;
3739       }
3740
3741     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3742       {
3743         struct d_print_template *hold_dpt;
3744         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3745
3746         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3747           a = d_index_template_argument (a, dpi->pack_index);
3748
3749         if (a == NULL)
3750           {
3751             d_print_error (dpi);
3752             return;
3753           }
3754
3755         /* While processing this parameter, we need to pop the list of
3756            templates.  This is because the template parameter may
3757            itself be a reference to a parameter of an outer
3758            template.  */
3759
3760         hold_dpt = dpi->templates;
3761         dpi->templates = hold_dpt->next;
3762
3763         d_print_comp (dpi, options, a);
3764
3765         dpi->templates = hold_dpt;
3766
3767         return;
3768       }
3769
3770     case DEMANGLE_COMPONENT_CTOR:
3771       d_print_comp (dpi, options, dc->u.s_ctor.name);
3772       return;
3773
3774     case DEMANGLE_COMPONENT_DTOR:
3775       d_append_char (dpi, '~');
3776       d_print_comp (dpi, options, dc->u.s_dtor.name);
3777       return;
3778
3779     case DEMANGLE_COMPONENT_VTABLE:
3780       d_append_string (dpi, "vtable for ");
3781       d_print_comp (dpi, options, d_left (dc));
3782       return;
3783
3784     case DEMANGLE_COMPONENT_VTT:
3785       d_append_string (dpi, "VTT for ");
3786       d_print_comp (dpi, options, d_left (dc));
3787       return;
3788
3789     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3790       d_append_string (dpi, "construction vtable for ");
3791       d_print_comp (dpi, options, d_left (dc));
3792       d_append_string (dpi, "-in-");
3793       d_print_comp (dpi, options, d_right (dc));
3794       return;
3795
3796     case DEMANGLE_COMPONENT_TYPEINFO:
3797       d_append_string (dpi, "typeinfo for ");
3798       d_print_comp (dpi, options, d_left (dc));
3799       return;
3800
3801     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3802       d_append_string (dpi, "typeinfo name for ");
3803       d_print_comp (dpi, options, d_left (dc));
3804       return;
3805
3806     case DEMANGLE_COMPONENT_TYPEINFO_FN:
3807       d_append_string (dpi, "typeinfo fn for ");
3808       d_print_comp (dpi, options, d_left (dc));
3809       return;
3810
3811     case DEMANGLE_COMPONENT_THUNK:
3812       d_append_string (dpi, "non-virtual thunk to ");
3813       d_print_comp (dpi, options, d_left (dc));
3814       return;
3815
3816     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3817       d_append_string (dpi, "virtual thunk to ");
3818       d_print_comp (dpi, options, d_left (dc));
3819       return;
3820
3821     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3822       d_append_string (dpi, "covariant return thunk to ");
3823       d_print_comp (dpi, options, d_left (dc));
3824       return;
3825
3826     case DEMANGLE_COMPONENT_JAVA_CLASS:
3827       d_append_string (dpi, "java Class for ");
3828       d_print_comp (dpi, options, d_left (dc));
3829       return;
3830
3831     case DEMANGLE_COMPONENT_GUARD:
3832       d_append_string (dpi, "guard variable for ");
3833       d_print_comp (dpi, options, d_left (dc));
3834       return;
3835
3836     case DEMANGLE_COMPONENT_REFTEMP:
3837       d_append_string (dpi, "reference temporary for ");
3838       d_print_comp (dpi, options, d_left (dc));
3839       return;
3840
3841     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3842       d_append_string (dpi, "hidden alias for ");
3843       d_print_comp (dpi, options, d_left (dc));
3844       return;
3845
3846     case DEMANGLE_COMPONENT_SUB_STD:
3847       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3848       return;
3849
3850     case DEMANGLE_COMPONENT_RESTRICT:
3851     case DEMANGLE_COMPONENT_VOLATILE:
3852     case DEMANGLE_COMPONENT_CONST:
3853       {
3854         struct d_print_mod *pdpm;
3855
3856         /* When printing arrays, it's possible to have cases where the
3857            same CV-qualifier gets pushed on the stack multiple times.
3858            We only need to print it once.  */
3859
3860         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3861           {
3862             if (! pdpm->printed)
3863               {
3864                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3865                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3866                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3867                   break;
3868                 if (pdpm->mod->type == dc->type)
3869                   {
3870                     d_print_comp (dpi, options, d_left (dc));
3871                     return;
3872                   }
3873               }
3874           }
3875       }
3876       goto modifier;
3877
3878     case DEMANGLE_COMPONENT_REFERENCE:
3879     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3880       {
3881         /* Handle reference smashing: & + && = &.  */
3882         const struct demangle_component *sub = d_left (dc);
3883         if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
3884           {
3885             struct demangle_component *a = d_lookup_template_argument (dpi, sub);
3886             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3887               a = d_index_template_argument (a, dpi->pack_index);
3888             sub = a;
3889           }
3890
3891         if (sub->type == DEMANGLE_COMPONENT_REFERENCE
3892             || sub->type == dc->type)
3893           dc = sub;
3894         else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
3895           mod_inner = d_left (sub);
3896       }
3897       /* Fall through.  */
3898
3899     case DEMANGLE_COMPONENT_RESTRICT_THIS:
3900     case DEMANGLE_COMPONENT_VOLATILE_THIS:
3901     case DEMANGLE_COMPONENT_CONST_THIS:
3902     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3903     case DEMANGLE_COMPONENT_POINTER:
3904     case DEMANGLE_COMPONENT_COMPLEX:
3905     case DEMANGLE_COMPONENT_IMAGINARY:
3906     modifier:
3907       {
3908         /* We keep a list of modifiers on the stack.  */
3909         struct d_print_mod dpm;
3910
3911         dpm.next = dpi->modifiers;
3912         dpi->modifiers = &dpm;
3913         dpm.mod = dc;
3914         dpm.printed = 0;
3915         dpm.templates = dpi->templates;
3916
3917         if (!mod_inner)
3918           mod_inner = d_left (dc);
3919
3920         d_print_comp (dpi, options, mod_inner);
3921
3922         /* If the modifier didn't get printed by the type, print it
3923            now.  */
3924         if (! dpm.printed)
3925           d_print_mod (dpi, options, dc);
3926
3927         dpi->modifiers = dpm.next;
3928
3929         return;
3930       }
3931
3932     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3933       if ((options & DMGL_JAVA) == 0)
3934         d_append_buffer (dpi, dc->u.s_builtin.type->name,
3935                          dc->u.s_builtin.type->len);
3936       else
3937         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3938                          dc->u.s_builtin.type->java_len);
3939       return;
3940
3941     case DEMANGLE_COMPONENT_VENDOR_TYPE:
3942       d_print_comp (dpi, options, d_left (dc));
3943       return;
3944
3945     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3946       {
3947         if ((options & DMGL_RET_POSTFIX) != 0)
3948           d_print_function_type (dpi,
3949                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3950                                  dc, dpi->modifiers);
3951
3952         /* Print return type if present */
3953         if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
3954           d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3955                         d_left (dc));
3956         else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
3957           {
3958             struct d_print_mod dpm;
3959
3960             /* We must pass this type down as a modifier in order to
3961                print it in the right location.  */
3962             dpm.next = dpi->modifiers;
3963             dpi->modifiers = &dpm;
3964             dpm.mod = dc;
3965             dpm.printed = 0;
3966             dpm.templates = dpi->templates;
3967
3968             d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3969                           d_left (dc));
3970
3971             dpi->modifiers = dpm.next;
3972
3973             if (dpm.printed)
3974               return;
3975
3976             /* In standard prefix notation, there is a space between the
3977                return type and the function signature.  */
3978             if ((options & DMGL_RET_POSTFIX) == 0)
3979               d_append_char (dpi, ' ');
3980           }
3981
3982         if ((options & DMGL_RET_POSTFIX) == 0)
3983           d_print_function_type (dpi,
3984                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3985                                  dc, dpi->modifiers);
3986
3987         return;
3988       }
3989
3990     case DEMANGLE_COMPONENT_ARRAY_TYPE:
3991       {
3992         struct d_print_mod *hold_modifiers;
3993         struct d_print_mod adpm[4];
3994         unsigned int i;
3995         struct d_print_mod *pdpm;
3996
3997         /* We must pass this type down as a modifier in order to print
3998            multi-dimensional arrays correctly.  If the array itself is
3999            CV-qualified, we act as though the element type were
4000            CV-qualified.  We do this by copying the modifiers down
4001            rather than fiddling pointers, so that we don't wind up
4002            with a d_print_mod higher on the stack pointing into our
4003            stack frame after we return.  */
4004
4005         hold_modifiers = dpi->modifiers;
4006
4007         adpm[0].next = hold_modifiers;
4008         dpi->modifiers = &adpm[0];
4009         adpm[0].mod = dc;
4010         adpm[0].printed = 0;
4011         adpm[0].templates = dpi->templates;
4012
4013         i = 1;
4014         pdpm = hold_modifiers;
4015         while (pdpm != NULL
4016                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
4017                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
4018                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
4019           {
4020             if (! pdpm->printed)
4021               {
4022                 if (i >= sizeof adpm / sizeof adpm[0])
4023                   {
4024                     d_print_error (dpi);
4025                     return;
4026                   }
4027
4028                 adpm[i] = *pdpm;
4029                 adpm[i].next = dpi->modifiers;
4030                 dpi->modifiers = &adpm[i];
4031                 pdpm->printed = 1;
4032                 ++i;
4033               }
4034
4035             pdpm = pdpm->next;
4036           }
4037
4038         d_print_comp (dpi, options, d_right (dc));
4039
4040         dpi->modifiers = hold_modifiers;
4041
4042         if (adpm[0].printed)
4043           return;
4044
4045         while (i > 1)
4046           {
4047             --i;
4048             d_print_mod (dpi, options, adpm[i].mod);
4049           }
4050
4051         d_print_array_type (dpi, options, dc, dpi->modifiers);
4052
4053         return;
4054       }
4055
4056     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4057     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4058       {
4059         struct d_print_mod dpm;
4060
4061         dpm.next = dpi->modifiers;
4062         dpi->modifiers = &dpm;
4063         dpm.mod = dc;
4064         dpm.printed = 0;
4065         dpm.templates = dpi->templates;
4066
4067         d_print_comp (dpi, options, d_right (dc));
4068
4069         /* If the modifier didn't get printed by the type, print it
4070            now.  */
4071         if (! dpm.printed)
4072           d_print_mod (dpi, options, dc);
4073
4074         dpi->modifiers = dpm.next;
4075
4076         return;
4077       }
4078
4079     case DEMANGLE_COMPONENT_FIXED_TYPE:
4080       if (dc->u.s_fixed.sat)
4081         d_append_string (dpi, "_Sat ");
4082       /* Don't print "int _Accum".  */
4083       if (dc->u.s_fixed.length->u.s_builtin.type
4084           != &cplus_demangle_builtin_types['i'-'a'])
4085         {
4086           d_print_comp (dpi, options, dc->u.s_fixed.length);
4087           d_append_char (dpi, ' ');
4088         }
4089       if (dc->u.s_fixed.accum)
4090         d_append_string (dpi, "_Accum");
4091       else
4092         d_append_string (dpi, "_Fract");
4093       return;
4094
4095     case DEMANGLE_COMPONENT_ARGLIST:
4096     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4097       if (d_left (dc) != NULL)
4098         d_print_comp (dpi, options, d_left (dc));
4099       if (d_right (dc) != NULL)
4100         {
4101           size_t len;
4102           unsigned long int flush_count;
4103           /* Make sure ", " isn't flushed by d_append_string, otherwise
4104              dpi->len -= 2 wouldn't work.  */
4105           if (dpi->len >= sizeof (dpi->buf) - 2)
4106             d_print_flush (dpi);
4107           d_append_string (dpi, ", ");
4108           len = dpi->len;
4109           flush_count = dpi->flush_count;
4110           d_print_comp (dpi, options, d_right (dc));
4111           /* If that didn't print anything (which can happen with empty
4112              template argument packs), remove the comma and space.  */
4113           if (dpi->flush_count == flush_count && dpi->len == len)
4114             dpi->len -= 2;
4115         }
4116       return;
4117
4118     case DEMANGLE_COMPONENT_OPERATOR:
4119       {
4120         char c;
4121
4122         d_append_string (dpi, "operator");
4123         c = dc->u.s_operator.op->name[0];
4124         if (IS_LOWER (c))
4125           d_append_char (dpi, ' ');
4126         d_append_buffer (dpi, dc->u.s_operator.op->name,
4127                          dc->u.s_operator.op->len);
4128         return;
4129       }
4130
4131     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4132       d_append_string (dpi, "operator ");
4133       d_print_comp (dpi, options, dc->u.s_extended_operator.name);
4134       return;
4135
4136     case DEMANGLE_COMPONENT_CAST:
4137       d_append_string (dpi, "operator ");
4138       d_print_cast (dpi, options, dc);
4139       return;
4140
4141     case DEMANGLE_COMPONENT_UNARY:
4142       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4143           && d_left (dc)->u.s_operator.op->len == 1
4144           && d_left (dc)->u.s_operator.op->name[0] == '&'
4145           && d_right (dc)->type == DEMANGLE_COMPONENT_TYPED_NAME
4146           && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_QUAL_NAME
4147           && d_right (d_right (dc))->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4148         {
4149           /* Address of a function (therefore in an expression context) must
4150              have its argument list suppressed.
4151
4152              unary operator ... dc
4153                operator & ... d_left (dc)
4154                typed name ... d_right (dc)
4155                  qualified name ... d_left (d_right (dc))
4156                    <names>
4157                  function type ... d_right (d_right (dc))
4158                    argument list
4159                      <arguments>  */
4160
4161           d_print_expr_op (dpi, options, d_left (dc));
4162           d_print_comp (dpi, options, d_left (d_right (dc)));
4163           return;
4164         }
4165       else if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4166                && d_left (dc)->u.s_operator.op->len == 1
4167                && d_left (dc)->u.s_operator.op->name[0] == '&'
4168                && d_right (dc)->type == DEMANGLE_COMPONENT_QUAL_NAME)
4169         {
4170           /* Keep also already processed variant without the argument list.
4171
4172              unary operator ... dc
4173                operator & ... d_left (dc)
4174                qualified name ... d_right (dc)
4175                  <names>  */
4176
4177           d_print_expr_op (dpi, options, d_left (dc));
4178           d_print_comp (dpi, options, d_right (dc));
4179           return;
4180         }
4181       else if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
4182         d_print_expr_op (dpi, options, d_left (dc));
4183       else
4184         {
4185           d_append_char (dpi, '(');
4186           d_print_cast (dpi, options, d_left (dc));
4187           d_append_char (dpi, ')');
4188         }
4189       d_print_subexpr (dpi, options, d_right (dc));
4190       return;
4191
4192     case DEMANGLE_COMPONENT_BINARY:
4193       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
4194         {
4195           d_print_error (dpi);
4196           return;
4197         }
4198
4199       /* We wrap an expression which uses the greater-than operator in
4200          an extra layer of parens so that it does not get confused
4201          with the '>' which ends the template parameters.  */
4202       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4203           && d_left (dc)->u.s_operator.op->len == 1
4204           && d_left (dc)->u.s_operator.op->name[0] == '>')
4205         d_append_char (dpi, '(');
4206
4207       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
4208           && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
4209         {
4210           /* Function call used in an expression should not have printed types
4211              of the function arguments.  Values of the function arguments still
4212              get printed below.  */
4213
4214           const struct demangle_component *func = d_left (d_right (dc));
4215
4216           if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
4217             d_print_error (dpi);
4218           d_print_subexpr (dpi, options, d_left (func));
4219         }
4220       else
4221         d_print_subexpr (dpi, options, d_left (d_right (dc)));
4222       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
4223         {
4224           d_append_char (dpi, '[');
4225           d_print_comp (dpi, options, d_right (d_right (dc)));
4226           d_append_char (dpi, ']');
4227         }
4228       else
4229         {
4230           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
4231             d_print_expr_op (dpi, options, d_left (dc));
4232           d_print_subexpr (dpi, options, d_right (d_right (dc)));
4233         }
4234
4235       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4236           && d_left (dc)->u.s_operator.op->len == 1
4237           && d_left (dc)->u.s_operator.op->name[0] == '>')
4238         d_append_char (dpi, ')');
4239
4240       return;
4241
4242     case DEMANGLE_COMPONENT_BINARY_ARGS:
4243       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
4244       d_print_error (dpi);
4245       return;
4246
4247     case DEMANGLE_COMPONENT_TRINARY:
4248       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
4249           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
4250         {
4251           d_print_error (dpi);
4252           return;
4253         }
4254       d_print_subexpr (dpi, options, d_left (d_right (dc)));
4255       d_print_expr_op (dpi, options, d_left (dc));
4256       d_print_subexpr (dpi, options, d_left (d_right (d_right (dc))));
4257       d_append_string (dpi, " : ");
4258       d_print_subexpr (dpi, options, d_right (d_right (d_right (dc))));
4259       return;
4260
4261     case DEMANGLE_COMPONENT_TRINARY_ARG1:
4262     case DEMANGLE_COMPONENT_TRINARY_ARG2:
4263       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
4264       d_print_error (dpi);
4265       return;
4266
4267     case DEMANGLE_COMPONENT_LITERAL:
4268     case DEMANGLE_COMPONENT_LITERAL_NEG:
4269       {
4270         enum d_builtin_type_print tp;
4271
4272         /* For some builtin types, produce simpler output.  */
4273         tp = D_PRINT_DEFAULT;
4274         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
4275           {
4276             tp = d_left (dc)->u.s_builtin.type->print;
4277             switch (tp)
4278               {
4279               case D_PRINT_INT:
4280               case D_PRINT_UNSIGNED:
4281               case D_PRINT_LONG:
4282               case D_PRINT_UNSIGNED_LONG:
4283               case D_PRINT_LONG_LONG:
4284               case D_PRINT_UNSIGNED_LONG_LONG:
4285                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
4286                   {
4287                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4288                       d_append_char (dpi, '-');
4289                     d_print_comp (dpi, options, d_right (dc));
4290                     switch (tp)
4291                       {
4292                       default:
4293                         break;
4294                       case D_PRINT_UNSIGNED:
4295                         d_append_char (dpi, 'u');
4296                         break;
4297                       case D_PRINT_LONG:
4298                         d_append_char (dpi, 'l');
4299                         break;
4300                       case D_PRINT_UNSIGNED_LONG:
4301                         d_append_string (dpi, "ul");
4302                         break;
4303                       case D_PRINT_LONG_LONG:
4304                         d_append_string (dpi, "ll");
4305                         break;
4306                       case D_PRINT_UNSIGNED_LONG_LONG:
4307                         d_append_string (dpi, "ull");
4308                         break;
4309                       }
4310                     return;
4311                   }
4312                 break;
4313
4314               case D_PRINT_BOOL:
4315                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
4316                     && d_right (dc)->u.s_name.len == 1
4317                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
4318                   {
4319                     switch (d_right (dc)->u.s_name.s[0])
4320                       {
4321                       case '0':
4322                         d_append_string (dpi, "false");
4323                         return;
4324                       case '1':
4325                         d_append_string (dpi, "true");
4326                         return;
4327                       default:
4328                         break;
4329                       }
4330                   }
4331                 break;
4332
4333               default:
4334                 break;
4335               }
4336           }
4337
4338         d_append_char (dpi, '(');
4339         d_print_comp (dpi, options, d_left (dc));
4340         d_append_char (dpi, ')');
4341         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4342           d_append_char (dpi, '-');
4343         if (tp == D_PRINT_FLOAT)
4344           d_append_char (dpi, '[');
4345         d_print_comp (dpi, options, d_right (dc));
4346         if (tp == D_PRINT_FLOAT)
4347           d_append_char (dpi, ']');
4348       }
4349       return;
4350
4351     case DEMANGLE_COMPONENT_NUMBER:
4352       d_append_num (dpi, dc->u.s_number.number);
4353       return;
4354
4355     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4356       d_append_string (dpi, "java resource ");
4357       d_print_comp (dpi, options, d_left (dc));
4358       return;
4359
4360     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4361       d_print_comp (dpi, options, d_left (dc));
4362       d_print_comp (dpi, options, d_right (dc));
4363       return;
4364
4365     case DEMANGLE_COMPONENT_CHARACTER:
4366       d_append_char (dpi, dc->u.s_character.character);
4367       return;
4368
4369     case DEMANGLE_COMPONENT_DECLTYPE:
4370       d_append_string (dpi, "decltype (");
4371       d_print_comp (dpi, options, d_left (dc));
4372       d_append_char (dpi, ')');
4373       return;
4374
4375     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4376       {
4377         int len;
4378         int i;
4379         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4380         if (a == NULL)
4381           {
4382             /* d_find_pack won't find anything if the only packs involved
4383                in this expansion are function parameter packs; in that
4384                case, just print the pattern and "...".  */
4385             d_print_subexpr (dpi, options, d_left (dc));
4386             d_append_string (dpi, "...");
4387             return;
4388           }
4389
4390         len = d_pack_length (a);
4391         dc = d_left (dc);
4392         for (i = 0; i < len; ++i)
4393           {
4394             dpi->pack_index = i;
4395             d_print_comp (dpi, options, dc);
4396             if (i < len-1)
4397               d_append_string (dpi, ", ");
4398           }
4399       }
4400       return;
4401
4402     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4403       d_append_string (dpi, "{parm#");
4404       d_append_num (dpi, dc->u.s_number.number + 1);
4405       d_append_char (dpi, '}');
4406       return;
4407
4408     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4409       d_append_string (dpi, "global constructors keyed to ");
4410       d_print_comp (dpi, options, dc->u.s_binary.left);
4411       return;
4412
4413     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4414       d_append_string (dpi, "global destructors keyed to ");
4415       d_print_comp (dpi, options, dc->u.s_binary.left);
4416       return;
4417
4418     case DEMANGLE_COMPONENT_LAMBDA:
4419       d_append_string (dpi, "{lambda(");
4420       d_print_comp (dpi, options, dc->u.s_unary_num.sub);
4421       d_append_string (dpi, ")#");
4422       d_append_num (dpi, dc->u.s_unary_num.num + 1);
4423       d_append_char (dpi, '}');
4424       return;
4425
4426     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4427       d_append_string (dpi, "{unnamed type#");
4428       d_append_num (dpi, dc->u.s_number.number + 1);
4429       d_append_char (dpi, '}');
4430       return;
4431
4432     default:
4433       d_print_error (dpi);
4434       return;
4435     }
4436 }
4437
4438 /* Print a Java dentifier.  For Java we try to handle encoded extended
4439    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
4440    so we don't it for C++.  Characters are encoded as
4441    __U<hex-char>+_.  */
4442
4443 static void
4444 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4445 {
4446   const char *p;
4447   const char *end;
4448
4449   end = name + len;
4450   for (p = name; p < end; ++p)
4451     {
4452       if (end - p > 3
4453           && p[0] == '_'
4454           && p[1] == '_'
4455           && p[2] == 'U')
4456         {
4457           unsigned long c;
4458           const char *q;
4459
4460           c = 0;
4461           for (q = p + 3; q < end; ++q)
4462             {
4463               int dig;
4464
4465               if (IS_DIGIT (*q))
4466                 dig = *q - '0';
4467               else if (*q >= 'A' && *q <= 'F')
4468                 dig = *q - 'A' + 10;
4469               else if (*q >= 'a' && *q <= 'f')
4470                 dig = *q - 'a' + 10;
4471               else
4472                 break;
4473
4474               c = c * 16 + dig;
4475             }
4476           /* If the Unicode character is larger than 256, we don't try
4477              to deal with it here.  FIXME.  */
4478           if (q < end && *q == '_' && c < 256)
4479             {
4480               d_append_char (dpi, c);
4481               p = q;
4482               continue;
4483             }
4484         }
4485
4486       d_append_char (dpi, *p);
4487     }
4488 }
4489
4490 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
4491    qualifiers on this after printing a function.  */
4492
4493 static void
4494 d_print_mod_list (struct d_print_info *dpi, int options,
4495                   struct d_print_mod *mods, int suffix)
4496 {
4497   struct d_print_template *hold_dpt;
4498
4499   if (mods == NULL || d_print_saw_error (dpi))
4500     return;
4501
4502   if (mods->printed
4503       || (! suffix
4504           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4505               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4506               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4507     {
4508       d_print_mod_list (dpi, options, mods->next, suffix);
4509       return;
4510     }
4511
4512   mods->printed = 1;
4513
4514   hold_dpt = dpi->templates;
4515   dpi->templates = mods->templates;
4516
4517   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4518     {
4519       d_print_function_type (dpi, options, mods->mod, mods->next);
4520       dpi->templates = hold_dpt;
4521       return;
4522     }
4523   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4524     {
4525       d_print_array_type (dpi, options, mods->mod, mods->next);
4526       dpi->templates = hold_dpt;
4527       return;
4528     }
4529   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4530     {
4531       struct d_print_mod *hold_modifiers;
4532       struct demangle_component *dc;
4533
4534       /* When this is on the modifier stack, we have pulled any
4535          qualifiers off the right argument already.  Otherwise, we
4536          print it as usual, but don't let the left argument see any
4537          modifiers.  */
4538
4539       hold_modifiers = dpi->modifiers;
4540       dpi->modifiers = NULL;
4541       d_print_comp (dpi, options, d_left (mods->mod));
4542       dpi->modifiers = hold_modifiers;
4543
4544       if ((options & DMGL_JAVA) == 0)
4545         d_append_string (dpi, "::");
4546       else
4547         d_append_char (dpi, '.');
4548
4549       dc = d_right (mods->mod);
4550
4551       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4552         {
4553           d_append_string (dpi, "{default arg#");
4554           d_append_num (dpi, dc->u.s_unary_num.num + 1);
4555           d_append_string (dpi, "}::");
4556           dc = dc->u.s_unary_num.sub;
4557         }
4558
4559       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4560              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4561              || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4562         dc = d_left (dc);
4563
4564       d_print_comp (dpi, options, dc);
4565
4566       dpi->templates = hold_dpt;
4567       return;
4568     }
4569
4570   d_print_mod (dpi, options, mods->mod);
4571
4572   dpi->templates = hold_dpt;
4573
4574   d_print_mod_list (dpi, options, mods->next, suffix);
4575 }
4576
4577 /* Print a modifier.  */
4578
4579 static void
4580 d_print_mod (struct d_print_info *dpi, int options,
4581              const struct demangle_component *mod)
4582 {
4583   switch (mod->type)
4584     {
4585     case DEMANGLE_COMPONENT_RESTRICT:
4586     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4587       d_append_string (dpi, " restrict");
4588       return;
4589     case DEMANGLE_COMPONENT_VOLATILE:
4590     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4591       d_append_string (dpi, " volatile");
4592       return;
4593     case DEMANGLE_COMPONENT_CONST:
4594     case DEMANGLE_COMPONENT_CONST_THIS:
4595       d_append_string (dpi, " const");
4596       return;
4597     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4598       d_append_char (dpi, ' ');
4599       d_print_comp (dpi, options, d_right (mod));
4600       return;
4601     case DEMANGLE_COMPONENT_POINTER:
4602       /* There is no pointer symbol in Java.  */
4603       if ((options & DMGL_JAVA) == 0)
4604         d_append_char (dpi, '*');
4605       return;
4606     case DEMANGLE_COMPONENT_REFERENCE:
4607       d_append_char (dpi, '&');
4608       return;
4609     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4610       d_append_string (dpi, "&&");
4611       return;
4612     case DEMANGLE_COMPONENT_COMPLEX:
4613       d_append_string (dpi, "complex ");
4614       return;
4615     case DEMANGLE_COMPONENT_IMAGINARY:
4616       d_append_string (dpi, "imaginary ");
4617       return;
4618     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4619       if (d_last_char (dpi) != '(')
4620         d_append_char (dpi, ' ');
4621       d_print_comp (dpi, options, d_left (mod));
4622       d_append_string (dpi, "::*");
4623       return;
4624     case DEMANGLE_COMPONENT_TYPED_NAME:
4625       d_print_comp (dpi, options, d_left (mod));
4626       return;
4627     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4628       d_append_string (dpi, " __vector(");
4629       d_print_comp (dpi, options, d_left (mod));
4630       d_append_char (dpi, ')');
4631       return;
4632
4633     default:
4634       /* Otherwise, we have something that won't go back on the
4635          modifier stack, so we can just print it.  */
4636       d_print_comp (dpi, options, mod);
4637       return;
4638     }
4639 }
4640
4641 /* Print a function type, except for the return type.  */
4642
4643 static void
4644 d_print_function_type (struct d_print_info *dpi, int options,
4645                        const struct demangle_component *dc,
4646                        struct d_print_mod *mods)
4647 {
4648   int need_paren;
4649   int need_space;
4650   struct d_print_mod *p;
4651   struct d_print_mod *hold_modifiers;
4652
4653   need_paren = 0;
4654   need_space = 0;
4655   for (p = mods; p != NULL; p = p->next)
4656     {
4657       if (p->printed)
4658         break;
4659
4660       switch (p->mod->type)
4661         {
4662         case DEMANGLE_COMPONENT_POINTER:
4663         case DEMANGLE_COMPONENT_REFERENCE:
4664         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4665           need_paren = 1;
4666           break;
4667         case DEMANGLE_COMPONENT_RESTRICT:
4668         case DEMANGLE_COMPONENT_VOLATILE:
4669         case DEMANGLE_COMPONENT_CONST:
4670         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4671         case DEMANGLE_COMPONENT_COMPLEX:
4672         case DEMANGLE_COMPONENT_IMAGINARY:
4673         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4674           need_space = 1;
4675           need_paren = 1;
4676           break;
4677         case DEMANGLE_COMPONENT_RESTRICT_THIS:
4678         case DEMANGLE_COMPONENT_VOLATILE_THIS:
4679         case DEMANGLE_COMPONENT_CONST_THIS:
4680           break;
4681         default:
4682           break;
4683         }
4684       if (need_paren)
4685         break;
4686     }
4687
4688   if (need_paren)
4689     {
4690       if (! need_space)
4691         {
4692           if (d_last_char (dpi) != '('
4693               && d_last_char (dpi) != '*')
4694             need_space = 1;
4695         }
4696       if (need_space && d_last_char (dpi) != ' ')
4697         d_append_char (dpi, ' ');
4698       d_append_char (dpi, '(');
4699     }
4700
4701   hold_modifiers = dpi->modifiers;
4702   dpi->modifiers = NULL;
4703
4704   d_print_mod_list (dpi, options, mods, 0);
4705
4706   if (need_paren)
4707     d_append_char (dpi, ')');
4708
4709   d_append_char (dpi, '(');
4710
4711   if (d_right (dc) != NULL)
4712     d_print_comp (dpi, options, d_right (dc));
4713
4714   d_append_char (dpi, ')');
4715
4716   d_print_mod_list (dpi, options, mods, 1);
4717
4718   dpi->modifiers = hold_modifiers;
4719 }
4720
4721 /* Print an array type, except for the element type.  */
4722
4723 static void
4724 d_print_array_type (struct d_print_info *dpi, int options,
4725                     const struct demangle_component *dc,
4726                     struct d_print_mod *mods)
4727 {
4728   int need_space;
4729
4730   need_space = 1;
4731   if (mods != NULL)
4732     {
4733       int need_paren;
4734       struct d_print_mod *p;
4735
4736       need_paren = 0;
4737       for (p = mods; p != NULL; p = p->next)
4738         {
4739           if (! p->printed)
4740             {
4741               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4742                 {
4743                   need_space = 0;
4744                   break;
4745                 }
4746               else
4747                 {
4748                   need_paren = 1;
4749                   need_space = 1;
4750                   break;
4751                 }
4752             }
4753         }
4754
4755       if (need_paren)
4756         d_append_string (dpi, " (");
4757
4758       d_print_mod_list (dpi, options, mods, 0);
4759
4760       if (need_paren)
4761         d_append_char (dpi, ')');
4762     }
4763
4764   if (need_space)
4765     d_append_char (dpi, ' ');
4766
4767   d_append_char (dpi, '[');
4768
4769   if (d_left (dc) != NULL)
4770     d_print_comp (dpi, options, d_left (dc));
4771
4772   d_append_char (dpi, ']');
4773 }
4774
4775 /* Print an operator in an expression.  */
4776
4777 static void
4778 d_print_expr_op (struct d_print_info *dpi, int options,
4779                  const struct demangle_component *dc)
4780 {
4781   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
4782     d_append_buffer (dpi, dc->u.s_operator.op->name,
4783                      dc->u.s_operator.op->len);
4784   else
4785     d_print_comp (dpi, options, dc);
4786 }
4787
4788 /* Print a cast.  */
4789
4790 static void
4791 d_print_cast (struct d_print_info *dpi, int options,
4792               const struct demangle_component *dc)
4793 {
4794   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
4795     d_print_comp (dpi, options, d_left (dc));
4796   else
4797     {
4798       struct d_print_mod *hold_dpm;
4799       struct d_print_template dpt;
4800
4801       /* It appears that for a templated cast operator, we need to put
4802          the template parameters in scope for the operator name, but
4803          not for the parameters.  The effect is that we need to handle
4804          the template printing here.  */
4805
4806       hold_dpm = dpi->modifiers;
4807       dpi->modifiers = NULL;
4808
4809       dpt.next = dpi->templates;
4810       dpi->templates = &dpt;
4811       dpt.template_decl = d_left (dc);
4812
4813       d_print_comp (dpi, options, d_left (d_left (dc)));
4814
4815       dpi->templates = dpt.next;
4816
4817       if (d_last_char (dpi) == '<')
4818         d_append_char (dpi, ' ');
4819       d_append_char (dpi, '<');
4820       d_print_comp (dpi, options, d_right (d_left (dc)));
4821       /* Avoid generating two consecutive '>' characters, to avoid
4822          the C++ syntactic ambiguity.  */
4823       if (d_last_char (dpi) == '>')
4824         d_append_char (dpi, ' ');
4825       d_append_char (dpi, '>');
4826
4827       dpi->modifiers = hold_dpm;
4828     }
4829 }
4830
4831 /* Initialize the information structure we use to pass around
4832    information.  */
4833
4834 CP_STATIC_IF_GLIBCPP_V3
4835 void
4836 cplus_demangle_init_info (const char *mangled, int options, size_t len,
4837                           struct d_info *di)
4838 {
4839   di->s = mangled;
4840   di->send = mangled + len;
4841   di->options = options;
4842
4843   di->n = mangled;
4844
4845   /* We can not need more components than twice the number of chars in
4846      the mangled string.  Most components correspond directly to
4847      chars, but the ARGLIST types are exceptions.  */
4848   di->num_comps = 2 * len;
4849   di->next_comp = 0;
4850
4851   /* Similarly, we can not need more substitutions than there are
4852      chars in the mangled string.  */
4853   di->num_subs = len;
4854   di->next_sub = 0;
4855   di->did_subs = 0;
4856
4857   di->last_name = NULL;
4858
4859   di->expansion = 0;
4860 }
4861
4862 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
4863    mangled name, return strings in repeated callback giving the demangled
4864    name.  OPTIONS is the usual libiberty demangler options.  On success,
4865    this returns 1.  On failure, returns 0.  */
4866
4867 static int
4868 d_demangle_callback (const char *mangled, int options,
4869                      demangle_callbackref callback, void *opaque)
4870 {
4871   enum
4872     {
4873       DCT_TYPE,
4874       DCT_MANGLED,
4875       DCT_GLOBAL_CTORS,
4876       DCT_GLOBAL_DTORS
4877     }
4878   type;
4879   struct d_info di;
4880   struct demangle_component *dc;
4881   int status;
4882
4883   if (mangled[0] == '_' && mangled[1] == 'Z')
4884     type = DCT_MANGLED;
4885   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4886            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
4887            && (mangled[9] == 'D' || mangled[9] == 'I')
4888            && mangled[10] == '_')
4889     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
4890   else
4891     {
4892       if ((options & DMGL_TYPES) == 0)
4893         return 0;
4894       type = DCT_TYPE;
4895     }
4896
4897   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4898
4899   {
4900 #ifdef CP_DYNAMIC_ARRAYS
4901     __extension__ struct demangle_component comps[di.num_comps];
4902     __extension__ struct demangle_component *subs[di.num_subs];
4903
4904     di.comps = comps;
4905     di.subs = subs;
4906 #else
4907     di.comps = alloca (di.num_comps * sizeof (*di.comps));
4908     di.subs = alloca (di.num_subs * sizeof (*di.subs));
4909 #endif
4910
4911     switch (type)
4912       {
4913       case DCT_TYPE:
4914         dc = cplus_demangle_type (&di);
4915         break;
4916       case DCT_MANGLED:
4917         dc = cplus_demangle_mangled_name (&di, 1);
4918         break;
4919       case DCT_GLOBAL_CTORS:
4920       case DCT_GLOBAL_DTORS:
4921         d_advance (&di, 11);
4922         dc = d_make_comp (&di,
4923                           (type == DCT_GLOBAL_CTORS
4924                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
4925                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
4926                           d_make_demangle_mangled_name (&di, d_str (&di)),
4927                           NULL);
4928         d_advance (&di, strlen (d_str (&di)));
4929         break;
4930       }
4931
4932     /* If DMGL_PARAMS is set, then if we didn't consume the entire
4933        mangled string, then we didn't successfully demangle it.  If
4934        DMGL_PARAMS is not set, we didn't look at the trailing
4935        parameters.  */
4936     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
4937       dc = NULL;
4938
4939 #ifdef CP_DEMANGLE_DEBUG
4940     d_dump (dc, 0);
4941 #endif
4942
4943     status = (dc != NULL)
4944              ? cplus_demangle_print_callback (options, dc, callback, opaque)
4945              : 0;
4946   }
4947
4948   return status;
4949 }
4950
4951 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
4952    name, return a buffer allocated with malloc holding the demangled
4953    name.  OPTIONS is the usual libiberty demangler options.  On
4954    success, this sets *PALC to the allocated size of the returned
4955    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
4956    a memory allocation failure, and returns NULL.  */
4957
4958 static char *
4959 d_demangle (const char *mangled, int options, size_t *palc)
4960 {
4961   struct d_growable_string dgs;
4962   int status;
4963
4964   d_growable_string_init (&dgs, 0);
4965
4966   status = d_demangle_callback (mangled, options,
4967                                 d_growable_string_callback_adapter, &dgs);
4968   if (status == 0)
4969     {
4970       free (dgs.buf);
4971       *palc = 0;
4972       return NULL;
4973     }
4974
4975   *palc = dgs.allocation_failure ? 1 : dgs.alc;
4976   return dgs.buf;
4977 }
4978
4979 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
4980
4981 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
4982
4983 /* ia64 ABI-mandated entry point in the C++ runtime library for
4984    performing demangling.  MANGLED_NAME is a NUL-terminated character
4985    string containing the name to be demangled.
4986
4987    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4988    *LENGTH bytes, into which the demangled name is stored.  If
4989    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4990    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4991    is placed in a region of memory allocated with malloc.
4992
4993    If LENGTH is non-NULL, the length of the buffer containing the
4994    demangled name, is placed in *LENGTH.
4995
4996    The return value is a pointer to the start of the NUL-terminated
4997    demangled name, or NULL if the demangling fails.  The caller is
4998    responsible for deallocating this memory using free.
4999
5000    *STATUS is set to one of the following values:
5001       0: The demangling operation succeeded.
5002      -1: A memory allocation failure occurred.
5003      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5004      -3: One of the arguments is invalid.
5005
5006    The demangling is performed using the C++ ABI mangling rules, with
5007    GNU extensions.  */
5008
5009 char *
5010 __cxa_demangle (const char *mangled_name, char *output_buffer,
5011                 size_t *length, int *status)
5012 {
5013   char *demangled;
5014   size_t alc;
5015
5016   if (mangled_name == NULL)
5017     {
5018       if (status != NULL)
5019         *status = -3;
5020       return NULL;
5021     }
5022
5023   if (output_buffer != NULL && length == NULL)
5024     {
5025       if (status != NULL)
5026         *status = -3;
5027       return NULL;
5028     }
5029
5030   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
5031
5032   if (demangled == NULL)
5033     {
5034       if (status != NULL)
5035         {
5036           if (alc == 1)
5037             *status = -1;
5038           else
5039             *status = -2;
5040         }
5041       return NULL;
5042     }
5043
5044   if (output_buffer == NULL)
5045     {
5046       if (length != NULL)
5047         *length = alc;
5048     }
5049   else
5050     {
5051       if (strlen (demangled) < *length)
5052         {
5053           strcpy (output_buffer, demangled);
5054           free (demangled);
5055           demangled = output_buffer;
5056         }
5057       else
5058         {
5059           free (output_buffer);
5060           *length = alc;
5061         }
5062     }
5063
5064   if (status != NULL)
5065     *status = 0;
5066
5067   return demangled;
5068 }
5069
5070 extern int __gcclibcxx_demangle_callback (const char *,
5071                                           void (*)
5072                                             (const char *, size_t, void *),
5073                                           void *);
5074
5075 /* Alternative, allocationless entry point in the C++ runtime library
5076    for performing demangling.  MANGLED_NAME is a NUL-terminated character
5077    string containing the name to be demangled.
5078
5079    CALLBACK is a callback function, called with demangled string
5080    segments as demangling progresses; it is called at least once,
5081    but may be called more than once.  OPAQUE is a generalized pointer
5082    used as a callback argument.
5083
5084    The return code is one of the following values, equivalent to
5085    the STATUS values of __cxa_demangle() (excluding -1, since this
5086    function performs no memory allocations):
5087       0: The demangling operation succeeded.
5088      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5089      -3: One of the arguments is invalid.
5090
5091    The demangling is performed using the C++ ABI mangling rules, with
5092    GNU extensions.  */
5093
5094 int
5095 __gcclibcxx_demangle_callback (const char *mangled_name,
5096                                void (*callback) (const char *, size_t, void *),
5097                                void *opaque)
5098 {
5099   int status;
5100
5101   if (mangled_name == NULL || callback == NULL)
5102     return -3;
5103
5104   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
5105                                 callback, opaque);
5106   if (status == 0)
5107     return -2;
5108
5109   return 0;
5110 }
5111
5112 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5113
5114 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
5115    mangled name, return a buffer allocated with malloc holding the
5116    demangled name.  Otherwise, return NULL.  */
5117
5118 char *
5119 cplus_demangle_v3 (const char *mangled, int options)
5120 {
5121   size_t alc;
5122
5123   return d_demangle (mangled, options, &alc);
5124 }
5125
5126 int
5127 cplus_demangle_v3_callback (const char *mangled, int options,
5128                             demangle_callbackref callback, void *opaque)
5129 {
5130   return d_demangle_callback (mangled, options, callback, opaque);
5131 }
5132
5133 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
5134    conventions, but the output formatting is a little different.
5135    This instructs the C++ demangler not to emit pointer characters ("*"), to
5136    use Java's namespace separator symbol ("." instead of "::"), and to output
5137    JArray<TYPE> as TYPE[].  */
5138
5139 char *
5140 java_demangle_v3 (const char *mangled)
5141 {
5142   size_t alc;
5143
5144   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
5145 }
5146
5147 int
5148 java_demangle_v3_callback (const char *mangled,
5149                            demangle_callbackref callback, void *opaque)
5150 {
5151   return d_demangle_callback (mangled,
5152                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
5153                               callback, opaque);
5154 }
5155
5156 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5157
5158 #ifndef IN_GLIBCPP_V3
5159
5160 /* Demangle a string in order to find out whether it is a constructor
5161    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
5162    *DTOR_KIND appropriately.  */
5163
5164 static int
5165 is_ctor_or_dtor (const char *mangled,
5166                  enum gnu_v3_ctor_kinds *ctor_kind,
5167                  enum gnu_v3_dtor_kinds *dtor_kind)
5168 {
5169   struct d_info di;
5170   struct demangle_component *dc;
5171   int ret;
5172
5173   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
5174   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
5175
5176   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
5177
5178   {
5179 #ifdef CP_DYNAMIC_ARRAYS
5180     __extension__ struct demangle_component comps[di.num_comps];
5181     __extension__ struct demangle_component *subs[di.num_subs];
5182
5183     di.comps = comps;
5184     di.subs = subs;
5185 #else
5186     di.comps = alloca (di.num_comps * sizeof (*di.comps));
5187     di.subs = alloca (di.num_subs * sizeof (*di.subs));
5188 #endif
5189
5190     dc = cplus_demangle_mangled_name (&di, 1);
5191
5192     /* Note that because we did not pass DMGL_PARAMS, we don't expect
5193        to demangle the entire string.  */
5194
5195     ret = 0;
5196     while (dc != NULL)
5197       {
5198         switch (dc->type)
5199           {
5200           default:
5201             dc = NULL;
5202             break;
5203           case DEMANGLE_COMPONENT_TYPED_NAME:
5204           case DEMANGLE_COMPONENT_TEMPLATE:
5205           case DEMANGLE_COMPONENT_RESTRICT_THIS:
5206           case DEMANGLE_COMPONENT_VOLATILE_THIS:
5207           case DEMANGLE_COMPONENT_CONST_THIS:
5208             dc = d_left (dc);
5209             break;
5210           case DEMANGLE_COMPONENT_QUAL_NAME:
5211           case DEMANGLE_COMPONENT_LOCAL_NAME:
5212             dc = d_right (dc);
5213             break;
5214           case DEMANGLE_COMPONENT_CTOR:
5215             *ctor_kind = dc->u.s_ctor.kind;
5216             ret = 1;
5217             dc = NULL;
5218             break;
5219           case DEMANGLE_COMPONENT_DTOR:
5220             *dtor_kind = dc->u.s_dtor.kind;
5221             ret = 1;
5222             dc = NULL;
5223             break;
5224           }
5225       }
5226   }
5227
5228   return ret;
5229 }
5230
5231 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5232    name.  A non-zero return indicates the type of constructor.  */
5233
5234 enum gnu_v3_ctor_kinds
5235 is_gnu_v3_mangled_ctor (const char *name)
5236 {
5237   enum gnu_v3_ctor_kinds ctor_kind;
5238   enum gnu_v3_dtor_kinds dtor_kind;
5239
5240   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5241     return (enum gnu_v3_ctor_kinds) 0;
5242   return ctor_kind;
5243 }
5244
5245
5246 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5247    name.  A non-zero return indicates the type of destructor.  */
5248
5249 enum gnu_v3_dtor_kinds
5250 is_gnu_v3_mangled_dtor (const char *name)
5251 {
5252   enum gnu_v3_ctor_kinds ctor_kind;
5253   enum gnu_v3_dtor_kinds dtor_kind;
5254
5255   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5256     return (enum gnu_v3_dtor_kinds) 0;
5257   return dtor_kind;
5258 }
5259
5260 #endif /* IN_GLIBCPP_V3 */
5261
5262 #ifdef STANDALONE_DEMANGLER
5263
5264 #include "getopt.h"
5265 #include "dyn-string.h"
5266
5267 static void print_usage (FILE* fp, int exit_value);
5268
5269 #define IS_ALPHA(CHAR)                                                  \
5270   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
5271    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5272
5273 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
5274 #define is_mangled_char(CHAR)                                           \
5275   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
5276    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5277
5278 /* The name of this program, as invoked.  */
5279 const char* program_name;
5280
5281 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
5282
5283 static void
5284 print_usage (FILE* fp, int exit_value)
5285 {
5286   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
5287   fprintf (fp, "Options:\n");
5288   fprintf (fp, "  -h,--help       Display this message.\n");
5289   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
5290   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
5291   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
5292
5293   exit (exit_value);
5294 }
5295
5296 /* Option specification for getopt_long.  */
5297 static const struct option long_options[] =
5298 {
5299   { "help",      no_argument, NULL, 'h' },
5300   { "no-params", no_argument, NULL, 'p' },
5301   { "verbose",   no_argument, NULL, 'v' },
5302   { NULL,        no_argument, NULL, 0   },
5303 };
5304
5305 /* Main entry for a demangling filter executable.  It will demangle
5306    its command line arguments, if any.  If none are provided, it will
5307    filter stdin to stdout, replacing any recognized mangled C++ names
5308    with their demangled equivalents.  */
5309
5310 int
5311 main (int argc, char *argv[])
5312 {
5313   int i;
5314   int opt_char;
5315   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
5316
5317   /* Use the program name of this program, as invoked.  */
5318   program_name = argv[0];
5319
5320   /* Parse options.  */
5321   do
5322     {
5323       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
5324       switch (opt_char)
5325         {
5326         case '?':  /* Unrecognized option.  */
5327           print_usage (stderr, 1);
5328           break;
5329
5330         case 'h':
5331           print_usage (stdout, 0);
5332           break;
5333
5334         case 'p':
5335           options &= ~ DMGL_PARAMS;
5336           break;
5337
5338         case 'v':
5339           options |= DMGL_VERBOSE;
5340           break;
5341         }
5342     }
5343   while (opt_char != -1);
5344
5345   if (optind == argc)
5346     /* No command line arguments were provided.  Filter stdin.  */
5347     {
5348       dyn_string_t mangled = dyn_string_new (3);
5349       char *s;
5350
5351       /* Read all of input.  */
5352       while (!feof (stdin))
5353         {
5354           char c;
5355
5356           /* Pile characters into mangled until we hit one that can't
5357              occur in a mangled name.  */
5358           c = getchar ();
5359           while (!feof (stdin) && is_mangled_char (c))
5360             {
5361               dyn_string_append_char (mangled, c);
5362               if (feof (stdin))
5363                 break;
5364               c = getchar ();
5365             }
5366
5367           if (dyn_string_length (mangled) > 0)
5368             {
5369 #ifdef IN_GLIBCPP_V3
5370               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
5371 #else
5372               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5373 #endif
5374
5375               if (s != NULL)
5376                 {
5377                   fputs (s, stdout);
5378                   free (s);
5379                 }
5380               else
5381                 {
5382                   /* It might not have been a mangled name.  Print the
5383                      original text.  */
5384                   fputs (dyn_string_buf (mangled), stdout);
5385                 }
5386
5387               dyn_string_clear (mangled);
5388             }
5389
5390           /* If we haven't hit EOF yet, we've read one character that
5391              can't occur in a mangled name, so print it out.  */
5392           if (!feof (stdin))
5393             putchar (c);
5394         }
5395
5396       dyn_string_delete (mangled);
5397     }
5398   else
5399     /* Demangle command line arguments.  */
5400     {
5401       /* Loop over command line arguments.  */
5402       for (i = optind; i < argc; ++i)
5403         {
5404           char *s;
5405 #ifdef IN_GLIBCPP_V3
5406           int status;
5407 #endif
5408
5409           /* Attempt to demangle.  */
5410 #ifdef IN_GLIBCPP_V3
5411           s = __cxa_demangle (argv[i], NULL, NULL, &status);
5412 #else
5413           s = cplus_demangle_v3 (argv[i], options);
5414 #endif
5415
5416           /* If it worked, print the demangled name.  */
5417           if (s != NULL)
5418             {
5419               printf ("%s\n", s);
5420               free (s);
5421             }
5422           else
5423             {
5424 #ifdef IN_GLIBCPP_V3
5425               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5426 #else
5427               fprintf (stderr, "Failed: %s\n", argv[i]);
5428 #endif
5429             }
5430         }
5431     }
5432
5433   return 0;
5434 }
5435
5436 #endif /* STANDALONE_DEMANGLER */