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