contrib/binutils-2.20/libiberty/cp-demangle.c

   1 /* Demangler for g++ V3 ABI.
   2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
   3    Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor <ian@wasabisystems.com>.
   5
   6    This file is part of the libiberty library, which is part of GCC.
   7
   8    This file is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    In addition to the permissions in the GNU General Public License, the
  14    Free Software Foundation gives you unlimited permission to link the
  15    compiled version of this file into combinations with other programs,
  16    and to distribute those combinations without any restriction coming
  17    from the use of this file.  (The General Public License restrictions
  18    do apply in other respects; for example, they cover modification of
  19    the file, and distribution when not linked into a combined
  20    executable.)
  21
  22    This program is distributed in the hope that it will be useful,
  23    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25    GNU General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program; if not, write to the Free Software
  29    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  30 */
  31
  32 /* This code implements a demangler for the g++ V3 ABI.  The ABI is
  33    described on this web page:
  34        http://www.codesourcery.com/cxx-abi/abi.html#mangling
  35
  36    This code was written while looking at the demangler written by
  37    Alex Samuel <samuel@codesourcery.com>.
  38
  39    This code first pulls the mangled name apart into a list of
  40    components, and then walks the list generating the demangled
  41    name.
  42
  43    This file will normally define the following functions, q.v.:
  44       char *cplus_demangle_v3(const char *mangled, int options)
  45       char *java_demangle_v3(const char *mangled)
  46       int cplus_demangle_v3_callback(const char *mangled, int options,
  47                                      demangle_callbackref callback)
  48       int java_demangle_v3_callback(const char *mangled,
  49                                     demangle_callbackref callback)
  50       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
  51       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
  52
  53    Also, the interface to the component list is public, and defined in
  54    demangle.h.  The interface consists of these types, which are
  55    defined in demangle.h:
  56       enum demangle_component_type
  57       struct demangle_component
  58       demangle_callbackref
  59    and these functions defined in this file:
  60       cplus_demangle_fill_name
  61       cplus_demangle_fill_extended_operator
  62       cplus_demangle_fill_ctor
  63       cplus_demangle_fill_dtor
  64       cplus_demangle_print
  65       cplus_demangle_print_callback
  66    and other functions defined in the file cp-demint.c.
  67
  68    This file also defines some other functions and variables which are
  69    only to be used by the file cp-demint.c.
  70
  71    Preprocessor macros you can define while compiling this file:
  72
  73    IN_LIBGCC2
  74       If defined, this file defines the following functions, q.v.:
  75          char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
  76                                int *status)
  77          int __gcclibcxx_demangle_callback (const char *,
  78                                             void (*)
  79                                               (const char *, size_t, void *),
  80                                             void *)
  81       instead of cplus_demangle_v3[_callback]() and
  82       java_demangle_v3[_callback]().
  83
  84    IN_GLIBCPP_V3
  85       If defined, this file defines only __cxa_demangle() and
  86       __gcclibcxx_demangle_callback(), and no other publically visible
  87       functions or variables.
  88
  89    STANDALONE_DEMANGLER
  90       If defined, this file defines a main() function which demangles
  91       any arguments, or, if none, demangles stdin.
  92
  93    CP_DEMANGLE_DEBUG
  94       If defined, turns on debugging mode, which prints information on
  95       stdout about the mangled string.  This is not generally useful.
  96 */
  97
  98 #if defined (_AIX) && !defined (__GNUC__)
  99  #pragma alloca
 100 #endif
 101
 102 #ifdef HAVE_CONFIG_H
 103 #include "config.h"
 104 #endif
 105
 106 #include <stdio.h>
 107
 108 #ifdef HAVE_STDLIB_H
 109 #include <stdlib.h>
 110 #endif
 111 #ifdef HAVE_STRING_H
 112 #include <string.h>
 113 #endif
 114
 115 #ifdef HAVE_ALLOCA_H
 116 # include <alloca.h>
 117 #else
 118 # ifndef alloca
 119 #  ifdef __GNUC__
 120 #   define alloca __builtin_alloca
 121 #  else
 122 extern char *alloca ();
 123 #  endif /* __GNUC__ */
 124 # endif /* alloca */
 125 #endif /* HAVE_ALLOCA_H */
 126
 127 #include "ansidecl.h"
 128 #include "libiberty.h"
 129 #include "demangle.h"
 130 #include "cp-demangle.h"
 131
 132 /* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
 133    also rename them via #define to avoid compiler errors when the
 134    static definition conflicts with the extern declaration in a header
 135    file.  */
 136 #ifdef IN_GLIBCPP_V3
 137
 138 #define CP_STATIC_IF_GLIBCPP_V3 static
 139
 140 #define cplus_demangle_fill_name d_fill_name
 141 static int d_fill_name (struct demangle_component *, const char *, int);
 142
 143 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
 144 static int
 145 d_fill_extended_operator (struct demangle_component *, int,
 146                           struct demangle_component *);
 147
 148 #define cplus_demangle_fill_ctor d_fill_ctor
 149 static int
 150 d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
 151              struct demangle_component *);
 152
 153 #define cplus_demangle_fill_dtor d_fill_dtor
 154 static int
 155 d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
 156              struct demangle_component *);
 157
 158 #define cplus_demangle_mangled_name d_mangled_name
 159 static struct demangle_component *d_mangled_name (struct d_info *, int);
 160
 161 #define cplus_demangle_type d_type
 162 static struct demangle_component *d_type (struct d_info *);
 163
 164 #define cplus_demangle_print d_print
 165 static char *d_print (int, const struct demangle_component *, int, size_t *);
 166
 167 #define cplus_demangle_print_callback d_print_callback
 168 static int d_print_callback (int, const struct demangle_component *,
 169                              demangle_callbackref, void *);
 170
 171 #define cplus_demangle_init_info d_init_info
 172 static void d_init_info (const char *, int, size_t, struct d_info *);
 173
 174 #else /* ! defined(IN_GLIBCPP_V3) */
 175 #define CP_STATIC_IF_GLIBCPP_V3
 176 #endif /* ! defined(IN_GLIBCPP_V3) */
 177
 178 /* See if the compiler supports dynamic arrays.  */
 179
 180 #ifdef __GNUC__
 181 #define CP_DYNAMIC_ARRAYS
 182 #else
 183 #ifdef __STDC__
 184 #ifdef __STDC_VERSION__
 185 #if __STDC_VERSION__ >= 199901L
 186 #define CP_DYNAMIC_ARRAYS
 187 #endif /* __STDC__VERSION >= 199901L */
 188 #endif /* defined (__STDC_VERSION__) */
 189 #endif /* defined (__STDC__) */
 190 #endif /* ! defined (__GNUC__) */
 191
 192 /* We avoid pulling in the ctype tables, to prevent pulling in
 193    additional unresolved symbols when this code is used in a library.
 194    FIXME: Is this really a valid reason?  This comes from the original
 195    V3 demangler code.
 196
 197    As of this writing this file has the following undefined references
 198    when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
 199    strcat, strlen.  */
 200
 201 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
 202 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
 203 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
 204
 205 /* The prefix prepended by GCC to an identifier represnting the
 206    anonymous namespace.  */
 207 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
 208 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
 209   (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
 210
 211 /* Information we keep for the standard substitutions.  */
 212
 213 struct d_standard_sub_info
 214 {
 215   /* The code for this substitution.  */
 216   char code;
 217   /* The simple string it expands to.  */
 218   const char *simple_expansion;
 219   /* The length of the simple expansion.  */
 220   int simple_len;
 221   /* The results of a full, verbose, expansion.  This is used when
 222      qualifying a constructor/destructor, or when in verbose mode.  */
 223   const char *full_expansion;
 224   /* The length of the full expansion.  */
 225   int full_len;
 226   /* What to set the last_name field of d_info to; NULL if we should
 227      not set it.  This is only relevant when qualifying a
 228      constructor/destructor.  */
 229   const char *set_last_name;
 230   /* The length of set_last_name.  */
 231   int set_last_name_len;
 232 };
 233
 234 /* Accessors for subtrees of struct demangle_component.  */
 235
 236 #define d_left(dc) ((dc)->u.s_binary.left)
 237 #define d_right(dc) ((dc)->u.s_binary.right)
 238
 239 /* A list of templates.  This is used while printing.  */
 240
 241 struct d_print_template
 242 {
 243   /* Next template on the list.  */
 244   struct d_print_template *next;
 245   /* This template.  */
 246   const struct demangle_component *template_decl;
 247 };
 248
 249 /* A list of type modifiers.  This is used while printing.  */
 250
 251 struct d_print_mod
 252 {
 253   /* Next modifier on the list.  These are in the reverse of the order
 254      in which they appeared in the mangled string.  */
 255   struct d_print_mod *next;
 256   /* The modifier.  */
 257   const struct demangle_component *mod;
 258   /* Whether this modifier was printed.  */
 259   int printed;
 260   /* The list of templates which applies to this modifier.  */
 261   struct d_print_template *templates;
 262 };
 263
 264 /* We use these structures to hold information during printing.  */
 265
 266 struct d_growable_string
 267 {
 268   /* Buffer holding the result.  */
 269   char *buf;
 270   /* Current length of data in buffer.  */
 271   size_t len;
 272   /* Allocated size of buffer.  */
 273   size_t alc;
 274   /* Set to 1 if we had a memory allocation failure.  */
 275   int allocation_failure;
 276 };
 277
 278 enum { D_PRINT_BUFFER_LENGTH = 256 };
 279 struct d_print_info
 280 {
 281   /* The options passed to the demangler.  */
 282   int options;
 283   /* Fixed-length allocated buffer for demangled data, flushed to the
 284      callback with a NUL termination once full.  */
 285   char buf[D_PRINT_BUFFER_LENGTH];
 286   /* Current length of data in buffer.  */
 287   size_t len;
 288   /* The last character printed, saved individually so that it survives
 289      any buffer flush.  */
 290   char last_char;
 291   /* Callback function to handle demangled buffer flush.  */
 292   demangle_callbackref callback;
 293   /* Opaque callback argument.  */
 294   void *opaque;
 295   /* The current list of templates, if any.  */
 296   struct d_print_template *templates;
 297   /* The current list of modifiers (e.g., pointer, reference, etc.),
 298      if any.  */
 299   struct d_print_mod *modifiers;
 300   /* Set to 1 if we saw a demangling error.  */
 301   int demangle_failure;
 302   /* The current index into any template argument packs we are using
 303      for printing.  */
 304   int pack_index;
 305 };
 306
 307 #ifdef CP_DEMANGLE_DEBUG
 308 static void d_dump (struct demangle_component *, int);
 309 #endif
 310
 311 static struct demangle_component *
 312 d_make_empty (struct d_info *);
 313
 314 static struct demangle_component *
 315 d_make_comp (struct d_info *, enum demangle_component_type,
 316              struct demangle_component *,
 317              struct demangle_component *);
 318
 319 static struct demangle_component *
 320 d_make_name (struct d_info *, const char *, int);
 321
 322 static struct demangle_component *
 323 d_make_builtin_type (struct d_info *,
 324                      const struct demangle_builtin_type_info *);
 325
 326 static struct demangle_component *
 327 d_make_operator (struct d_info *,
 328                  const struct demangle_operator_info *);
 329
 330 static struct demangle_component *
 331 d_make_extended_operator (struct d_info *, int,
 332                           struct demangle_component *);
 333
 334 static struct demangle_component *
 335 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
 336              struct demangle_component *);
 337
 338 static struct demangle_component *
 339 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
 340              struct demangle_component *);
 341
 342 static struct demangle_component *
 343 d_make_template_param (struct d_info *, long);
 344
 345 static struct demangle_component *
 346 d_make_sub (struct d_info *, const char *, int);
 347
 348 static int
 349 has_return_type (struct demangle_component *);
 350
 351 static int
 352 is_ctor_dtor_or_conversion (struct demangle_component *);
 353
 354 static struct demangle_component *d_encoding (struct d_info *, int);
 355
 356 static struct demangle_component *d_name (struct d_info *);
 357
 358 static struct demangle_component *d_nested_name (struct d_info *);
 359
 360 static struct demangle_component *d_prefix (struct d_info *);
 361
 362 static struct demangle_component *d_unqualified_name (struct d_info *);
 363
 364 static struct demangle_component *d_source_name (struct d_info *);
 365
 366 static long d_number (struct d_info *);
 367
 368 static struct demangle_component *d_identifier (struct d_info *, int);
 369
 370 static struct demangle_component *d_operator_name (struct d_info *);
 371
 372 static struct demangle_component *d_special_name (struct d_info *);
 373
 374 static int d_call_offset (struct d_info *, int);
 375
 376 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
 377
 378 static struct demangle_component **
 379 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
 380
 381 static struct demangle_component *
 382 d_function_type (struct d_info *);
 383
 384 static struct demangle_component *
 385 d_bare_function_type (struct d_info *, int);
 386
 387 static struct demangle_component *
 388 d_class_enum_type (struct d_info *);
 389
 390 static struct demangle_component *d_array_type (struct d_info *);
 391
 392 static struct demangle_component *
 393 d_pointer_to_member_type (struct d_info *);
 394
 395 static struct demangle_component *
 396 d_template_param (struct d_info *);
 397
 398 static struct demangle_component *d_template_args (struct d_info *);
 399
 400 static struct demangle_component *
 401 d_template_arg (struct d_info *);
 402
 403 static struct demangle_component *d_expression (struct d_info *);
 404
 405 static struct demangle_component *d_expr_primary (struct d_info *);
 406
 407 static struct demangle_component *d_local_name (struct d_info *);
 408
 409 static int d_discriminator (struct d_info *);
 410
 411 static int
 412 d_add_substitution (struct d_info *, struct demangle_component *);
 413
 414 static struct demangle_component *d_substitution (struct d_info *, int);
 415
 416 static void d_growable_string_init (struct d_growable_string *, size_t);
 417
 418 static inline void
 419 d_growable_string_resize (struct d_growable_string *, size_t);
 420
 421 static inline void
 422 d_growable_string_append_buffer (struct d_growable_string *,
 423                                  const char *, size_t);
 424 static void
 425 d_growable_string_callback_adapter (const char *, size_t, void *);
 426
 427 static void
 428 d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
 429
 430 static inline void d_print_error (struct d_print_info *);
 431
 432 static inline int d_print_saw_error (struct d_print_info *);
 433
 434 static inline void d_print_flush (struct d_print_info *);
 435
 436 static inline void d_append_char (struct d_print_info *, char);
 437
 438 static inline void d_append_buffer (struct d_print_info *,
 439                                     const char *, size_t);
 440
 441 static inline void d_append_string (struct d_print_info *, const char *);
 442
 443 static inline char d_last_char (struct d_print_info *);
 444
 445 static void
 446 d_print_comp (struct d_print_info *, const struct demangle_component *);
 447
 448 static void
 449 d_print_java_identifier (struct d_print_info *, const char *, int);
 450
 451 static void
 452 d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
 453
 454 static void
 455 d_print_mod (struct d_print_info *, const struct demangle_component *);
 456
 457 static void
 458 d_print_function_type (struct d_print_info *,
 459                        const struct demangle_component *,
 460                        struct d_print_mod *);
 461
 462 static void
 463 d_print_array_type (struct d_print_info *,
 464                     const struct demangle_component *,
 465                     struct d_print_mod *);
 466
 467 static void
 468 d_print_expr_op (struct d_print_info *, const struct demangle_component *);
 469
 470 static void
 471 d_print_cast (struct d_print_info *, const struct demangle_component *);
 472
 473 static int d_demangle_callback (const char *, int,
 474                                 demangle_callbackref, void *);
 475 static char *d_demangle (const char *, int, size_t *);
 476
 477 #ifdef CP_DEMANGLE_DEBUG
 478
 479 static void
 480 d_dump (struct demangle_component *dc, int indent)
 481 {
 482   int i;
 483
 484   if (dc == NULL)
 485     {
 486       if (indent == 0)
 487         printf ("failed demangling\n");
 488       return;
 489     }
 490
 491   for (i = 0; i < indent; ++i)
 492     putchar (' ');
 493
 494   switch (dc->type)
 495     {
 496     case DEMANGLE_COMPONENT_NAME:
 497       printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
 498       return;
 499     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
 500       printf ("template parameter %ld\n", dc->u.s_number.number);
 501       return;
 502     case DEMANGLE_COMPONENT_CTOR:
 503       printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
 504       d_dump (dc->u.s_ctor.name, indent + 2);
 505       return;
 506     case DEMANGLE_COMPONENT_DTOR:
 507       printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
 508       d_dump (dc->u.s_dtor.name, indent + 2);
 509       return;
 510     case DEMANGLE_COMPONENT_SUB_STD:
 511       printf ("standard substitution %s\n", dc->u.s_string.string);
 512       return;
 513     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
 514       printf ("builtin type %s\n", dc->u.s_builtin.type->name);
 515       return;
 516     case DEMANGLE_COMPONENT_OPERATOR:
 517       printf ("operator %s\n", dc->u.s_operator.op->name);
 518       return;
 519     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 520       printf ("extended operator with %d args\n",
 521               dc->u.s_extended_operator.args);
 522       d_dump (dc->u.s_extended_operator.name, indent + 2);
 523       return;
 524
 525     case DEMANGLE_COMPONENT_QUAL_NAME:
 526       printf ("qualified name\n");
 527       break;
 528     case DEMANGLE_COMPONENT_LOCAL_NAME:
 529       printf ("local name\n");
 530       break;
 531     case DEMANGLE_COMPONENT_TYPED_NAME:
 532       printf ("typed name\n");
 533       break;
 534     case DEMANGLE_COMPONENT_TEMPLATE:
 535       printf ("template\n");
 536       break;
 537     case DEMANGLE_COMPONENT_VTABLE:
 538       printf ("vtable\n");
 539       break;
 540     case DEMANGLE_COMPONENT_VTT:
 541       printf ("VTT\n");
 542       break;
 543     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 544       printf ("construction vtable\n");
 545       break;
 546     case DEMANGLE_COMPONENT_TYPEINFO:
 547       printf ("typeinfo\n");
 548       break;
 549     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 550       printf ("typeinfo name\n");
 551       break;
 552     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 553       printf ("typeinfo function\n");
 554       break;
 555     case DEMANGLE_COMPONENT_THUNK:
 556       printf ("thunk\n");
 557       break;
 558     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 559       printf ("virtual thunk\n");
 560       break;
 561     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 562       printf ("covariant thunk\n");
 563       break;
 564     case DEMANGLE_COMPONENT_JAVA_CLASS:
 565       printf ("java class\n");
 566       break;
 567     case DEMANGLE_COMPONENT_GUARD:
 568       printf ("guard\n");
 569       break;
 570     case DEMANGLE_COMPONENT_REFTEMP:
 571       printf ("reference temporary\n");
 572       break;
 573     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 574       printf ("hidden alias\n");
 575       break;
 576     case DEMANGLE_COMPONENT_RESTRICT:
 577       printf ("restrict\n");
 578       break;
 579     case DEMANGLE_COMPONENT_VOLATILE:
 580       printf ("volatile\n");
 581       break;
 582     case DEMANGLE_COMPONENT_CONST:
 583       printf ("const\n");
 584       break;
 585     case DEMANGLE_COMPONENT_RESTRICT_THIS:
 586       printf ("restrict this\n");
 587       break;
 588     case DEMANGLE_COMPONENT_VOLATILE_THIS:
 589       printf ("volatile this\n");
 590       break;
 591     case DEMANGLE_COMPONENT_CONST_THIS:
 592       printf ("const this\n");
 593       break;
 594     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 595       printf ("vendor type qualifier\n");
 596       break;
 597     case DEMANGLE_COMPONENT_POINTER:
 598       printf ("pointer\n");
 599       break;
 600     case DEMANGLE_COMPONENT_REFERENCE:
 601       printf ("reference\n");
 602       break;
 603     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 604       printf ("rvalue reference\n");
 605       break;
 606     case DEMANGLE_COMPONENT_COMPLEX:
 607       printf ("complex\n");
 608       break;
 609     case DEMANGLE_COMPONENT_IMAGINARY:
 610       printf ("imaginary\n");
 611       break;
 612     case DEMANGLE_COMPONENT_VENDOR_TYPE:
 613       printf ("vendor type\n");
 614       break;
 615     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 616       printf ("function type\n");
 617       break;
 618     case DEMANGLE_COMPONENT_ARRAY_TYPE:
 619       printf ("array type\n");
 620       break;
 621     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 622       printf ("pointer to member type\n");
 623       break;
 624     case DEMANGLE_COMPONENT_FIXED_TYPE:
 625       printf ("fixed-point type\n");
 626       break;
 627     case DEMANGLE_COMPONENT_ARGLIST:
 628       printf ("argument list\n");
 629       break;
 630     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 631       printf ("template argument list\n");
 632       break;
 633     case DEMANGLE_COMPONENT_CAST:
 634       printf ("cast\n");
 635       break;
 636     case DEMANGLE_COMPONENT_UNARY:
 637       printf ("unary operator\n");
 638       break;
 639     case DEMANGLE_COMPONENT_BINARY:
 640       printf ("binary operator\n");
 641       break;
 642     case DEMANGLE_COMPONENT_BINARY_ARGS:
 643       printf ("binary operator arguments\n");
 644       break;
 645     case DEMANGLE_COMPONENT_TRINARY:
 646       printf ("trinary operator\n");
 647       break;
 648     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 649       printf ("trinary operator arguments 1\n");
 650       break;
 651     case DEMANGLE_COMPONENT_TRINARY_ARG2:
 652       printf ("trinary operator arguments 1\n");
 653       break;
 654     case DEMANGLE_COMPONENT_LITERAL:
 655       printf ("literal\n");
 656       break;
 657     case DEMANGLE_COMPONENT_LITERAL_NEG:
 658       printf ("negative literal\n");
 659       break;
 660     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 661       printf ("java resource\n");
 662       break;
 663     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 664       printf ("compound name\n");
 665       break;
 666     case DEMANGLE_COMPONENT_CHARACTER:
 667       printf ("character '%c'\n",  dc->u.s_character.character);
 668       return;
 669     case DEMANGLE_COMPONENT_DECLTYPE:
 670       printf ("decltype\n");
 671       break;
 672     case DEMANGLE_COMPONENT_PACK_EXPANSION:
 673       printf ("pack expansion\n");
 674       break;
 675     }
 676
 677   d_dump (d_left (dc), indent + 2);
 678   d_dump (d_right (dc), indent + 2);
 679 }
 680
 681 #endif /* CP_DEMANGLE_DEBUG */
 682
 683 /* Fill in a DEMANGLE_COMPONENT_NAME.  */
 684
 685 CP_STATIC_IF_GLIBCPP_V3
 686 int
 687 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
 688 {
 689   if (p == NULL || s == NULL || len == 0)
 690     return 0;
 691   p->type = DEMANGLE_COMPONENT_NAME;
 692   p->u.s_name.s = s;
 693   p->u.s_name.len = len;
 694   return 1;
 695 }
 696
 697 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
 698
 699 CP_STATIC_IF_GLIBCPP_V3
 700 int
 701 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
 702                                        struct demangle_component *name)
 703 {
 704   if (p == NULL || args < 0 || name == NULL)
 705     return 0;
 706   p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
 707   p->u.s_extended_operator.args = args;
 708   p->u.s_extended_operator.name = name;
 709   return 1;
 710 }
 711
 712 /* Fill in a DEMANGLE_COMPONENT_CTOR.  */
 713
 714 CP_STATIC_IF_GLIBCPP_V3
 715 int
 716 cplus_demangle_fill_ctor (struct demangle_component *p,
 717                           enum gnu_v3_ctor_kinds kind,
 718                           struct demangle_component *name)
 719 {
 720   if (p == NULL
 721       || name == NULL
 722       || (int) kind < gnu_v3_complete_object_ctor
 723       || (int) kind > gnu_v3_complete_object_allocating_ctor)
 724     return 0;
 725   p->type = DEMANGLE_COMPONENT_CTOR;
 726   p->u.s_ctor.kind = kind;
 727   p->u.s_ctor.name = name;
 728   return 1;
 729 }
 730
 731 /* Fill in a DEMANGLE_COMPONENT_DTOR.  */
 732
 733 CP_STATIC_IF_GLIBCPP_V3
 734 int
 735 cplus_demangle_fill_dtor (struct demangle_component *p,
 736                           enum gnu_v3_dtor_kinds kind,
 737                           struct demangle_component *name)
 738 {
 739   if (p == NULL
 740       || name == NULL
 741       || (int) kind < gnu_v3_deleting_dtor
 742       || (int) kind > gnu_v3_base_object_dtor)
 743     return 0;
 744   p->type = DEMANGLE_COMPONENT_DTOR;
 745   p->u.s_dtor.kind = kind;
 746   p->u.s_dtor.name = name;
 747   return 1;
 748 }
 749
 750 /* Add a new component.  */
 751
 752 static struct demangle_component *
 753 d_make_empty (struct d_info *di)
 754 {
 755   struct demangle_component *p;
 756
 757   if (di->next_comp >= di->num_comps)
 758     return NULL;
 759   p = &di->comps[di->next_comp];
 760   ++di->next_comp;
 761   return p;
 762 }
 763
 764 /* Add a new generic component.  */
 765
 766 static struct demangle_component *
 767 d_make_comp (struct d_info *di, enum demangle_component_type type,
 768              struct demangle_component *left,
 769              struct demangle_component *right)
 770 {
 771   struct demangle_component *p;
 772
 773   /* We check for errors here.  A typical error would be a NULL return
 774      from a subroutine.  We catch those here, and return NULL
 775      upward.  */
 776   switch (type)
 777     {
 778       /* These types require two parameters.  */
 779     case DEMANGLE_COMPONENT_QUAL_NAME:
 780     case DEMANGLE_COMPONENT_LOCAL_NAME:
 781     case DEMANGLE_COMPONENT_TYPED_NAME:
 782     case DEMANGLE_COMPONENT_TEMPLATE:
 783     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 784     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 785     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 786     case DEMANGLE_COMPONENT_UNARY:
 787     case DEMANGLE_COMPONENT_BINARY:
 788     case DEMANGLE_COMPONENT_BINARY_ARGS:
 789     case DEMANGLE_COMPONENT_TRINARY:
 790     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 791     case DEMANGLE_COMPONENT_TRINARY_ARG2:
 792     case DEMANGLE_COMPONENT_LITERAL:
 793     case DEMANGLE_COMPONENT_LITERAL_NEG:
 794     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 795       if (left == NULL || right == NULL)
 796         return NULL;
 797       break;
 798
 799       /* These types only require one parameter.  */
 800     case DEMANGLE_COMPONENT_VTABLE:
 801     case DEMANGLE_COMPONENT_VTT:
 802     case DEMANGLE_COMPONENT_TYPEINFO:
 803     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 804     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 805     case DEMANGLE_COMPONENT_THUNK:
 806     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 807     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 808     case DEMANGLE_COMPONENT_JAVA_CLASS:
 809     case DEMANGLE_COMPONENT_GUARD:
 810     case DEMANGLE_COMPONENT_REFTEMP:
 811     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 812     case DEMANGLE_COMPONENT_POINTER:
 813     case DEMANGLE_COMPONENT_REFERENCE:
 814     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 815     case DEMANGLE_COMPONENT_COMPLEX:
 816     case DEMANGLE_COMPONENT_IMAGINARY:
 817     case DEMANGLE_COMPONENT_VENDOR_TYPE:
 818     case DEMANGLE_COMPONENT_CAST:
 819     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 820     case DEMANGLE_COMPONENT_DECLTYPE:
 821     case DEMANGLE_COMPONENT_PACK_EXPANSION:
 822     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
 823     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
 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           d_number (di);
2155           peek = d_next_char (di);
2156           ret->u.s_fixed.sat = (peek == 's');
2157           break;
2158
2159         default:
2160           return NULL;
2161         }
2162       break;
2163
2164     default:
2165       return NULL;
2166     }
2167
2168   if (can_subst)
2169     {
2170       if (! d_add_substitution (di, ret))
2171         return NULL;
2172     }
2173
2174   return ret;
2175 }
2176
2177 /* <CV-qualifiers> ::= [r] [V] [K]  */
2178
2179 static struct demangle_component **
2180 d_cv_qualifiers (struct d_info *di,
2181                  struct demangle_component **pret, int member_fn)
2182 {
2183   char peek;
2184
2185   peek = d_peek_char (di);
2186   while (peek == 'r' || peek == 'V' || peek == 'K')
2187     {
2188       enum demangle_component_type t;
2189
2190       d_advance (di, 1);
2191       if (peek == 'r')
2192         {
2193           t = (member_fn
2194                ? DEMANGLE_COMPONENT_RESTRICT_THIS
2195                : DEMANGLE_COMPONENT_RESTRICT);
2196           di->expansion += sizeof "restrict";
2197         }
2198       else if (peek == 'V')
2199         {
2200           t = (member_fn
2201                ? DEMANGLE_COMPONENT_VOLATILE_THIS
2202                : DEMANGLE_COMPONENT_VOLATILE);
2203           di->expansion += sizeof "volatile";
2204         }
2205       else
2206         {
2207           t = (member_fn
2208                ? DEMANGLE_COMPONENT_CONST_THIS
2209                : DEMANGLE_COMPONENT_CONST);
2210           di->expansion += sizeof "const";
2211         }
2212
2213       *pret = d_make_comp (di, t, NULL, NULL);
2214       if (*pret == NULL)
2215         return NULL;
2216       pret = &d_left (*pret);
2217
2218       peek = d_peek_char (di);
2219     }
2220
2221   return pret;
2222 }
2223
2224 /* <function-type> ::= F [Y] <bare-function-type> E  */
2225
2226 static struct demangle_component *
2227 d_function_type (struct d_info *di)
2228 {
2229   struct demangle_component *ret;
2230
2231   if (! d_check_char (di, 'F'))
2232     return NULL;
2233   if (d_peek_char (di) == 'Y')
2234     {
2235       /* Function has C linkage.  We don't print this information.
2236          FIXME: We should print it in verbose mode.  */
2237       d_advance (di, 1);
2238     }
2239   ret = d_bare_function_type (di, 1);
2240   if (! d_check_char (di, 'E'))
2241     return NULL;
2242   return ret;
2243 }
2244
2245 /* <bare-function-type> ::= [J]<type>+  */
2246
2247 static struct demangle_component *
2248 d_bare_function_type (struct d_info *di, int has_return_type)
2249 {
2250   struct demangle_component *return_type;
2251   struct demangle_component *tl;
2252   struct demangle_component **ptl;
2253   char peek;
2254
2255   /* Detect special qualifier indicating that the first argument
2256      is the return type.  */
2257   peek = d_peek_char (di);
2258   if (peek == 'J')
2259     {
2260       d_advance (di, 1);
2261       has_return_type = 1;
2262     }
2263
2264   return_type = NULL;
2265   tl = NULL;
2266   ptl = &tl;
2267   while (1)
2268     {
2269       struct demangle_component *type;
2270
2271       peek = d_peek_char (di);
2272       if (peek == '\0' || peek == 'E')
2273         break;
2274       type = cplus_demangle_type (di);
2275       if (type == NULL)
2276         return NULL;
2277       if (has_return_type)
2278         {
2279           return_type = type;
2280           has_return_type = 0;
2281         }
2282       else
2283         {
2284           *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2285           if (*ptl == NULL)
2286             return NULL;
2287           ptl = &d_right (*ptl);
2288         }
2289     }
2290
2291   /* There should be at least one parameter type besides the optional
2292      return type.  A function which takes no arguments will have a
2293      single parameter type void.  */
2294   if (tl == NULL)
2295     return NULL;
2296
2297   /* If we have a single parameter type void, omit it.  */
2298   if (d_right (tl) == NULL
2299       && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2300       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2301     {
2302       di->expansion -= d_left (tl)->u.s_builtin.type->len;
2303       tl = NULL;
2304     }
2305
2306   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
2307 }
2308
2309 /* <class-enum-type> ::= <name>  */
2310
2311 static struct demangle_component *
2312 d_class_enum_type (struct d_info *di)
2313 {
2314   return d_name (di);
2315 }
2316
2317 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2318                 ::= A [<(dimension) expression>] _ <(element) type>
2319 */
2320
2321 static struct demangle_component *
2322 d_array_type (struct d_info *di)
2323 {
2324   char peek;
2325   struct demangle_component *dim;
2326
2327   if (! d_check_char (di, 'A'))
2328     return NULL;
2329
2330   peek = d_peek_char (di);
2331   if (peek == '_')
2332     dim = NULL;
2333   else if (IS_DIGIT (peek))
2334     {
2335       const char *s;
2336
2337       s = d_str (di);
2338       do
2339         {
2340           d_advance (di, 1);
2341           peek = d_peek_char (di);
2342         }
2343       while (IS_DIGIT (peek));
2344       dim = d_make_name (di, s, d_str (di) - s);
2345       if (dim == NULL)
2346         return NULL;
2347     }
2348   else
2349     {
2350       dim = d_expression (di);
2351       if (dim == NULL)
2352         return NULL;
2353     }
2354
2355   if (! d_check_char (di, '_'))
2356     return NULL;
2357
2358   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2359                       cplus_demangle_type (di));
2360 }
2361
2362 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
2363
2364 static struct demangle_component *
2365 d_pointer_to_member_type (struct d_info *di)
2366 {
2367   struct demangle_component *cl;
2368   struct demangle_component *mem;
2369   struct demangle_component **pmem;
2370
2371   if (! d_check_char (di, 'M'))
2372     return NULL;
2373
2374   cl = cplus_demangle_type (di);
2375
2376   /* The ABI specifies that any type can be a substitution source, and
2377      that M is followed by two types, and that when a CV-qualified
2378      type is seen both the base type and the CV-qualified types are
2379      substitution sources.  The ABI also specifies that for a pointer
2380      to a CV-qualified member function, the qualifiers are attached to
2381      the second type.  Given the grammar, a plain reading of the ABI
2382      suggests that both the CV-qualified member function and the
2383      non-qualified member function are substitution sources.  However,
2384      g++ does not work that way.  g++ treats only the CV-qualified
2385      member function as a substitution source.  FIXME.  So to work
2386      with g++, we need to pull off the CV-qualifiers here, in order to
2387      avoid calling add_substitution() in cplus_demangle_type().  But
2388      for a CV-qualified member which is not a function, g++ does
2389      follow the ABI, so we need to handle that case here by calling
2390      d_add_substitution ourselves.  */
2391
2392   pmem = d_cv_qualifiers (di, &mem, 1);
2393   if (pmem == NULL)
2394     return NULL;
2395   *pmem = cplus_demangle_type (di);
2396   if (*pmem == NULL)
2397     return NULL;
2398
2399   if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
2400     {
2401       if (! d_add_substitution (di, mem))
2402         return NULL;
2403     }
2404
2405   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2406 }
2407
2408 /* <template-param> ::= T_
2409                     ::= T <(parameter-2 non-negative) number> _
2410 */
2411
2412 static struct demangle_component *
2413 d_template_param (struct d_info *di)
2414 {
2415   long param;
2416
2417   if (! d_check_char (di, 'T'))
2418     return NULL;
2419
2420   if (d_peek_char (di) == '_')
2421     param = 0;
2422   else
2423     {
2424       param = d_number (di);
2425       if (param < 0)
2426         return NULL;
2427       param += 1;
2428     }
2429
2430   if (! d_check_char (di, '_'))
2431     return NULL;
2432
2433   ++di->did_subs;
2434
2435   return d_make_template_param (di, param);
2436 }
2437
2438 /* <template-args> ::= I <template-arg>+ E  */
2439
2440 static struct demangle_component *
2441 d_template_args (struct d_info *di)
2442 {
2443   struct demangle_component *hold_last_name;
2444   struct demangle_component *al;
2445   struct demangle_component **pal;
2446
2447   /* Preserve the last name we saw--don't let the template arguments
2448      clobber it, as that would give us the wrong name for a subsequent
2449      constructor or destructor.  */
2450   hold_last_name = di->last_name;
2451
2452   if (! d_check_char (di, 'I'))
2453     return NULL;
2454
2455   if (d_peek_char (di) == 'E')
2456     {
2457       /* An argument pack can be empty.  */
2458       d_advance (di, 1);
2459       return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2460     }
2461
2462   al = NULL;
2463   pal = &al;
2464   while (1)
2465     {
2466       struct demangle_component *a;
2467
2468       a = d_template_arg (di);
2469       if (a == NULL)
2470         return NULL;
2471
2472       *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2473       if (*pal == NULL)
2474         return NULL;
2475       pal = &d_right (*pal);
2476
2477       if (d_peek_char (di) == 'E')
2478         {
2479           d_advance (di, 1);
2480           break;
2481         }
2482     }
2483
2484   di->last_name = hold_last_name;
2485
2486   return al;
2487 }
2488
2489 /* <template-arg> ::= <type>
2490                   ::= X <expression> E
2491                   ::= <expr-primary>
2492 */
2493
2494 static struct demangle_component *
2495 d_template_arg (struct d_info *di)
2496 {
2497   struct demangle_component *ret;
2498
2499   switch (d_peek_char (di))
2500     {
2501     case 'X':
2502       d_advance (di, 1);
2503       ret = d_expression (di);
2504       if (! d_check_char (di, 'E'))
2505         return NULL;
2506       return ret;
2507
2508     case 'L':
2509       return d_expr_primary (di);
2510
2511     case 'I':
2512       /* An argument pack.  */
2513       return d_template_args (di);
2514
2515     default:
2516       return cplus_demangle_type (di);
2517     }
2518 }
2519
2520 /* Subroutine of <expression> ::= cl <expression>+ E */
2521
2522 static struct demangle_component *
2523 d_exprlist (struct d_info *di)
2524 {
2525   struct demangle_component *list = NULL;
2526   struct demangle_component **p = &list;
2527
2528   if (d_peek_char (di) == 'E')
2529     {
2530       d_advance (di, 1);
2531       return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
2532     }
2533
2534   while (1)
2535     {
2536       struct demangle_component *arg = d_expression (di);
2537       if (arg == NULL)
2538         return NULL;
2539
2540       *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
2541       if (*p == NULL)
2542         return NULL;
2543       p = &d_right (*p);
2544
2545       if (d_peek_char (di) == 'E')
2546         {
2547           d_advance (di, 1);
2548           break;
2549         }
2550     }
2551
2552   return list;
2553 }
2554
2555 /* <expression> ::= <(unary) operator-name> <expression>
2556                 ::= <(binary) operator-name> <expression> <expression>
2557                 ::= <(trinary) operator-name> <expression> <expression> <expression>
2558                 ::= cl <expression>+ E
2559                 ::= st <type>
2560                 ::= <template-param>
2561                 ::= sr <type> <unqualified-name>
2562                 ::= sr <type> <unqualified-name> <template-args>
2563                 ::= <expr-primary>
2564 */
2565
2566 static struct demangle_component *
2567 d_expression (struct d_info *di)
2568 {
2569   char peek;
2570
2571   peek = d_peek_char (di);
2572   if (peek == 'L')
2573     return d_expr_primary (di);
2574   else if (peek == 'T')
2575     return d_template_param (di);
2576   else if (peek == 's' && d_peek_next_char (di) == 'r')
2577     {
2578       struct demangle_component *type;
2579       struct demangle_component *name;
2580
2581       d_advance (di, 2);
2582       type = cplus_demangle_type (di);
2583       name = d_unqualified_name (di);
2584       if (d_peek_char (di) != 'I')
2585         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2586       else
2587         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2588                             d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2589                                          d_template_args (di)));
2590     }
2591   else if (peek == 's' && d_peek_next_char (di) == 'p')
2592     {
2593       d_advance (di, 2);
2594       return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2595                           d_expression (di), NULL);
2596     }
2597   else if (peek == 'f' && d_peek_next_char (di) == 'p')
2598     {
2599       /* Function parameter used in a late-specified return type.  */
2600       int index;
2601       d_advance (di, 2);
2602       if (d_peek_char (di) == '_')
2603         index = 1;
2604       else
2605         {
2606           index = d_number (di);
2607           if (index < 0)
2608             return NULL;
2609           index += 2;
2610         }
2611
2612       if (! d_check_char (di, '_'))
2613         return NULL;
2614
2615       return d_make_function_param (di, index);
2616     }
2617   else if (IS_DIGIT (peek))
2618     {
2619       /* We can get an unqualified name as an expression in the case of
2620          a dependent member access, i.e. decltype(T().i).  */
2621       struct demangle_component *name = d_unqualified_name (di);
2622       if (name == NULL)
2623         return NULL;
2624       if (d_peek_char (di) == 'I')
2625         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2626                             d_template_args (di));
2627       else
2628         return name;
2629     }
2630   else
2631     {
2632       struct demangle_component *op;
2633       int args;
2634
2635       op = d_operator_name (di);
2636       if (op == NULL)
2637         return NULL;
2638
2639       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2640         di->expansion += op->u.s_operator.op->len - 2;
2641
2642       if (op->type == DEMANGLE_COMPONENT_OPERATOR
2643           && strcmp (op->u.s_operator.op->code, "st") == 0)
2644         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2645                             cplus_demangle_type (di));
2646
2647       switch (op->type)
2648         {
2649         default:
2650           return NULL;
2651         case DEMANGLE_COMPONENT_OPERATOR:
2652           args = op->u.s_operator.op->args;
2653           break;
2654         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2655           args = op->u.s_extended_operator.args;
2656           break;
2657         case DEMANGLE_COMPONENT_CAST:
2658           args = 1;
2659           break;
2660         }
2661
2662       switch (args)
2663         {
2664         case 1:
2665           {
2666             struct demangle_component *operand;
2667             if (op->type == DEMANGLE_COMPONENT_CAST
2668                 && d_check_char (di, '_'))
2669               operand = d_exprlist (di);
2670             else
2671               operand = d_expression (di);
2672             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2673                                 operand);
2674           }
2675         case 2:
2676           {
2677             struct demangle_component *left;
2678             struct demangle_component *right;
2679
2680             left = d_expression (di);
2681             if (!strcmp (op->u.s_operator.op->code, "cl"))
2682               right = d_exprlist (di);
2683             else
2684               right = d_expression (di);
2685
2686             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2687                                 d_make_comp (di,
2688                                              DEMANGLE_COMPONENT_BINARY_ARGS,
2689                                              left, right));
2690           }
2691         case 3:
2692           {
2693             struct demangle_component *first;
2694             struct demangle_component *second;
2695
2696             first = d_expression (di);
2697             second = d_expression (di);
2698             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2699                                 d_make_comp (di,
2700                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
2701                                              first,
2702                                              d_make_comp (di,
2703                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
2704                                                           second,
2705                                                           d_expression (di))));
2706           }
2707         default:
2708           return NULL;
2709         }
2710     }
2711 }
2712
2713 /* <expr-primary> ::= L <type> <(value) number> E
2714                   ::= L <type> <(value) float> E
2715                   ::= L <mangled-name> E
2716 */
2717
2718 static struct demangle_component *
2719 d_expr_primary (struct d_info *di)
2720 {
2721   struct demangle_component *ret;
2722
2723   if (! d_check_char (di, 'L'))
2724     return NULL;
2725   if (d_peek_char (di) == '_'
2726       /* Workaround for G++ bug; see comment in write_template_arg.  */
2727       || d_peek_char (di) == 'Z')
2728     ret = cplus_demangle_mangled_name (di, 0);
2729   else
2730     {
2731       struct demangle_component *type;
2732       enum demangle_component_type t;
2733       const char *s;
2734
2735       type = cplus_demangle_type (di);
2736       if (type == NULL)
2737         return NULL;
2738
2739       /* If we have a type we know how to print, we aren't going to
2740          print the type name itself.  */
2741       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2742           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2743         di->expansion -= type->u.s_builtin.type->len;
2744
2745       /* Rather than try to interpret the literal value, we just
2746          collect it as a string.  Note that it's possible to have a
2747          floating point literal here.  The ABI specifies that the
2748          format of such literals is machine independent.  That's fine,
2749          but what's not fine is that versions of g++ up to 3.2 with
2750          -fabi-version=1 used upper case letters in the hex constant,
2751          and dumped out gcc's internal representation.  That makes it
2752          hard to tell where the constant ends, and hard to dump the
2753          constant in any readable form anyhow.  We don't attempt to
2754          handle these cases.  */
2755
2756       t = DEMANGLE_COMPONENT_LITERAL;
2757       if (d_peek_char (di) == 'n')
2758         {
2759           t = DEMANGLE_COMPONENT_LITERAL_NEG;
2760           d_advance (di, 1);
2761         }
2762       s = d_str (di);
2763       while (d_peek_char (di) != 'E')
2764         {
2765           if (d_peek_char (di) == '\0')
2766             return NULL;
2767           d_advance (di, 1);
2768         }
2769       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2770     }
2771   if (! d_check_char (di, 'E'))
2772     return NULL;
2773   return ret;
2774 }
2775
2776 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2777                 ::= Z <(function) encoding> E s [<discriminator>]
2778 */
2779
2780 static struct demangle_component *
2781 d_local_name (struct d_info *di)
2782 {
2783   struct demangle_component *function;
2784
2785   if (! d_check_char (di, 'Z'))
2786     return NULL;
2787
2788   function = d_encoding (di, 0);
2789
2790   if (! d_check_char (di, 'E'))
2791     return NULL;
2792
2793   if (d_peek_char (di) == 's')
2794     {
2795       d_advance (di, 1);
2796       if (! d_discriminator (di))
2797         return NULL;
2798       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2799                           d_make_name (di, "string literal",
2800                                        sizeof "string literal" - 1));
2801     }
2802   else
2803     {
2804       struct demangle_component *name;
2805
2806       name = d_name (di);
2807       if (! d_discriminator (di))
2808         return NULL;
2809       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2810     }
2811 }
2812
2813 /* <discriminator> ::= _ <(non-negative) number>
2814
2815    We demangle the discriminator, but we don't print it out.  FIXME:
2816    We should print it out in verbose mode.  */
2817
2818 static int
2819 d_discriminator (struct d_info *di)
2820 {
2821   long discrim;
2822
2823   if (d_peek_char (di) != '_')
2824     return 1;
2825   d_advance (di, 1);
2826   discrim = d_number (di);
2827   if (discrim < 0)
2828     return 0;
2829   return 1;
2830 }
2831
2832 /* Add a new substitution.  */
2833
2834 static int
2835 d_add_substitution (struct d_info *di, struct demangle_component *dc)
2836 {
2837   if (dc == NULL)
2838     return 0;
2839   if (di->next_sub >= di->num_subs)
2840     return 0;
2841   di->subs[di->next_sub] = dc;
2842   ++di->next_sub;
2843   return 1;
2844 }
2845
2846 /* <substitution> ::= S <seq-id> _
2847                   ::= S_
2848                   ::= St
2849                   ::= Sa
2850                   ::= Sb
2851                   ::= Ss
2852                   ::= Si
2853                   ::= So
2854                   ::= Sd
2855
2856    If PREFIX is non-zero, then this type is being used as a prefix in
2857    a qualified name.  In this case, for the standard substitutions, we
2858    need to check whether we are being used as a prefix for a
2859    constructor or destructor, and return a full template name.
2860    Otherwise we will get something like std::iostream::~iostream()
2861    which does not correspond particularly well to any function which
2862    actually appears in the source.
2863 */
2864
2865 static const struct d_standard_sub_info standard_subs[] =
2866 {
2867   { 't', NL ("std"),
2868     NL ("std"),
2869     NULL, 0 },
2870   { 'a', NL ("std::allocator"),
2871     NL ("std::allocator"),
2872     NL ("allocator") },
2873   { 'b', NL ("std::basic_string"),
2874     NL ("std::basic_string"),
2875     NL ("basic_string") },
2876   { 's', NL ("std::string"),
2877     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
2878     NL ("basic_string") },
2879   { 'i', NL ("std::istream"),
2880     NL ("std::basic_istream<char, std::char_traits<char> >"),
2881     NL ("basic_istream") },
2882   { 'o', NL ("std::ostream"),
2883     NL ("std::basic_ostream<char, std::char_traits<char> >"),
2884     NL ("basic_ostream") },
2885   { 'd', NL ("std::iostream"),
2886     NL ("std::basic_iostream<char, std::char_traits<char> >"),
2887     NL ("basic_iostream") }
2888 };
2889
2890 static struct demangle_component *
2891 d_substitution (struct d_info *di, int prefix)
2892 {
2893   char c;
2894
2895   if (! d_check_char (di, 'S'))
2896     return NULL;
2897
2898   c = d_next_char (di);
2899   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
2900     {
2901       unsigned int id;
2902
2903       id = 0;
2904       if (c != '_')
2905         {
2906           do
2907             {
2908               unsigned int new_id;
2909
2910               if (IS_DIGIT (c))
2911                 new_id = id * 36 + c - '0';
2912               else if (IS_UPPER (c))
2913                 new_id = id * 36 + c - 'A' + 10;
2914               else
2915                 return NULL;
2916               if (new_id < id)
2917                 return NULL;
2918               id = new_id;
2919               c = d_next_char (di);
2920             }
2921           while (c != '_');
2922
2923           ++id;
2924         }
2925
2926       if (id >= (unsigned int) di->next_sub)
2927         return NULL;
2928
2929       ++di->did_subs;
2930
2931       return di->subs[id];
2932     }
2933   else
2934     {
2935       int verbose;
2936       const struct d_standard_sub_info *p;
2937       const struct d_standard_sub_info *pend;
2938
2939       verbose = (di->options & DMGL_VERBOSE) != 0;
2940       if (! verbose && prefix)
2941         {
2942           char peek;
2943
2944           peek = d_peek_char (di);
2945           if (peek == 'C' || peek == 'D')
2946             verbose = 1;
2947         }
2948
2949       pend = (&standard_subs[0]
2950               + sizeof standard_subs / sizeof standard_subs[0]);
2951       for (p = &standard_subs[0]; p < pend; ++p)
2952         {
2953           if (c == p->code)
2954             {
2955               const char *s;
2956               int len;
2957
2958               if (p->set_last_name != NULL)
2959                 di->last_name = d_make_sub (di, p->set_last_name,
2960                                             p->set_last_name_len);
2961               if (verbose)
2962                 {
2963                   s = p->full_expansion;
2964                   len = p->full_len;
2965                 }
2966               else
2967                 {
2968                   s = p->simple_expansion;
2969                   len = p->simple_len;
2970                 }
2971               di->expansion += len;
2972               return d_make_sub (di, s, len);
2973             }
2974         }
2975
2976       return NULL;
2977     }
2978 }
2979
2980 /* Initialize a growable string.  */
2981
2982 static void
2983 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
2984 {
2985   dgs->buf = NULL;
2986   dgs->len = 0;
2987   dgs->alc = 0;
2988   dgs->allocation_failure = 0;
2989
2990   if (estimate > 0)
2991     d_growable_string_resize (dgs, estimate);
2992 }
2993
2994 /* Grow a growable string to a given size.  */
2995
2996 static inline void
2997 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
2998 {
2999   size_t newalc;
3000   char *newbuf;
3001
3002   if (dgs->allocation_failure)
3003     return;
3004
3005   /* Start allocation at two bytes to avoid any possibility of confusion
3006      with the special value of 1 used as a return in *palc to indicate
3007      allocation failures.  */
3008   newalc = dgs->alc > 0 ? dgs->alc : 2;
3009   while (newalc < need)
3010     newalc <<= 1;
3011
3012   newbuf = (char *) realloc (dgs->buf, newalc);
3013   if (newbuf == NULL)
3014     {
3015       free (dgs->buf);
3016       dgs->buf = NULL;
3017       dgs->len = 0;
3018       dgs->alc = 0;
3019       dgs->allocation_failure = 1;
3020       return;
3021     }
3022   dgs->buf = newbuf;
3023   dgs->alc = newalc;
3024 }
3025
3026 /* Append a buffer to a growable string.  */
3027
3028 static inline void
3029 d_growable_string_append_buffer (struct d_growable_string *dgs,
3030                                  const char *s, size_t l)
3031 {
3032   size_t need;
3033
3034   need = dgs->len + l + 1;
3035   if (need > dgs->alc)
3036     d_growable_string_resize (dgs, need);
3037
3038   if (dgs->allocation_failure)
3039     return;
3040
3041   memcpy (dgs->buf + dgs->len, s, l);
3042   dgs->buf[dgs->len + l] = '\0';
3043   dgs->len += l;
3044 }
3045
3046 /* Bridge growable strings to the callback mechanism.  */
3047
3048 static void
3049 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3050 {
3051   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3052
3053   d_growable_string_append_buffer (dgs, s, l);
3054 }
3055
3056 /* Initialize a print information structure.  */
3057
3058 static void
3059 d_print_init (struct d_print_info *dpi, int options,
3060               demangle_callbackref callback, void *opaque)
3061 {
3062   dpi->options = options;
3063   dpi->len = 0;
3064   dpi->last_char = '\0';
3065   dpi->templates = NULL;
3066   dpi->modifiers = NULL;
3067
3068   dpi->callback = callback;
3069   dpi->opaque = opaque;
3070
3071   dpi->demangle_failure = 0;
3072 }
3073
3074 /* Indicate that an error occurred during printing, and test for error.  */
3075
3076 static inline void
3077 d_print_error (struct d_print_info *dpi)
3078 {
3079   dpi->demangle_failure = 1;
3080 }
3081
3082 static inline int
3083 d_print_saw_error (struct d_print_info *dpi)
3084 {
3085   return dpi->demangle_failure != 0;
3086 }
3087
3088 /* Flush buffered characters to the callback.  */
3089
3090 static inline void
3091 d_print_flush (struct d_print_info *dpi)
3092 {
3093   dpi->buf[dpi->len] = '\0';
3094   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3095   dpi->len = 0;
3096 }
3097
3098 /* Append characters and buffers for printing.  */
3099
3100 static inline void
3101 d_append_char (struct d_print_info *dpi, char c)
3102 {
3103   if (dpi->len == sizeof (dpi->buf) - 1)
3104     d_print_flush (dpi);
3105
3106   dpi->buf[dpi->len++] = c;
3107   dpi->last_char = c;
3108 }
3109
3110 static inline void
3111 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3112 {
3113   size_t i;
3114
3115   for (i = 0; i < l; i++)
3116     d_append_char (dpi, s[i]);
3117 }
3118
3119 static inline void
3120 d_append_string (struct d_print_info *dpi, const char *s)
3121 {
3122   d_append_buffer (dpi, s, strlen (s));
3123 }
3124
3125 static inline char
3126 d_last_char (struct d_print_info *dpi)
3127 {
3128   return dpi->last_char;
3129 }
3130
3131 /* Turn components into a human readable string.  OPTIONS is the
3132    options bits passed to the demangler.  DC is the tree to print.
3133    CALLBACK is a function to call to flush demangled string segments
3134    as they fill the intermediate buffer, and OPAQUE is a generalized
3135    callback argument.  On success, this returns 1.  On failure,
3136    it returns 0, indicating a bad parse.  It does not use heap
3137    memory to build an output string, so cannot encounter memory
3138    allocation failure.  */
3139
3140 CP_STATIC_IF_GLIBCPP_V3
3141 int
3142 cplus_demangle_print_callback (int options,
3143                                const struct demangle_component *dc,
3144                                demangle_callbackref callback, void *opaque)
3145 {
3146   struct d_print_info dpi;
3147
3148   d_print_init (&dpi, options, callback, opaque);
3149
3150   d_print_comp (&dpi, dc);
3151
3152   d_print_flush (&dpi);
3153
3154   return ! d_print_saw_error (&dpi);
3155 }
3156
3157 /* Turn components into a human readable string.  OPTIONS is the
3158    options bits passed to the demangler.  DC is the tree to print.
3159    ESTIMATE is a guess at the length of the result.  This returns a
3160    string allocated by malloc, or NULL on error.  On success, this
3161    sets *PALC to the size of the allocated buffer.  On failure, this
3162    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3163    failure.  */
3164
3165 CP_STATIC_IF_GLIBCPP_V3
3166 char *
3167 cplus_demangle_print (int options, const struct demangle_component *dc,
3168                       int estimate, size_t *palc)
3169 {
3170   struct d_growable_string dgs;
3171
3172   d_growable_string_init (&dgs, estimate);
3173
3174   if (! cplus_demangle_print_callback (options, dc,
3175                                        d_growable_string_callback_adapter,
3176                                        &dgs))
3177     {
3178       free (dgs.buf);
3179       *palc = 0;
3180       return NULL;
3181     }
3182
3183   *palc = dgs.allocation_failure ? 1 : dgs.alc;
3184   return dgs.buf;
3185 }
3186
3187 /* Returns the I'th element of the template arglist ARGS, or NULL on
3188    failure.  */
3189
3190 static struct demangle_component *
3191 d_index_template_argument (struct demangle_component *args, int i)
3192 {
3193   struct demangle_component *a;
3194
3195   for (a = args;
3196        a != NULL;
3197        a = d_right (a))
3198     {
3199       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3200         return NULL;
3201       if (i <= 0)
3202         break;
3203       --i;
3204     }
3205   if (i != 0 || a == NULL)
3206     return NULL;
3207
3208   return d_left (a);
3209 }
3210
3211 /* Returns the template argument from the current context indicated by DC,
3212    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
3213
3214 static struct demangle_component *
3215 d_lookup_template_argument (struct d_print_info *dpi,
3216                             const struct demangle_component *dc)
3217 {
3218   if (dpi->templates == NULL)
3219     {
3220       d_print_error (dpi);
3221       return NULL;
3222     }
3223
3224   return d_index_template_argument
3225     (d_right (dpi->templates->template_decl),
3226      dc->u.s_number.number);
3227 }
3228
3229 /* Returns a template argument pack used in DC (any will do), or NULL.  */
3230
3231 static struct demangle_component *
3232 d_find_pack (struct d_print_info *dpi,
3233              const struct demangle_component *dc)
3234 {
3235   struct demangle_component *a;
3236   if (dc == NULL)
3237     return NULL;
3238
3239   switch (dc->type)
3240     {
3241     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3242       a = d_lookup_template_argument (dpi, dc);
3243       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3244         return a;
3245       return NULL;
3246
3247     case DEMANGLE_COMPONENT_PACK_EXPANSION:
3248       return NULL;
3249
3250     case DEMANGLE_COMPONENT_NAME:
3251     case DEMANGLE_COMPONENT_OPERATOR:
3252     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3253     case DEMANGLE_COMPONENT_SUB_STD:
3254     case DEMANGLE_COMPONENT_CHARACTER:
3255     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3256       return NULL;
3257
3258     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3259       return d_find_pack (dpi, dc->u.s_extended_operator.name);
3260     case DEMANGLE_COMPONENT_CTOR:
3261       return d_find_pack (dpi, dc->u.s_ctor.name);
3262     case DEMANGLE_COMPONENT_DTOR:
3263       return d_find_pack (dpi, dc->u.s_dtor.name);
3264
3265     default:
3266       a = d_find_pack (dpi, d_left (dc));
3267       if (a)
3268         return a;
3269       return d_find_pack (dpi, d_right (dc));
3270     }
3271 }
3272
3273 /* Returns the length of the template argument pack DC.  */
3274
3275 static int
3276 d_pack_length (const struct demangle_component *dc)
3277 {
3278   int count = 0;
3279   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3280          && d_left (dc) != NULL)
3281     {
3282       ++count;
3283       dc = d_right (dc);
3284     }
3285   return count;
3286 }
3287
3288 /* DC is a component of a mangled expression.  Print it, wrapped in parens
3289    if needed.  */
3290
3291 static void
3292 d_print_subexpr (struct d_print_info *dpi,
3293                  const struct demangle_component *dc)
3294 {
3295   int simple = 0;
3296   if (dc->type == DEMANGLE_COMPONENT_NAME
3297       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3298     simple = 1;
3299   if (!simple)
3300     d_append_char (dpi, '(');
3301   d_print_comp (dpi, dc);
3302   if (!simple)
3303     d_append_char (dpi, ')');
3304 }
3305
3306 /* Subroutine to handle components.  */
3307
3308 static void
3309 d_print_comp (struct d_print_info *dpi,
3310               const struct demangle_component *dc)
3311 {
3312   if (dc == NULL)
3313     {
3314       d_print_error (dpi);
3315       return;
3316     }
3317   if (d_print_saw_error (dpi))
3318     return;
3319
3320   switch (dc->type)
3321     {
3322     case DEMANGLE_COMPONENT_NAME:
3323       if ((dpi->options & DMGL_JAVA) == 0)
3324         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3325       else
3326         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3327       return;
3328
3329     case DEMANGLE_COMPONENT_QUAL_NAME:
3330     case DEMANGLE_COMPONENT_LOCAL_NAME:
3331       d_print_comp (dpi, d_left (dc));
3332       if ((dpi->options & DMGL_JAVA) == 0)
3333         d_append_string (dpi, "::");
3334       else
3335         d_append_char (dpi, '.');
3336       d_print_comp (dpi, d_right (dc));
3337       return;
3338
3339     case DEMANGLE_COMPONENT_TYPED_NAME:
3340       {
3341         struct d_print_mod *hold_modifiers;
3342         struct demangle_component *typed_name;
3343         struct d_print_mod adpm[4];
3344         unsigned int i;
3345         struct d_print_template dpt;
3346
3347         /* Pass the name down to the type so that it can be printed in
3348            the right place for the type.  We also have to pass down
3349            any CV-qualifiers, which apply to the this parameter.  */
3350         hold_modifiers = dpi->modifiers;
3351         dpi->modifiers = 0;
3352         i = 0;
3353         typed_name = d_left (dc);
3354         while (typed_name != NULL)
3355           {
3356             if (i >= sizeof adpm / sizeof adpm[0])
3357               {
3358                 d_print_error (dpi);
3359                 return;
3360               }
3361
3362             adpm[i].next = dpi->modifiers;
3363             dpi->modifiers = &adpm[i];
3364             adpm[i].mod = typed_name;
3365             adpm[i].printed = 0;
3366             adpm[i].templates = dpi->templates;
3367             ++i;
3368
3369             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3370                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3371                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3372               break;
3373
3374             typed_name = d_left (typed_name);
3375           }
3376
3377         if (typed_name == NULL)
3378           {
3379             d_print_error (dpi);
3380             return;
3381           }
3382
3383         /* If typed_name is a template, then it applies to the
3384            function type as well.  */
3385         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3386           {
3387             dpt.next = dpi->templates;
3388             dpi->templates = &dpt;
3389             dpt.template_decl = typed_name;
3390           }
3391
3392         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3393            there may be CV-qualifiers on its right argument which
3394            really apply here; this happens when parsing a class which
3395            is local to a function.  */
3396         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3397           {
3398             struct demangle_component *local_name;
3399
3400             local_name = d_right (typed_name);
3401             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3402                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3403                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3404               {
3405                 if (i >= sizeof adpm / sizeof adpm[0])
3406                   {
3407                     d_print_error (dpi);
3408                     return;
3409                   }
3410
3411                 adpm[i] = adpm[i - 1];
3412                 adpm[i].next = &adpm[i - 1];
3413                 dpi->modifiers = &adpm[i];
3414
3415                 adpm[i - 1].mod = local_name;
3416                 adpm[i - 1].printed = 0;
3417                 adpm[i - 1].templates = dpi->templates;
3418                 ++i;
3419
3420                 local_name = d_left (local_name);
3421               }
3422           }
3423
3424         d_print_comp (dpi, d_right (dc));
3425
3426         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3427           dpi->templates = dpt.next;
3428
3429         /* If the modifiers didn't get printed by the type, print them
3430            now.  */
3431         while (i > 0)
3432           {
3433             --i;
3434             if (! adpm[i].printed)
3435               {
3436                 d_append_char (dpi, ' ');
3437                 d_print_mod (dpi, adpm[i].mod);
3438               }
3439           }
3440
3441         dpi->modifiers = hold_modifiers;
3442
3443         return;
3444       }
3445
3446     case DEMANGLE_COMPONENT_TEMPLATE:
3447       {
3448         struct d_print_mod *hold_dpm;
3449         struct demangle_component *dcl;
3450
3451         /* Don't push modifiers into a template definition.  Doing so
3452            could give the wrong definition for a template argument.
3453            Instead, treat the template essentially as a name.  */
3454
3455         hold_dpm = dpi->modifiers;
3456         dpi->modifiers = NULL;
3457
3458         dcl = d_left (dc);
3459
3460         if ((dpi->options & DMGL_JAVA) != 0
3461             && dcl->type == DEMANGLE_COMPONENT_NAME
3462             && dcl->u.s_name.len == 6
3463             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3464           {
3465             /* Special-case Java arrays, so that JArray<TYPE> appears
3466                instead as TYPE[].  */
3467
3468             d_print_comp (dpi, d_right (dc));
3469             d_append_string (dpi, "[]");
3470           }
3471         else
3472           {
3473             d_print_comp (dpi, dcl);
3474             if (d_last_char (dpi) == '<')
3475               d_append_char (dpi, ' ');
3476             d_append_char (dpi, '<');
3477             d_print_comp (dpi, d_right (dc));
3478             /* Avoid generating two consecutive '>' characters, to avoid
3479                the C++ syntactic ambiguity.  */
3480             if (d_last_char (dpi) == '>')
3481               d_append_char (dpi, ' ');
3482             d_append_char (dpi, '>');
3483           }
3484
3485         dpi->modifiers = hold_dpm;
3486
3487         return;
3488       }
3489
3490     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3491       {
3492         struct d_print_template *hold_dpt;
3493         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3494
3495         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3496           a = d_index_template_argument (a, dpi->pack_index);
3497
3498         if (a == NULL)
3499           {
3500             d_print_error (dpi);
3501             return;
3502           }
3503
3504         /* While processing this parameter, we need to pop the list of
3505            templates.  This is because the template parameter may
3506            itself be a reference to a parameter of an outer
3507            template.  */
3508
3509         hold_dpt = dpi->templates;
3510         dpi->templates = hold_dpt->next;
3511
3512         d_print_comp (dpi, a);
3513
3514         dpi->templates = hold_dpt;
3515
3516         return;
3517       }
3518
3519     case DEMANGLE_COMPONENT_CTOR:
3520       d_print_comp (dpi, dc->u.s_ctor.name);
3521       return;
3522
3523     case DEMANGLE_COMPONENT_DTOR:
3524       d_append_char (dpi, '~');
3525       d_print_comp (dpi, dc->u.s_dtor.name);
3526       return;
3527
3528     case DEMANGLE_COMPONENT_VTABLE:
3529       d_append_string (dpi, "vtable for ");
3530       d_print_comp (dpi, d_left (dc));
3531       return;
3532
3533     case DEMANGLE_COMPONENT_VTT:
3534       d_append_string (dpi, "VTT for ");
3535       d_print_comp (dpi, d_left (dc));
3536       return;
3537
3538     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3539       d_append_string (dpi, "construction vtable for ");
3540       d_print_comp (dpi, d_left (dc));
3541       d_append_string (dpi, "-in-");
3542       d_print_comp (dpi, d_right (dc));
3543       return;
3544
3545     case DEMANGLE_COMPONENT_TYPEINFO:
3546       d_append_string (dpi, "typeinfo for ");
3547       d_print_comp (dpi, d_left (dc));
3548       return;
3549
3550     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3551       d_append_string (dpi, "typeinfo name for ");
3552       d_print_comp (dpi, d_left (dc));
3553       return;
3554
3555     case DEMANGLE_COMPONENT_TYPEINFO_FN:
3556       d_append_string (dpi, "typeinfo fn for ");
3557       d_print_comp (dpi, d_left (dc));
3558       return;
3559
3560     case DEMANGLE_COMPONENT_THUNK:
3561       d_append_string (dpi, "non-virtual thunk to ");
3562       d_print_comp (dpi, d_left (dc));
3563       return;
3564
3565     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3566       d_append_string (dpi, "virtual thunk to ");
3567       d_print_comp (dpi, d_left (dc));
3568       return;
3569
3570     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3571       d_append_string (dpi, "covariant return thunk to ");
3572       d_print_comp (dpi, d_left (dc));
3573       return;
3574
3575     case DEMANGLE_COMPONENT_JAVA_CLASS:
3576       d_append_string (dpi, "java Class for ");
3577       d_print_comp (dpi, d_left (dc));
3578       return;
3579
3580     case DEMANGLE_COMPONENT_GUARD:
3581       d_append_string (dpi, "guard variable for ");
3582       d_print_comp (dpi, d_left (dc));
3583       return;
3584
3585     case DEMANGLE_COMPONENT_REFTEMP:
3586       d_append_string (dpi, "reference temporary for ");
3587       d_print_comp (dpi, d_left (dc));
3588       return;
3589
3590     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3591       d_append_string (dpi, "hidden alias for ");
3592       d_print_comp (dpi, d_left (dc));
3593       return;
3594
3595     case DEMANGLE_COMPONENT_SUB_STD:
3596       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3597       return;
3598
3599     case DEMANGLE_COMPONENT_RESTRICT:
3600     case DEMANGLE_COMPONENT_VOLATILE:
3601     case DEMANGLE_COMPONENT_CONST:
3602       {
3603         struct d_print_mod *pdpm;
3604
3605         /* When printing arrays, it's possible to have cases where the
3606            same CV-qualifier gets pushed on the stack multiple times.
3607            We only need to print it once.  */
3608
3609         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3610           {
3611             if (! pdpm->printed)
3612               {
3613                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3614                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3615                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3616                   break;
3617                 if (pdpm->mod->type == dc->type)
3618                   {
3619                     d_print_comp (dpi, d_left (dc));
3620                     return;
3621                   }
3622               }
3623           }
3624       }
3625       /* Fall through.  */
3626     case DEMANGLE_COMPONENT_RESTRICT_THIS:
3627     case DEMANGLE_COMPONENT_VOLATILE_THIS:
3628     case DEMANGLE_COMPONENT_CONST_THIS:
3629     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3630     case DEMANGLE_COMPONENT_POINTER:
3631     case DEMANGLE_COMPONENT_REFERENCE:
3632     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3633     case DEMANGLE_COMPONENT_COMPLEX:
3634     case DEMANGLE_COMPONENT_IMAGINARY:
3635       {
3636         /* We keep a list of modifiers on the stack.  */
3637         struct d_print_mod dpm;
3638
3639         dpm.next = dpi->modifiers;
3640         dpi->modifiers = &dpm;
3641         dpm.mod = dc;
3642         dpm.printed = 0;
3643         dpm.templates = dpi->templates;
3644
3645         d_print_comp (dpi, d_left (dc));
3646
3647         /* If the modifier didn't get printed by the type, print it
3648            now.  */
3649         if (! dpm.printed)
3650           d_print_mod (dpi, dc);
3651
3652         dpi->modifiers = dpm.next;
3653
3654         return;
3655       }
3656
3657     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3658       if ((dpi->options & DMGL_JAVA) == 0)
3659         d_append_buffer (dpi, dc->u.s_builtin.type->name,
3660                          dc->u.s_builtin.type->len);
3661       else
3662         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3663                          dc->u.s_builtin.type->java_len);
3664       return;
3665
3666     case DEMANGLE_COMPONENT_VENDOR_TYPE:
3667       d_print_comp (dpi, d_left (dc));
3668       return;
3669
3670     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3671       {
3672         if ((dpi->options & DMGL_RET_POSTFIX) != 0)
3673           d_print_function_type (dpi, dc, dpi->modifiers);
3674
3675         /* Print return type if present */
3676         if (d_left (dc) != NULL)
3677           {
3678             struct d_print_mod dpm;
3679
3680             /* We must pass this type down as a modifier in order to
3681                print it in the right location.  */
3682             dpm.next = dpi->modifiers;
3683             dpi->modifiers = &dpm;
3684             dpm.mod = dc;
3685             dpm.printed = 0;
3686             dpm.templates = dpi->templates;
3687
3688             d_print_comp (dpi, d_left (dc));
3689
3690             dpi->modifiers = dpm.next;
3691
3692             if (dpm.printed)
3693               return;
3694
3695             /* In standard prefix notation, there is a space between the
3696                return type and the function signature.  */
3697             if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3698               d_append_char (dpi, ' ');
3699           }
3700
3701         if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3702           d_print_function_type (dpi, dc, dpi->modifiers);
3703
3704         return;
3705       }
3706
3707     case DEMANGLE_COMPONENT_ARRAY_TYPE:
3708       {
3709         struct d_print_mod *hold_modifiers;
3710         struct d_print_mod adpm[4];
3711         unsigned int i;
3712         struct d_print_mod *pdpm;
3713
3714         /* We must pass this type down as a modifier in order to print
3715            multi-dimensional arrays correctly.  If the array itself is
3716            CV-qualified, we act as though the element type were
3717            CV-qualified.  We do this by copying the modifiers down
3718            rather than fiddling pointers, so that we don't wind up
3719            with a d_print_mod higher on the stack pointing into our
3720            stack frame after we return.  */
3721
3722         hold_modifiers = dpi->modifiers;
3723
3724         adpm[0].next = hold_modifiers;
3725         dpi->modifiers = &adpm[0];
3726         adpm[0].mod = dc;
3727         adpm[0].printed = 0;
3728         adpm[0].templates = dpi->templates;
3729
3730         i = 1;
3731         pdpm = hold_modifiers;
3732         while (pdpm != NULL
3733                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3734                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3735                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3736           {
3737             if (! pdpm->printed)
3738               {
3739                 if (i >= sizeof adpm / sizeof adpm[0])
3740                   {
3741                     d_print_error (dpi);
3742                     return;
3743                   }
3744
3745                 adpm[i] = *pdpm;
3746                 adpm[i].next = dpi->modifiers;
3747                 dpi->modifiers = &adpm[i];
3748                 pdpm->printed = 1;
3749                 ++i;
3750               }
3751
3752             pdpm = pdpm->next;
3753           }
3754
3755         d_print_comp (dpi, d_right (dc));
3756
3757         dpi->modifiers = hold_modifiers;
3758
3759         if (adpm[0].printed)
3760           return;
3761
3762         while (i > 1)
3763           {
3764             --i;
3765             d_print_mod (dpi, adpm[i].mod);
3766           }
3767
3768         d_print_array_type (dpi, dc, dpi->modifiers);
3769
3770         return;
3771       }
3772
3773     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3774       {
3775         struct d_print_mod dpm;
3776
3777         dpm.next = dpi->modifiers;
3778         dpi->modifiers = &dpm;
3779         dpm.mod = dc;
3780         dpm.printed = 0;
3781         dpm.templates = dpi->templates;
3782
3783         d_print_comp (dpi, d_right (dc));
3784
3785         /* If the modifier didn't get printed by the type, print it
3786            now.  */
3787         if (! dpm.printed)
3788           {
3789             d_append_char (dpi, ' ');
3790             d_print_comp (dpi, d_left (dc));
3791             d_append_string (dpi, "::*");
3792           }
3793
3794         dpi->modifiers = dpm.next;
3795
3796         return;
3797       }
3798
3799     case DEMANGLE_COMPONENT_FIXED_TYPE:
3800       if (dc->u.s_fixed.sat)
3801         d_append_string (dpi, "_Sat ");
3802       /* Don't print "int _Accum".  */
3803       if (dc->u.s_fixed.length->u.s_builtin.type
3804           != &cplus_demangle_builtin_types['i'-'a'])
3805         {
3806           d_print_comp (dpi, dc->u.s_fixed.length);
3807           d_append_char (dpi, ' ');
3808         }
3809       if (dc->u.s_fixed.accum)
3810         d_append_string (dpi, "_Accum");
3811       else
3812         d_append_string (dpi, "_Fract");
3813       return;
3814
3815     case DEMANGLE_COMPONENT_ARGLIST:
3816     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
3817       if (d_left (dc) != NULL)
3818         d_print_comp (dpi, d_left (dc));
3819       if (d_right (dc) != NULL)
3820         {
3821           size_t len;
3822           d_append_string (dpi, ", ");
3823           len = dpi->len;
3824           d_print_comp (dpi, d_right (dc));
3825           /* If that didn't print anything (which can happen with empty
3826              template argument packs), remove the comma and space.  */
3827           if (dpi->len == len)
3828             dpi->len -= 2;
3829         }
3830       return;
3831
3832     case DEMANGLE_COMPONENT_OPERATOR:
3833       {
3834         char c;
3835
3836         d_append_string (dpi, "operator");
3837         c = dc->u.s_operator.op->name[0];
3838         if (IS_LOWER (c))
3839           d_append_char (dpi, ' ');
3840         d_append_buffer (dpi, dc->u.s_operator.op->name,
3841                          dc->u.s_operator.op->len);
3842         return;
3843       }
3844
3845     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3846       d_append_string (dpi, "operator ");
3847       d_print_comp (dpi, dc->u.s_extended_operator.name);
3848       return;
3849
3850     case DEMANGLE_COMPONENT_CAST:
3851       d_append_string (dpi, "operator ");
3852       d_print_cast (dpi, dc);
3853       return;
3854
3855     case DEMANGLE_COMPONENT_UNARY:
3856       if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
3857         d_print_expr_op (dpi, d_left (dc));
3858       else
3859         {
3860           d_append_char (dpi, '(');
3861           d_print_cast (dpi, d_left (dc));
3862           d_append_char (dpi, ')');
3863         }
3864       d_print_subexpr (dpi, d_right (dc));
3865       return;
3866
3867     case DEMANGLE_COMPONENT_BINARY:
3868       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
3869         {
3870           d_print_error (dpi);
3871           return;
3872         }
3873
3874       /* We wrap an expression which uses the greater-than operator in
3875          an extra layer of parens so that it does not get confused
3876          with the '>' which ends the template parameters.  */
3877       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3878           && d_left (dc)->u.s_operator.op->len == 1
3879           && d_left (dc)->u.s_operator.op->name[0] == '>')
3880         d_append_char (dpi, '(');
3881
3882       d_print_subexpr (dpi, d_left (d_right (dc)));
3883       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
3884         d_print_expr_op (dpi, d_left (dc));
3885       d_print_subexpr (dpi, d_right (d_right (dc)));
3886
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       return;
3893
3894     case DEMANGLE_COMPONENT_BINARY_ARGS:
3895       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
3896       d_print_error (dpi);
3897       return;
3898
3899     case DEMANGLE_COMPONENT_TRINARY:
3900       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
3901           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
3902         {
3903           d_print_error (dpi);
3904           return;
3905         }
3906       d_print_subexpr (dpi, d_left (d_right (dc)));
3907       d_print_expr_op (dpi, d_left (dc));
3908       d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
3909       d_append_string (dpi, " : ");
3910       d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
3911       return;
3912
3913     case DEMANGLE_COMPONENT_TRINARY_ARG1:
3914     case DEMANGLE_COMPONENT_TRINARY_ARG2:
3915       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
3916       d_print_error (dpi);
3917       return;
3918
3919     case DEMANGLE_COMPONENT_LITERAL:
3920     case DEMANGLE_COMPONENT_LITERAL_NEG:
3921       {
3922         enum d_builtin_type_print tp;
3923
3924         /* For some builtin types, produce simpler output.  */
3925         tp = D_PRINT_DEFAULT;
3926         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
3927           {
3928             tp = d_left (dc)->u.s_builtin.type->print;
3929             switch (tp)
3930               {
3931               case D_PRINT_INT:
3932               case D_PRINT_UNSIGNED:
3933               case D_PRINT_LONG:
3934               case D_PRINT_UNSIGNED_LONG:
3935               case D_PRINT_LONG_LONG:
3936               case D_PRINT_UNSIGNED_LONG_LONG:
3937                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
3938                   {
3939                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3940                       d_append_char (dpi, '-');
3941                     d_print_comp (dpi, d_right (dc));
3942                     switch (tp)
3943                       {
3944                       default:
3945                         break;
3946                       case D_PRINT_UNSIGNED:
3947                         d_append_char (dpi, 'u');
3948                         break;
3949                       case D_PRINT_LONG:
3950                         d_append_char (dpi, 'l');
3951                         break;
3952                       case D_PRINT_UNSIGNED_LONG:
3953                         d_append_string (dpi, "ul");
3954                         break;
3955                       case D_PRINT_LONG_LONG:
3956                         d_append_string (dpi, "ll");
3957                         break;
3958                       case D_PRINT_UNSIGNED_LONG_LONG:
3959                         d_append_string (dpi, "ull");
3960                         break;
3961                       }
3962                     return;
3963                   }
3964                 break;
3965
3966               case D_PRINT_BOOL:
3967                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
3968                     && d_right (dc)->u.s_name.len == 1
3969                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
3970                   {
3971                     switch (d_right (dc)->u.s_name.s[0])
3972                       {
3973                       case '0':
3974                         d_append_string (dpi, "false");
3975                         return;
3976                       case '1':
3977                         d_append_string (dpi, "true");
3978                         return;
3979                       default:
3980                         break;
3981                       }
3982                   }
3983                 break;
3984
3985               default:
3986                 break;
3987               }
3988           }
3989
3990         d_append_char (dpi, '(');
3991         d_print_comp (dpi, d_left (dc));
3992         d_append_char (dpi, ')');
3993         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3994           d_append_char (dpi, '-');
3995         if (tp == D_PRINT_FLOAT)
3996           d_append_char (dpi, '[');
3997         d_print_comp (dpi, d_right (dc));
3998         if (tp == D_PRINT_FLOAT)
3999           d_append_char (dpi, ']');
4000       }
4001       return;
4002
4003     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4004       d_append_string (dpi, "java resource ");
4005       d_print_comp (dpi, d_left (dc));
4006       return;
4007
4008     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4009       d_print_comp (dpi, d_left (dc));
4010       d_print_comp (dpi, d_right (dc));
4011       return;
4012
4013     case DEMANGLE_COMPONENT_CHARACTER:
4014       d_append_char (dpi, dc->u.s_character.character);
4015       return;
4016
4017     case DEMANGLE_COMPONENT_DECLTYPE:
4018       d_append_string (dpi, "decltype (");
4019       d_print_comp (dpi, d_left (dc));
4020       d_append_char (dpi, ')');
4021       return;
4022
4023     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4024       {
4025         int len;
4026         int i;
4027         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4028         if (a == NULL)
4029           {
4030             /* d_find_pack won't find anything if the only packs involved
4031                in this expansion are function parameter packs; in that
4032                case, just print the pattern and "...".  */
4033             d_print_subexpr (dpi, d_left (dc));
4034             d_append_string (dpi, "...");
4035             return;
4036           }
4037
4038         len = d_pack_length (a);
4039         dc = d_left (dc);
4040         for (i = 0; i < len; ++i)
4041           {
4042             dpi->pack_index = i;
4043             d_print_comp (dpi, dc);
4044             if (i < len-1)
4045               d_append_string (dpi, ", ");
4046           }
4047       }
4048       return;
4049
4050     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4051       {
4052         char buf[25];
4053         d_append_string (dpi, "parm#");
4054         sprintf(buf,"%ld", dc->u.s_number.number);
4055         d_append_string (dpi, buf);
4056         return;
4057       }
4058
4059     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4060       d_append_string (dpi, "global constructors keyed to ");
4061       d_print_comp (dpi, dc->u.s_binary.left);
4062       return;
4063
4064     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4065       d_append_string (dpi, "global destructors keyed to ");
4066       d_print_comp (dpi, dc->u.s_binary.left);
4067       return;
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   enum
4500     {
4501       DCT_TYPE,
4502       DCT_MANGLED,
4503       DCT_GLOBAL_CTORS,
4504       DCT_GLOBAL_DTORS
4505     }
4506   type;
4507   struct d_info di;
4508   struct demangle_component *dc;
4509   int status;
4510
4511   if (mangled[0] == '_' && mangled[1] == 'Z')
4512     type = DCT_MANGLED;
4513   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4514            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
4515            && (mangled[9] == 'D' || mangled[9] == 'I')
4516            && mangled[10] == '_')
4517     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
4518   else
4519     {
4520       if ((options & DMGL_TYPES) == 0)
4521         return 0;
4522       type = DCT_TYPE;
4523     }
4524
4525   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4526
4527   {
4528 #ifdef CP_DYNAMIC_ARRAYS
4529     __extension__ struct demangle_component comps[di.num_comps];
4530     __extension__ struct demangle_component *subs[di.num_subs];
4531
4532     di.comps = comps;
4533     di.subs = subs;
4534 #else
4535     di.comps = alloca (di.num_comps * sizeof (*di.comps));
4536     di.subs = alloca (di.num_subs * sizeof (*di.subs));
4537 #endif
4538
4539     switch (type)
4540       {
4541       case DCT_TYPE:
4542         dc = cplus_demangle_type (&di);
4543         break;
4544       case DCT_MANGLED:
4545         dc = cplus_demangle_mangled_name (&di, 1);
4546         break;
4547       case DCT_GLOBAL_CTORS:
4548       case DCT_GLOBAL_DTORS:
4549         d_advance (&di, 11);
4550         dc = d_make_comp (&di,
4551                           (type == DCT_GLOBAL_CTORS
4552                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
4553                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
4554                           d_make_name (&di, d_str (&di), strlen (d_str (&di))),
4555                           NULL);
4556         d_advance (&di, strlen (d_str (&di)));
4557         break;
4558       }
4559
4560     /* If DMGL_PARAMS is set, then if we didn't consume the entire
4561        mangled string, then we didn't successfully demangle it.  If
4562        DMGL_PARAMS is not set, we didn't look at the trailing
4563        parameters.  */
4564     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
4565       dc = NULL;
4566
4567 #ifdef CP_DEMANGLE_DEBUG
4568     d_dump (dc, 0);
4569 #endif
4570
4571     status = (dc != NULL)
4572              ? cplus_demangle_print_callback (options, dc, callback, opaque)
4573              : 0;
4574   }
4575
4576   return status;
4577 }
4578
4579 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
4580    name, return a buffer allocated with malloc holding the demangled
4581    name.  OPTIONS is the usual libiberty demangler options.  On
4582    success, this sets *PALC to the allocated size of the returned
4583    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
4584    a memory allocation failure, and returns NULL.  */
4585
4586 static char *
4587 d_demangle (const char *mangled, int options, size_t *palc)
4588 {
4589   struct d_growable_string dgs;
4590   int status;
4591
4592   d_growable_string_init (&dgs, 0);
4593
4594   status = d_demangle_callback (mangled, options,
4595                                 d_growable_string_callback_adapter, &dgs);
4596   if (status == 0)
4597     {
4598       free (dgs.buf);
4599       *palc = 0;
4600       return NULL;
4601     }
4602
4603   *palc = dgs.allocation_failure ? 1 : 0;
4604   return dgs.buf;
4605 }
4606
4607 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
4608
4609 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
4610
4611 /* ia64 ABI-mandated entry point in the C++ runtime library for
4612    performing demangling.  MANGLED_NAME is a NUL-terminated character
4613    string containing the name to be demangled.
4614
4615    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4616    *LENGTH bytes, into which the demangled name is stored.  If
4617    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4618    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4619    is placed in a region of memory allocated with malloc.
4620
4621    If LENGTH is non-NULL, the length of the buffer containing the
4622    demangled name, is placed in *LENGTH.
4623
4624    The return value is a pointer to the start of the NUL-terminated
4625    demangled name, or NULL if the demangling fails.  The caller is
4626    responsible for deallocating this memory using free.
4627
4628    *STATUS is set to one of the following values:
4629       0: The demangling operation succeeded.
4630      -1: A memory allocation failure occurred.
4631      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4632      -3: One of the arguments is invalid.
4633
4634    The demangling is performed using the C++ ABI mangling rules, with
4635    GNU extensions.  */
4636
4637 char *
4638 __cxa_demangle (const char *mangled_name, char *output_buffer,
4639                 size_t *length, int *status)
4640 {
4641   char *demangled;
4642   size_t alc;
4643
4644   if (mangled_name == NULL)
4645     {
4646       if (status != NULL)
4647         *status = -3;
4648       return NULL;
4649     }
4650
4651   if (output_buffer != NULL && length == NULL)
4652     {
4653       if (status != NULL)
4654         *status = -3;
4655       return NULL;
4656     }
4657
4658   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
4659
4660   if (demangled == NULL)
4661     {
4662       if (status != NULL)
4663         {
4664           if (alc == 1)
4665             *status = -1;
4666           else
4667             *status = -2;
4668         }
4669       return NULL;
4670     }
4671
4672   if (output_buffer == NULL)
4673     {
4674       if (length != NULL)
4675         *length = alc;
4676     }
4677   else
4678     {
4679       if (strlen (demangled) < *length)
4680         {
4681           strcpy (output_buffer, demangled);
4682           free (demangled);
4683           demangled = output_buffer;
4684         }
4685       else
4686         {
4687           free (output_buffer);
4688           *length = alc;
4689         }
4690     }
4691
4692   if (status != NULL)
4693     *status = 0;
4694
4695   return demangled;
4696 }
4697
4698 extern int __gcclibcxx_demangle_callback (const char *,
4699                                           void (*)
4700                                             (const char *, size_t, void *),
4701                                           void *);
4702
4703 /* Alternative, allocationless entry point in the C++ runtime library
4704    for performing demangling.  MANGLED_NAME is a NUL-terminated character
4705    string containing the name to be demangled.
4706
4707    CALLBACK is a callback function, called with demangled string
4708    segments as demangling progresses; it is called at least once,
4709    but may be called more than once.  OPAQUE is a generalized pointer
4710    used as a callback argument.
4711
4712    The return code is one of the following values, equivalent to
4713    the STATUS values of __cxa_demangle() (excluding -1, since this
4714    function performs no memory allocations):
4715       0: The demangling operation succeeded.
4716      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4717      -3: One of the arguments is invalid.
4718
4719    The demangling is performed using the C++ ABI mangling rules, with
4720    GNU extensions.  */
4721
4722 int
4723 __gcclibcxx_demangle_callback (const char *mangled_name,
4724                                void (*callback) (const char *, size_t, void *),
4725                                void *opaque)
4726 {
4727   int status;
4728
4729   if (mangled_name == NULL || callback == NULL)
4730     return -3;
4731
4732   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
4733                                 callback, opaque);
4734   if (status == 0)
4735     return -2;
4736
4737   return 0;
4738 }
4739
4740 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
4741
4742 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
4743    mangled name, return a buffer allocated with malloc holding the
4744    demangled name.  Otherwise, return NULL.  */
4745
4746 char *
4747 cplus_demangle_v3 (const char *mangled, int options)
4748 {
4749   size_t alc;
4750
4751   return d_demangle (mangled, options, &alc);
4752 }
4753
4754 int
4755 cplus_demangle_v3_callback (const char *mangled, int options,
4756                             demangle_callbackref callback, void *opaque)
4757 {
4758   return d_demangle_callback (mangled, options, callback, opaque);
4759 }
4760
4761 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
4762    conventions, but the output formatting is a little different.
4763    This instructs the C++ demangler not to emit pointer characters ("*"), to
4764    use Java's namespace separator symbol ("." instead of "::"), and to output
4765    JArray<TYPE> as TYPE[].  */
4766
4767 char *
4768 java_demangle_v3 (const char *mangled)
4769 {
4770   size_t alc;
4771
4772   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
4773 }
4774
4775 int
4776 java_demangle_v3_callback (const char *mangled,
4777                            demangle_callbackref callback, void *opaque)
4778 {
4779   return d_demangle_callback (mangled,
4780                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
4781                               callback, opaque);
4782 }
4783
4784 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4785
4786 #ifndef IN_GLIBCPP_V3
4787
4788 /* Demangle a string in order to find out whether it is a constructor
4789    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
4790    *DTOR_KIND appropriately.  */
4791
4792 static int
4793 is_ctor_or_dtor (const char *mangled,
4794                  enum gnu_v3_ctor_kinds *ctor_kind,
4795                  enum gnu_v3_dtor_kinds *dtor_kind)
4796 {
4797   struct d_info di;
4798   struct demangle_component *dc;
4799   int ret;
4800
4801   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
4802   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
4803
4804   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
4805
4806   {
4807 #ifdef CP_DYNAMIC_ARRAYS
4808     __extension__ struct demangle_component comps[di.num_comps];
4809     __extension__ struct demangle_component *subs[di.num_subs];
4810
4811     di.comps = comps;
4812     di.subs = subs;
4813 #else
4814     di.comps = alloca (di.num_comps * sizeof (*di.comps));
4815     di.subs = alloca (di.num_subs * sizeof (*di.subs));
4816 #endif
4817
4818     dc = cplus_demangle_mangled_name (&di, 1);
4819
4820     /* Note that because we did not pass DMGL_PARAMS, we don't expect
4821        to demangle the entire string.  */
4822
4823     ret = 0;
4824     while (dc != NULL)
4825       {
4826         switch (dc->type)
4827           {
4828           default:
4829             dc = NULL;
4830             break;
4831           case DEMANGLE_COMPONENT_TYPED_NAME:
4832           case DEMANGLE_COMPONENT_TEMPLATE:
4833           case DEMANGLE_COMPONENT_RESTRICT_THIS:
4834           case DEMANGLE_COMPONENT_VOLATILE_THIS:
4835           case DEMANGLE_COMPONENT_CONST_THIS:
4836             dc = d_left (dc);
4837             break;
4838           case DEMANGLE_COMPONENT_QUAL_NAME:
4839           case DEMANGLE_COMPONENT_LOCAL_NAME:
4840             dc = d_right (dc);
4841             break;
4842           case DEMANGLE_COMPONENT_CTOR:
4843             *ctor_kind = dc->u.s_ctor.kind;
4844             ret = 1;
4845             dc = NULL;
4846             break;
4847           case DEMANGLE_COMPONENT_DTOR:
4848             *dtor_kind = dc->u.s_dtor.kind;
4849             ret = 1;
4850             dc = NULL;
4851             break;
4852           }
4853       }
4854   }
4855
4856   return ret;
4857 }
4858
4859 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4860    name.  A non-zero return indicates the type of constructor.  */
4861
4862 enum gnu_v3_ctor_kinds
4863 is_gnu_v3_mangled_ctor (const char *name)
4864 {
4865   enum gnu_v3_ctor_kinds ctor_kind;
4866   enum gnu_v3_dtor_kinds dtor_kind;
4867
4868   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4869     return (enum gnu_v3_ctor_kinds) 0;
4870   return ctor_kind;
4871 }
4872
4873
4874 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4875    name.  A non-zero return indicates the type of destructor.  */
4876
4877 enum gnu_v3_dtor_kinds
4878 is_gnu_v3_mangled_dtor (const char *name)
4879 {
4880   enum gnu_v3_ctor_kinds ctor_kind;
4881   enum gnu_v3_dtor_kinds dtor_kind;
4882
4883   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4884     return (enum gnu_v3_dtor_kinds) 0;
4885   return dtor_kind;
4886 }
4887
4888 #endif /* IN_GLIBCPP_V3 */
4889
4890 #ifdef STANDALONE_DEMANGLER
4891
4892 #include "getopt.h"
4893 #include "dyn-string.h"
4894
4895 static void print_usage (FILE* fp, int exit_value);
4896
4897 #define IS_ALPHA(CHAR)                                                  \
4898   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
4899    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4900
4901 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
4902 #define is_mangled_char(CHAR)                                           \
4903   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
4904    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
4905
4906 /* The name of this program, as invoked.  */
4907 const char* program_name;
4908
4909 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
4910
4911 static void
4912 print_usage (FILE* fp, int exit_value)
4913 {
4914   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
4915   fprintf (fp, "Options:\n");
4916   fprintf (fp, "  -h,--help       Display this message.\n");
4917   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
4918   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
4919   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
4920
4921   exit (exit_value);
4922 }
4923
4924 /* Option specification for getopt_long.  */
4925 static const struct option long_options[] =
4926 {
4927   { "help",      no_argument, NULL, 'h' },
4928   { "no-params", no_argument, NULL, 'p' },
4929   { "verbose",   no_argument, NULL, 'v' },
4930   { NULL,        no_argument, NULL, 0   },
4931 };
4932
4933 /* Main entry for a demangling filter executable.  It will demangle
4934    its command line arguments, if any.  If none are provided, it will
4935    filter stdin to stdout, replacing any recognized mangled C++ names
4936    with their demangled equivalents.  */
4937
4938 int
4939 main (int argc, char *argv[])
4940 {
4941   int i;
4942   int opt_char;
4943   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
4944
4945   /* Use the program name of this program, as invoked.  */
4946   program_name = argv[0];
4947
4948   /* Parse options.  */
4949   do
4950     {
4951       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
4952       switch (opt_char)
4953         {
4954         case '?':  /* Unrecognized option.  */
4955           print_usage (stderr, 1);
4956           break;
4957
4958         case 'h':
4959           print_usage (stdout, 0);
4960           break;
4961
4962         case 'p':
4963           options &= ~ DMGL_PARAMS;
4964           break;
4965
4966         case 'v':
4967           options |= DMGL_VERBOSE;
4968           break;
4969         }
4970     }
4971   while (opt_char != -1);
4972
4973   if (optind == argc)
4974     /* No command line arguments were provided.  Filter stdin.  */
4975     {
4976       dyn_string_t mangled = dyn_string_new (3);
4977       char *s;
4978
4979       /* Read all of input.  */
4980       while (!feof (stdin))
4981         {
4982           char c;
4983
4984           /* Pile characters into mangled until we hit one that can't
4985              occur in a mangled name.  */
4986           c = getchar ();
4987           while (!feof (stdin) && is_mangled_char (c))
4988             {
4989               dyn_string_append_char (mangled, c);
4990               if (feof (stdin))
4991                 break;
4992               c = getchar ();
4993             }
4994
4995           if (dyn_string_length (mangled) > 0)
4996             {
4997 #ifdef IN_GLIBCPP_V3
4998               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
4999 #else
5000               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5001 #endif
5002
5003               if (s != NULL)
5004                 {
5005                   fputs (s, stdout);
5006                   free (s);
5007                 }
5008               else
5009                 {
5010                   /* It might not have been a mangled name.  Print the
5011                      original text.  */
5012                   fputs (dyn_string_buf (mangled), stdout);
5013                 }
5014
5015               dyn_string_clear (mangled);
5016             }
5017
5018           /* If we haven't hit EOF yet, we've read one character that
5019              can't occur in a mangled name, so print it out.  */
5020           if (!feof (stdin))
5021             putchar (c);
5022         }
5023
5024       dyn_string_delete (mangled);
5025     }
5026   else
5027     /* Demangle command line arguments.  */
5028     {
5029       /* Loop over command line arguments.  */
5030       for (i = optind; i < argc; ++i)
5031         {
5032           char *s;
5033 #ifdef IN_GLIBCPP_V3
5034           int status;
5035 #endif
5036
5037           /* Attempt to demangle.  */
5038 #ifdef IN_GLIBCPP_V3
5039           s = __cxa_demangle (argv[i], NULL, NULL, &status);
5040 #else
5041           s = cplus_demangle_v3 (argv[i], options);
5042 #endif
5043
5044           /* If it worked, print the demangled name.  */
5045           if (s != NULL)
5046             {
5047               printf ("%s\n", s);
5048               free (s);
5049             }
5050           else
5051             {
5052 #ifdef IN_GLIBCPP_V3
5053               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5054 #else
5055               fprintf (stderr, "Failed: %s\n", argv[i]);
5056 #endif
5057             }
5058         }
5059     }
5060
5061   return 0;
5062 }
5063
5064 #endif /* STANDALONE_DEMANGLER */