libiberty/cp-demangle.c

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