OSDN Git Service

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