libiberty/cp-demangle.c

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