OSDN Git Service

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