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