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