libiberty/cp-demangle.c

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