OSDN Git Service

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