libiberty/cp-demangle.c

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