OSDN Git Service

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