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