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