OSDN Git Service

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