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> ::= <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
1951   return_type = NULL;
1952   tl = NULL;
1953   ptl = &tl;
1954   while (1)
1955     {
1956       char peek;
1957       struct demangle_component *type;
1958
1959       peek = d_peek_char (di);
1960       if (peek == '\0' || peek == 'E')
1961         break;
1962       type = cplus_demangle_type (di);
1963       if (type == NULL)
1964         return NULL;
1965       if (has_return_type)
1966         {
1967           return_type = type;
1968           has_return_type = 0;
1969         }
1970       else
1971         {
1972           *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
1973           if (*ptl == NULL)
1974             return NULL;
1975           ptl = &d_right (*ptl);
1976         }
1977     }
1978
1979   /* There should be at least one parameter type besides the optional
1980      return type.  A function which takes no arguments will have a
1981      single parameter type void.  */
1982   if (tl == NULL)
1983     return NULL;
1984
1985   /* If we have a single parameter type void, omit it.  */
1986   if (d_right (tl) == NULL
1987       && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
1988       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
1989     {
1990       di->expansion -= d_left (tl)->u.s_builtin.type->len;
1991       tl = NULL;
1992     }
1993
1994   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
1995 }
1996
1997 /* <class-enum-type> ::= <name>  */
1998
1999 static struct demangle_component *
2000 d_class_enum_type (struct d_info *di)
2001 {
2002   return d_name (di);
2003 }
2004
2005 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2006                 ::= A [<(dimension) expression>] _ <(element) type>
2007 */
2008
2009 static struct demangle_component *
2010 d_array_type (struct d_info *di)
2011 {
2012   char peek;
2013   struct demangle_component *dim;
2014
2015   if (d_next_char (di) != 'A')
2016     return NULL;
2017
2018   peek = d_peek_char (di);
2019   if (peek == '_')
2020     dim = NULL;
2021   else if (IS_DIGIT (peek))
2022     {
2023       const char *s;
2024
2025       s = d_str (di);
2026       do
2027         {
2028           d_advance (di, 1);
2029           peek = d_peek_char (di);
2030         }
2031       while (IS_DIGIT (peek));
2032       dim = d_make_name (di, s, d_str (di) - s);
2033       if (dim == NULL)
2034         return NULL;
2035     }
2036   else
2037     {
2038       dim = d_expression (di);
2039       if (dim == NULL)
2040         return NULL;
2041     }
2042
2043   if (d_next_char (di) != '_')
2044     return NULL;
2045
2046   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2047                       cplus_demangle_type (di));
2048 }
2049
2050 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
2051
2052 static struct demangle_component *
2053 d_pointer_to_member_type (struct d_info *di)
2054 {
2055   struct demangle_component *cl;
2056   struct demangle_component *mem;
2057   struct demangle_component **pmem;
2058
2059   if (d_next_char (di) != 'M')
2060     return NULL;
2061
2062   cl = cplus_demangle_type (di);
2063
2064   /* The ABI specifies that any type can be a substitution source, and
2065      that M is followed by two types, and that when a CV-qualified
2066      type is seen both the base type and the CV-qualified types are
2067      substitution sources.  The ABI also specifies that for a pointer
2068      to a CV-qualified member function, the qualifiers are attached to
2069      the second type.  Given the grammar, a plain reading of the ABI
2070      suggests that both the CV-qualified member function and the
2071      non-qualified member function are substitution sources.  However,
2072      g++ does not work that way.  g++ treats only the CV-qualified
2073      member function as a substitution source.  FIXME.  So to work
2074      with g++, we need to pull off the CV-qualifiers here, in order to
2075      avoid calling add_substitution() in cplus_demangle_type().  */
2076
2077   pmem = d_cv_qualifiers (di, &mem, 1);
2078   if (pmem == NULL)
2079     return NULL;
2080   *pmem = cplus_demangle_type (di);
2081
2082   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2083 }
2084
2085 /* <template-param> ::= T_
2086                     ::= T <(parameter-2 non-negative) number> _
2087 */
2088
2089 static struct demangle_component *
2090 d_template_param (struct d_info *di)
2091 {
2092   long param;
2093
2094   if (d_next_char (di) != 'T')
2095     return NULL;
2096
2097   if (d_peek_char (di) == '_')
2098     param = 0;
2099   else
2100     {
2101       param = d_number (di);
2102       if (param < 0)
2103         return NULL;
2104       param += 1;
2105     }
2106
2107   if (d_next_char (di) != '_')
2108     return NULL;
2109
2110   ++di->did_subs;
2111
2112   return d_make_template_param (di, param);
2113 }
2114
2115 /* <template-args> ::= I <template-arg>+ E  */
2116
2117 static struct demangle_component *
2118 d_template_args (struct d_info *di)
2119 {
2120   struct demangle_component *hold_last_name;
2121   struct demangle_component *al;
2122   struct demangle_component **pal;
2123
2124   /* Preserve the last name we saw--don't let the template arguments
2125      clobber it, as that would give us the wrong name for a subsequent
2126      constructor or destructor.  */
2127   hold_last_name = di->last_name;
2128
2129   if (d_next_char (di) != 'I')
2130     return NULL;
2131
2132   al = NULL;
2133   pal = &al;
2134   while (1)
2135     {
2136       struct demangle_component *a;
2137
2138       a = d_template_arg (di);
2139       if (a == NULL)
2140         return NULL;
2141
2142       *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2143       if (*pal == NULL)
2144         return NULL;
2145       pal = &d_right (*pal);
2146
2147       if (d_peek_char (di) == 'E')
2148         {
2149           d_advance (di, 1);
2150           break;
2151         }
2152     }
2153
2154   di->last_name = hold_last_name;
2155
2156   return al;
2157 }
2158
2159 /* <template-arg> ::= <type>
2160                   ::= X <expression> E
2161                   ::= <expr-primary>
2162 */
2163
2164 static struct demangle_component *
2165 d_template_arg (struct d_info *di)
2166 {
2167   struct demangle_component *ret;
2168
2169   switch (d_peek_char (di))
2170     {
2171     case 'X':
2172       d_advance (di, 1);
2173       ret = d_expression (di);
2174       if (d_next_char (di) != 'E')
2175         return NULL;
2176       return ret;
2177
2178     case 'L':
2179       return d_expr_primary (di);
2180
2181     default:
2182       return cplus_demangle_type (di);
2183     }
2184 }
2185
2186 /* <expression> ::= <(unary) operator-name> <expression>
2187                 ::= <(binary) operator-name> <expression> <expression>
2188                 ::= <(trinary) operator-name> <expression> <expression> <expression>
2189                 ::= st <type>
2190                 ::= <template-param>
2191                 ::= sr <type> <unqualified-name>
2192                 ::= sr <type> <unqualified-name> <template-args>
2193                 ::= <expr-primary>
2194 */
2195
2196 static struct demangle_component *
2197 d_expression (struct d_info *di)
2198 {
2199   char peek;
2200
2201   peek = d_peek_char (di);
2202   if (peek == 'L')
2203     return d_expr_primary (di);
2204   else if (peek == 'T')
2205     return d_template_param (di);
2206   else if (peek == 's' && d_peek_next_char (di) == 'r')
2207     {
2208       struct demangle_component *type;
2209       struct demangle_component *name;
2210
2211       d_advance (di, 2);
2212       type = cplus_demangle_type (di);
2213       name = d_unqualified_name (di);
2214       if (d_peek_char (di) != 'I')
2215         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2216       else
2217         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2218                             d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2219                                          d_template_args (di)));
2220     }
2221   else
2222     {
2223       struct demangle_component *op;
2224       int args;
2225
2226       op = d_operator_name (di);
2227       if (op == NULL)
2228         return NULL;
2229
2230       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2231         di->expansion += op->u.s_operator.op->len - 2;
2232
2233       if (op->type == DEMANGLE_COMPONENT_OPERATOR
2234           && strcmp (op->u.s_operator.op->code, "st") == 0)
2235         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2236                             cplus_demangle_type (di));
2237
2238       switch (op->type)
2239         {
2240         default:
2241           return NULL;
2242         case DEMANGLE_COMPONENT_OPERATOR:
2243           args = op->u.s_operator.op->args;
2244           break;
2245         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2246           args = op->u.s_extended_operator.args;
2247           break;
2248         case DEMANGLE_COMPONENT_CAST:
2249           args = 1;
2250           break;
2251         }
2252
2253       switch (args)
2254         {
2255         case 1:
2256           return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2257                               d_expression (di));
2258         case 2:
2259           {
2260             struct demangle_component *left;
2261
2262             left = d_expression (di);
2263             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2264                                 d_make_comp (di,
2265                                              DEMANGLE_COMPONENT_BINARY_ARGS,
2266                                              left,
2267                                              d_expression (di)));
2268           }
2269         case 3:
2270           {
2271             struct demangle_component *first;
2272             struct demangle_component *second;
2273
2274             first = d_expression (di);
2275             second = d_expression (di);
2276             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2277                                 d_make_comp (di,
2278                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
2279                                              first,
2280                                              d_make_comp (di,
2281                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
2282                                                           second,
2283                                                           d_expression (di))));
2284           }
2285         default:
2286           return NULL;
2287         }
2288     }
2289 }
2290
2291 /* <expr-primary> ::= L <type> <(value) number> E
2292                   ::= L <type> <(value) float> E
2293                   ::= L <mangled-name> E
2294 */
2295
2296 static struct demangle_component *
2297 d_expr_primary (struct d_info *di)
2298 {
2299   struct demangle_component *ret;
2300
2301   if (d_next_char (di) != 'L')
2302     return NULL;
2303   if (d_peek_char (di) == '_')
2304     ret = cplus_demangle_mangled_name (di, 0);
2305   else
2306     {
2307       struct demangle_component *type;
2308       enum demangle_component_type t;
2309       const char *s;
2310
2311       type = cplus_demangle_type (di);
2312       if (type == NULL)
2313         return NULL;
2314
2315       /* If we have a type we know how to print, we aren't going to
2316          print the type name itself.  */
2317       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2318           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2319         di->expansion -= type->u.s_builtin.type->len;
2320
2321       /* Rather than try to interpret the literal value, we just
2322          collect it as a string.  Note that it's possible to have a
2323          floating point literal here.  The ABI specifies that the
2324          format of such literals is machine independent.  That's fine,
2325          but what's not fine is that versions of g++ up to 3.2 with
2326          -fabi-version=1 used upper case letters in the hex constant,
2327          and dumped out gcc's internal representation.  That makes it
2328          hard to tell where the constant ends, and hard to dump the
2329          constant in any readable form anyhow.  We don't attempt to
2330          handle these cases.  */
2331
2332       t = DEMANGLE_COMPONENT_LITERAL;
2333       if (d_peek_char (di) == 'n')
2334         {
2335           t = DEMANGLE_COMPONENT_LITERAL_NEG;
2336           d_advance (di, 1);
2337         }
2338       s = d_str (di);
2339       while (d_peek_char (di) != 'E')
2340         d_advance (di, 1);
2341       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2342     }
2343   if (d_next_char (di) != 'E')
2344     return NULL;
2345   return ret;
2346 }
2347
2348 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2349                 ::= Z <(function) encoding> E s [<discriminator>]
2350 */
2351
2352 static struct demangle_component *
2353 d_local_name (struct d_info *di)
2354 {
2355   struct demangle_component *function;
2356
2357   if (d_next_char (di) != 'Z')
2358     return NULL;
2359
2360   function = d_encoding (di, 0);
2361
2362   if (d_next_char (di) != 'E')
2363     return NULL;
2364
2365   if (d_peek_char (di) == 's')
2366     {
2367       d_advance (di, 1);
2368       if (! d_discriminator (di))
2369         return NULL;
2370       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2371                           d_make_name (di, "string literal",
2372                                        sizeof "string literal" - 1));
2373     }
2374   else
2375     {
2376       struct demangle_component *name;
2377
2378       name = d_name (di);
2379       if (! d_discriminator (di))
2380         return NULL;
2381       return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2382     }
2383 }
2384
2385 /* <discriminator> ::= _ <(non-negative) number>
2386
2387    We demangle the discriminator, but we don't print it out.  FIXME:
2388    We should print it out in verbose mode.  */
2389
2390 static int
2391 d_discriminator (struct d_info *di)
2392 {
2393   long discrim;
2394
2395   if (d_peek_char (di) != '_')
2396     return 1;
2397   d_advance (di, 1);
2398   discrim = d_number (di);
2399   if (discrim < 0)
2400     return 0;
2401   return 1;
2402 }
2403
2404 /* Add a new substitution.  */
2405
2406 static int
2407 d_add_substitution (struct d_info *di, struct demangle_component *dc)
2408 {
2409   if (dc == NULL)
2410     return 0;
2411   if (di->next_sub >= di->num_subs)
2412     return 0;
2413   di->subs[di->next_sub] = dc;
2414   ++di->next_sub;
2415   return 1;
2416 }
2417
2418 /* <substitution> ::= S <seq-id> _
2419                   ::= S_
2420                   ::= St
2421                   ::= Sa
2422                   ::= Sb
2423                   ::= Ss
2424                   ::= Si
2425                   ::= So
2426                   ::= Sd
2427
2428    If PREFIX is non-zero, then this type is being used as a prefix in
2429    a qualified name.  In this case, for the standard substitutions, we
2430    need to check whether we are being used as a prefix for a
2431    constructor or destructor, and return a full template name.
2432    Otherwise we will get something like std::iostream::~iostream()
2433    which does not correspond particularly well to any function which
2434    actually appears in the source.
2435 */
2436
2437 static const struct d_standard_sub_info standard_subs[] =
2438 {
2439   { 't', NL ("std"),
2440     NL ("std"),
2441     NULL, 0 },
2442   { 'a', NL ("std::allocator"),
2443     NL ("std::allocator"),
2444     NL ("allocator") },
2445   { 'b', NL ("std::basic_string"),
2446     NL ("std::basic_string"),
2447     NL ("basic_string") },
2448   { 's', NL ("std::string"),
2449     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
2450     NL ("basic_string") },
2451   { 'i', NL ("std::istream"),
2452     NL ("std::basic_istream<char, std::char_traits<char> >"),
2453     NL ("basic_istream") },
2454   { 'o', NL ("std::ostream"),
2455     NL ("std::basic_ostream<char, std::char_traits<char> >"),
2456     NL ("basic_ostream") },
2457   { 'd', NL ("std::iostream"),
2458     NL ("std::basic_iostream<char, std::char_traits<char> >"),
2459     NL ("basic_iostream") }
2460 };
2461
2462 static struct demangle_component *
2463 d_substitution (struct d_info *di, int prefix)
2464 {
2465   char c;
2466
2467   if (d_next_char (di) != 'S')
2468     return NULL;
2469
2470   c = d_next_char (di);
2471   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
2472     {
2473       int id;
2474
2475       id = 0;
2476       if (c != '_')
2477         {
2478           do
2479             {
2480               if (IS_DIGIT (c))
2481                 id = id * 36 + c - '0';
2482               else if (IS_UPPER (c))
2483                 id = id * 36 + c - 'A' + 10;
2484               else
2485                 return NULL;
2486               c = d_next_char (di);
2487             }
2488           while (c != '_');
2489
2490           ++id;
2491         }
2492
2493       if (id >= di->next_sub)
2494         return NULL;
2495
2496       ++di->did_subs;
2497
2498       return di->subs[id];
2499     }
2500   else
2501     {
2502       int verbose;
2503       const struct d_standard_sub_info *p;
2504       const struct d_standard_sub_info *pend;
2505
2506       verbose = (di->options & DMGL_VERBOSE) != 0;
2507       if (! verbose && prefix)
2508         {
2509           char peek;
2510
2511           peek = d_peek_char (di);
2512           if (peek == 'C' || peek == 'D')
2513             verbose = 1;
2514         }
2515
2516       pend = (&standard_subs[0]
2517               + sizeof standard_subs / sizeof standard_subs[0]);
2518       for (p = &standard_subs[0]; p < pend; ++p)
2519         {
2520           if (c == p->code)
2521             {
2522               const char *s;
2523               int len;
2524
2525               if (p->set_last_name != NULL)
2526                 di->last_name = d_make_sub (di, p->set_last_name,
2527                                             p->set_last_name_len);
2528               if (verbose)
2529                 {
2530                   s = p->full_expansion;
2531                   len = p->full_len;
2532                 }
2533               else
2534                 {
2535                   s = p->simple_expansion;
2536                   len = p->simple_len;
2537                 }
2538               di->expansion += len;
2539               return d_make_sub (di, s, len);
2540             }
2541         }
2542
2543       return NULL;
2544     }
2545 }
2546
2547 /* Resize the print buffer.  */
2548
2549 static void
2550 d_print_resize (struct d_print_info *dpi, size_t add)
2551 {
2552   size_t need;
2553
2554   if (dpi->buf == NULL)
2555     return;
2556   need = dpi->len + add;
2557   while (need > dpi->alc)
2558     {
2559       size_t newalc;
2560       char *newbuf;
2561
2562       newalc = dpi->alc * 2;
2563       newbuf = (char *) realloc (dpi->buf, newalc);
2564       if (newbuf == NULL)
2565         {
2566           free (dpi->buf);
2567           dpi->buf = NULL;
2568           dpi->allocation_failure = 1;
2569           return;
2570         }
2571       dpi->buf = newbuf;
2572       dpi->alc = newalc;
2573     }
2574 }
2575
2576 /* Append a character to the print buffer.  */
2577
2578 static void
2579 d_print_append_char (struct d_print_info *dpi, int c)
2580 {
2581   if (dpi->buf != NULL)
2582     {
2583       if (dpi->len >= dpi->alc)
2584         {
2585           d_print_resize (dpi, 1);
2586           if (dpi->buf == NULL)
2587             return;
2588         }
2589
2590       dpi->buf[dpi->len] = c;
2591       ++dpi->len;
2592     }
2593 }
2594
2595 /* Append a buffer to the print buffer.  */
2596
2597 static void
2598 d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
2599 {
2600   if (dpi->buf != NULL)
2601     {
2602       if (dpi->len + l > dpi->alc)
2603         {
2604           d_print_resize (dpi, l);
2605           if (dpi->buf == NULL)
2606             return;
2607         }
2608
2609       memcpy (dpi->buf + dpi->len, s, l);
2610       dpi->len += l;
2611     }
2612 }
2613
2614 /* Indicate that an error occurred during printing.  */
2615
2616 static void
2617 d_print_error (struct d_print_info *dpi)
2618 {
2619   free (dpi->buf);
2620   dpi->buf = NULL;
2621 }
2622
2623 /* Turn components into a human readable string.  OPTIONS is the
2624    options bits passed to the demangler.  DC is the tree to print.
2625    ESTIMATE is a guess at the length of the result.  This returns a
2626    string allocated by malloc, or NULL on error.  On success, this
2627    sets *PALC to the size of the allocated buffer.  On failure, this
2628    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
2629    failure.  */
2630
2631 CP_STATIC_IF_GLIBCPP_V3
2632 char *
2633 cplus_demangle_print (int options, const struct demangle_component *dc,
2634                       int estimate, size_t *palc)
2635 {
2636   struct d_print_info dpi;
2637
2638   dpi.options = options;
2639
2640   dpi.alc = estimate + 1;
2641   dpi.buf = (char *) malloc (dpi.alc);
2642   if (dpi.buf == NULL)
2643     {
2644       *palc = 1;
2645       return NULL;
2646     }
2647
2648   dpi.len = 0;
2649   dpi.templates = NULL;
2650   dpi.modifiers = NULL;
2651
2652   dpi.allocation_failure = 0;
2653
2654   d_print_comp (&dpi, dc);
2655
2656   d_append_char (&dpi, '\0');
2657
2658   if (dpi.buf != NULL)
2659     *palc = dpi.alc;
2660   else
2661     *palc = dpi.allocation_failure;
2662
2663   return dpi.buf;
2664 }
2665
2666 /* Subroutine to handle components.  */
2667
2668 static void
2669 d_print_comp (struct d_print_info *dpi,
2670               const struct demangle_component *dc)
2671 {
2672   if (dc == NULL)
2673     {
2674       d_print_error (dpi);
2675       return;
2676     }
2677   if (d_print_saw_error (dpi))
2678     return;
2679
2680   switch (dc->type)
2681     {
2682     case DEMANGLE_COMPONENT_NAME:
2683       if ((dpi->options & DMGL_JAVA) == 0)
2684         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
2685       else
2686         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
2687       return;
2688
2689     case DEMANGLE_COMPONENT_QUAL_NAME:
2690     case DEMANGLE_COMPONENT_LOCAL_NAME:
2691       d_print_comp (dpi, d_left (dc));
2692       if ((dpi->options & DMGL_JAVA) == 0)
2693         d_append_string_constant (dpi, "::");
2694       else
2695         d_append_char (dpi, '.');
2696       d_print_comp (dpi, d_right (dc));
2697       return;
2698
2699     case DEMANGLE_COMPONENT_TYPED_NAME:
2700       {
2701         struct d_print_mod *hold_modifiers;
2702         struct demangle_component *typed_name;
2703         struct d_print_mod adpm[4];
2704         unsigned int i;
2705         struct d_print_template dpt;
2706
2707         /* Pass the name down to the type so that it can be printed in
2708            the right place for the type.  We also have to pass down
2709            any CV-qualifiers, which apply to the this parameter.  */
2710         hold_modifiers = dpi->modifiers;
2711         i = 0;
2712         typed_name = d_left (dc);
2713         while (typed_name != NULL)
2714           {
2715             if (i >= sizeof adpm / sizeof adpm[0])
2716               {
2717                 d_print_error (dpi);
2718                 return;
2719               }
2720
2721             adpm[i].next = dpi->modifiers;
2722             dpi->modifiers = &adpm[i];
2723             adpm[i].mod = typed_name;
2724             adpm[i].printed = 0;
2725             adpm[i].templates = dpi->templates;
2726             ++i;
2727
2728             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
2729                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
2730                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
2731               break;
2732
2733             typed_name = d_left (typed_name);
2734           }
2735
2736         /* If typed_name is a template, then it applies to the
2737            function type as well.  */
2738         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
2739           {
2740             dpt.next = dpi->templates;
2741             dpi->templates = &dpt;
2742             dpt.template_decl = typed_name;
2743           }
2744
2745         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
2746            there may be CV-qualifiers on its right argument which
2747            really apply here; this happens when parsing a class which
2748            is local to a function.  */
2749         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
2750           {
2751             struct demangle_component *local_name;
2752
2753             local_name = d_right (typed_name);
2754             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
2755                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
2756                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
2757               {
2758                 if (i >= sizeof adpm / sizeof adpm[0])
2759                   {
2760                     d_print_error (dpi);
2761                     return;
2762                   }
2763
2764                 adpm[i] = adpm[i - 1];
2765                 adpm[i].next = &adpm[i - 1];
2766                 dpi->modifiers = &adpm[i];
2767
2768                 adpm[i - 1].mod = local_name;
2769                 adpm[i - 1].printed = 0;
2770                 adpm[i - 1].templates = dpi->templates;
2771                 ++i;
2772
2773                 local_name = d_left (local_name);
2774               }
2775           }
2776
2777         d_print_comp (dpi, d_right (dc));
2778
2779         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
2780           dpi->templates = dpt.next;
2781
2782         /* If the modifiers didn't get printed by the type, print them
2783            now.  */
2784         while (i > 0)
2785           {
2786             --i;
2787             if (! adpm[i].printed)
2788               {
2789                 d_append_char (dpi, ' ');
2790                 d_print_mod (dpi, adpm[i].mod);
2791               }
2792           }
2793
2794         dpi->modifiers = hold_modifiers;
2795
2796         return;
2797       }
2798
2799     case DEMANGLE_COMPONENT_TEMPLATE:
2800       {
2801         struct d_print_mod *hold_dpm;
2802
2803         /* Don't push modifiers into a template definition.  Doing so
2804            could give the wrong definition for a template argument.
2805            Instead, treat the template essentially as a name.  */
2806
2807         hold_dpm = dpi->modifiers;
2808         dpi->modifiers = NULL;
2809
2810         d_print_comp (dpi, d_left (dc));
2811         if (d_last_char (dpi) == '<')
2812           d_append_char (dpi, ' ');
2813         d_append_char (dpi, '<');
2814         d_print_comp (dpi, d_right (dc));
2815         /* Avoid generating two consecutive '>' characters, to avoid
2816            the C++ syntactic ambiguity.  */
2817         if (d_last_char (dpi) == '>')
2818           d_append_char (dpi, ' ');
2819         d_append_char (dpi, '>');
2820
2821         dpi->modifiers = hold_dpm;
2822
2823         return;
2824       }
2825
2826     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
2827       {
2828         long i;
2829         struct demangle_component *a;
2830         struct d_print_template *hold_dpt;
2831
2832         if (dpi->templates == NULL)
2833           {
2834             d_print_error (dpi);
2835             return;
2836           }
2837         i = dc->u.s_number.number;
2838         for (a = d_right (dpi->templates->template_decl);
2839              a != NULL;
2840              a = d_right (a))
2841           {
2842             if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
2843               {
2844                 d_print_error (dpi);
2845                 return;
2846               }
2847             if (i <= 0)
2848               break;
2849             --i;
2850           }
2851         if (i != 0 || a == NULL)
2852           {
2853             d_print_error (dpi);
2854             return;
2855           }
2856
2857         /* While processing this parameter, we need to pop the list of
2858            templates.  This is because the template parameter may
2859            itself be a reference to a parameter of an outer
2860            template.  */
2861
2862         hold_dpt = dpi->templates;
2863         dpi->templates = hold_dpt->next;
2864
2865         d_print_comp (dpi, d_left (a));
2866
2867         dpi->templates = hold_dpt;
2868
2869         return;
2870       }
2871
2872     case DEMANGLE_COMPONENT_CTOR:
2873       d_print_comp (dpi, dc->u.s_ctor.name);
2874       return;
2875
2876     case DEMANGLE_COMPONENT_DTOR:
2877       d_append_char (dpi, '~');
2878       d_print_comp (dpi, dc->u.s_dtor.name);
2879       return;
2880
2881     case DEMANGLE_COMPONENT_VTABLE:
2882       d_append_string_constant (dpi, "vtable for ");
2883       d_print_comp (dpi, d_left (dc));
2884       return;
2885
2886     case DEMANGLE_COMPONENT_VTT:
2887       d_append_string_constant (dpi, "VTT for ");
2888       d_print_comp (dpi, d_left (dc));
2889       return;
2890
2891     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
2892       d_append_string_constant (dpi, "construction vtable for ");
2893       d_print_comp (dpi, d_left (dc));
2894       d_append_string_constant (dpi, "-in-");
2895       d_print_comp (dpi, d_right (dc));
2896       return;
2897
2898     case DEMANGLE_COMPONENT_TYPEINFO:
2899       d_append_string_constant (dpi, "typeinfo for ");
2900       d_print_comp (dpi, d_left (dc));
2901       return;
2902
2903     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
2904       d_append_string_constant (dpi, "typeinfo name for ");
2905       d_print_comp (dpi, d_left (dc));
2906       return;
2907
2908     case DEMANGLE_COMPONENT_TYPEINFO_FN:
2909       d_append_string_constant (dpi, "typeinfo fn for ");
2910       d_print_comp (dpi, d_left (dc));
2911       return;
2912
2913     case DEMANGLE_COMPONENT_THUNK:
2914       d_append_string_constant (dpi, "non-virtual thunk to ");
2915       d_print_comp (dpi, d_left (dc));
2916       return;
2917
2918     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
2919       d_append_string_constant (dpi, "virtual thunk to ");
2920       d_print_comp (dpi, d_left (dc));
2921       return;
2922
2923     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
2924       d_append_string_constant (dpi, "covariant return thunk to ");
2925       d_print_comp (dpi, d_left (dc));
2926       return;
2927
2928     case DEMANGLE_COMPONENT_JAVA_CLASS:
2929       d_append_string_constant (dpi, "java Class for ");
2930       d_print_comp (dpi, d_left (dc));
2931       return;
2932
2933     case DEMANGLE_COMPONENT_GUARD:
2934       d_append_string_constant (dpi, "guard variable for ");
2935       d_print_comp (dpi, d_left (dc));
2936       return;
2937
2938     case DEMANGLE_COMPONENT_REFTEMP:
2939       d_append_string_constant (dpi, "reference temporary for ");
2940       d_print_comp (dpi, d_left (dc));
2941       return;
2942
2943     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
2944       d_append_string_constant (dpi, "hidden alias for ");
2945       d_print_comp (dpi, d_left (dc));
2946       return;
2947
2948     case DEMANGLE_COMPONENT_SUB_STD:
2949       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
2950       return;
2951
2952     case DEMANGLE_COMPONENT_RESTRICT:
2953     case DEMANGLE_COMPONENT_VOLATILE:
2954     case DEMANGLE_COMPONENT_CONST:
2955       {
2956         struct d_print_mod *pdpm;
2957
2958         /* When printing arrays, it's possible to have cases where the
2959            same CV-qualifier gets pushed on the stack multiple times.
2960            We only need to print it once.  */
2961
2962         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
2963           {
2964             if (! pdpm->printed)
2965               {
2966                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
2967                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
2968                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
2969                   break;
2970                 if (pdpm->mod->type == dc->type)
2971                   {
2972                     d_print_comp (dpi, d_left (dc));
2973                     return;
2974                   }
2975               }
2976           }
2977       }
2978       /* Fall through.  */
2979     case DEMANGLE_COMPONENT_RESTRICT_THIS:
2980     case DEMANGLE_COMPONENT_VOLATILE_THIS:
2981     case DEMANGLE_COMPONENT_CONST_THIS:
2982     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
2983     case DEMANGLE_COMPONENT_POINTER:
2984     case DEMANGLE_COMPONENT_REFERENCE:
2985     case DEMANGLE_COMPONENT_COMPLEX:
2986     case DEMANGLE_COMPONENT_IMAGINARY:
2987       {
2988         /* We keep a list of modifiers on the stack.  */
2989         struct d_print_mod dpm;
2990
2991         dpm.next = dpi->modifiers;
2992         dpi->modifiers = &dpm;
2993         dpm.mod = dc;
2994         dpm.printed = 0;
2995         dpm.templates = dpi->templates;
2996
2997         d_print_comp (dpi, d_left (dc));
2998
2999         /* If the modifier didn't get printed by the type, print it
3000            now.  */
3001         if (! dpm.printed)
3002           d_print_mod (dpi, dc);
3003
3004         dpi->modifiers = dpm.next;
3005
3006         return;
3007       }
3008
3009     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3010       if ((dpi->options & DMGL_JAVA) == 0)
3011         d_append_buffer (dpi, dc->u.s_builtin.type->name,
3012                          dc->u.s_builtin.type->len);
3013       else
3014         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3015                          dc->u.s_builtin.type->java_len);
3016       return;
3017
3018     case DEMANGLE_COMPONENT_VENDOR_TYPE:
3019       d_print_comp (dpi, d_left (dc));
3020       return;
3021
3022     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3023       {
3024         if (d_left (dc) != NULL)
3025           {
3026             struct d_print_mod dpm;
3027
3028             /* We must pass this type down as a modifier in order to
3029                print it in the right location.  */
3030
3031             dpm.next = dpi->modifiers;
3032             dpi->modifiers = &dpm;
3033             dpm.mod = dc;
3034             dpm.printed = 0;
3035             dpm.templates = dpi->templates;
3036
3037             d_print_comp (dpi, d_left (dc));
3038
3039             dpi->modifiers = dpm.next;
3040
3041             if (dpm.printed)
3042               return;
3043
3044             d_append_char (dpi, ' ');
3045           }
3046
3047         d_print_function_type (dpi, dc, dpi->modifiers);
3048
3049         return;
3050       }
3051
3052     case DEMANGLE_COMPONENT_ARRAY_TYPE:
3053       {
3054         struct d_print_mod *hold_modifiers;
3055         struct d_print_mod adpm[4];
3056         unsigned int i;
3057         struct d_print_mod *pdpm;
3058
3059         /* We must pass this type down as a modifier in order to print
3060            multi-dimensional arrays correctly.  If the array itself is
3061            CV-qualified, we act as though the element type were
3062            CV-qualified.  We do this by copying the modifiers down
3063            rather than fiddling pointers, so that we don't wind up
3064            with a d_print_mod higher on the stack pointing into our
3065            stack frame after we return.  */
3066
3067         hold_modifiers = dpi->modifiers;
3068
3069         adpm[0].next = hold_modifiers;
3070         dpi->modifiers = &adpm[0];
3071         adpm[0].mod = dc;
3072         adpm[0].printed = 0;
3073         adpm[0].templates = dpi->templates;
3074
3075         i = 1;
3076         pdpm = hold_modifiers;
3077         while (pdpm != NULL
3078                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3079                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3080                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3081           {
3082             if (! pdpm->printed)
3083               {
3084                 if (i >= sizeof adpm / sizeof adpm[0])
3085                   {
3086                     d_print_error (dpi);
3087                     return;
3088                   }
3089
3090                 adpm[i] = *pdpm;
3091                 adpm[i].next = dpi->modifiers;
3092                 dpi->modifiers = &adpm[i];
3093                 pdpm->printed = 1;
3094                 ++i;
3095               }
3096
3097             pdpm = pdpm->next;
3098           }
3099
3100         d_print_comp (dpi, d_right (dc));
3101
3102         dpi->modifiers = hold_modifiers;
3103
3104         if (adpm[0].printed)
3105           return;
3106
3107         while (i > 1)
3108           {
3109             --i;
3110             d_print_mod (dpi, adpm[i].mod);
3111           }
3112
3113         d_print_array_type (dpi, dc, dpi->modifiers);
3114
3115         return;
3116       }
3117
3118     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3119       {
3120         struct d_print_mod dpm;
3121
3122         dpm.next = dpi->modifiers;
3123         dpi->modifiers = &dpm;
3124         dpm.mod = dc;
3125         dpm.printed = 0;
3126         dpm.templates = dpi->templates;
3127
3128         d_print_comp (dpi, d_right (dc));
3129
3130         /* If the modifier didn't get printed by the type, print it
3131            now.  */
3132         if (! dpm.printed)
3133           {
3134             d_append_char (dpi, ' ');
3135             d_print_comp (dpi, d_left (dc));
3136             d_append_string_constant (dpi, "::*");
3137           }
3138
3139         dpi->modifiers = dpm.next;
3140
3141         return;
3142       }
3143
3144     case DEMANGLE_COMPONENT_ARGLIST:
3145     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
3146       d_print_comp (dpi, d_left (dc));
3147       if (d_right (dc) != NULL)
3148         {
3149           d_append_string_constant (dpi, ", ");
3150           d_print_comp (dpi, d_right (dc));
3151         }
3152       return;
3153
3154     case DEMANGLE_COMPONENT_OPERATOR:
3155       {
3156         char c;
3157
3158         d_append_string_constant (dpi, "operator");
3159         c = dc->u.s_operator.op->name[0];
3160         if (IS_LOWER (c))
3161           d_append_char (dpi, ' ');
3162         d_append_buffer (dpi, dc->u.s_operator.op->name,
3163                          dc->u.s_operator.op->len);
3164         return;
3165       }
3166
3167     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3168       d_append_string_constant (dpi, "operator ");
3169       d_print_comp (dpi, dc->u.s_extended_operator.name);
3170       return;
3171
3172     case DEMANGLE_COMPONENT_CAST:
3173       d_append_string_constant (dpi, "operator ");
3174       d_print_cast (dpi, dc);
3175       return;
3176
3177     case DEMANGLE_COMPONENT_UNARY:
3178       if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
3179         d_print_expr_op (dpi, d_left (dc));
3180       else
3181         {
3182           d_append_char (dpi, '(');
3183           d_print_cast (dpi, d_left (dc));
3184           d_append_char (dpi, ')');
3185         }
3186       d_append_char (dpi, '(');
3187       d_print_comp (dpi, d_right (dc));
3188       d_append_char (dpi, ')');
3189       return;
3190
3191     case DEMANGLE_COMPONENT_BINARY:
3192       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
3193         {
3194           d_print_error (dpi);
3195           return;
3196         }
3197
3198       /* We wrap an expression which uses the greater-than operator in
3199          an extra layer of parens so that it does not get confused
3200          with the '>' which ends the template parameters.  */
3201       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3202           && d_left (dc)->u.s_operator.op->len == 1
3203           && d_left (dc)->u.s_operator.op->name[0] == '>')
3204         d_append_char (dpi, '(');
3205
3206       d_append_char (dpi, '(');
3207       d_print_comp (dpi, d_left (d_right (dc)));
3208       d_append_string_constant (dpi, ") ");
3209       d_print_expr_op (dpi, d_left (dc));
3210       d_append_string_constant (dpi, " (");
3211       d_print_comp (dpi, d_right (d_right (dc)));
3212       d_append_char (dpi, ')');
3213
3214       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3215           && d_left (dc)->u.s_operator.op->len == 1
3216           && d_left (dc)->u.s_operator.op->name[0] == '>')
3217         d_append_char (dpi, ')');
3218
3219       return;
3220
3221     case DEMANGLE_COMPONENT_BINARY_ARGS:
3222       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
3223       d_print_error (dpi);
3224       return;
3225
3226     case DEMANGLE_COMPONENT_TRINARY:
3227       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
3228           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
3229         {
3230           d_print_error (dpi);
3231           return;
3232         }
3233       d_append_char (dpi, '(');
3234       d_print_comp (dpi, d_left (d_right (dc)));
3235       d_append_string_constant (dpi, ") ");
3236       d_print_expr_op (dpi, d_left (dc));
3237       d_append_string_constant (dpi, " (");
3238       d_print_comp (dpi, d_left (d_right (d_right (dc))));
3239       d_append_string_constant (dpi, ") : (");
3240       d_print_comp (dpi, d_right (d_right (d_right (dc))));
3241       d_append_char (dpi, ')');
3242       return;
3243
3244     case DEMANGLE_COMPONENT_TRINARY_ARG1:
3245     case DEMANGLE_COMPONENT_TRINARY_ARG2:
3246       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
3247       d_print_error (dpi);
3248       return;
3249
3250     case DEMANGLE_COMPONENT_LITERAL:
3251     case DEMANGLE_COMPONENT_LITERAL_NEG:
3252       {
3253         enum d_builtin_type_print tp;
3254
3255         /* For some builtin types, produce simpler output.  */
3256         tp = D_PRINT_DEFAULT;
3257         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
3258           {
3259             tp = d_left (dc)->u.s_builtin.type->print;
3260             switch (tp)
3261               {
3262               case D_PRINT_INT:
3263               case D_PRINT_UNSIGNED:
3264               case D_PRINT_LONG:
3265               case D_PRINT_UNSIGNED_LONG:
3266               case D_PRINT_LONG_LONG:
3267               case D_PRINT_UNSIGNED_LONG_LONG:
3268                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
3269                   {
3270                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3271                       d_append_char (dpi, '-');
3272                     d_print_comp (dpi, d_right (dc));
3273                     switch (tp)
3274                       {
3275                       default:
3276                         break;
3277                       case D_PRINT_UNSIGNED:
3278                         d_append_char (dpi, 'u');
3279                         break;
3280                       case D_PRINT_LONG:
3281                         d_append_char (dpi, 'l');
3282                         break;
3283                       case D_PRINT_UNSIGNED_LONG:
3284                         d_append_string_constant (dpi, "ul");
3285                         break;
3286                       case D_PRINT_LONG_LONG:
3287                         d_append_string_constant (dpi, "ll");
3288                         break;
3289                       case D_PRINT_UNSIGNED_LONG_LONG:
3290                         d_append_string_constant (dpi, "ull");
3291                         break;
3292                       }
3293                     return;
3294                   }
3295                 break;
3296
3297               case D_PRINT_BOOL:
3298                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
3299                     && d_right (dc)->u.s_name.len == 1
3300                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
3301                   {
3302                     switch (d_right (dc)->u.s_name.s[0])
3303                       {
3304                       case '0':
3305                         d_append_string_constant (dpi, "false");
3306                         return;
3307                       case '1':
3308                         d_append_string_constant (dpi, "true");
3309                         return;
3310                       default:
3311                         break;
3312                       }
3313                   }
3314                 break;
3315
3316               default:
3317                 break;
3318               }
3319           }
3320
3321         d_append_char (dpi, '(');
3322         d_print_comp (dpi, d_left (dc));
3323         d_append_char (dpi, ')');
3324         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3325           d_append_char (dpi, '-');
3326         if (tp == D_PRINT_FLOAT)
3327           d_append_char (dpi, '[');
3328         d_print_comp (dpi, d_right (dc));
3329         if (tp == D_PRINT_FLOAT)
3330           d_append_char (dpi, ']');
3331       }
3332       return;
3333
3334     default:
3335       d_print_error (dpi);
3336       return;
3337     }
3338 }
3339
3340 /* Print a Java dentifier.  For Java we try to handle encoded extended
3341    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
3342    so we don't it for C++.  Characters are encoded as
3343    __U<hex-char>+_.  */
3344
3345 static void
3346 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
3347 {
3348   const char *p;
3349   const char *end;
3350
3351   end = name + len;
3352   for (p = name; p < end; ++p)
3353     {
3354       if (end - p > 3
3355           && p[0] == '_'
3356           && p[1] == '_'
3357           && p[2] == 'U')
3358         {
3359           unsigned long c;
3360           const char *q;
3361
3362           c = 0;
3363           for (q = p + 3; q < end; ++q)
3364             {
3365               int dig;
3366
3367               if (IS_DIGIT (*q))
3368                 dig = *q - '0';
3369               else if (*q >= 'A' && *q <= 'F')
3370                 dig = *q - 'A' + 10;
3371               else if (*q >= 'a' && *q <= 'f')
3372                 dig = *q - 'a' + 10;
3373               else
3374                 break;
3375
3376               c = c * 16 + dig;
3377             }
3378           /* If the Unicode character is larger than 256, we don't try
3379              to deal with it here.  FIXME.  */
3380           if (q < end && *q == '_' && c < 256)
3381             {
3382               d_append_char (dpi, c);
3383               p = q;
3384               continue;
3385             }
3386         }
3387
3388       d_append_char (dpi, *p);
3389     }
3390 }
3391
3392 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
3393    qualifiers on this after printing a function.  */
3394
3395 static void
3396 d_print_mod_list (struct d_print_info *dpi,
3397                   struct d_print_mod *mods, int suffix)
3398 {
3399   struct d_print_template *hold_dpt;
3400
3401   if (mods == NULL || d_print_saw_error (dpi))
3402     return;
3403
3404   if (mods->printed
3405       || (! suffix
3406           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3407               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3408               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
3409     {
3410       d_print_mod_list (dpi, mods->next, suffix);
3411       return;
3412     }
3413
3414   mods->printed = 1;
3415
3416   hold_dpt = dpi->templates;
3417   dpi->templates = mods->templates;
3418
3419   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
3420     {
3421       d_print_function_type (dpi, mods->mod, mods->next);
3422       dpi->templates = hold_dpt;
3423       return;
3424     }
3425   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
3426     {
3427       d_print_array_type (dpi, mods->mod, mods->next);
3428       dpi->templates = hold_dpt;
3429       return;
3430     }
3431   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3432     {
3433       struct d_print_mod *hold_modifiers;
3434       struct demangle_component *dc;
3435
3436       /* When this is on the modifier stack, we have pulled any
3437          qualifiers off the right argument already.  Otherwise, we
3438          print it as usual, but don't let the left argument see any
3439          modifiers.  */
3440
3441       hold_modifiers = dpi->modifiers;
3442       dpi->modifiers = NULL;
3443       d_print_comp (dpi, d_left (mods->mod));
3444       dpi->modifiers = hold_modifiers;
3445
3446       if ((dpi->options & DMGL_JAVA) == 0)
3447         d_append_string_constant (dpi, "::");
3448       else
3449         d_append_char (dpi, '.');
3450
3451       dc = d_right (mods->mod);
3452       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3453              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3454              || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
3455         dc = d_left (dc);
3456
3457       d_print_comp (dpi, dc);
3458
3459       dpi->templates = hold_dpt;
3460       return;
3461     }
3462
3463   d_print_mod (dpi, mods->mod);
3464
3465   dpi->templates = hold_dpt;
3466
3467   d_print_mod_list (dpi, mods->next, suffix);
3468 }
3469
3470 /* Print a modifier.  */
3471
3472 static void
3473 d_print_mod (struct d_print_info *dpi,
3474              const struct demangle_component *mod)
3475 {
3476   switch (mod->type)
3477     {
3478     case DEMANGLE_COMPONENT_RESTRICT:
3479     case DEMANGLE_COMPONENT_RESTRICT_THIS:
3480       d_append_string_constant (dpi, " restrict");
3481       return;
3482     case DEMANGLE_COMPONENT_VOLATILE:
3483     case DEMANGLE_COMPONENT_VOLATILE_THIS:
3484       d_append_string_constant (dpi, " volatile");
3485       return;
3486     case DEMANGLE_COMPONENT_CONST:
3487     case DEMANGLE_COMPONENT_CONST_THIS:
3488       d_append_string_constant (dpi, " const");
3489       return;
3490     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3491       d_append_char (dpi, ' ');
3492       d_print_comp (dpi, d_right (mod));
3493       return;
3494     case DEMANGLE_COMPONENT_POINTER:
3495       /* There is no pointer symbol in Java.  */
3496       if ((dpi->options & DMGL_JAVA) == 0)
3497         d_append_char (dpi, '*');
3498       return;
3499     case DEMANGLE_COMPONENT_REFERENCE:
3500       d_append_char (dpi, '&');
3501       return;
3502     case DEMANGLE_COMPONENT_COMPLEX:
3503       d_append_string_constant (dpi, "complex ");
3504       return;
3505     case DEMANGLE_COMPONENT_IMAGINARY:
3506       d_append_string_constant (dpi, "imaginary ");
3507       return;
3508     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3509       if (d_last_char (dpi) != '(')
3510         d_append_char (dpi, ' ');
3511       d_print_comp (dpi, d_left (mod));
3512       d_append_string_constant (dpi, "::*");
3513       return;
3514     case DEMANGLE_COMPONENT_TYPED_NAME:
3515       d_print_comp (dpi, d_left (mod));
3516       return;
3517     default:
3518       /* Otherwise, we have something that won't go back on the
3519          modifier stack, so we can just print it.  */
3520       d_print_comp (dpi, mod);
3521       return;
3522     }
3523 }
3524
3525 /* Print a function type, except for the return type.  */
3526
3527 static void
3528 d_print_function_type (struct d_print_info *dpi,
3529                        const struct demangle_component *dc,
3530                        struct d_print_mod *mods)
3531 {
3532   int need_paren;
3533   int saw_mod;
3534   int need_space;
3535   struct d_print_mod *p;
3536   struct d_print_mod *hold_modifiers;
3537
3538   need_paren = 0;
3539   saw_mod = 0;
3540   need_space = 0;
3541   for (p = mods; p != NULL; p = p->next)
3542     {
3543       if (p->printed)
3544         break;
3545
3546       saw_mod = 1;
3547       switch (p->mod->type)
3548         {
3549         case DEMANGLE_COMPONENT_POINTER:
3550         case DEMANGLE_COMPONENT_REFERENCE:
3551           need_paren = 1;
3552           break;
3553         case DEMANGLE_COMPONENT_RESTRICT:
3554         case DEMANGLE_COMPONENT_VOLATILE:
3555         case DEMANGLE_COMPONENT_CONST:
3556         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3557         case DEMANGLE_COMPONENT_COMPLEX:
3558         case DEMANGLE_COMPONENT_IMAGINARY:
3559         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3560           need_space = 1;
3561           need_paren = 1;
3562           break;
3563         case DEMANGLE_COMPONENT_RESTRICT_THIS:
3564         case DEMANGLE_COMPONENT_VOLATILE_THIS:
3565         case DEMANGLE_COMPONENT_CONST_THIS:
3566           break;
3567         default:
3568           break;
3569         }
3570       if (need_paren)
3571         break;
3572     }
3573
3574   if (d_left (dc) != NULL && ! saw_mod)
3575     need_paren = 1;
3576
3577   if (need_paren)
3578     {
3579       if (! need_space)
3580         {
3581           if (d_last_char (dpi) != '('
3582               && d_last_char (dpi) != '*')
3583             need_space = 1;
3584         }
3585       if (need_space && d_last_char (dpi) != ' ')
3586         d_append_char (dpi, ' ');
3587       d_append_char (dpi, '(');
3588     }
3589
3590   hold_modifiers = dpi->modifiers;
3591   dpi->modifiers = NULL;
3592
3593   d_print_mod_list (dpi, mods, 0);
3594
3595   if (need_paren)
3596     d_append_char (dpi, ')');
3597
3598   d_append_char (dpi, '(');
3599
3600   if (d_right (dc) != NULL)
3601     d_print_comp (dpi, d_right (dc));
3602
3603   d_append_char (dpi, ')');
3604
3605   d_print_mod_list (dpi, mods, 1);
3606
3607   dpi->modifiers = hold_modifiers;
3608 }
3609
3610 /* Print an array type, except for the element type.  */
3611
3612 static void
3613 d_print_array_type (struct d_print_info *dpi,
3614                     const struct demangle_component *dc,
3615                     struct d_print_mod *mods)
3616 {
3617   int need_space;
3618
3619   need_space = 1;
3620   if (mods != NULL)
3621     {
3622       int need_paren;
3623       struct d_print_mod *p;
3624
3625       need_paren = 0;
3626       for (p = mods; p != NULL; p = p->next)
3627         {
3628           if (! p->printed)
3629             {
3630               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
3631                 {
3632                   need_space = 0;
3633                   break;
3634                 }
3635               else
3636                 {
3637                   need_paren = 1;
3638                   need_space = 1;
3639                   break;
3640                 }
3641             }
3642         }
3643
3644       if (need_paren)
3645         d_append_string_constant (dpi, " (");
3646
3647       d_print_mod_list (dpi, mods, 0);
3648
3649       if (need_paren)
3650         d_append_char (dpi, ')');
3651     }
3652
3653   if (need_space)
3654     d_append_char (dpi, ' ');
3655
3656   d_append_char (dpi, '[');
3657
3658   if (d_left (dc) != NULL)
3659     d_print_comp (dpi, d_left (dc));
3660
3661   d_append_char (dpi, ']');
3662 }
3663
3664 /* Print an operator in an expression.  */
3665
3666 static void
3667 d_print_expr_op (struct d_print_info *dpi,
3668                  const struct demangle_component *dc)
3669 {
3670   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
3671     d_append_buffer (dpi, dc->u.s_operator.op->name,
3672                      dc->u.s_operator.op->len);
3673   else
3674     d_print_comp (dpi, dc);
3675 }
3676
3677 /* Print a cast.  */
3678
3679 static void
3680 d_print_cast (struct d_print_info *dpi,
3681               const struct demangle_component *dc)
3682 {
3683   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
3684     d_print_comp (dpi, d_left (dc));
3685   else
3686     {
3687       struct d_print_mod *hold_dpm;
3688       struct d_print_template dpt;
3689
3690       /* It appears that for a templated cast operator, we need to put
3691          the template parameters in scope for the operator name, but
3692          not for the parameters.  The effect is that we need to handle
3693          the template printing here.  */
3694
3695       hold_dpm = dpi->modifiers;
3696       dpi->modifiers = NULL;
3697
3698       dpt.next = dpi->templates;
3699       dpi->templates = &dpt;
3700       dpt.template_decl = d_left (dc);
3701
3702       d_print_comp (dpi, d_left (d_left (dc)));
3703
3704       dpi->templates = dpt.next;
3705
3706       if (d_last_char (dpi) == '<')
3707         d_append_char (dpi, ' ');
3708       d_append_char (dpi, '<');
3709       d_print_comp (dpi, d_right (d_left (dc)));
3710       /* Avoid generating two consecutive '>' characters, to avoid
3711          the C++ syntactic ambiguity.  */
3712       if (d_last_char (dpi) == '>')
3713         d_append_char (dpi, ' ');
3714       d_append_char (dpi, '>');
3715
3716       dpi->modifiers = hold_dpm;
3717     }
3718 }
3719
3720 /* Initialize the information structure we use to pass around
3721    information.  */
3722
3723 CP_STATIC_IF_GLIBCPP_V3
3724 void
3725 cplus_demangle_init_info (const char *mangled, int options, size_t len,
3726                           struct d_info *di)
3727 {
3728   di->s = mangled;
3729   di->send = mangled + len;
3730   di->options = options;
3731
3732   di->n = mangled;
3733
3734   /* We can not need more components than twice the number of chars in
3735      the mangled string.  Most components correspond directly to
3736      chars, but the ARGLIST types are exceptions.  */
3737   di->num_comps = 2 * len;
3738   di->next_comp = 0;
3739
3740   /* Similarly, we can not need more substitutions than there are
3741      chars in the mangled string.  */
3742   di->num_subs = len;
3743   di->next_sub = 0;
3744   di->did_subs = 0;
3745
3746   di->last_name = NULL;
3747
3748   di->expansion = 0;
3749 }
3750
3751 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
3752    name, return a buffer allocated with malloc holding the demangled
3753    name.  OPTIONS is the usual libiberty demangler options.  On
3754    success, this sets *PALC to the allocated size of the returned
3755    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
3756    a memory allocation failure.  On failure, this returns NULL.  */
3757
3758 static char *
3759 d_demangle (const char* mangled, int options, size_t *palc)
3760 {
3761   size_t len;
3762   int type;
3763   struct d_info di;
3764   struct demangle_component *dc;
3765   int estimate;
3766   char *ret;
3767
3768   *palc = 0;
3769
3770   len = strlen (mangled);
3771
3772   if (mangled[0] == '_' && mangled[1] == 'Z')
3773     type = 0;
3774   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
3775            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
3776            && (mangled[9] == 'D' || mangled[9] == 'I')
3777            && mangled[10] == '_')
3778     {
3779       char *r;
3780
3781       r = (char *) malloc (40 + len - 11);
3782       if (r == NULL)
3783         *palc = 1;
3784       else
3785         {
3786           if (mangled[9] == 'I')
3787             strcpy (r, "global constructors keyed to ");
3788           else
3789             strcpy (r, "global destructors keyed to ");
3790           strcat (r, mangled + 11);
3791         }
3792       return r;
3793     }
3794   else
3795     {
3796       if ((options & DMGL_TYPES) == 0)
3797         return NULL;
3798       type = 1;
3799     }
3800
3801   cplus_demangle_init_info (mangled, options, len, &di);
3802
3803   {
3804 #ifdef CP_DYNAMIC_ARRAYS
3805     __extension__ struct demangle_component comps[di.num_comps];
3806     __extension__ struct demangle_component *subs[di.num_subs];
3807
3808     di.comps = &comps[0];
3809     di.subs = &subs[0];
3810 #else
3811     di.comps = ((struct demangle_component *)
3812                 malloc (di.num_comps * sizeof (struct demangle_component)));
3813     di.subs = ((struct demangle_component **)
3814                malloc (di.num_subs * sizeof (struct demangle_component *)));
3815     if (di.comps == NULL || di.subs == NULL)
3816       {
3817         if (di.comps != NULL)
3818           free (di.comps);
3819         if (di.subs != NULL)
3820           free (di.subs);
3821         *palc = 1;
3822         return NULL;
3823       }
3824 #endif
3825
3826     if (! type)
3827       dc = cplus_demangle_mangled_name (&di, 1);
3828     else
3829       dc = cplus_demangle_type (&di);
3830
3831     /* If DMGL_PARAMS is set, then if we didn't consume the entire
3832        mangled string, then we didn't successfully demangle it.  If
3833        DMGL_PARAMS is not set, we didn't look at the trailing
3834        parameters.  */
3835     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
3836       dc = NULL;
3837
3838 #ifdef CP_DEMANGLE_DEBUG
3839     if (dc == NULL)
3840       printf ("failed demangling\n");
3841     else
3842       d_dump (dc, 0);
3843 #endif
3844
3845     /* We try to guess the length of the demangled string, to minimize
3846        calls to realloc during demangling.  */
3847     estimate = len + di.expansion + 10 * di.did_subs;
3848     estimate += estimate / 8;
3849
3850     ret = NULL;
3851     if (dc != NULL)
3852       ret = cplus_demangle_print (options, dc, estimate, palc);
3853
3854 #ifndef CP_DYNAMIC_ARRAYS
3855     free (di.comps);
3856     free (di.subs);
3857 #endif
3858
3859 #ifdef CP_DEMANGLE_DEBUG
3860     if (ret != NULL)
3861       {
3862         int rlen;
3863
3864         rlen = strlen (ret);
3865         if (rlen > 2 * estimate)
3866           printf ("*** Length %d much greater than estimate %d\n",
3867                   rlen, estimate);
3868         else if (rlen > estimate)
3869           printf ("*** Length %d greater than estimate %d\n",
3870                   rlen, estimate);
3871         else if (rlen < estimate / 2)
3872           printf ("*** Length %d much less than estimate %d\n",
3873                   rlen, estimate);
3874       }
3875 #endif
3876   }
3877
3878   return ret;
3879 }
3880
3881 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
3882
3883 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
3884
3885 /* ia64 ABI-mandated entry point in the C++ runtime library for
3886    performing demangling.  MANGLED_NAME is a NUL-terminated character
3887    string containing the name to be demangled.
3888
3889    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
3890    *LENGTH bytes, into which the demangled name is stored.  If
3891    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
3892    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
3893    is placed in a region of memory allocated with malloc.
3894
3895    If LENGTH is non-NULL, the length of the buffer conaining the
3896    demangled name, is placed in *LENGTH.
3897
3898    The return value is a pointer to the start of the NUL-terminated
3899    demangled name, or NULL if the demangling fails.  The caller is
3900    responsible for deallocating this memory using free.
3901
3902    *STATUS is set to one of the following values:
3903       0: The demangling operation succeeded.
3904      -1: A memory allocation failure occurred.
3905      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
3906      -3: One of the arguments is invalid.
3907
3908    The demangling is performed using the C++ ABI mangling rules, with
3909    GNU extensions.  */
3910
3911 char *
3912 __cxa_demangle (const char *mangled_name, char *output_buffer,
3913                 size_t *length, int *status)
3914 {
3915   char *demangled;
3916   size_t alc;
3917
3918   if (mangled_name == NULL)
3919     {
3920       if (status != NULL)
3921         *status = -3;
3922       return NULL;
3923     }
3924
3925   if (output_buffer != NULL && length == NULL)
3926     {
3927       if (status != NULL)
3928         *status = -3;
3929       return NULL;
3930     }
3931
3932   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
3933
3934   if (demangled == NULL)
3935     {
3936       if (status != NULL)
3937         {
3938           if (alc == 1)
3939             *status = -1;
3940           else
3941             *status = -2;
3942         }
3943       return NULL;
3944     }
3945
3946   if (output_buffer == NULL)
3947     {
3948       if (length != NULL)
3949         *length = alc;
3950     }
3951   else
3952     {
3953       if (strlen (demangled) < *length)
3954         {
3955           strcpy (output_buffer, demangled);
3956           free (demangled);
3957           demangled = output_buffer;
3958         }
3959       else
3960         {
3961           free (output_buffer);
3962           *length = alc;
3963         }
3964     }
3965
3966   if (status != NULL)
3967     *status = 0;
3968
3969   return demangled;
3970 }
3971
3972 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
3973
3974 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
3975    mangled name, return a buffer allocated with malloc holding the
3976    demangled name.  Otherwise, return NULL.  */
3977
3978 char *
3979 cplus_demangle_v3 (const char* mangled, int options)
3980 {
3981   size_t alc;
3982
3983   return d_demangle (mangled, options, &alc);
3984 }
3985
3986 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
3987    conventions, but the output formatting is a little different.
3988    This instructs the C++ demangler not to emit pointer characters ("*"), and
3989    to use Java's namespace separator symbol ("." instead of "::").  It then
3990    does an additional pass over the demangled output to replace instances
3991    of JArray<TYPE> with TYPE[].  */
3992
3993 char *
3994 java_demangle_v3 (const char* mangled)
3995 {
3996   size_t alc;
3997   char *demangled;
3998   int nesting;
3999   char *from;
4000   char *to;
4001
4002   demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS, &alc);
4003
4004   if (demangled == NULL)
4005     return NULL;
4006
4007   nesting = 0;
4008   from = demangled;
4009   to = from;
4010   while (*from != '\0')
4011     {
4012       if (strncmp (from, "JArray<", 7) == 0)
4013         {
4014           from += 7;
4015           ++nesting;
4016         }
4017       else if (nesting > 0 && *from == '>')
4018         {
4019           while (to > demangled && to[-1] == ' ')
4020             --to;
4021           *to++ = '[';
4022           *to++ = ']';
4023           --nesting;
4024           ++from;
4025         }
4026       else
4027         *to++ = *from++;
4028     }
4029
4030   *to = '\0';
4031
4032   return demangled;
4033 }
4034
4035 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4036
4037 #ifndef IN_GLIBCPP_V3
4038
4039 /* Demangle a string in order to find out whether it is a constructor
4040    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
4041    *DTOR_KIND appropriately.  */
4042
4043 static int
4044 is_ctor_or_dtor (const char *mangled,
4045                  enum gnu_v3_ctor_kinds *ctor_kind,
4046                  enum gnu_v3_dtor_kinds *dtor_kind)
4047 {
4048   struct d_info di;
4049   struct demangle_component *dc;
4050   int ret;
4051
4052   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
4053   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
4054
4055   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
4056
4057   {
4058 #ifdef CP_DYNAMIC_ARRAYS
4059     __extension__ struct demangle_component comps[di.num_comps];
4060     __extension__ struct demangle_component *subs[di.num_subs];
4061
4062     di.comps = &comps[0];
4063     di.subs = &subs[0];
4064 #else
4065     di.comps = ((struct demangle_component *)
4066                 malloc (di.num_comps * sizeof (struct demangle_component)));
4067     di.subs = ((struct demangle_component **)
4068                malloc (di.num_subs * sizeof (struct demangle_component *)));
4069     if (di.comps == NULL || di.subs == NULL)
4070       {
4071         if (di.comps != NULL)
4072           free (di.comps);
4073         if (di.subs != NULL)
4074           free (di.subs);
4075         return 0;
4076       }
4077 #endif
4078
4079     dc = cplus_demangle_mangled_name (&di, 1);
4080
4081     /* Note that because we did not pass DMGL_PARAMS, we don't expect
4082        to demangle the entire string.  */
4083
4084     ret = 0;
4085     while (dc != NULL)
4086       {
4087         switch (dc->type)
4088           {
4089           default:
4090             dc = NULL;
4091             break;
4092           case DEMANGLE_COMPONENT_TYPED_NAME:
4093           case DEMANGLE_COMPONENT_TEMPLATE:
4094           case DEMANGLE_COMPONENT_RESTRICT_THIS:
4095           case DEMANGLE_COMPONENT_VOLATILE_THIS:
4096           case DEMANGLE_COMPONENT_CONST_THIS:
4097             dc = d_left (dc);
4098             break;
4099           case DEMANGLE_COMPONENT_QUAL_NAME:
4100           case DEMANGLE_COMPONENT_LOCAL_NAME:
4101             dc = d_right (dc);
4102             break;
4103           case DEMANGLE_COMPONENT_CTOR:
4104             *ctor_kind = dc->u.s_ctor.kind;
4105             ret = 1;
4106             dc = NULL;
4107             break;
4108           case DEMANGLE_COMPONENT_DTOR:
4109             *dtor_kind = dc->u.s_dtor.kind;
4110             ret = 1;
4111             dc = NULL;
4112             break;
4113           }
4114       }
4115
4116 #ifndef CP_DYNAMIC_ARRAYS
4117     free (di.subs);
4118     free (di.comps);
4119 #endif
4120   }
4121
4122   return ret;
4123 }
4124
4125 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4126    name.  A non-zero return indicates the type of constructor.  */
4127
4128 enum gnu_v3_ctor_kinds
4129 is_gnu_v3_mangled_ctor (const char *name)
4130 {
4131   enum gnu_v3_ctor_kinds ctor_kind;
4132   enum gnu_v3_dtor_kinds dtor_kind;
4133
4134   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4135     return (enum gnu_v3_ctor_kinds) 0;
4136   return ctor_kind;
4137 }
4138
4139
4140 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4141    name.  A non-zero return indicates the type of destructor.  */
4142
4143 enum gnu_v3_dtor_kinds
4144 is_gnu_v3_mangled_dtor (const char *name)
4145 {
4146   enum gnu_v3_ctor_kinds ctor_kind;
4147   enum gnu_v3_dtor_kinds dtor_kind;
4148
4149   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4150     return (enum gnu_v3_dtor_kinds) 0;
4151   return dtor_kind;
4152 }
4153
4154 #endif /* IN_GLIBCPP_V3 */
4155
4156 #ifdef STANDALONE_DEMANGLER
4157
4158 #include "getopt.h"
4159 #include "dyn-string.h"
4160
4161 static void print_usage (FILE* fp, int exit_value);
4162
4163 #define IS_ALPHA(CHAR)                                                  \
4164   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
4165    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4166
4167 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
4168 #define is_mangled_char(CHAR)                                           \
4169   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
4170    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
4171
4172 /* The name of this program, as invoked.  */
4173 const char* program_name;
4174
4175 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
4176
4177 static void
4178 print_usage (FILE* fp, int exit_value)
4179 {
4180   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
4181   fprintf (fp, "Options:\n");
4182   fprintf (fp, "  -h,--help       Display this message.\n");
4183   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
4184   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
4185   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
4186
4187   exit (exit_value);
4188 }
4189
4190 /* Option specification for getopt_long.  */
4191 static const struct option long_options[] =
4192 {
4193   { "help",      no_argument, NULL, 'h' },
4194   { "no-params", no_argument, NULL, 'p' },
4195   { "verbose",   no_argument, NULL, 'v' },
4196   { NULL,        no_argument, NULL, 0   },
4197 };
4198
4199 /* Main entry for a demangling filter executable.  It will demangle
4200    its command line arguments, if any.  If none are provided, it will
4201    filter stdin to stdout, replacing any recognized mangled C++ names
4202    with their demangled equivalents.  */
4203
4204 int
4205 main (int argc, char *argv[])
4206 {
4207   int i;
4208   int opt_char;
4209   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
4210
4211   /* Use the program name of this program, as invoked.  */
4212   program_name = argv[0];
4213
4214   /* Parse options.  */
4215   do
4216     {
4217       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
4218       switch (opt_char)
4219         {
4220         case '?':  /* Unrecognized option.  */
4221           print_usage (stderr, 1);
4222           break;
4223
4224         case 'h':
4225           print_usage (stdout, 0);
4226           break;
4227
4228         case 'p':
4229           options &= ~ DMGL_PARAMS;
4230           break;
4231
4232         case 'v':
4233           options |= DMGL_VERBOSE;
4234           break;
4235         }
4236     }
4237   while (opt_char != -1);
4238
4239   if (optind == argc)
4240     /* No command line arguments were provided.  Filter stdin.  */
4241     {
4242       dyn_string_t mangled = dyn_string_new (3);
4243       char *s;
4244
4245       /* Read all of input.  */
4246       while (!feof (stdin))
4247         {
4248           char c;
4249
4250           /* Pile characters into mangled until we hit one that can't
4251              occur in a mangled name.  */
4252           c = getchar ();
4253           while (!feof (stdin) && is_mangled_char (c))
4254             {
4255               dyn_string_append_char (mangled, c);
4256               if (feof (stdin))
4257                 break;
4258               c = getchar ();
4259             }
4260
4261           if (dyn_string_length (mangled) > 0)
4262             {
4263 #ifdef IN_GLIBCPP_V3
4264               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
4265 #else
4266               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
4267 #endif
4268
4269               if (s != NULL)
4270                 {
4271                   fputs (s, stdout);
4272                   free (s);
4273                 }
4274               else
4275                 {
4276                   /* It might not have been a mangled name.  Print the
4277                      original text.  */
4278                   fputs (dyn_string_buf (mangled), stdout);
4279                 }
4280
4281               dyn_string_clear (mangled);
4282             }
4283
4284           /* If we haven't hit EOF yet, we've read one character that
4285              can't occur in a mangled name, so print it out.  */
4286           if (!feof (stdin))
4287             putchar (c);
4288         }
4289
4290       dyn_string_delete (mangled);
4291     }
4292   else
4293     /* Demangle command line arguments.  */
4294     {
4295       /* Loop over command line arguments.  */
4296       for (i = optind; i < argc; ++i)
4297         {
4298           char *s;
4299 #ifdef IN_GLIBCPP_V3
4300           int status;
4301 #endif
4302
4303           /* Attempt to demangle.  */
4304 #ifdef IN_GLIBCPP_V3
4305           s = __cxa_demangle (argv[i], NULL, NULL, &status);
4306 #else
4307           s = cplus_demangle_v3 (argv[i], options);
4308 #endif
4309
4310           /* If it worked, print the demangled name.  */
4311           if (s != NULL)
4312             {
4313               printf ("%s\n", s);
4314               free (s);
4315             }
4316           else
4317             {
4318 #ifdef IN_GLIBCPP_V3
4319               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
4320 #else
4321               fprintf (stderr, "Failed: %s\n", argv[i]);
4322 #endif
4323             }
4324         }
4325     }
4326
4327   return 0;
4328 }
4329
4330 #endif /* STANDALONE_DEMANGLER */