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