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

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