libiberty/cp-demangle.c

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