libiberty/cp-demangle.c

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