libiberty/cp-demangle.c

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