OSDN Git Service

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