OSDN Git Service

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