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