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