libiberty/cp-demangle.c

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