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