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