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       || (int) kind < gnu_v3_complete_object_ctor
 723       || (int) 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       || (int) kind < gnu_v3_deleting_dtor
 742       || (int) 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 == 's' && d_peek_next_char (di) == 'p')
2590     {
2591       d_advance (di, 2);
2592       return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2593                           d_expression (di), NULL);
2594     }
2595   else if (peek == 'f' && d_peek_next_char (di) == 'p')
2596     {
2597       /* Function parameter used in a late-specified return type.  */
2598       int index;
2599       d_advance (di, 2);
2600       if (d_peek_char (di) == '_')
2601         index = 1;
2602       else
2603         {
2604           index = d_number (di);
2605           if (index < 0)
2606             return NULL;
2607           index += 2;
2608         }
2609
2610       if (! d_check_char (di, '_'))
2611         return NULL;
2612
2613       return d_make_function_param (di, index);
2614     }
2615   else if (IS_DIGIT (peek))
2616     {
2617       /* We can get an unqualified name as an expression in the case of
2618          a dependent member access, i.e. decltype(T().i).  */
2619       struct demangle_component *name = d_unqualified_name (di);
2620       if (name == NULL)
2621         return NULL;
2622       if (d_peek_char (di) == 'I')
2623         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2624                             d_template_args (di));
2625       else
2626         return name;
2627     }
2628   else
2629     {
2630       struct demangle_component *op;
2631       int args;
2632
2633       op = d_operator_name (di);
2634       if (op == NULL)
2635         return NULL;
2636
2637       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2638         di->expansion += op->u.s_operator.op->len - 2;
2639
2640       if (op->type == DEMANGLE_COMPONENT_OPERATOR
2641           && strcmp (op->u.s_operator.op->code, "st") == 0)
2642         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2643                             cplus_demangle_type (di));
2644
2645       switch (op->type)
2646         {
2647         default:
2648           return NULL;
2649         case DEMANGLE_COMPONENT_OPERATOR:
2650           args = op->u.s_operator.op->args;
2651           break;
2652         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2653           args = op->u.s_extended_operator.args;
2654           break;
2655         case DEMANGLE_COMPONENT_CAST:
2656           args = 1;
2657           break;
2658         }
2659
2660       switch (args)
2661         {
2662         case 1:
2663           {
2664             struct demangle_component *operand;
2665             if (op->type == DEMANGLE_COMPONENT_CAST
2666                 && d_check_char (di, '_'))
2667               operand = d_exprlist (di);
2668             else
2669               operand = d_expression (di);
2670             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2671                                 operand);
2672           }
2673         case 2:
2674           {
2675             struct demangle_component *left;
2676             struct demangle_component *right;
2677
2678             left = d_expression (di);
2679             if (!strcmp (op->u.s_operator.op->code, "cl"))
2680               right = d_exprlist (di);
2681             else
2682               right = d_expression (di);
2683
2684             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2685                                 d_make_comp (di,
2686                                              DEMANGLE_COMPONENT_BINARY_ARGS,
2687                                              left, right));
2688           }
2689         case 3:
2690           {
2691             struct demangle_component *first;
2692             struct demangle_component *second;
2693
2694             first = d_expression (di);
2695             second = d_expression (di);
2696             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2697                                 d_make_comp (di,
2698                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
2699                                              first,
2700                                              d_make_comp (di,
2701                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
2702                                                           second,
2703                                                           d_expression (di))));
2704           }
2705         default:
2706           return NULL;
2707         }
2708     }
2709 }
2710
2711 /* <expr-primary> ::= L <type> <(value) number> E
2712                   ::= L <type> <(value) float> E
2713                   ::= L <mangled-name> E
2714 */
2715
2716 static struct demangle_component *
2717 d_expr_primary (struct d_info *di)
2718 {
2719   struct demangle_component *ret;
2720
2721   if (! d_check_char (di, 'L'))
2722     return NULL;
2723   if (d_peek_char (di) == '_'
2724       /* Workaround for G++ bug; see comment in write_template_arg.  */
2725       || d_peek_char (di) == 'Z')
2726     ret = cplus_demangle_mangled_name (di, 0);
2727   else
2728     {
2729       struct demangle_component *type;
2730       enum demangle_component_type t;
2731       const char *s;
2732
2733       type = cplus_demangle_type (di);
2734       if (type == NULL)
2735         return NULL;
2736
2737       /* If we have a type we know how to print, we aren't going to
2738          print the type name itself.  */
2739       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2740           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2741         di->expansion -= type->u.s_builtin.type->len;
2742
2743       /* Rather than try to interpret the literal value, we just
2744          collect it as a string.  Note that it's possible to have a
2745          floating point literal here.  The ABI specifies that the
2746          format of such literals is machine independent.  That's fine,
2747          but what's not fine is that versions of g++ up to 3.2 with
2748          -fabi-version=1 used upper case letters in the hex constant,
2749          and dumped out gcc's internal representation.  That makes it
2750          hard to tell where the constant ends, and hard to dump the
2751          constant in any readable form anyhow.  We don't attempt to
2752          handle these cases.  */
2753
2754       t = DEMANGLE_COMPONENT_LITERAL;
2755       if (d_peek_char (di) == 'n')
2756         {
2757           t = DEMANGLE_COMPONENT_LITERAL_NEG;
2758           d_advance (di, 1);
2759         }
2760       s = d_str (di);
2761       while (d_peek_char (di) != 'E')
2762         {
2763           if (d_peek_char (di) == '\0')
2764             return NULL;
2765           d_advance (di, 1);
2766         }
2767       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2768     }
2769   if (! d_check_char (di, 'E'))
2770     return NULL;
2771   return ret;
2772 }
2773
2774 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2775                 ::= Z <(function) encoding> E s [<discriminator>]
2776 */
2777
2778 static struct demangle_component *
2779 d_local_name (struct d_info *di)
2780 {
2781   struct demangle_component *function;
2782
2783   if (! d_check_char (di, 'Z'))
2784     return NULL;
2785
2786   function = d_encoding (di, 0);
2787
2788   if (! d_check_char (di, 'E'))
2789     return NULL;
2790
2791   if (d_peek_char (di) == 's')
2792     {
2793       d_advance (di, 1);
2794       if (! d_discriminator (di))
2795         return NULL;
2796       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2797                           d_make_name (di, "string literal",
2798                                        sizeof "string literal" - 1));
2799     }
2800   else
2801     {
2802       struct demangle_component *name;
2803
2804       name = d_name (di);
2805       if (! d_discriminator (di))
2806         return NULL;
2807       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2808     }
2809 }
2810
2811 /* <discriminator> ::= _ <(non-negative) number>
2812
2813    We demangle the discriminator, but we don't print it out.  FIXME:
2814    We should print it out in verbose mode.  */
2815
2816 static int
2817 d_discriminator (struct d_info *di)
2818 {
2819   long discrim;
2820
2821   if (d_peek_char (di) != '_')
2822     return 1;
2823   d_advance (di, 1);
2824   discrim = d_number (di);
2825   if (discrim < 0)
2826     return 0;
2827   return 1;
2828 }
2829
2830 /* Add a new substitution.  */
2831
2832 static int
2833 d_add_substitution (struct d_info *di, struct demangle_component *dc)
2834 {
2835   if (dc == NULL)
2836     return 0;
2837   if (di->next_sub >= di->num_subs)
2838     return 0;
2839   di->subs[di->next_sub] = dc;
2840   ++di->next_sub;
2841   return 1;
2842 }
2843
2844 /* <substitution> ::= S <seq-id> _
2845                   ::= S_
2846                   ::= St
2847                   ::= Sa
2848                   ::= Sb
2849                   ::= Ss
2850                   ::= Si
2851                   ::= So
2852                   ::= Sd
2853
2854    If PREFIX is non-zero, then this type is being used as a prefix in
2855    a qualified name.  In this case, for the standard substitutions, we
2856    need to check whether we are being used as a prefix for a
2857    constructor or destructor, and return a full template name.
2858    Otherwise we will get something like std::iostream::~iostream()
2859    which does not correspond particularly well to any function which
2860    actually appears in the source.
2861 */
2862
2863 static const struct d_standard_sub_info standard_subs[] =
2864 {
2865   { 't', NL ("std"),
2866     NL ("std"),
2867     NULL, 0 },
2868   { 'a', NL ("std::allocator"),
2869     NL ("std::allocator"),
2870     NL ("allocator") },
2871   { 'b', NL ("std::basic_string"),
2872     NL ("std::basic_string"),
2873     NL ("basic_string") },
2874   { 's', NL ("std::string"),
2875     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
2876     NL ("basic_string") },
2877   { 'i', NL ("std::istream"),
2878     NL ("std::basic_istream<char, std::char_traits<char> >"),
2879     NL ("basic_istream") },
2880   { 'o', NL ("std::ostream"),
2881     NL ("std::basic_ostream<char, std::char_traits<char> >"),
2882     NL ("basic_ostream") },
2883   { 'd', NL ("std::iostream"),
2884     NL ("std::basic_iostream<char, std::char_traits<char> >"),
2885     NL ("basic_iostream") }
2886 };
2887
2888 static struct demangle_component *
2889 d_substitution (struct d_info *di, int prefix)
2890 {
2891   char c;
2892
2893   if (! d_check_char (di, 'S'))
2894     return NULL;
2895
2896   c = d_next_char (di);
2897   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
2898     {
2899       unsigned int id;
2900
2901       id = 0;
2902       if (c != '_')
2903         {
2904           do
2905             {
2906               unsigned int new_id;
2907
2908               if (IS_DIGIT (c))
2909                 new_id = id * 36 + c - '0';
2910               else if (IS_UPPER (c))
2911                 new_id = id * 36 + c - 'A' + 10;
2912               else
2913                 return NULL;
2914               if (new_id < id)
2915                 return NULL;
2916               id = new_id;
2917               c = d_next_char (di);
2918             }
2919           while (c != '_');
2920
2921           ++id;
2922         }
2923
2924       if (id >= (unsigned int) di->next_sub)
2925         return NULL;
2926
2927       ++di->did_subs;
2928
2929       return di->subs[id];
2930     }
2931   else
2932     {
2933       int verbose;
2934       const struct d_standard_sub_info *p;
2935       const struct d_standard_sub_info *pend;
2936
2937       verbose = (di->options & DMGL_VERBOSE) != 0;
2938       if (! verbose && prefix)
2939         {
2940           char peek;
2941
2942           peek = d_peek_char (di);
2943           if (peek == 'C' || peek == 'D')
2944             verbose = 1;
2945         }
2946
2947       pend = (&standard_subs[0]
2948               + sizeof standard_subs / sizeof standard_subs[0]);
2949       for (p = &standard_subs[0]; p < pend; ++p)
2950         {
2951           if (c == p->code)
2952             {
2953               const char *s;
2954               int len;
2955
2956               if (p->set_last_name != NULL)
2957                 di->last_name = d_make_sub (di, p->set_last_name,
2958                                             p->set_last_name_len);
2959               if (verbose)
2960                 {
2961                   s = p->full_expansion;
2962                   len = p->full_len;
2963                 }
2964               else
2965                 {
2966                   s = p->simple_expansion;
2967                   len = p->simple_len;
2968                 }
2969               di->expansion += len;
2970               return d_make_sub (di, s, len);
2971             }
2972         }
2973
2974       return NULL;
2975     }
2976 }
2977
2978 /* Initialize a growable string.  */
2979
2980 static void
2981 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
2982 {
2983   dgs->buf = NULL;
2984   dgs->len = 0;
2985   dgs->alc = 0;
2986   dgs->allocation_failure = 0;
2987
2988   if (estimate > 0)
2989     d_growable_string_resize (dgs, estimate);
2990 }
2991
2992 /* Grow a growable string to a given size.  */
2993
2994 static inline void
2995 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
2996 {
2997   size_t newalc;
2998   char *newbuf;
2999
3000   if (dgs->allocation_failure)
3001     return;
3002
3003   /* Start allocation at two bytes to avoid any possibility of confusion
3004      with the special value of 1 used as a return in *palc to indicate
3005      allocation failures.  */
3006   newalc = dgs->alc > 0 ? dgs->alc : 2;
3007   while (newalc < need)
3008     newalc <<= 1;
3009
3010   newbuf = (char *) realloc (dgs->buf, newalc);
3011   if (newbuf == NULL)
3012     {
3013       free (dgs->buf);
3014       dgs->buf = NULL;
3015       dgs->len = 0;
3016       dgs->alc = 0;
3017       dgs->allocation_failure = 1;
3018       return;
3019     }
3020   dgs->buf = newbuf;
3021   dgs->alc = newalc;
3022 }
3023
3024 /* Append a buffer to a growable string.  */
3025
3026 static inline void
3027 d_growable_string_append_buffer (struct d_growable_string *dgs,
3028                                  const char *s, size_t l)
3029 {
3030   size_t need;
3031
3032   need = dgs->len + l + 1;
3033   if (need > dgs->alc)
3034     d_growable_string_resize (dgs, need);
3035
3036   if (dgs->allocation_failure)
3037     return;
3038
3039   memcpy (dgs->buf + dgs->len, s, l);
3040   dgs->buf[dgs->len + l] = '\0';
3041   dgs->len += l;
3042 }
3043
3044 /* Bridge growable strings to the callback mechanism.  */
3045
3046 static void
3047 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3048 {
3049   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3050
3051   d_growable_string_append_buffer (dgs, s, l);
3052 }
3053
3054 /* Initialize a print information structure.  */
3055
3056 static void
3057 d_print_init (struct d_print_info *dpi, int options,
3058               demangle_callbackref callback, void *opaque)
3059 {
3060   dpi->options = options;
3061   dpi->len = 0;
3062   dpi->last_char = '\0';
3063   dpi->templates = NULL;
3064   dpi->modifiers = NULL;
3065
3066   dpi->callback = callback;
3067   dpi->opaque = opaque;
3068
3069   dpi->demangle_failure = 0;
3070 }
3071
3072 /* Indicate that an error occurred during printing, and test for error.  */
3073
3074 static inline void
3075 d_print_error (struct d_print_info *dpi)
3076 {
3077   dpi->demangle_failure = 1;
3078 }
3079
3080 static inline int
3081 d_print_saw_error (struct d_print_info *dpi)
3082 {
3083   return dpi->demangle_failure != 0;
3084 }
3085
3086 /* Flush buffered characters to the callback.  */
3087
3088 static inline void
3089 d_print_flush (struct d_print_info *dpi)
3090 {
3091   dpi->buf[dpi->len] = '\0';
3092   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3093   dpi->len = 0;
3094 }
3095
3096 /* Append characters and buffers for printing.  */
3097
3098 static inline void
3099 d_append_char (struct d_print_info *dpi, char c)
3100 {
3101   if (dpi->len == sizeof (dpi->buf) - 1)
3102     d_print_flush (dpi);
3103
3104   dpi->buf[dpi->len++] = c;
3105   dpi->last_char = c;
3106 }
3107
3108 static inline void
3109 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3110 {
3111   size_t i;
3112
3113   for (i = 0; i < l; i++)
3114     d_append_char (dpi, s[i]);
3115 }
3116
3117 static inline void
3118 d_append_string (struct d_print_info *dpi, const char *s)
3119 {
3120   d_append_buffer (dpi, s, strlen (s));
3121 }
3122
3123 static inline char
3124 d_last_char (struct d_print_info *dpi)
3125 {
3126   return dpi->last_char;
3127 }
3128
3129 /* Turn components into a human readable string.  OPTIONS is the
3130    options bits passed to the demangler.  DC is the tree to print.
3131    CALLBACK is a function to call to flush demangled string segments
3132    as they fill the intermediate buffer, and OPAQUE is a generalized
3133    callback argument.  On success, this returns 1.  On failure,
3134    it returns 0, indicating a bad parse.  It does not use heap
3135    memory to build an output string, so cannot encounter memory
3136    allocation failure.  */
3137
3138 CP_STATIC_IF_GLIBCPP_V3
3139 int
3140 cplus_demangle_print_callback (int options,
3141                                const struct demangle_component *dc,
3142                                demangle_callbackref callback, void *opaque)
3143 {
3144   struct d_print_info dpi;
3145
3146   d_print_init (&dpi, options, callback, opaque);
3147
3148   d_print_comp (&dpi, dc);
3149
3150   d_print_flush (&dpi);
3151
3152   return ! d_print_saw_error (&dpi);
3153 }
3154
3155 /* Turn components into a human readable string.  OPTIONS is the
3156    options bits passed to the demangler.  DC is the tree to print.
3157    ESTIMATE is a guess at the length of the result.  This returns a
3158    string allocated by malloc, or NULL on error.  On success, this
3159    sets *PALC to the size of the allocated buffer.  On failure, this
3160    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3161    failure.  */
3162
3163 CP_STATIC_IF_GLIBCPP_V3
3164 char *
3165 cplus_demangle_print (int options, const struct demangle_component *dc,
3166                       int estimate, size_t *palc)
3167 {
3168   struct d_growable_string dgs;
3169
3170   d_growable_string_init (&dgs, estimate);
3171
3172   if (! cplus_demangle_print_callback (options, dc,
3173                                        d_growable_string_callback_adapter,
3174                                        &dgs))
3175     {
3176       free (dgs.buf);
3177       *palc = 0;
3178       return NULL;
3179     }
3180
3181   *palc = dgs.allocation_failure ? 1 : dgs.alc;
3182   return dgs.buf;
3183 }
3184
3185 /* Returns the I'th element of the template arglist ARGS, or NULL on
3186    failure.  */
3187
3188 static struct demangle_component *
3189 d_index_template_argument (struct demangle_component *args, int i)
3190 {
3191   struct demangle_component *a;
3192
3193   for (a = args;
3194        a != NULL;
3195        a = d_right (a))
3196     {
3197       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3198         return NULL;
3199       if (i <= 0)
3200         break;
3201       --i;
3202     }
3203   if (i != 0 || a == NULL)
3204     return NULL;
3205
3206   return d_left (a);
3207 }
3208
3209 /* Returns the template argument from the current context indicated by DC,
3210    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
3211
3212 static struct demangle_component *
3213 d_lookup_template_argument (struct d_print_info *dpi,
3214                             const struct demangle_component *dc)
3215 {
3216   if (dpi->templates == NULL)
3217     {
3218       d_print_error (dpi);
3219       return NULL;
3220     }
3221
3222   return d_index_template_argument
3223     (d_right (dpi->templates->template_decl),
3224      dc->u.s_number.number);
3225 }
3226
3227 /* Returns a template argument pack used in DC (any will do), or NULL.  */
3228
3229 static struct demangle_component *
3230 d_find_pack (struct d_print_info *dpi,
3231              const struct demangle_component *dc)
3232 {
3233   struct demangle_component *a;
3234   if (dc == NULL)
3235     return NULL;
3236
3237   switch (dc->type)
3238     {
3239     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3240       a = d_lookup_template_argument (dpi, dc);
3241       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3242         return a;
3243       return NULL;
3244
3245     case DEMANGLE_COMPONENT_PACK_EXPANSION:
3246       return NULL;
3247
3248     case DEMANGLE_COMPONENT_NAME:
3249     case DEMANGLE_COMPONENT_OPERATOR:
3250     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3251     case DEMANGLE_COMPONENT_SUB_STD:
3252     case DEMANGLE_COMPONENT_CHARACTER:
3253     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3254       return NULL;
3255
3256     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3257       return d_find_pack (dpi, dc->u.s_extended_operator.name);
3258     case DEMANGLE_COMPONENT_CTOR:
3259       return d_find_pack (dpi, dc->u.s_ctor.name);
3260     case DEMANGLE_COMPONENT_DTOR:
3261       return d_find_pack (dpi, dc->u.s_dtor.name);
3262
3263     default:
3264       a = d_find_pack (dpi, d_left (dc));
3265       if (a)
3266         return a;
3267       return d_find_pack (dpi, d_right (dc));
3268     }
3269 }
3270
3271 /* Returns the length of the template argument pack DC.  */
3272
3273 static int
3274 d_pack_length (const struct demangle_component *dc)
3275 {
3276   int count = 0;
3277   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3278          && d_left (dc) != NULL)
3279     {
3280       ++count;
3281       dc = d_right (dc);
3282     }
3283   return count;
3284 }
3285
3286 /* DC is a component of a mangled expression.  Print it, wrapped in parens
3287    if needed.  */
3288
3289 static void
3290 d_print_subexpr (struct d_print_info *dpi,
3291                  const struct demangle_component *dc)
3292 {
3293   int simple = 0;
3294   if (dc->type == DEMANGLE_COMPONENT_NAME
3295       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3296     simple = 1;
3297   if (!simple)
3298     d_append_char (dpi, '(');
3299   d_print_comp (dpi, dc);
3300   if (!simple)
3301     d_append_char (dpi, ')');
3302 }
3303
3304 /* Subroutine to handle components.  */
3305
3306 static void
3307 d_print_comp (struct d_print_info *dpi,
3308               const struct demangle_component *dc)
3309 {
3310   if (dc == NULL)
3311     {
3312       d_print_error (dpi);
3313       return;
3314     }
3315   if (d_print_saw_error (dpi))
3316     return;
3317
3318   switch (dc->type)
3319     {
3320     case DEMANGLE_COMPONENT_NAME:
3321       if ((dpi->options & DMGL_JAVA) == 0)
3322         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3323       else
3324         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3325       return;
3326
3327     case DEMANGLE_COMPONENT_QUAL_NAME:
3328     case DEMANGLE_COMPONENT_LOCAL_NAME:
3329       d_print_comp (dpi, d_left (dc));
3330       if ((dpi->options & DMGL_JAVA) == 0)
3331         d_append_string (dpi, "::");
3332       else
3333         d_append_char (dpi, '.');
3334       d_print_comp (dpi, d_right (dc));
3335       return;
3336
3337     case DEMANGLE_COMPONENT_TYPED_NAME:
3338       {
3339         struct d_print_mod *hold_modifiers;
3340         struct demangle_component *typed_name;
3341         struct d_print_mod adpm[4];
3342         unsigned int i;
3343         struct d_print_template dpt;
3344
3345         /* Pass the name down to the type so that it can be printed in
3346            the right place for the type.  We also have to pass down
3347            any CV-qualifiers, which apply to the this parameter.  */
3348         hold_modifiers = dpi->modifiers;
3349         dpi->modifiers = 0;
3350         i = 0;
3351         typed_name = d_left (dc);
3352         while (typed_name != NULL)
3353           {
3354             if (i >= sizeof adpm / sizeof adpm[0])
3355               {
3356                 d_print_error (dpi);
3357                 return;
3358               }
3359
3360             adpm[i].next = dpi->modifiers;
3361             dpi->modifiers = &adpm[i];
3362             adpm[i].mod = typed_name;
3363             adpm[i].printed = 0;
3364             adpm[i].templates = dpi->templates;
3365             ++i;
3366
3367             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3368                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3369                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3370               break;
3371
3372             typed_name = d_left (typed_name);
3373           }
3374
3375         if (typed_name == NULL)
3376           {
3377             d_print_error (dpi);
3378             return;
3379           }
3380
3381         /* If typed_name is a template, then it applies to the
3382            function type as well.  */
3383         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3384           {
3385             dpt.next = dpi->templates;
3386             dpi->templates = &dpt;
3387             dpt.template_decl = typed_name;
3388           }
3389
3390         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3391            there may be CV-qualifiers on its right argument which
3392            really apply here; this happens when parsing a class which
3393            is local to a function.  */
3394         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3395           {
3396             struct demangle_component *local_name;
3397
3398             local_name = d_right (typed_name);
3399             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3400                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3401                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3402               {
3403                 if (i >= sizeof adpm / sizeof adpm[0])
3404                   {
3405                     d_print_error (dpi);
3406                     return;
3407                   }
3408
3409                 adpm[i] = adpm[i - 1];
3410                 adpm[i].next = &adpm[i - 1];
3411                 dpi->modifiers = &adpm[i];
3412
3413                 adpm[i - 1].mod = local_name;
3414                 adpm[i - 1].printed = 0;
3415                 adpm[i - 1].templates = dpi->templates;
3416                 ++i;
3417
3418                 local_name = d_left (local_name);
3419               }
3420           }
3421
3422         d_print_comp (dpi, d_right (dc));
3423
3424         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3425           dpi->templates = dpt.next;
3426
3427         /* If the modifiers didn't get printed by the type, print them
3428            now.  */
3429         while (i > 0)
3430           {
3431             --i;
3432             if (! adpm[i].printed)
3433               {
3434                 d_append_char (dpi, ' ');
3435                 d_print_mod (dpi, adpm[i].mod);
3436               }
3437           }
3438
3439         dpi->modifiers = hold_modifiers;
3440
3441         return;
3442       }
3443
3444     case DEMANGLE_COMPONENT_TEMPLATE:
3445       {
3446         struct d_print_mod *hold_dpm;
3447         struct demangle_component *dcl;
3448
3449         /* Don't push modifiers into a template definition.  Doing so
3450            could give the wrong definition for a template argument.
3451            Instead, treat the template essentially as a name.  */
3452
3453         hold_dpm = dpi->modifiers;
3454         dpi->modifiers = NULL;
3455
3456         dcl = d_left (dc);
3457
3458         if ((dpi->options & DMGL_JAVA) != 0
3459             && dcl->type == DEMANGLE_COMPONENT_NAME
3460             && dcl->u.s_name.len == 6
3461             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3462           {
3463             /* Special-case Java arrays, so that JArray<TYPE> appears
3464                instead as TYPE[].  */
3465
3466             d_print_comp (dpi, d_right (dc));
3467             d_append_string (dpi, "[]");
3468           }
3469         else
3470           {
3471             d_print_comp (dpi, dcl);
3472             if (d_last_char (dpi) == '<')
3473               d_append_char (dpi, ' ');
3474             d_append_char (dpi, '<');
3475             d_print_comp (dpi, d_right (dc));
3476             /* Avoid generating two consecutive '>' characters, to avoid
3477                the C++ syntactic ambiguity.  */
3478             if (d_last_char (dpi) == '>')
3479               d_append_char (dpi, ' ');
3480             d_append_char (dpi, '>');
3481           }
3482
3483         dpi->modifiers = hold_dpm;
3484
3485         return;
3486       }
3487
3488     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3489       {
3490         struct d_print_template *hold_dpt;
3491         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3492
3493         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3494           a = d_index_template_argument (a, dpi->pack_index);
3495
3496         if (a == NULL)
3497           {
3498             d_print_error (dpi);
3499             return;
3500           }
3501
3502         /* While processing this parameter, we need to pop the list of
3503            templates.  This is because the template parameter may
3504            itself be a reference to a parameter of an outer
3505            template.  */
3506
3507         hold_dpt = dpi->templates;
3508         dpi->templates = hold_dpt->next;
3509
3510         d_print_comp (dpi, a);
3511
3512         dpi->templates = hold_dpt;
3513
3514         return;
3515       }
3516
3517     case DEMANGLE_COMPONENT_CTOR:
3518       d_print_comp (dpi, dc->u.s_ctor.name);
3519       return;
3520
3521     case DEMANGLE_COMPONENT_DTOR:
3522       d_append_char (dpi, '~');
3523       d_print_comp (dpi, dc->u.s_dtor.name);
3524       return;
3525
3526     case DEMANGLE_COMPONENT_VTABLE:
3527       d_append_string (dpi, "vtable for ");
3528       d_print_comp (dpi, d_left (dc));
3529       return;
3530
3531     case DEMANGLE_COMPONENT_VTT:
3532       d_append_string (dpi, "VTT for ");
3533       d_print_comp (dpi, d_left (dc));
3534       return;
3535
3536     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3537       d_append_string (dpi, "construction vtable for ");
3538       d_print_comp (dpi, d_left (dc));
3539       d_append_string (dpi, "-in-");
3540       d_print_comp (dpi, d_right (dc));
3541       return;
3542
3543     case DEMANGLE_COMPONENT_TYPEINFO:
3544       d_append_string (dpi, "typeinfo for ");
3545       d_print_comp (dpi, d_left (dc));
3546       return;
3547
3548     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3549       d_append_string (dpi, "typeinfo name for ");
3550       d_print_comp (dpi, d_left (dc));
3551       return;
3552
3553     case DEMANGLE_COMPONENT_TYPEINFO_FN:
3554       d_append_string (dpi, "typeinfo fn for ");
3555       d_print_comp (dpi, d_left (dc));
3556       return;
3557
3558     case DEMANGLE_COMPONENT_THUNK:
3559       d_append_string (dpi, "non-virtual thunk to ");
3560       d_print_comp (dpi, d_left (dc));
3561       return;
3562
3563     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3564       d_append_string (dpi, "virtual thunk to ");
3565       d_print_comp (dpi, d_left (dc));
3566       return;
3567
3568     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3569       d_append_string (dpi, "covariant return thunk to ");
3570       d_print_comp (dpi, d_left (dc));
3571       return;
3572
3573     case DEMANGLE_COMPONENT_JAVA_CLASS:
3574       d_append_string (dpi, "java Class for ");
3575       d_print_comp (dpi, d_left (dc));
3576       return;
3577
3578     case DEMANGLE_COMPONENT_GUARD:
3579       d_append_string (dpi, "guard variable for ");
3580       d_print_comp (dpi, d_left (dc));
3581       return;
3582
3583     case DEMANGLE_COMPONENT_REFTEMP:
3584       d_append_string (dpi, "reference temporary for ");
3585       d_print_comp (dpi, d_left (dc));
3586       return;
3587
3588     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3589       d_append_string (dpi, "hidden alias for ");
3590       d_print_comp (dpi, d_left (dc));
3591       return;
3592
3593     case DEMANGLE_COMPONENT_SUB_STD:
3594       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3595       return;
3596
3597     case DEMANGLE_COMPONENT_RESTRICT:
3598     case DEMANGLE_COMPONENT_VOLATILE:
3599     case DEMANGLE_COMPONENT_CONST:
3600       {
3601         struct d_print_mod *pdpm;
3602
3603         /* When printing arrays, it's possible to have cases where the
3604            same CV-qualifier gets pushed on the stack multiple times.
3605            We only need to print it once.  */
3606
3607         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3608           {
3609             if (! pdpm->printed)
3610               {
3611                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3612                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3613                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3614                   break;
3615                 if (pdpm->mod->type == dc->type)
3616                   {
3617                     d_print_comp (dpi, d_left (dc));
3618                     return;
3619                   }
3620               }
3621           }
3622       }
3623       /* Fall through.  */
3624     case DEMANGLE_COMPONENT_RESTRICT_THIS:
3625     case DEMANGLE_COMPONENT_VOLATILE_THIS:
3626     case DEMANGLE_COMPONENT_CONST_THIS:
3627     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3628     case DEMANGLE_COMPONENT_POINTER:
3629     case DEMANGLE_COMPONENT_REFERENCE:
3630     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3631     case DEMANGLE_COMPONENT_COMPLEX:
3632     case DEMANGLE_COMPONENT_IMAGINARY:
3633       {
3634         /* We keep a list of modifiers on the stack.  */
3635         struct d_print_mod dpm;
3636
3637         dpm.next = dpi->modifiers;
3638         dpi->modifiers = &dpm;
3639         dpm.mod = dc;
3640         dpm.printed = 0;
3641         dpm.templates = dpi->templates;
3642
3643         d_print_comp (dpi, d_left (dc));
3644
3645         /* If the modifier didn't get printed by the type, print it
3646            now.  */
3647         if (! dpm.printed)
3648           d_print_mod (dpi, dc);
3649
3650         dpi->modifiers = dpm.next;
3651
3652         return;
3653       }
3654
3655     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3656       if ((dpi->options & DMGL_JAVA) == 0)
3657         d_append_buffer (dpi, dc->u.s_builtin.type->name,
3658                          dc->u.s_builtin.type->len);
3659       else
3660         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3661                          dc->u.s_builtin.type->java_len);
3662       return;
3663
3664     case DEMANGLE_COMPONENT_VENDOR_TYPE:
3665       d_print_comp (dpi, d_left (dc));
3666       return;
3667
3668     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3669       {
3670         if ((dpi->options & DMGL_RET_POSTFIX) != 0)
3671           d_print_function_type (dpi, dc, dpi->modifiers);
3672
3673         /* Print return type if present */
3674         if (d_left (dc) != NULL)
3675           {
3676             struct d_print_mod dpm;
3677
3678             /* We must pass this type down as a modifier in order to
3679                print it in the right location.  */
3680             dpm.next = dpi->modifiers;
3681             dpi->modifiers = &dpm;
3682             dpm.mod = dc;
3683             dpm.printed = 0;
3684             dpm.templates = dpi->templates;
3685
3686             d_print_comp (dpi, d_left (dc));
3687
3688             dpi->modifiers = dpm.next;
3689
3690             if (dpm.printed)
3691               return;
3692
3693             /* In standard prefix notation, there is a space between the
3694                return type and the function signature.  */
3695             if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3696               d_append_char (dpi, ' ');
3697           }
3698
3699         if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3700           d_print_function_type (dpi, dc, dpi->modifiers);
3701
3702         return;
3703       }
3704
3705     case DEMANGLE_COMPONENT_ARRAY_TYPE:
3706       {
3707         struct d_print_mod *hold_modifiers;
3708         struct d_print_mod adpm[4];
3709         unsigned int i;
3710         struct d_print_mod *pdpm;
3711
3712         /* We must pass this type down as a modifier in order to print
3713            multi-dimensional arrays correctly.  If the array itself is
3714            CV-qualified, we act as though the element type were
3715            CV-qualified.  We do this by copying the modifiers down
3716            rather than fiddling pointers, so that we don't wind up
3717            with a d_print_mod higher on the stack pointing into our
3718            stack frame after we return.  */
3719
3720         hold_modifiers = dpi->modifiers;
3721
3722         adpm[0].next = hold_modifiers;
3723         dpi->modifiers = &adpm[0];
3724         adpm[0].mod = dc;
3725         adpm[0].printed = 0;
3726         adpm[0].templates = dpi->templates;
3727
3728         i = 1;
3729         pdpm = hold_modifiers;
3730         while (pdpm != NULL
3731                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3732                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3733                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3734           {
3735             if (! pdpm->printed)
3736               {
3737                 if (i >= sizeof adpm / sizeof adpm[0])
3738                   {
3739                     d_print_error (dpi);
3740                     return;
3741                   }
3742
3743                 adpm[i] = *pdpm;
3744                 adpm[i].next = dpi->modifiers;
3745                 dpi->modifiers = &adpm[i];
3746                 pdpm->printed = 1;
3747                 ++i;
3748               }
3749
3750             pdpm = pdpm->next;
3751           }
3752
3753         d_print_comp (dpi, d_right (dc));
3754
3755         dpi->modifiers = hold_modifiers;
3756
3757         if (adpm[0].printed)
3758           return;
3759
3760         while (i > 1)
3761           {
3762             --i;
3763             d_print_mod (dpi, adpm[i].mod);
3764           }
3765
3766         d_print_array_type (dpi, dc, dpi->modifiers);
3767
3768         return;
3769       }
3770
3771     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3772       {
3773         struct d_print_mod dpm;
3774
3775         dpm.next = dpi->modifiers;
3776         dpi->modifiers = &dpm;
3777         dpm.mod = dc;
3778         dpm.printed = 0;
3779         dpm.templates = dpi->templates;
3780
3781         d_print_comp (dpi, d_right (dc));
3782
3783         /* If the modifier didn't get printed by the type, print it
3784            now.  */
3785         if (! dpm.printed)
3786           {
3787             d_append_char (dpi, ' ');
3788             d_print_comp (dpi, d_left (dc));
3789             d_append_string (dpi, "::*");
3790           }
3791
3792         dpi->modifiers = dpm.next;
3793
3794         return;
3795       }
3796
3797     case DEMANGLE_COMPONENT_FIXED_TYPE:
3798       if (dc->u.s_fixed.sat)
3799         d_append_string (dpi, "_Sat ");
3800       /* Don't print "int _Accum".  */
3801       if (dc->u.s_fixed.length->u.s_builtin.type
3802           != &cplus_demangle_builtin_types['i'-'a'])
3803         {
3804           d_print_comp (dpi, dc->u.s_fixed.length);
3805           d_append_char (dpi, ' ');
3806         }
3807       if (dc->u.s_fixed.accum)
3808         d_append_string (dpi, "_Accum");
3809       else
3810         d_append_string (dpi, "_Fract");
3811       return;
3812
3813     case DEMANGLE_COMPONENT_ARGLIST:
3814     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
3815       if (d_left (dc) != NULL)
3816         d_print_comp (dpi, d_left (dc));
3817       if (d_right (dc) != NULL)
3818         {
3819           size_t len;
3820           d_append_string (dpi, ", ");
3821           len = dpi->len;
3822           d_print_comp (dpi, d_right (dc));
3823           /* If that didn't print anything (which can happen with empty
3824              template argument packs), remove the comma and space.  */
3825           if (dpi->len == len)
3826             dpi->len -= 2;
3827         }
3828       return;
3829
3830     case DEMANGLE_COMPONENT_OPERATOR:
3831       {
3832         char c;
3833
3834         d_append_string (dpi, "operator");
3835         c = dc->u.s_operator.op->name[0];
3836         if (IS_LOWER (c))
3837           d_append_char (dpi, ' ');
3838         d_append_buffer (dpi, dc->u.s_operator.op->name,
3839                          dc->u.s_operator.op->len);
3840         return;
3841       }
3842
3843     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3844       d_append_string (dpi, "operator ");
3845       d_print_comp (dpi, dc->u.s_extended_operator.name);
3846       return;
3847
3848     case DEMANGLE_COMPONENT_CAST:
3849       d_append_string (dpi, "operator ");
3850       d_print_cast (dpi, dc);
3851       return;
3852
3853     case DEMANGLE_COMPONENT_UNARY:
3854       if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
3855         d_print_expr_op (dpi, d_left (dc));
3856       else
3857         {
3858           d_append_char (dpi, '(');
3859           d_print_cast (dpi, d_left (dc));
3860           d_append_char (dpi, ')');
3861         }
3862       d_print_subexpr (dpi, d_right (dc));
3863       return;
3864
3865     case DEMANGLE_COMPONENT_BINARY:
3866       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
3867         {
3868           d_print_error (dpi);
3869           return;
3870         }
3871
3872       /* We wrap an expression which uses the greater-than operator in
3873          an extra layer of parens so that it does not get confused
3874          with the '>' which ends the template parameters.  */
3875       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3876           && d_left (dc)->u.s_operator.op->len == 1
3877           && d_left (dc)->u.s_operator.op->name[0] == '>')
3878         d_append_char (dpi, '(');
3879
3880       d_print_subexpr (dpi, d_left (d_right (dc)));
3881       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
3882         d_print_expr_op (dpi, d_left (dc));
3883       d_print_subexpr (dpi, d_right (d_right (dc)));
3884
3885       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3886           && d_left (dc)->u.s_operator.op->len == 1
3887           && d_left (dc)->u.s_operator.op->name[0] == '>')
3888         d_append_char (dpi, ')');
3889
3890       return;
3891
3892     case DEMANGLE_COMPONENT_BINARY_ARGS:
3893       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
3894       d_print_error (dpi);
3895       return;
3896
3897     case DEMANGLE_COMPONENT_TRINARY:
3898       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
3899           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
3900         {
3901           d_print_error (dpi);
3902           return;
3903         }
3904       d_print_subexpr (dpi, d_left (d_right (dc)));
3905       d_print_expr_op (dpi, d_left (dc));
3906       d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
3907       d_append_string (dpi, " : ");
3908       d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
3909       return;
3910
3911     case DEMANGLE_COMPONENT_TRINARY_ARG1:
3912     case DEMANGLE_COMPONENT_TRINARY_ARG2:
3913       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
3914       d_print_error (dpi);
3915       return;
3916
3917     case DEMANGLE_COMPONENT_LITERAL:
3918     case DEMANGLE_COMPONENT_LITERAL_NEG:
3919       {
3920         enum d_builtin_type_print tp;
3921
3922         /* For some builtin types, produce simpler output.  */
3923         tp = D_PRINT_DEFAULT;
3924         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
3925           {
3926             tp = d_left (dc)->u.s_builtin.type->print;
3927             switch (tp)
3928               {
3929               case D_PRINT_INT:
3930               case D_PRINT_UNSIGNED:
3931               case D_PRINT_LONG:
3932               case D_PRINT_UNSIGNED_LONG:
3933               case D_PRINT_LONG_LONG:
3934               case D_PRINT_UNSIGNED_LONG_LONG:
3935                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
3936                   {
3937                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3938                       d_append_char (dpi, '-');
3939                     d_print_comp (dpi, d_right (dc));
3940                     switch (tp)
3941                       {
3942                       default:
3943                         break;
3944                       case D_PRINT_UNSIGNED:
3945                         d_append_char (dpi, 'u');
3946                         break;
3947                       case D_PRINT_LONG:
3948                         d_append_char (dpi, 'l');
3949                         break;
3950                       case D_PRINT_UNSIGNED_LONG:
3951                         d_append_string (dpi, "ul");
3952                         break;
3953                       case D_PRINT_LONG_LONG:
3954                         d_append_string (dpi, "ll");
3955                         break;
3956                       case D_PRINT_UNSIGNED_LONG_LONG:
3957                         d_append_string (dpi, "ull");
3958                         break;
3959                       }
3960                     return;
3961                   }
3962                 break;
3963
3964               case D_PRINT_BOOL:
3965                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
3966                     && d_right (dc)->u.s_name.len == 1
3967                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
3968                   {
3969                     switch (d_right (dc)->u.s_name.s[0])
3970                       {
3971                       case '0':
3972                         d_append_string (dpi, "false");
3973                         return;
3974                       case '1':
3975                         d_append_string (dpi, "true");
3976                         return;
3977                       default:
3978                         break;
3979                       }
3980                   }
3981                 break;
3982
3983               default:
3984                 break;
3985               }
3986           }
3987
3988         d_append_char (dpi, '(');
3989         d_print_comp (dpi, d_left (dc));
3990         d_append_char (dpi, ')');
3991         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3992           d_append_char (dpi, '-');
3993         if (tp == D_PRINT_FLOAT)
3994           d_append_char (dpi, '[');
3995         d_print_comp (dpi, d_right (dc));
3996         if (tp == D_PRINT_FLOAT)
3997           d_append_char (dpi, ']');
3998       }
3999       return;
4000
4001     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4002       d_append_string (dpi, "java resource ");
4003       d_print_comp (dpi, d_left (dc));
4004       return;
4005
4006     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4007       d_print_comp (dpi, d_left (dc));
4008       d_print_comp (dpi, d_right (dc));
4009       return;
4010
4011     case DEMANGLE_COMPONENT_CHARACTER:
4012       d_append_char (dpi, dc->u.s_character.character);
4013       return;
4014
4015     case DEMANGLE_COMPONENT_DECLTYPE:
4016       d_append_string (dpi, "decltype (");
4017       d_print_comp (dpi, d_left (dc));
4018       d_append_char (dpi, ')');
4019       return;
4020
4021     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4022       {
4023         int len;
4024         int i;
4025         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4026         if (a == NULL)
4027           {
4028             /* d_find_pack won't find anything if the only packs involved
4029                in this expansion are function parameter packs; in that
4030                case, just print the pattern and "...".  */
4031             d_print_subexpr (dpi, d_left (dc));
4032             d_append_string (dpi, "...");
4033             return;
4034           }
4035
4036         len = d_pack_length (a);
4037         dc = d_left (dc);
4038         for (i = 0; i < len; ++i)
4039           {
4040             dpi->pack_index = i;
4041             d_print_comp (dpi, dc);
4042             if (i < len-1)
4043               d_append_string (dpi, ", ");
4044           }
4045       }
4046       return;
4047
4048     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4049       {
4050         char buf[25];
4051         d_append_string (dpi, "parm#");
4052         sprintf(buf,"%ld", dc->u.s_number.number);
4053         d_append_string (dpi, buf);
4054         return;
4055       }
4056
4057     default:
4058       d_print_error (dpi);
4059       return;
4060     }
4061 }
4062
4063 /* Print a Java dentifier.  For Java we try to handle encoded extended
4064    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
4065    so we don't it for C++.  Characters are encoded as
4066    __U<hex-char>+_.  */
4067
4068 static void
4069 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4070 {
4071   const char *p;
4072   const char *end;
4073
4074   end = name + len;
4075   for (p = name; p < end; ++p)
4076     {
4077       if (end - p > 3
4078           && p[0] == '_'
4079           && p[1] == '_'
4080           && p[2] == 'U')
4081         {
4082           unsigned long c;
4083           const char *q;
4084
4085           c = 0;
4086           for (q = p + 3; q < end; ++q)
4087             {
4088               int dig;
4089
4090               if (IS_DIGIT (*q))
4091                 dig = *q - '0';
4092               else if (*q >= 'A' && *q <= 'F')
4093                 dig = *q - 'A' + 10;
4094               else if (*q >= 'a' && *q <= 'f')
4095                 dig = *q - 'a' + 10;
4096               else
4097                 break;
4098
4099               c = c * 16 + dig;
4100             }
4101           /* If the Unicode character is larger than 256, we don't try
4102              to deal with it here.  FIXME.  */
4103           if (q < end && *q == '_' && c < 256)
4104             {
4105               d_append_char (dpi, c);
4106               p = q;
4107               continue;
4108             }
4109         }
4110
4111       d_append_char (dpi, *p);
4112     }
4113 }
4114
4115 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
4116    qualifiers on this after printing a function.  */
4117
4118 static void
4119 d_print_mod_list (struct d_print_info *dpi,
4120                   struct d_print_mod *mods, int suffix)
4121 {
4122   struct d_print_template *hold_dpt;
4123
4124   if (mods == NULL || d_print_saw_error (dpi))
4125     return;
4126
4127   if (mods->printed
4128       || (! suffix
4129           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4130               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4131               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4132     {
4133       d_print_mod_list (dpi, mods->next, suffix);
4134       return;
4135     }
4136
4137   mods->printed = 1;
4138
4139   hold_dpt = dpi->templates;
4140   dpi->templates = mods->templates;
4141
4142   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4143     {
4144       d_print_function_type (dpi, mods->mod, mods->next);
4145       dpi->templates = hold_dpt;
4146       return;
4147     }
4148   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4149     {
4150       d_print_array_type (dpi, mods->mod, mods->next);
4151       dpi->templates = hold_dpt;
4152       return;
4153     }
4154   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4155     {
4156       struct d_print_mod *hold_modifiers;
4157       struct demangle_component *dc;
4158
4159       /* When this is on the modifier stack, we have pulled any
4160          qualifiers off the right argument already.  Otherwise, we
4161          print it as usual, but don't let the left argument see any
4162          modifiers.  */
4163
4164       hold_modifiers = dpi->modifiers;
4165       dpi->modifiers = NULL;
4166       d_print_comp (dpi, d_left (mods->mod));
4167       dpi->modifiers = hold_modifiers;
4168
4169       if ((dpi->options & DMGL_JAVA) == 0)
4170         d_append_string (dpi, "::");
4171       else
4172         d_append_char (dpi, '.');
4173
4174       dc = d_right (mods->mod);
4175       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4176              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4177              || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4178         dc = d_left (dc);
4179
4180       d_print_comp (dpi, dc);
4181
4182       dpi->templates = hold_dpt;
4183       return;
4184     }
4185
4186   d_print_mod (dpi, mods->mod);
4187
4188   dpi->templates = hold_dpt;
4189
4190   d_print_mod_list (dpi, mods->next, suffix);
4191 }
4192
4193 /* Print a modifier.  */
4194
4195 static void
4196 d_print_mod (struct d_print_info *dpi,
4197              const struct demangle_component *mod)
4198 {
4199   switch (mod->type)
4200     {
4201     case DEMANGLE_COMPONENT_RESTRICT:
4202     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4203       d_append_string (dpi, " restrict");
4204       return;
4205     case DEMANGLE_COMPONENT_VOLATILE:
4206     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4207       d_append_string (dpi, " volatile");
4208       return;
4209     case DEMANGLE_COMPONENT_CONST:
4210     case DEMANGLE_COMPONENT_CONST_THIS:
4211       d_append_string (dpi, " const");
4212       return;
4213     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4214       d_append_char (dpi, ' ');
4215       d_print_comp (dpi, d_right (mod));
4216       return;
4217     case DEMANGLE_COMPONENT_POINTER:
4218       /* There is no pointer symbol in Java.  */
4219       if ((dpi->options & DMGL_JAVA) == 0)
4220         d_append_char (dpi, '*');
4221       return;
4222     case DEMANGLE_COMPONENT_REFERENCE:
4223       d_append_char (dpi, '&');
4224       return;
4225     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4226       d_append_string (dpi, "&&");
4227       return;
4228     case DEMANGLE_COMPONENT_COMPLEX:
4229       d_append_string (dpi, "complex ");
4230       return;
4231     case DEMANGLE_COMPONENT_IMAGINARY:
4232       d_append_string (dpi, "imaginary ");
4233       return;
4234     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4235       if (d_last_char (dpi) != '(')
4236         d_append_char (dpi, ' ');
4237       d_print_comp (dpi, d_left (mod));
4238       d_append_string (dpi, "::*");
4239       return;
4240     case DEMANGLE_COMPONENT_TYPED_NAME:
4241       d_print_comp (dpi, d_left (mod));
4242       return;
4243     default:
4244       /* Otherwise, we have something that won't go back on the
4245          modifier stack, so we can just print it.  */
4246       d_print_comp (dpi, mod);
4247       return;
4248     }
4249 }
4250
4251 /* Print a function type, except for the return type.  */
4252
4253 static void
4254 d_print_function_type (struct d_print_info *dpi,
4255                        const struct demangle_component *dc,
4256                        struct d_print_mod *mods)
4257 {
4258   int need_paren;
4259   int saw_mod;
4260   int need_space;
4261   struct d_print_mod *p;
4262   struct d_print_mod *hold_modifiers;
4263
4264   need_paren = 0;
4265   saw_mod = 0;
4266   need_space = 0;
4267   for (p = mods; p != NULL; p = p->next)
4268     {
4269       if (p->printed)
4270         break;
4271
4272       saw_mod = 1;
4273       switch (p->mod->type)
4274         {
4275         case DEMANGLE_COMPONENT_POINTER:
4276         case DEMANGLE_COMPONENT_REFERENCE:
4277         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4278           need_paren = 1;
4279           break;
4280         case DEMANGLE_COMPONENT_RESTRICT:
4281         case DEMANGLE_COMPONENT_VOLATILE:
4282         case DEMANGLE_COMPONENT_CONST:
4283         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4284         case DEMANGLE_COMPONENT_COMPLEX:
4285         case DEMANGLE_COMPONENT_IMAGINARY:
4286         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4287           need_space = 1;
4288           need_paren = 1;
4289           break;
4290         case DEMANGLE_COMPONENT_RESTRICT_THIS:
4291         case DEMANGLE_COMPONENT_VOLATILE_THIS:
4292         case DEMANGLE_COMPONENT_CONST_THIS:
4293           break;
4294         default:
4295           break;
4296         }
4297       if (need_paren)
4298         break;
4299     }
4300
4301   if (d_left (dc) != NULL && ! saw_mod)
4302     need_paren = 1;
4303
4304   if (need_paren)
4305     {
4306       if (! need_space)
4307         {
4308           if (d_last_char (dpi) != '('
4309               && d_last_char (dpi) != '*')
4310             need_space = 1;
4311         }
4312       if (need_space && d_last_char (dpi) != ' ')
4313         d_append_char (dpi, ' ');
4314       d_append_char (dpi, '(');
4315     }
4316
4317   hold_modifiers = dpi->modifiers;
4318   dpi->modifiers = NULL;
4319
4320   d_print_mod_list (dpi, mods, 0);
4321
4322   if (need_paren)
4323     d_append_char (dpi, ')');
4324
4325   d_append_char (dpi, '(');
4326
4327   if (d_right (dc) != NULL)
4328     d_print_comp (dpi, d_right (dc));
4329
4330   d_append_char (dpi, ')');
4331
4332   d_print_mod_list (dpi, mods, 1);
4333
4334   dpi->modifiers = hold_modifiers;
4335 }
4336
4337 /* Print an array type, except for the element type.  */
4338
4339 static void
4340 d_print_array_type (struct d_print_info *dpi,
4341                     const struct demangle_component *dc,
4342                     struct d_print_mod *mods)
4343 {
4344   int need_space;
4345
4346   need_space = 1;
4347   if (mods != NULL)
4348     {
4349       int need_paren;
4350       struct d_print_mod *p;
4351
4352       need_paren = 0;
4353       for (p = mods; p != NULL; p = p->next)
4354         {
4355           if (! p->printed)
4356             {
4357               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4358                 {
4359                   need_space = 0;
4360                   break;
4361                 }
4362               else
4363                 {
4364                   need_paren = 1;
4365                   need_space = 1;
4366                   break;
4367                 }
4368             }
4369         }
4370
4371       if (need_paren)
4372         d_append_string (dpi, " (");
4373
4374       d_print_mod_list (dpi, mods, 0);
4375
4376       if (need_paren)
4377         d_append_char (dpi, ')');
4378     }
4379
4380   if (need_space)
4381     d_append_char (dpi, ' ');
4382
4383   d_append_char (dpi, '[');
4384
4385   if (d_left (dc) != NULL)
4386     d_print_comp (dpi, d_left (dc));
4387
4388   d_append_char (dpi, ']');
4389 }
4390
4391 /* Print an operator in an expression.  */
4392
4393 static void
4394 d_print_expr_op (struct d_print_info *dpi,
4395                  const struct demangle_component *dc)
4396 {
4397   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
4398     d_append_buffer (dpi, dc->u.s_operator.op->name,
4399                      dc->u.s_operator.op->len);
4400   else
4401     d_print_comp (dpi, dc);
4402 }
4403
4404 /* Print a cast.  */
4405
4406 static void
4407 d_print_cast (struct d_print_info *dpi,
4408               const struct demangle_component *dc)
4409 {
4410   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
4411     d_print_comp (dpi, d_left (dc));
4412   else
4413     {
4414       struct d_print_mod *hold_dpm;
4415       struct d_print_template dpt;
4416
4417       /* It appears that for a templated cast operator, we need to put
4418          the template parameters in scope for the operator name, but
4419          not for the parameters.  The effect is that we need to handle
4420          the template printing here.  */
4421
4422       hold_dpm = dpi->modifiers;
4423       dpi->modifiers = NULL;
4424
4425       dpt.next = dpi->templates;
4426       dpi->templates = &dpt;
4427       dpt.template_decl = d_left (dc);
4428
4429       d_print_comp (dpi, d_left (d_left (dc)));
4430
4431       dpi->templates = dpt.next;
4432
4433       if (d_last_char (dpi) == '<')
4434         d_append_char (dpi, ' ');
4435       d_append_char (dpi, '<');
4436       d_print_comp (dpi, d_right (d_left (dc)));
4437       /* Avoid generating two consecutive '>' characters, to avoid
4438          the C++ syntactic ambiguity.  */
4439       if (d_last_char (dpi) == '>')
4440         d_append_char (dpi, ' ');
4441       d_append_char (dpi, '>');
4442
4443       dpi->modifiers = hold_dpm;
4444     }
4445 }
4446
4447 /* Initialize the information structure we use to pass around
4448    information.  */
4449
4450 CP_STATIC_IF_GLIBCPP_V3
4451 void
4452 cplus_demangle_init_info (const char *mangled, int options, size_t len,
4453                           struct d_info *di)
4454 {
4455   di->s = mangled;
4456   di->send = mangled + len;
4457   di->options = options;
4458
4459   di->n = mangled;
4460
4461   /* We can not need more components than twice the number of chars in
4462      the mangled string.  Most components correspond directly to
4463      chars, but the ARGLIST types are exceptions.  */
4464   di->num_comps = 2 * len;
4465   di->next_comp = 0;
4466
4467   /* Similarly, we can not need more substitutions than there are
4468      chars in the mangled string.  */
4469   di->num_subs = len;
4470   di->next_sub = 0;
4471   di->did_subs = 0;
4472
4473   di->last_name = NULL;
4474
4475   di->expansion = 0;
4476 }
4477
4478 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
4479    mangled name, return strings in repeated callback giving the demangled
4480    name.  OPTIONS is the usual libiberty demangler options.  On success,
4481    this returns 1.  On failure, returns 0.  */
4482
4483 static int
4484 d_demangle_callback (const char *mangled, int options,
4485                      demangle_callbackref callback, void *opaque)
4486 {
4487   int type;
4488   struct d_info di;
4489   struct demangle_component *dc;
4490   int status;
4491
4492   if (mangled[0] == '_' && mangled[1] == 'Z')
4493     type = 0;
4494   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4495            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
4496            && (mangled[9] == 'D' || mangled[9] == 'I')
4497            && mangled[10] == '_')
4498     {
4499       const char *intro;
4500
4501       intro = (mangled[9] == 'I')
4502               ? "global constructors keyed to "
4503               : "global destructors keyed to ";
4504
4505       callback (intro, strlen (intro), opaque);
4506       callback (mangled + 11, strlen (mangled + 11), opaque);
4507       return 1;
4508     }
4509   else
4510     {
4511       if ((options & DMGL_TYPES) == 0)
4512         return 0;
4513       type = 1;
4514     }
4515
4516   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4517
4518   {
4519 #ifdef CP_DYNAMIC_ARRAYS
4520     __extension__ struct demangle_component comps[di.num_comps];
4521     __extension__ struct demangle_component *subs[di.num_subs];
4522
4523     di.comps = comps;
4524     di.subs = subs;
4525 #else
4526     di.comps = alloca (di.num_comps * sizeof (*di.comps));
4527     di.subs = alloca (di.num_subs * sizeof (*di.subs));
4528 #endif
4529
4530     if (type)
4531       dc = cplus_demangle_type (&di);
4532     else
4533       dc = cplus_demangle_mangled_name (&di, 1);
4534
4535     /* If DMGL_PARAMS is set, then if we didn't consume the entire
4536        mangled string, then we didn't successfully demangle it.  If
4537        DMGL_PARAMS is not set, we didn't look at the trailing
4538        parameters.  */
4539     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
4540       dc = NULL;
4541
4542 #ifdef CP_DEMANGLE_DEBUG
4543     d_dump (dc, 0);
4544 #endif
4545
4546     status = (dc != NULL)
4547              ? cplus_demangle_print_callback (options, dc, callback, opaque)
4548              : 0;
4549   }
4550
4551   return status;
4552 }
4553
4554 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
4555    name, return a buffer allocated with malloc holding the demangled
4556    name.  OPTIONS is the usual libiberty demangler options.  On
4557    success, this sets *PALC to the allocated size of the returned
4558    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
4559    a memory allocation failure, and returns NULL.  */
4560
4561 static char *
4562 d_demangle (const char *mangled, int options, size_t *palc)
4563 {
4564   struct d_growable_string dgs;
4565   int status;
4566
4567   d_growable_string_init (&dgs, 0);
4568
4569   status = d_demangle_callback (mangled, options,
4570                                 d_growable_string_callback_adapter, &dgs);
4571   if (status == 0)
4572     {
4573       free (dgs.buf);
4574       *palc = 0;
4575       return NULL;
4576     }
4577
4578   *palc = dgs.allocation_failure ? 1 : 0;
4579   return dgs.buf;
4580 }
4581
4582 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
4583
4584 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
4585
4586 /* ia64 ABI-mandated entry point in the C++ runtime library for
4587    performing demangling.  MANGLED_NAME is a NUL-terminated character
4588    string containing the name to be demangled.
4589
4590    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4591    *LENGTH bytes, into which the demangled name is stored.  If
4592    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4593    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4594    is placed in a region of memory allocated with malloc.
4595
4596    If LENGTH is non-NULL, the length of the buffer containing the
4597    demangled name, is placed in *LENGTH.
4598
4599    The return value is a pointer to the start of the NUL-terminated
4600    demangled name, or NULL if the demangling fails.  The caller is
4601    responsible for deallocating this memory using free.
4602
4603    *STATUS is set to one of the following values:
4604       0: The demangling operation succeeded.
4605      -1: A memory allocation failure occurred.
4606      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4607      -3: One of the arguments is invalid.
4608
4609    The demangling is performed using the C++ ABI mangling rules, with
4610    GNU extensions.  */
4611
4612 char *
4613 __cxa_demangle (const char *mangled_name, char *output_buffer,
4614                 size_t *length, int *status)
4615 {
4616   char *demangled;
4617   size_t alc;
4618
4619   if (mangled_name == NULL)
4620     {
4621       if (status != NULL)
4622         *status = -3;
4623       return NULL;
4624     }
4625
4626   if (output_buffer != NULL && length == NULL)
4627     {
4628       if (status != NULL)
4629         *status = -3;
4630       return NULL;
4631     }
4632
4633   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
4634
4635   if (demangled == NULL)
4636     {
4637       if (status != NULL)
4638         {
4639           if (alc == 1)
4640             *status = -1;
4641           else
4642             *status = -2;
4643         }
4644       return NULL;
4645     }
4646
4647   if (output_buffer == NULL)
4648     {
4649       if (length != NULL)
4650         *length = alc;
4651     }
4652   else
4653     {
4654       if (strlen (demangled) < *length)
4655         {
4656           strcpy (output_buffer, demangled);
4657           free (demangled);
4658           demangled = output_buffer;
4659         }
4660       else
4661         {
4662           free (output_buffer);
4663           *length = alc;
4664         }
4665     }
4666
4667   if (status != NULL)
4668     *status = 0;
4669
4670   return demangled;
4671 }
4672
4673 extern int __gcclibcxx_demangle_callback (const char *,
4674                                           void (*)
4675                                             (const char *, size_t, void *),
4676                                           void *);
4677
4678 /* Alternative, allocationless entry point in the C++ runtime library
4679    for performing demangling.  MANGLED_NAME is a NUL-terminated character
4680    string containing the name to be demangled.
4681
4682    CALLBACK is a callback function, called with demangled string
4683    segments as demangling progresses; it is called at least once,
4684    but may be called more than once.  OPAQUE is a generalized pointer
4685    used as a callback argument.
4686
4687    The return code is one of the following values, equivalent to
4688    the STATUS values of __cxa_demangle() (excluding -1, since this
4689    function performs no memory allocations):
4690       0: The demangling operation succeeded.
4691      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4692      -3: One of the arguments is invalid.
4693
4694    The demangling is performed using the C++ ABI mangling rules, with
4695    GNU extensions.  */
4696
4697 int
4698 __gcclibcxx_demangle_callback (const char *mangled_name,
4699                                void (*callback) (const char *, size_t, void *),
4700                                void *opaque)
4701 {
4702   int status;
4703
4704   if (mangled_name == NULL || callback == NULL)
4705     return -3;
4706
4707   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
4708                                 callback, opaque);
4709   if (status == 0)
4710     return -2;
4711
4712   return 0;
4713 }
4714
4715 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
4716
4717 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
4718    mangled name, return a buffer allocated with malloc holding the
4719    demangled name.  Otherwise, return NULL.  */
4720
4721 char *
4722 cplus_demangle_v3 (const char *mangled, int options)
4723 {
4724   size_t alc;
4725
4726   return d_demangle (mangled, options, &alc);
4727 }
4728
4729 int
4730 cplus_demangle_v3_callback (const char *mangled, int options,
4731                             demangle_callbackref callback, void *opaque)
4732 {
4733   return d_demangle_callback (mangled, options, callback, opaque);
4734 }
4735
4736 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
4737    conventions, but the output formatting is a little different.
4738    This instructs the C++ demangler not to emit pointer characters ("*"), to
4739    use Java's namespace separator symbol ("." instead of "::"), and to output
4740    JArray<TYPE> as TYPE[].  */
4741
4742 char *
4743 java_demangle_v3 (const char *mangled)
4744 {
4745   size_t alc;
4746
4747   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
4748 }
4749
4750 int
4751 java_demangle_v3_callback (const char *mangled,
4752                            demangle_callbackref callback, void *opaque)
4753 {
4754   return d_demangle_callback (mangled,
4755                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
4756                               callback, opaque);
4757 }
4758
4759 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4760
4761 #ifndef IN_GLIBCPP_V3
4762
4763 /* Demangle a string in order to find out whether it is a constructor
4764    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
4765    *DTOR_KIND appropriately.  */
4766
4767 static int
4768 is_ctor_or_dtor (const char *mangled,
4769                  enum gnu_v3_ctor_kinds *ctor_kind,
4770                  enum gnu_v3_dtor_kinds *dtor_kind)
4771 {
4772   struct d_info di;
4773   struct demangle_component *dc;
4774   int ret;
4775
4776   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
4777   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
4778
4779   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
4780
4781   {
4782 #ifdef CP_DYNAMIC_ARRAYS
4783     __extension__ struct demangle_component comps[di.num_comps];
4784     __extension__ struct demangle_component *subs[di.num_subs];
4785
4786     di.comps = comps;
4787     di.subs = subs;
4788 #else
4789     di.comps = alloca (di.num_comps * sizeof (*di.comps));
4790     di.subs = alloca (di.num_subs * sizeof (*di.subs));
4791 #endif
4792
4793     dc = cplus_demangle_mangled_name (&di, 1);
4794
4795     /* Note that because we did not pass DMGL_PARAMS, we don't expect
4796        to demangle the entire string.  */
4797
4798     ret = 0;
4799     while (dc != NULL)
4800       {
4801         switch (dc->type)
4802           {
4803           default:
4804             dc = NULL;
4805             break;
4806           case DEMANGLE_COMPONENT_TYPED_NAME:
4807           case DEMANGLE_COMPONENT_TEMPLATE:
4808           case DEMANGLE_COMPONENT_RESTRICT_THIS:
4809           case DEMANGLE_COMPONENT_VOLATILE_THIS:
4810           case DEMANGLE_COMPONENT_CONST_THIS:
4811             dc = d_left (dc);
4812             break;
4813           case DEMANGLE_COMPONENT_QUAL_NAME:
4814           case DEMANGLE_COMPONENT_LOCAL_NAME:
4815             dc = d_right (dc);
4816             break;
4817           case DEMANGLE_COMPONENT_CTOR:
4818             *ctor_kind = dc->u.s_ctor.kind;
4819             ret = 1;
4820             dc = NULL;
4821             break;
4822           case DEMANGLE_COMPONENT_DTOR:
4823             *dtor_kind = dc->u.s_dtor.kind;
4824             ret = 1;
4825             dc = NULL;
4826             break;
4827           }
4828       }
4829   }
4830
4831   return ret;
4832 }
4833
4834 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4835    name.  A non-zero return indicates the type of constructor.  */
4836
4837 enum gnu_v3_ctor_kinds
4838 is_gnu_v3_mangled_ctor (const char *name)
4839 {
4840   enum gnu_v3_ctor_kinds ctor_kind;
4841   enum gnu_v3_dtor_kinds dtor_kind;
4842
4843   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4844     return (enum gnu_v3_ctor_kinds) 0;
4845   return ctor_kind;
4846 }
4847
4848
4849 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4850    name.  A non-zero return indicates the type of destructor.  */
4851
4852 enum gnu_v3_dtor_kinds
4853 is_gnu_v3_mangled_dtor (const char *name)
4854 {
4855   enum gnu_v3_ctor_kinds ctor_kind;
4856   enum gnu_v3_dtor_kinds dtor_kind;
4857
4858   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4859     return (enum gnu_v3_dtor_kinds) 0;
4860   return dtor_kind;
4861 }
4862
4863 #endif /* IN_GLIBCPP_V3 */
4864
4865 #ifdef STANDALONE_DEMANGLER
4866
4867 #include "getopt.h"
4868 #include "dyn-string.h"
4869
4870 static void print_usage (FILE* fp, int exit_value);
4871
4872 #define IS_ALPHA(CHAR)                                                  \
4873   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
4874    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4875
4876 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
4877 #define is_mangled_char(CHAR)                                           \
4878   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
4879    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
4880
4881 /* The name of this program, as invoked.  */
4882 const char* program_name;
4883
4884 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
4885
4886 static void
4887 print_usage (FILE* fp, int exit_value)
4888 {
4889   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
4890   fprintf (fp, "Options:\n");
4891   fprintf (fp, "  -h,--help       Display this message.\n");
4892   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
4893   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
4894   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
4895
4896   exit (exit_value);
4897 }
4898
4899 /* Option specification for getopt_long.  */
4900 static const struct option long_options[] =
4901 {
4902   { "help",      no_argument, NULL, 'h' },
4903   { "no-params", no_argument, NULL, 'p' },
4904   { "verbose",   no_argument, NULL, 'v' },
4905   { NULL,        no_argument, NULL, 0   },
4906 };
4907
4908 /* Main entry for a demangling filter executable.  It will demangle
4909    its command line arguments, if any.  If none are provided, it will
4910    filter stdin to stdout, replacing any recognized mangled C++ names
4911    with their demangled equivalents.  */
4912
4913 int
4914 main (int argc, char *argv[])
4915 {
4916   int i;
4917   int opt_char;
4918   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
4919
4920   /* Use the program name of this program, as invoked.  */
4921   program_name = argv[0];
4922
4923   /* Parse options.  */
4924   do
4925     {
4926       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
4927       switch (opt_char)
4928         {
4929         case '?':  /* Unrecognized option.  */
4930           print_usage (stderr, 1);
4931           break;
4932
4933         case 'h':
4934           print_usage (stdout, 0);
4935           break;
4936
4937         case 'p':
4938           options &= ~ DMGL_PARAMS;
4939           break;
4940
4941         case 'v':
4942           options |= DMGL_VERBOSE;
4943           break;
4944         }
4945     }
4946   while (opt_char != -1);
4947
4948   if (optind == argc)
4949     /* No command line arguments were provided.  Filter stdin.  */
4950     {
4951       dyn_string_t mangled = dyn_string_new (3);
4952       char *s;
4953
4954       /* Read all of input.  */
4955       while (!feof (stdin))
4956         {
4957           char c;
4958
4959           /* Pile characters into mangled until we hit one that can't
4960              occur in a mangled name.  */
4961           c = getchar ();
4962           while (!feof (stdin) && is_mangled_char (c))
4963             {
4964               dyn_string_append_char (mangled, c);
4965               if (feof (stdin))
4966                 break;
4967               c = getchar ();
4968             }
4969
4970           if (dyn_string_length (mangled) > 0)
4971             {
4972 #ifdef IN_GLIBCPP_V3
4973               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
4974 #else
4975               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
4976 #endif
4977
4978               if (s != NULL)
4979                 {
4980                   fputs (s, stdout);
4981                   free (s);
4982                 }
4983               else
4984                 {
4985                   /* It might not have been a mangled name.  Print the
4986                      original text.  */
4987                   fputs (dyn_string_buf (mangled), stdout);
4988                 }
4989
4990               dyn_string_clear (mangled);
4991             }
4992
4993           /* If we haven't hit EOF yet, we've read one character that
4994              can't occur in a mangled name, so print it out.  */
4995           if (!feof (stdin))
4996             putchar (c);
4997         }
4998
4999       dyn_string_delete (mangled);
5000     }
5001   else
5002     /* Demangle command line arguments.  */
5003     {
5004       /* Loop over command line arguments.  */
5005       for (i = optind; i < argc; ++i)
5006         {
5007           char *s;
5008 #ifdef IN_GLIBCPP_V3
5009           int status;
5010 #endif
5011
5012           /* Attempt to demangle.  */
5013 #ifdef IN_GLIBCPP_V3
5014           s = __cxa_demangle (argv[i], NULL, NULL, &status);
5015 #else
5016           s = cplus_demangle_v3 (argv[i], options);
5017 #endif
5018
5019           /* If it worked, print the demangled name.  */
5020           if (s != NULL)
5021             {
5022               printf ("%s\n", s);
5023               free (s);
5024             }
5025           else
5026             {
5027 #ifdef IN_GLIBCPP_V3
5028               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5029 #else
5030               fprintf (stderr, "Failed: %s\n", argv[i]);
5031 #endif
5032             }
5033         }
5034     }
5035
5036   return 0;
5037 }
5038
5039 #endif /* STANDALONE_DEMANGLER */