contrib/gdb-7/libiberty/cp-demangle.c

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