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