contrib/gcc-4.4/libiberty/cp-demangle.c

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