PR middle-end/66633
[official-gcc.git] / libiberty / cp-demangle.c
blob2988b6bcb01a3be2108b87c10640c437daf4b068
1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2014
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@wasabisystems.com>.
6 This file is part of the libiberty library, which is part of GCC.
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.
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.)
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.
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.
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
36 This code was written while looking at the demangler written by
37 Alex Samuel <samuel@codesourcery.com>.
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.
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)
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.
68 This file also defines some other functions and variables which are
69 only to be used by the file cp-demint.c.
71 Preprocessor macros you can define while compiling this file:
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]().
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.
89 STANDALONE_DEMANGLER
90 If defined, this file defines a main() function which demangles
91 any arguments, or, if none, demangles stdin.
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.
98 #if defined (_AIX) && !defined (__GNUC__)
99 #pragma alloca
100 #endif
102 #ifdef HAVE_CONFIG_H
103 #include "config.h"
104 #endif
106 #include <stdio.h>
108 #ifdef HAVE_STDLIB_H
109 #include <stdlib.h>
110 #endif
111 #ifdef HAVE_STRING_H
112 #include <string.h>
113 #endif
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 */
127 #include "ansidecl.h"
128 #include "libiberty.h"
129 #include "demangle.h"
130 #include "cp-demangle.h"
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
138 #define CP_STATIC_IF_GLIBCPP_V3 static
140 #define cplus_demangle_fill_name d_fill_name
141 static int d_fill_name (struct demangle_component *, const char *, int);
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 *);
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 *);
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 *);
158 #define cplus_demangle_mangled_name d_mangled_name
159 static struct demangle_component *d_mangled_name (struct d_info *, int);
161 #define cplus_demangle_type d_type
162 static struct demangle_component *d_type (struct d_info *);
164 #define cplus_demangle_print d_print
165 static char *d_print (int, const struct demangle_component *, int, size_t *);
167 #define cplus_demangle_print_callback d_print_callback
168 static int d_print_callback (int, const struct demangle_component *,
169 demangle_callbackref, void *);
171 #define cplus_demangle_init_info d_init_info
172 static void d_init_info (const char *, int, size_t, struct d_info *);
174 #else /* ! defined(IN_GLIBCPP_V3) */
175 #define CP_STATIC_IF_GLIBCPP_V3
176 #endif /* ! defined(IN_GLIBCPP_V3) */
178 /* See if the compiler supports dynamic arrays. */
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__) */
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.
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. */
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')
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)
211 /* Information we keep for the standard substitutions. */
213 struct d_standard_sub_info
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;
234 /* Accessors for subtrees of struct demangle_component. */
236 #define d_left(dc) ((dc)->u.s_binary.left)
237 #define d_right(dc) ((dc)->u.s_binary.right)
239 /* A list of templates. This is used while printing. */
241 struct d_print_template
243 /* Next template on the list. */
244 struct d_print_template *next;
245 /* This template. */
246 const struct demangle_component *template_decl;
249 /* A list of type modifiers. This is used while printing. */
251 struct d_print_mod
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;
264 /* We use these structures to hold information during printing. */
266 struct d_growable_string
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;
278 /* Stack of components, innermost first, used to avoid loops. */
280 struct d_component_stack
282 /* This component. */
283 const struct demangle_component *dc;
284 /* This component's parent. */
285 const struct d_component_stack *parent;
288 /* A demangle component and some scope captured when it was first
289 traversed. */
291 struct d_saved_scope
293 /* The component whose scope this is. */
294 const struct demangle_component *container;
295 /* The list of templates, if any, that was current when this
296 scope was captured. */
297 struct d_print_template *templates;
300 /* Checkpoint structure to allow backtracking. This holds copies
301 of the fields of struct d_info that need to be restored
302 if a trial parse needs to be backtracked over. */
304 struct d_info_checkpoint
306 const char *n;
307 int next_comp;
308 int next_sub;
309 int did_subs;
310 int expansion;
313 enum { D_PRINT_BUFFER_LENGTH = 256 };
314 struct d_print_info
316 /* Fixed-length allocated buffer for demangled data, flushed to the
317 callback with a NUL termination once full. */
318 char buf[D_PRINT_BUFFER_LENGTH];
319 /* Current length of data in buffer. */
320 size_t len;
321 /* The last character printed, saved individually so that it survives
322 any buffer flush. */
323 char last_char;
324 /* Callback function to handle demangled buffer flush. */
325 demangle_callbackref callback;
326 /* Opaque callback argument. */
327 void *opaque;
328 /* The current list of templates, if any. */
329 struct d_print_template *templates;
330 /* The current list of modifiers (e.g., pointer, reference, etc.),
331 if any. */
332 struct d_print_mod *modifiers;
333 /* Set to 1 if we saw a demangling error. */
334 int demangle_failure;
335 /* The current index into any template argument packs we are using
336 for printing. */
337 int pack_index;
338 /* Number of d_print_flush calls so far. */
339 unsigned long int flush_count;
340 /* Stack of components, innermost first, used to avoid loops. */
341 const struct d_component_stack *component_stack;
342 /* Array of saved scopes for evaluating substitutions. */
343 struct d_saved_scope *saved_scopes;
344 /* Index of the next unused saved scope in the above array. */
345 int next_saved_scope;
346 /* Number of saved scopes in the above array. */
347 int num_saved_scopes;
348 /* Array of templates for saving into scopes. */
349 struct d_print_template *copy_templates;
350 /* Index of the next unused copy template in the above array. */
351 int next_copy_template;
352 /* Number of copy templates in the above array. */
353 int num_copy_templates;
354 /* The nearest enclosing template, if any. */
355 const struct demangle_component *current_template;
358 #ifdef CP_DEMANGLE_DEBUG
359 static void d_dump (struct demangle_component *, int);
360 #endif
362 static struct demangle_component *
363 d_make_empty (struct d_info *);
365 static struct demangle_component *
366 d_make_comp (struct d_info *, enum demangle_component_type,
367 struct demangle_component *,
368 struct demangle_component *);
370 static struct demangle_component *
371 d_make_name (struct d_info *, const char *, int);
373 static struct demangle_component *
374 d_make_demangle_mangled_name (struct d_info *, const char *);
376 static struct demangle_component *
377 d_make_builtin_type (struct d_info *,
378 const struct demangle_builtin_type_info *);
380 static struct demangle_component *
381 d_make_operator (struct d_info *,
382 const struct demangle_operator_info *);
384 static struct demangle_component *
385 d_make_extended_operator (struct d_info *, int,
386 struct demangle_component *);
388 static struct demangle_component *
389 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
390 struct demangle_component *);
392 static struct demangle_component *
393 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
394 struct demangle_component *);
396 static struct demangle_component *
397 d_make_template_param (struct d_info *, long);
399 static struct demangle_component *
400 d_make_sub (struct d_info *, const char *, int);
402 static int
403 has_return_type (struct demangle_component *);
405 static int
406 is_ctor_dtor_or_conversion (struct demangle_component *);
408 static struct demangle_component *d_encoding (struct d_info *, int);
410 static struct demangle_component *d_name (struct d_info *);
412 static struct demangle_component *d_nested_name (struct d_info *);
414 static struct demangle_component *d_prefix (struct d_info *);
416 static struct demangle_component *d_unqualified_name (struct d_info *);
418 static struct demangle_component *d_source_name (struct d_info *);
420 static long d_number (struct d_info *);
422 static struct demangle_component *d_identifier (struct d_info *, int);
424 static struct demangle_component *d_operator_name (struct d_info *);
426 static struct demangle_component *d_special_name (struct d_info *);
428 static int d_call_offset (struct d_info *, int);
430 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
432 static struct demangle_component **
433 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
435 static struct demangle_component *
436 d_ref_qualifier (struct d_info *, struct demangle_component *);
438 static struct demangle_component *
439 d_function_type (struct d_info *);
441 static struct demangle_component *
442 d_bare_function_type (struct d_info *, int);
444 static struct demangle_component *
445 d_class_enum_type (struct d_info *);
447 static struct demangle_component *d_array_type (struct d_info *);
449 static struct demangle_component *d_vector_type (struct d_info *);
451 static struct demangle_component *
452 d_pointer_to_member_type (struct d_info *);
454 static struct demangle_component *
455 d_template_param (struct d_info *);
457 static struct demangle_component *d_template_args (struct d_info *);
459 static struct demangle_component *
460 d_template_arg (struct d_info *);
462 static struct demangle_component *d_expression (struct d_info *);
464 static struct demangle_component *d_expr_primary (struct d_info *);
466 static struct demangle_component *d_local_name (struct d_info *);
468 static int d_discriminator (struct d_info *);
470 static struct demangle_component *d_lambda (struct d_info *);
472 static struct demangle_component *d_unnamed_type (struct d_info *);
474 static struct demangle_component *
475 d_clone_suffix (struct d_info *, struct demangle_component *);
477 static int
478 d_add_substitution (struct d_info *, struct demangle_component *);
480 static struct demangle_component *d_substitution (struct d_info *, int);
482 static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
484 static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
486 static void d_growable_string_init (struct d_growable_string *, size_t);
488 static inline void
489 d_growable_string_resize (struct d_growable_string *, size_t);
491 static inline void
492 d_growable_string_append_buffer (struct d_growable_string *,
493 const char *, size_t);
494 static void
495 d_growable_string_callback_adapter (const char *, size_t, void *);
497 static void
498 d_print_init (struct d_print_info *, demangle_callbackref, void *,
499 const struct demangle_component *);
501 static inline void d_print_error (struct d_print_info *);
503 static inline int d_print_saw_error (struct d_print_info *);
505 static inline void d_print_flush (struct d_print_info *);
507 static inline void d_append_char (struct d_print_info *, char);
509 static inline void d_append_buffer (struct d_print_info *,
510 const char *, size_t);
512 static inline void d_append_string (struct d_print_info *, const char *);
514 static inline char d_last_char (struct d_print_info *);
516 static void
517 d_print_comp (struct d_print_info *, int, const struct demangle_component *);
519 static void
520 d_print_java_identifier (struct d_print_info *, const char *, int);
522 static void
523 d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
525 static void
526 d_print_mod (struct d_print_info *, int, const struct demangle_component *);
528 static void
529 d_print_function_type (struct d_print_info *, int,
530 const struct demangle_component *,
531 struct d_print_mod *);
533 static void
534 d_print_array_type (struct d_print_info *, int,
535 const struct demangle_component *,
536 struct d_print_mod *);
538 static void
539 d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);
541 static void
542 d_print_cast (struct d_print_info *, int, const struct demangle_component *);
544 static int d_demangle_callback (const char *, int,
545 demangle_callbackref, void *);
546 static char *d_demangle (const char *, int, size_t *);
548 #ifdef CP_DEMANGLE_DEBUG
550 static void
551 d_dump (struct demangle_component *dc, int indent)
553 int i;
555 if (dc == NULL)
557 if (indent == 0)
558 printf ("failed demangling\n");
559 return;
562 for (i = 0; i < indent; ++i)
563 putchar (' ');
565 switch (dc->type)
567 case DEMANGLE_COMPONENT_NAME:
568 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
569 return;
570 case DEMANGLE_COMPONENT_TAGGED_NAME:
571 printf ("tagged name\n");
572 d_dump (dc->u.s_binary.left, indent + 2);
573 d_dump (dc->u.s_binary.right, indent + 2);
574 return;
575 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
576 printf ("template parameter %ld\n", dc->u.s_number.number);
577 return;
578 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
579 printf ("function parameter %ld\n", dc->u.s_number.number);
580 return;
581 case DEMANGLE_COMPONENT_CTOR:
582 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
583 d_dump (dc->u.s_ctor.name, indent + 2);
584 return;
585 case DEMANGLE_COMPONENT_DTOR:
586 printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
587 d_dump (dc->u.s_dtor.name, indent + 2);
588 return;
589 case DEMANGLE_COMPONENT_SUB_STD:
590 printf ("standard substitution %s\n", dc->u.s_string.string);
591 return;
592 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
593 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
594 return;
595 case DEMANGLE_COMPONENT_OPERATOR:
596 printf ("operator %s\n", dc->u.s_operator.op->name);
597 return;
598 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
599 printf ("extended operator with %d args\n",
600 dc->u.s_extended_operator.args);
601 d_dump (dc->u.s_extended_operator.name, indent + 2);
602 return;
604 case DEMANGLE_COMPONENT_QUAL_NAME:
605 printf ("qualified name\n");
606 break;
607 case DEMANGLE_COMPONENT_LOCAL_NAME:
608 printf ("local name\n");
609 break;
610 case DEMANGLE_COMPONENT_TYPED_NAME:
611 printf ("typed name\n");
612 break;
613 case DEMANGLE_COMPONENT_TEMPLATE:
614 printf ("template\n");
615 break;
616 case DEMANGLE_COMPONENT_VTABLE:
617 printf ("vtable\n");
618 break;
619 case DEMANGLE_COMPONENT_VTT:
620 printf ("VTT\n");
621 break;
622 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
623 printf ("construction vtable\n");
624 break;
625 case DEMANGLE_COMPONENT_TYPEINFO:
626 printf ("typeinfo\n");
627 break;
628 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
629 printf ("typeinfo name\n");
630 break;
631 case DEMANGLE_COMPONENT_TYPEINFO_FN:
632 printf ("typeinfo function\n");
633 break;
634 case DEMANGLE_COMPONENT_THUNK:
635 printf ("thunk\n");
636 break;
637 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
638 printf ("virtual thunk\n");
639 break;
640 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
641 printf ("covariant thunk\n");
642 break;
643 case DEMANGLE_COMPONENT_JAVA_CLASS:
644 printf ("java class\n");
645 break;
646 case DEMANGLE_COMPONENT_GUARD:
647 printf ("guard\n");
648 break;
649 case DEMANGLE_COMPONENT_REFTEMP:
650 printf ("reference temporary\n");
651 break;
652 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
653 printf ("hidden alias\n");
654 break;
655 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
656 printf ("transaction clone\n");
657 break;
658 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
659 printf ("non-transaction clone\n");
660 break;
661 case DEMANGLE_COMPONENT_RESTRICT:
662 printf ("restrict\n");
663 break;
664 case DEMANGLE_COMPONENT_VOLATILE:
665 printf ("volatile\n");
666 break;
667 case DEMANGLE_COMPONENT_CONST:
668 printf ("const\n");
669 break;
670 case DEMANGLE_COMPONENT_RESTRICT_THIS:
671 printf ("restrict this\n");
672 break;
673 case DEMANGLE_COMPONENT_VOLATILE_THIS:
674 printf ("volatile this\n");
675 break;
676 case DEMANGLE_COMPONENT_CONST_THIS:
677 printf ("const this\n");
678 break;
679 case DEMANGLE_COMPONENT_REFERENCE_THIS:
680 printf ("reference this\n");
681 break;
682 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
683 printf ("rvalue reference this\n");
684 break;
685 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
686 printf ("vendor type qualifier\n");
687 break;
688 case DEMANGLE_COMPONENT_POINTER:
689 printf ("pointer\n");
690 break;
691 case DEMANGLE_COMPONENT_REFERENCE:
692 printf ("reference\n");
693 break;
694 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
695 printf ("rvalue reference\n");
696 break;
697 case DEMANGLE_COMPONENT_COMPLEX:
698 printf ("complex\n");
699 break;
700 case DEMANGLE_COMPONENT_IMAGINARY:
701 printf ("imaginary\n");
702 break;
703 case DEMANGLE_COMPONENT_VENDOR_TYPE:
704 printf ("vendor type\n");
705 break;
706 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
707 printf ("function type\n");
708 break;
709 case DEMANGLE_COMPONENT_ARRAY_TYPE:
710 printf ("array type\n");
711 break;
712 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
713 printf ("pointer to member type\n");
714 break;
715 case DEMANGLE_COMPONENT_FIXED_TYPE:
716 printf ("fixed-point type, accum? %d, sat? %d\n",
717 dc->u.s_fixed.accum, dc->u.s_fixed.sat);
718 d_dump (dc->u.s_fixed.length, indent + 2)
719 break;
720 case DEMANGLE_COMPONENT_ARGLIST:
721 printf ("argument list\n");
722 break;
723 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
724 printf ("template argument list\n");
725 break;
726 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
727 printf ("initializer list\n");
728 break;
729 case DEMANGLE_COMPONENT_CAST:
730 printf ("cast\n");
731 break;
732 case DEMANGLE_COMPONENT_NULLARY:
733 printf ("nullary operator\n");
734 break;
735 case DEMANGLE_COMPONENT_UNARY:
736 printf ("unary operator\n");
737 break;
738 case DEMANGLE_COMPONENT_BINARY:
739 printf ("binary operator\n");
740 break;
741 case DEMANGLE_COMPONENT_BINARY_ARGS:
742 printf ("binary operator arguments\n");
743 break;
744 case DEMANGLE_COMPONENT_TRINARY:
745 printf ("trinary operator\n");
746 break;
747 case DEMANGLE_COMPONENT_TRINARY_ARG1:
748 printf ("trinary operator arguments 1\n");
749 break;
750 case DEMANGLE_COMPONENT_TRINARY_ARG2:
751 printf ("trinary operator arguments 1\n");
752 break;
753 case DEMANGLE_COMPONENT_LITERAL:
754 printf ("literal\n");
755 break;
756 case DEMANGLE_COMPONENT_LITERAL_NEG:
757 printf ("negative literal\n");
758 break;
759 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
760 printf ("java resource\n");
761 break;
762 case DEMANGLE_COMPONENT_COMPOUND_NAME:
763 printf ("compound name\n");
764 break;
765 case DEMANGLE_COMPONENT_CHARACTER:
766 printf ("character '%c'\n", dc->u.s_character.character);
767 return;
768 case DEMANGLE_COMPONENT_NUMBER:
769 printf ("number %ld\n", dc->u.s_number.number);
770 return;
771 case DEMANGLE_COMPONENT_DECLTYPE:
772 printf ("decltype\n");
773 break;
774 case DEMANGLE_COMPONENT_PACK_EXPANSION:
775 printf ("pack expansion\n");
776 break;
777 case DEMANGLE_COMPONENT_TLS_INIT:
778 printf ("tls init function\n");
779 break;
780 case DEMANGLE_COMPONENT_TLS_WRAPPER:
781 printf ("tls wrapper function\n");
782 break;
783 case DEMANGLE_COMPONENT_DEFAULT_ARG:
784 printf ("default argument %d\n", dc->u.s_unary_num.num);
785 d_dump (dc->u.s_unary_num.sub, indent+2);
786 return;
787 case DEMANGLE_COMPONENT_LAMBDA:
788 printf ("lambda %d\n", dc->u.s_unary_num.num);
789 d_dump (dc->u.s_unary_num.sub, indent+2);
790 return;
793 d_dump (d_left (dc), indent + 2);
794 d_dump (d_right (dc), indent + 2);
797 #endif /* CP_DEMANGLE_DEBUG */
799 /* Fill in a DEMANGLE_COMPONENT_NAME. */
801 CP_STATIC_IF_GLIBCPP_V3
803 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
805 if (p == NULL || s == NULL || len == 0)
806 return 0;
807 p->type = DEMANGLE_COMPONENT_NAME;
808 p->u.s_name.s = s;
809 p->u.s_name.len = len;
810 return 1;
813 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
815 CP_STATIC_IF_GLIBCPP_V3
817 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
818 struct demangle_component *name)
820 if (p == NULL || args < 0 || name == NULL)
821 return 0;
822 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
823 p->u.s_extended_operator.args = args;
824 p->u.s_extended_operator.name = name;
825 return 1;
828 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
830 CP_STATIC_IF_GLIBCPP_V3
832 cplus_demangle_fill_ctor (struct demangle_component *p,
833 enum gnu_v3_ctor_kinds kind,
834 struct demangle_component *name)
836 if (p == NULL
837 || name == NULL
838 || (int) kind < gnu_v3_complete_object_ctor
839 || (int) kind > gnu_v3_object_ctor_group)
840 return 0;
841 p->type = DEMANGLE_COMPONENT_CTOR;
842 p->u.s_ctor.kind = kind;
843 p->u.s_ctor.name = name;
844 return 1;
847 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
849 CP_STATIC_IF_GLIBCPP_V3
851 cplus_demangle_fill_dtor (struct demangle_component *p,
852 enum gnu_v3_dtor_kinds kind,
853 struct demangle_component *name)
855 if (p == NULL
856 || name == NULL
857 || (int) kind < gnu_v3_deleting_dtor
858 || (int) kind > gnu_v3_object_dtor_group)
859 return 0;
860 p->type = DEMANGLE_COMPONENT_DTOR;
861 p->u.s_dtor.kind = kind;
862 p->u.s_dtor.name = name;
863 return 1;
866 /* Add a new component. */
868 static struct demangle_component *
869 d_make_empty (struct d_info *di)
871 struct demangle_component *p;
873 if (di->next_comp >= di->num_comps)
874 return NULL;
875 p = &di->comps[di->next_comp];
876 ++di->next_comp;
877 return p;
880 /* Add a new generic component. */
882 static struct demangle_component *
883 d_make_comp (struct d_info *di, enum demangle_component_type type,
884 struct demangle_component *left,
885 struct demangle_component *right)
887 struct demangle_component *p;
889 /* We check for errors here. A typical error would be a NULL return
890 from a subroutine. We catch those here, and return NULL
891 upward. */
892 switch (type)
894 /* These types require two parameters. */
895 case DEMANGLE_COMPONENT_QUAL_NAME:
896 case DEMANGLE_COMPONENT_LOCAL_NAME:
897 case DEMANGLE_COMPONENT_TYPED_NAME:
898 case DEMANGLE_COMPONENT_TAGGED_NAME:
899 case DEMANGLE_COMPONENT_TEMPLATE:
900 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
901 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
902 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
903 case DEMANGLE_COMPONENT_UNARY:
904 case DEMANGLE_COMPONENT_BINARY:
905 case DEMANGLE_COMPONENT_BINARY_ARGS:
906 case DEMANGLE_COMPONENT_TRINARY:
907 case DEMANGLE_COMPONENT_TRINARY_ARG1:
908 case DEMANGLE_COMPONENT_LITERAL:
909 case DEMANGLE_COMPONENT_LITERAL_NEG:
910 case DEMANGLE_COMPONENT_COMPOUND_NAME:
911 case DEMANGLE_COMPONENT_VECTOR_TYPE:
912 case DEMANGLE_COMPONENT_CLONE:
913 if (left == NULL || right == NULL)
914 return NULL;
915 break;
917 /* These types only require one parameter. */
918 case DEMANGLE_COMPONENT_VTABLE:
919 case DEMANGLE_COMPONENT_VTT:
920 case DEMANGLE_COMPONENT_TYPEINFO:
921 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
922 case DEMANGLE_COMPONENT_TYPEINFO_FN:
923 case DEMANGLE_COMPONENT_THUNK:
924 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
925 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
926 case DEMANGLE_COMPONENT_JAVA_CLASS:
927 case DEMANGLE_COMPONENT_GUARD:
928 case DEMANGLE_COMPONENT_TLS_INIT:
929 case DEMANGLE_COMPONENT_TLS_WRAPPER:
930 case DEMANGLE_COMPONENT_REFTEMP:
931 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
932 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
933 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
934 case DEMANGLE_COMPONENT_POINTER:
935 case DEMANGLE_COMPONENT_REFERENCE:
936 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
937 case DEMANGLE_COMPONENT_COMPLEX:
938 case DEMANGLE_COMPONENT_IMAGINARY:
939 case DEMANGLE_COMPONENT_VENDOR_TYPE:
940 case DEMANGLE_COMPONENT_CAST:
941 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
942 case DEMANGLE_COMPONENT_DECLTYPE:
943 case DEMANGLE_COMPONENT_PACK_EXPANSION:
944 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
945 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
946 case DEMANGLE_COMPONENT_NULLARY:
947 case DEMANGLE_COMPONENT_TRINARY_ARG2:
948 if (left == NULL)
949 return NULL;
950 break;
952 /* This needs a right parameter, but the left parameter can be
953 empty. */
954 case DEMANGLE_COMPONENT_ARRAY_TYPE:
955 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
956 if (right == NULL)
957 return NULL;
958 break;
960 /* These are allowed to have no parameters--in some cases they
961 will be filled in later. */
962 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
963 case DEMANGLE_COMPONENT_RESTRICT:
964 case DEMANGLE_COMPONENT_VOLATILE:
965 case DEMANGLE_COMPONENT_CONST:
966 case DEMANGLE_COMPONENT_RESTRICT_THIS:
967 case DEMANGLE_COMPONENT_VOLATILE_THIS:
968 case DEMANGLE_COMPONENT_CONST_THIS:
969 case DEMANGLE_COMPONENT_REFERENCE_THIS:
970 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
971 case DEMANGLE_COMPONENT_ARGLIST:
972 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
973 break;
975 /* Other types should not be seen here. */
976 default:
977 return NULL;
980 p = d_make_empty (di);
981 if (p != NULL)
983 p->type = type;
984 p->u.s_binary.left = left;
985 p->u.s_binary.right = right;
987 return p;
990 /* Add a new demangle mangled name component. */
992 static struct demangle_component *
993 d_make_demangle_mangled_name (struct d_info *di, const char *s)
995 if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
996 return d_make_name (di, s, strlen (s));
997 d_advance (di, 2);
998 return d_encoding (di, 0);
1001 /* Add a new name component. */
1003 static struct demangle_component *
1004 d_make_name (struct d_info *di, const char *s, int len)
1006 struct demangle_component *p;
1008 p = d_make_empty (di);
1009 if (! cplus_demangle_fill_name (p, s, len))
1010 return NULL;
1011 return p;
1014 /* Add a new builtin type component. */
1016 static struct demangle_component *
1017 d_make_builtin_type (struct d_info *di,
1018 const struct demangle_builtin_type_info *type)
1020 struct demangle_component *p;
1022 if (type == NULL)
1023 return NULL;
1024 p = d_make_empty (di);
1025 if (p != NULL)
1027 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
1028 p->u.s_builtin.type = type;
1030 return p;
1033 /* Add a new operator component. */
1035 static struct demangle_component *
1036 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
1038 struct demangle_component *p;
1040 p = d_make_empty (di);
1041 if (p != NULL)
1043 p->type = DEMANGLE_COMPONENT_OPERATOR;
1044 p->u.s_operator.op = op;
1046 return p;
1049 /* Add a new extended operator component. */
1051 static struct demangle_component *
1052 d_make_extended_operator (struct d_info *di, int args,
1053 struct demangle_component *name)
1055 struct demangle_component *p;
1057 p = d_make_empty (di);
1058 if (! cplus_demangle_fill_extended_operator (p, args, name))
1059 return NULL;
1060 return p;
1063 static struct demangle_component *
1064 d_make_default_arg (struct d_info *di, int num,
1065 struct demangle_component *sub)
1067 struct demangle_component *p = d_make_empty (di);
1068 if (p)
1070 p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
1071 p->u.s_unary_num.num = num;
1072 p->u.s_unary_num.sub = sub;
1074 return p;
1077 /* Add a new constructor component. */
1079 static struct demangle_component *
1080 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
1081 struct demangle_component *name)
1083 struct demangle_component *p;
1085 p = d_make_empty (di);
1086 if (! cplus_demangle_fill_ctor (p, kind, name))
1087 return NULL;
1088 return p;
1091 /* Add a new destructor component. */
1093 static struct demangle_component *
1094 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
1095 struct demangle_component *name)
1097 struct demangle_component *p;
1099 p = d_make_empty (di);
1100 if (! cplus_demangle_fill_dtor (p, kind, name))
1101 return NULL;
1102 return p;
1105 /* Add a new template parameter. */
1107 static struct demangle_component *
1108 d_make_template_param (struct d_info *di, long i)
1110 struct demangle_component *p;
1112 p = d_make_empty (di);
1113 if (p != NULL)
1115 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
1116 p->u.s_number.number = i;
1118 return p;
1121 /* Add a new function parameter. */
1123 static struct demangle_component *
1124 d_make_function_param (struct d_info *di, long i)
1126 struct demangle_component *p;
1128 p = d_make_empty (di);
1129 if (p != NULL)
1131 p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1132 p->u.s_number.number = i;
1134 return p;
1137 /* Add a new standard substitution component. */
1139 static struct demangle_component *
1140 d_make_sub (struct d_info *di, const char *name, int len)
1142 struct demangle_component *p;
1144 p = d_make_empty (di);
1145 if (p != NULL)
1147 p->type = DEMANGLE_COMPONENT_SUB_STD;
1148 p->u.s_string.string = name;
1149 p->u.s_string.len = len;
1151 return p;
1154 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1156 TOP_LEVEL is non-zero when called at the top level. */
1158 CP_STATIC_IF_GLIBCPP_V3
1159 struct demangle_component *
1160 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1162 struct demangle_component *p;
1164 if (! d_check_char (di, '_')
1165 /* Allow missing _ if not at toplevel to work around a
1166 bug in G++ abi-version=2 mangling; see the comment in
1167 write_template_arg. */
1168 && top_level)
1169 return NULL;
1170 if (! d_check_char (di, 'Z'))
1171 return NULL;
1172 p = d_encoding (di, top_level);
1174 /* If at top level and parsing parameters, check for a clone
1175 suffix. */
1176 if (top_level && (di->options & DMGL_PARAMS) != 0)
1177 while (d_peek_char (di) == '.'
1178 && (IS_LOWER (d_peek_next_char (di))
1179 || d_peek_next_char (di) == '_'
1180 || IS_DIGIT (d_peek_next_char (di))))
1181 p = d_clone_suffix (di, p);
1183 return p;
1186 /* Return whether a function should have a return type. The argument
1187 is the function name, which may be qualified in various ways. The
1188 rules are that template functions have return types with some
1189 exceptions, function types which are not part of a function name
1190 mangling have return types with some exceptions, and non-template
1191 function names do not have return types. The exceptions are that
1192 constructors, destructors, and conversion operators do not have
1193 return types. */
1195 static int
1196 has_return_type (struct demangle_component *dc)
1198 if (dc == NULL)
1199 return 0;
1200 switch (dc->type)
1202 default:
1203 return 0;
1204 case DEMANGLE_COMPONENT_TEMPLATE:
1205 return ! is_ctor_dtor_or_conversion (d_left (dc));
1206 case DEMANGLE_COMPONENT_RESTRICT_THIS:
1207 case DEMANGLE_COMPONENT_VOLATILE_THIS:
1208 case DEMANGLE_COMPONENT_CONST_THIS:
1209 case DEMANGLE_COMPONENT_REFERENCE_THIS:
1210 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
1211 return has_return_type (d_left (dc));
1215 /* Return whether a name is a constructor, a destructor, or a
1216 conversion operator. */
1218 static int
1219 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1221 if (dc == NULL)
1222 return 0;
1223 switch (dc->type)
1225 default:
1226 return 0;
1227 case DEMANGLE_COMPONENT_QUAL_NAME:
1228 case DEMANGLE_COMPONENT_LOCAL_NAME:
1229 return is_ctor_dtor_or_conversion (d_right (dc));
1230 case DEMANGLE_COMPONENT_CTOR:
1231 case DEMANGLE_COMPONENT_DTOR:
1232 case DEMANGLE_COMPONENT_CAST:
1233 return 1;
1237 /* <encoding> ::= <(function) name> <bare-function-type>
1238 ::= <(data) name>
1239 ::= <special-name>
1241 TOP_LEVEL is non-zero when called at the top level, in which case
1242 if DMGL_PARAMS is not set we do not demangle the function
1243 parameters. We only set this at the top level, because otherwise
1244 we would not correctly demangle names in local scopes. */
1246 static struct demangle_component *
1247 d_encoding (struct d_info *di, int top_level)
1249 char peek = d_peek_char (di);
1251 if (peek == 'G' || peek == 'T')
1252 return d_special_name (di);
1253 else
1255 struct demangle_component *dc;
1257 dc = d_name (di);
1259 if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1261 /* Strip off any initial CV-qualifiers, as they really apply
1262 to the `this' parameter, and they were not output by the
1263 v2 demangler without DMGL_PARAMS. */
1264 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1265 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1266 || dc->type == DEMANGLE_COMPONENT_CONST_THIS
1267 || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
1268 || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
1269 dc = d_left (dc);
1271 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1272 there may be CV-qualifiers on its right argument which
1273 really apply here; this happens when parsing a class
1274 which is local to a function. */
1275 if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1277 struct demangle_component *dcr;
1279 dcr = d_right (dc);
1280 while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1281 || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1282 || dcr->type == DEMANGLE_COMPONENT_CONST_THIS
1283 || dcr->type == DEMANGLE_COMPONENT_REFERENCE_THIS
1284 || dcr->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
1285 dcr = d_left (dcr);
1286 dc->u.s_binary.right = dcr;
1289 return dc;
1292 peek = d_peek_char (di);
1293 if (dc == NULL || peek == '\0' || peek == 'E')
1294 return dc;
1295 return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1296 d_bare_function_type (di, has_return_type (dc)));
1300 /* <tagged-name> ::= <name> B <source-name> */
1302 static struct demangle_component *
1303 d_abi_tags (struct d_info *di, struct demangle_component *dc)
1305 char peek;
1306 while (peek = d_peek_char (di),
1307 peek == 'B')
1309 struct demangle_component *tag;
1310 d_advance (di, 1);
1311 tag = d_source_name (di);
1312 dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
1314 return dc;
1317 /* <name> ::= <nested-name>
1318 ::= <unscoped-name>
1319 ::= <unscoped-template-name> <template-args>
1320 ::= <local-name>
1322 <unscoped-name> ::= <unqualified-name>
1323 ::= St <unqualified-name>
1325 <unscoped-template-name> ::= <unscoped-name>
1326 ::= <substitution>
1329 static struct demangle_component *
1330 d_name (struct d_info *di)
1332 char peek = d_peek_char (di);
1333 struct demangle_component *dc;
1335 switch (peek)
1337 case 'N':
1338 return d_nested_name (di);
1340 case 'Z':
1341 return d_local_name (di);
1343 case 'U':
1344 return d_unqualified_name (di);
1346 case 'S':
1348 int subst;
1350 if (d_peek_next_char (di) != 't')
1352 dc = d_substitution (di, 0);
1353 subst = 1;
1355 else
1357 d_advance (di, 2);
1358 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1359 d_make_name (di, "std", 3),
1360 d_unqualified_name (di));
1361 di->expansion += 3;
1362 subst = 0;
1365 if (d_peek_char (di) != 'I')
1367 /* The grammar does not permit this case to occur if we
1368 called d_substitution() above (i.e., subst == 1). We
1369 don't bother to check. */
1371 else
1373 /* This is <template-args>, which means that we just saw
1374 <unscoped-template-name>, which is a substitution
1375 candidate if we didn't just get it from a
1376 substitution. */
1377 if (! subst)
1379 if (! d_add_substitution (di, dc))
1380 return NULL;
1382 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1383 d_template_args (di));
1386 return dc;
1389 case 'L':
1390 default:
1391 dc = d_unqualified_name (di);
1392 if (d_peek_char (di) == 'I')
1394 /* This is <template-args>, which means that we just saw
1395 <unscoped-template-name>, which is a substitution
1396 candidate. */
1397 if (! d_add_substitution (di, dc))
1398 return NULL;
1399 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1400 d_template_args (di));
1402 return dc;
1406 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1407 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1410 static struct demangle_component *
1411 d_nested_name (struct d_info *di)
1413 struct demangle_component *ret;
1414 struct demangle_component **pret;
1415 struct demangle_component *rqual;
1417 if (! d_check_char (di, 'N'))
1418 return NULL;
1420 pret = d_cv_qualifiers (di, &ret, 1);
1421 if (pret == NULL)
1422 return NULL;
1424 /* Parse the ref-qualifier now and then attach it
1425 once we have something to attach it to. */
1426 rqual = d_ref_qualifier (di, NULL);
1428 *pret = d_prefix (di);
1429 if (*pret == NULL)
1430 return NULL;
1432 if (rqual)
1434 d_left (rqual) = ret;
1435 ret = rqual;
1438 if (! d_check_char (di, 'E'))
1439 return NULL;
1441 return ret;
1444 /* <prefix> ::= <prefix> <unqualified-name>
1445 ::= <template-prefix> <template-args>
1446 ::= <template-param>
1447 ::= <decltype>
1449 ::= <substitution>
1451 <template-prefix> ::= <prefix> <(template) unqualified-name>
1452 ::= <template-param>
1453 ::= <substitution>
1456 static struct demangle_component *
1457 d_prefix (struct d_info *di)
1459 struct demangle_component *ret = NULL;
1461 while (1)
1463 char peek;
1464 enum demangle_component_type comb_type;
1465 struct demangle_component *dc;
1467 peek = d_peek_char (di);
1468 if (peek == '\0')
1469 return NULL;
1471 /* The older code accepts a <local-name> here, but I don't see
1472 that in the grammar. The older code does not accept a
1473 <template-param> here. */
1475 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1476 if (peek == 'D')
1478 char peek2 = d_peek_next_char (di);
1479 if (peek2 == 'T' || peek2 == 't')
1480 /* Decltype. */
1481 dc = cplus_demangle_type (di);
1482 else
1483 /* Destructor name. */
1484 dc = d_unqualified_name (di);
1486 else if (IS_DIGIT (peek)
1487 || IS_LOWER (peek)
1488 || peek == 'C'
1489 || peek == 'U'
1490 || peek == 'L')
1491 dc = d_unqualified_name (di);
1492 else if (peek == 'S')
1493 dc = d_substitution (di, 1);
1494 else if (peek == 'I')
1496 if (ret == NULL)
1497 return NULL;
1498 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1499 dc = d_template_args (di);
1501 else if (peek == 'T')
1502 dc = d_template_param (di);
1503 else if (peek == 'E')
1504 return ret;
1505 else if (peek == 'M')
1507 /* Initializer scope for a lambda. We don't need to represent
1508 this; the normal code will just treat the variable as a type
1509 scope, which gives appropriate output. */
1510 if (ret == NULL)
1511 return NULL;
1512 d_advance (di, 1);
1513 continue;
1515 else
1516 return NULL;
1518 if (ret == NULL)
1519 ret = dc;
1520 else
1521 ret = d_make_comp (di, comb_type, ret, dc);
1523 if (peek != 'S' && d_peek_char (di) != 'E')
1525 if (! d_add_substitution (di, ret))
1526 return NULL;
1531 /* <unqualified-name> ::= <operator-name>
1532 ::= <ctor-dtor-name>
1533 ::= <source-name>
1534 ::= <local-source-name>
1536 <local-source-name> ::= L <source-name> <discriminator>
1539 static struct demangle_component *
1540 d_unqualified_name (struct d_info *di)
1542 struct demangle_component *ret;
1543 char peek;
1545 peek = d_peek_char (di);
1546 if (IS_DIGIT (peek))
1547 ret = d_source_name (di);
1548 else if (IS_LOWER (peek))
1550 ret = d_operator_name (di);
1551 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1553 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1554 if (!strcmp (ret->u.s_operator.op->code, "li"))
1555 ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
1556 d_source_name (di));
1559 else if (peek == 'C' || peek == 'D')
1560 ret = d_ctor_dtor_name (di);
1561 else if (peek == 'L')
1563 d_advance (di, 1);
1565 ret = d_source_name (di);
1566 if (ret == NULL)
1567 return NULL;
1568 if (! d_discriminator (di))
1569 return NULL;
1571 else if (peek == 'U')
1573 switch (d_peek_next_char (di))
1575 case 'l':
1576 ret = d_lambda (di);
1577 break;
1578 case 't':
1579 ret = d_unnamed_type (di);
1580 break;
1581 default:
1582 return NULL;
1585 else
1586 return NULL;
1588 if (d_peek_char (di) == 'B')
1589 ret = d_abi_tags (di, ret);
1590 return ret;
1593 /* <source-name> ::= <(positive length) number> <identifier> */
1595 static struct demangle_component *
1596 d_source_name (struct d_info *di)
1598 long len;
1599 struct demangle_component *ret;
1601 len = d_number (di);
1602 if (len <= 0)
1603 return NULL;
1604 ret = d_identifier (di, len);
1605 di->last_name = ret;
1606 return ret;
1609 /* number ::= [n] <(non-negative decimal integer)> */
1611 static long
1612 d_number (struct d_info *di)
1614 int negative;
1615 char peek;
1616 long ret;
1618 negative = 0;
1619 peek = d_peek_char (di);
1620 if (peek == 'n')
1622 negative = 1;
1623 d_advance (di, 1);
1624 peek = d_peek_char (di);
1627 ret = 0;
1628 while (1)
1630 if (! IS_DIGIT (peek))
1632 if (negative)
1633 ret = - ret;
1634 return ret;
1636 ret = ret * 10 + peek - '0';
1637 d_advance (di, 1);
1638 peek = d_peek_char (di);
1642 /* Like d_number, but returns a demangle_component. */
1644 static struct demangle_component *
1645 d_number_component (struct d_info *di)
1647 struct demangle_component *ret = d_make_empty (di);
1648 if (ret)
1650 ret->type = DEMANGLE_COMPONENT_NUMBER;
1651 ret->u.s_number.number = d_number (di);
1653 return ret;
1656 /* identifier ::= <(unqualified source code identifier)> */
1658 static struct demangle_component *
1659 d_identifier (struct d_info *di, int len)
1661 const char *name;
1663 name = d_str (di);
1665 if (di->send - name < len)
1666 return NULL;
1668 d_advance (di, len);
1670 /* A Java mangled name may have a trailing '$' if it is a C++
1671 keyword. This '$' is not included in the length count. We just
1672 ignore the '$'. */
1673 if ((di->options & DMGL_JAVA) != 0
1674 && d_peek_char (di) == '$')
1675 d_advance (di, 1);
1677 /* Look for something which looks like a gcc encoding of an
1678 anonymous namespace, and replace it with a more user friendly
1679 name. */
1680 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1681 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1682 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1684 const char *s;
1686 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1687 if ((*s == '.' || *s == '_' || *s == '$')
1688 && s[1] == 'N')
1690 di->expansion -= len - sizeof "(anonymous namespace)";
1691 return d_make_name (di, "(anonymous namespace)",
1692 sizeof "(anonymous namespace)" - 1);
1696 return d_make_name (di, name, len);
1699 /* operator_name ::= many different two character encodings.
1700 ::= cv <type>
1701 ::= v <digit> <source-name>
1703 This list is sorted for binary search. */
1705 #define NL(s) s, (sizeof s) - 1
1707 CP_STATIC_IF_GLIBCPP_V3
1708 const struct demangle_operator_info cplus_demangle_operators[] =
1710 { "aN", NL ("&="), 2 },
1711 { "aS", NL ("="), 2 },
1712 { "aa", NL ("&&"), 2 },
1713 { "ad", NL ("&"), 1 },
1714 { "an", NL ("&"), 2 },
1715 { "at", NL ("alignof "), 1 },
1716 { "az", NL ("alignof "), 1 },
1717 { "cc", NL ("const_cast"), 2 },
1718 { "cl", NL ("()"), 2 },
1719 { "cm", NL (","), 2 },
1720 { "co", NL ("~"), 1 },
1721 { "dV", NL ("/="), 2 },
1722 { "da", NL ("delete[] "), 1 },
1723 { "dc", NL ("dynamic_cast"), 2 },
1724 { "de", NL ("*"), 1 },
1725 { "dl", NL ("delete "), 1 },
1726 { "ds", NL (".*"), 2 },
1727 { "dt", NL ("."), 2 },
1728 { "dv", NL ("/"), 2 },
1729 { "eO", NL ("^="), 2 },
1730 { "eo", NL ("^"), 2 },
1731 { "eq", NL ("=="), 2 },
1732 { "ge", NL (">="), 2 },
1733 { "gs", NL ("::"), 1 },
1734 { "gt", NL (">"), 2 },
1735 { "ix", NL ("[]"), 2 },
1736 { "lS", NL ("<<="), 2 },
1737 { "le", NL ("<="), 2 },
1738 { "li", NL ("operator\"\" "), 1 },
1739 { "ls", NL ("<<"), 2 },
1740 { "lt", NL ("<"), 2 },
1741 { "mI", NL ("-="), 2 },
1742 { "mL", NL ("*="), 2 },
1743 { "mi", NL ("-"), 2 },
1744 { "ml", NL ("*"), 2 },
1745 { "mm", NL ("--"), 1 },
1746 { "na", NL ("new[]"), 3 },
1747 { "ne", NL ("!="), 2 },
1748 { "ng", NL ("-"), 1 },
1749 { "nt", NL ("!"), 1 },
1750 { "nw", NL ("new"), 3 },
1751 { "oR", NL ("|="), 2 },
1752 { "oo", NL ("||"), 2 },
1753 { "or", NL ("|"), 2 },
1754 { "pL", NL ("+="), 2 },
1755 { "pl", NL ("+"), 2 },
1756 { "pm", NL ("->*"), 2 },
1757 { "pp", NL ("++"), 1 },
1758 { "ps", NL ("+"), 1 },
1759 { "pt", NL ("->"), 2 },
1760 { "qu", NL ("?"), 3 },
1761 { "rM", NL ("%="), 2 },
1762 { "rS", NL (">>="), 2 },
1763 { "rc", NL ("reinterpret_cast"), 2 },
1764 { "rm", NL ("%"), 2 },
1765 { "rs", NL (">>"), 2 },
1766 { "sc", NL ("static_cast"), 2 },
1767 { "st", NL ("sizeof "), 1 },
1768 { "sz", NL ("sizeof "), 1 },
1769 { "tr", NL ("throw"), 0 },
1770 { "tw", NL ("throw "), 1 },
1771 { NULL, NULL, 0, 0 }
1774 static struct demangle_component *
1775 d_operator_name (struct d_info *di)
1777 char c1;
1778 char c2;
1780 c1 = d_next_char (di);
1781 c2 = d_next_char (di);
1782 if (c1 == 'v' && IS_DIGIT (c2))
1783 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1784 else if (c1 == 'c' && c2 == 'v')
1786 struct demangle_component *type;
1787 int was_conversion = di->is_conversion;
1789 di->is_conversion = ! di->is_expression;
1790 type = cplus_demangle_type (di);
1791 di->is_conversion = was_conversion;
1792 return d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
1794 else
1796 /* LOW is the inclusive lower bound. */
1797 int low = 0;
1798 /* HIGH is the exclusive upper bound. We subtract one to ignore
1799 the sentinel at the end of the array. */
1800 int high = ((sizeof (cplus_demangle_operators)
1801 / sizeof (cplus_demangle_operators[0]))
1802 - 1);
1804 while (1)
1806 int i;
1807 const struct demangle_operator_info *p;
1809 i = low + (high - low) / 2;
1810 p = cplus_demangle_operators + i;
1812 if (c1 == p->code[0] && c2 == p->code[1])
1813 return d_make_operator (di, p);
1815 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1816 high = i;
1817 else
1818 low = i + 1;
1819 if (low == high)
1820 return NULL;
1825 static struct demangle_component *
1826 d_make_character (struct d_info *di, int c)
1828 struct demangle_component *p;
1829 p = d_make_empty (di);
1830 if (p != NULL)
1832 p->type = DEMANGLE_COMPONENT_CHARACTER;
1833 p->u.s_character.character = c;
1835 return p;
1838 static struct demangle_component *
1839 d_java_resource (struct d_info *di)
1841 struct demangle_component *p = NULL;
1842 struct demangle_component *next = NULL;
1843 long len, i;
1844 char c;
1845 const char *str;
1847 len = d_number (di);
1848 if (len <= 1)
1849 return NULL;
1851 /* Eat the leading '_'. */
1852 if (d_next_char (di) != '_')
1853 return NULL;
1854 len--;
1856 str = d_str (di);
1857 i = 0;
1859 while (len > 0)
1861 c = str[i];
1862 if (!c)
1863 return NULL;
1865 /* Each chunk is either a '$' escape... */
1866 if (c == '$')
1868 i++;
1869 switch (str[i++])
1871 case 'S':
1872 c = '/';
1873 break;
1874 case '_':
1875 c = '.';
1876 break;
1877 case '$':
1878 c = '$';
1879 break;
1880 default:
1881 return NULL;
1883 next = d_make_character (di, c);
1884 d_advance (di, i);
1885 str = d_str (di);
1886 len -= i;
1887 i = 0;
1888 if (next == NULL)
1889 return NULL;
1891 /* ... or a sequence of characters. */
1892 else
1894 while (i < len && str[i] && str[i] != '$')
1895 i++;
1897 next = d_make_name (di, str, i);
1898 d_advance (di, i);
1899 str = d_str (di);
1900 len -= i;
1901 i = 0;
1902 if (next == NULL)
1903 return NULL;
1906 if (p == NULL)
1907 p = next;
1908 else
1910 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
1911 if (p == NULL)
1912 return NULL;
1916 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
1918 return p;
1921 /* <special-name> ::= TV <type>
1922 ::= TT <type>
1923 ::= TI <type>
1924 ::= TS <type>
1925 ::= GV <(object) name>
1926 ::= T <call-offset> <(base) encoding>
1927 ::= Tc <call-offset> <call-offset> <(base) encoding>
1928 Also g++ extensions:
1929 ::= TC <type> <(offset) number> _ <(base) type>
1930 ::= TF <type>
1931 ::= TJ <type>
1932 ::= GR <name>
1933 ::= GA <encoding>
1934 ::= Gr <resource name>
1935 ::= GTt <encoding>
1936 ::= GTn <encoding>
1939 static struct demangle_component *
1940 d_special_name (struct d_info *di)
1942 di->expansion += 20;
1943 if (d_check_char (di, 'T'))
1945 switch (d_next_char (di))
1947 case 'V':
1948 di->expansion -= 5;
1949 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1950 cplus_demangle_type (di), NULL);
1951 case 'T':
1952 di->expansion -= 10;
1953 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1954 cplus_demangle_type (di), NULL);
1955 case 'I':
1956 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1957 cplus_demangle_type (di), NULL);
1958 case 'S':
1959 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1960 cplus_demangle_type (di), NULL);
1962 case 'h':
1963 if (! d_call_offset (di, 'h'))
1964 return NULL;
1965 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1966 d_encoding (di, 0), NULL);
1968 case 'v':
1969 if (! d_call_offset (di, 'v'))
1970 return NULL;
1971 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1972 d_encoding (di, 0), NULL);
1974 case 'c':
1975 if (! d_call_offset (di, '\0'))
1976 return NULL;
1977 if (! d_call_offset (di, '\0'))
1978 return NULL;
1979 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1980 d_encoding (di, 0), NULL);
1982 case 'C':
1984 struct demangle_component *derived_type;
1985 long offset;
1986 struct demangle_component *base_type;
1988 derived_type = cplus_demangle_type (di);
1989 offset = d_number (di);
1990 if (offset < 0)
1991 return NULL;
1992 if (! d_check_char (di, '_'))
1993 return NULL;
1994 base_type = cplus_demangle_type (di);
1995 /* We don't display the offset. FIXME: We should display
1996 it in verbose mode. */
1997 di->expansion += 5;
1998 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1999 base_type, derived_type);
2002 case 'F':
2003 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
2004 cplus_demangle_type (di), NULL);
2005 case 'J':
2006 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
2007 cplus_demangle_type (di), NULL);
2009 case 'H':
2010 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
2011 d_name (di), NULL);
2013 case 'W':
2014 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
2015 d_name (di), NULL);
2017 default:
2018 return NULL;
2021 else if (d_check_char (di, 'G'))
2023 switch (d_next_char (di))
2025 case 'V':
2026 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
2028 case 'R':
2030 struct demangle_component *name = d_name (di);
2031 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
2032 d_number_component (di));
2035 case 'A':
2036 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
2037 d_encoding (di, 0), NULL);
2039 case 'T':
2040 switch (d_next_char (di))
2042 case 'n':
2043 return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
2044 d_encoding (di, 0), NULL);
2045 default:
2046 /* ??? The proposal is that other letters (such as 'h') stand
2047 for different variants of transaction cloning, such as
2048 compiling directly for hardware transaction support. But
2049 they still should all be transactional clones of some sort
2050 so go ahead and call them that. */
2051 case 't':
2052 return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
2053 d_encoding (di, 0), NULL);
2056 case 'r':
2057 return d_java_resource (di);
2059 default:
2060 return NULL;
2063 else
2064 return NULL;
2067 /* <call-offset> ::= h <nv-offset> _
2068 ::= v <v-offset> _
2070 <nv-offset> ::= <(offset) number>
2072 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2074 The C parameter, if not '\0', is a character we just read which is
2075 the start of the <call-offset>.
2077 We don't display the offset information anywhere. FIXME: We should
2078 display it in verbose mode. */
2080 static int
2081 d_call_offset (struct d_info *di, int c)
2083 if (c == '\0')
2084 c = d_next_char (di);
2086 if (c == 'h')
2087 d_number (di);
2088 else if (c == 'v')
2090 d_number (di);
2091 if (! d_check_char (di, '_'))
2092 return 0;
2093 d_number (di);
2095 else
2096 return 0;
2098 if (! d_check_char (di, '_'))
2099 return 0;
2101 return 1;
2104 /* <ctor-dtor-name> ::= C1
2105 ::= C2
2106 ::= C3
2107 ::= D0
2108 ::= D1
2109 ::= D2
2112 static struct demangle_component *
2113 d_ctor_dtor_name (struct d_info *di)
2115 if (di->last_name != NULL)
2117 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
2118 di->expansion += di->last_name->u.s_name.len;
2119 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
2120 di->expansion += di->last_name->u.s_string.len;
2122 switch (d_peek_char (di))
2124 case 'C':
2126 enum gnu_v3_ctor_kinds kind;
2128 switch (d_peek_next_char (di))
2130 case '1':
2131 kind = gnu_v3_complete_object_ctor;
2132 break;
2133 case '2':
2134 kind = gnu_v3_base_object_ctor;
2135 break;
2136 case '3':
2137 kind = gnu_v3_complete_object_allocating_ctor;
2138 break;
2139 case '4':
2140 kind = gnu_v3_unified_ctor;
2141 break;
2142 case '5':
2143 kind = gnu_v3_object_ctor_group;
2144 break;
2145 default:
2146 return NULL;
2148 d_advance (di, 2);
2149 return d_make_ctor (di, kind, di->last_name);
2152 case 'D':
2154 enum gnu_v3_dtor_kinds kind;
2156 switch (d_peek_next_char (di))
2158 case '0':
2159 kind = gnu_v3_deleting_dtor;
2160 break;
2161 case '1':
2162 kind = gnu_v3_complete_object_dtor;
2163 break;
2164 case '2':
2165 kind = gnu_v3_base_object_dtor;
2166 break;
2167 /* digit '3' is not used */
2168 case '4':
2169 kind = gnu_v3_unified_dtor;
2170 break;
2171 case '5':
2172 kind = gnu_v3_object_dtor_group;
2173 break;
2174 default:
2175 return NULL;
2177 d_advance (di, 2);
2178 return d_make_dtor (di, kind, di->last_name);
2181 default:
2182 return NULL;
2186 /* <type> ::= <builtin-type>
2187 ::= <function-type>
2188 ::= <class-enum-type>
2189 ::= <array-type>
2190 ::= <pointer-to-member-type>
2191 ::= <template-param>
2192 ::= <template-template-param> <template-args>
2193 ::= <substitution>
2194 ::= <CV-qualifiers> <type>
2195 ::= P <type>
2196 ::= R <type>
2197 ::= O <type> (C++0x)
2198 ::= C <type>
2199 ::= G <type>
2200 ::= U <source-name> <type>
2202 <builtin-type> ::= various one letter codes
2203 ::= u <source-name>
2206 CP_STATIC_IF_GLIBCPP_V3
2207 const struct demangle_builtin_type_info
2208 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
2210 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
2211 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
2212 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
2213 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
2214 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
2215 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
2216 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
2217 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
2218 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
2219 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
2220 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2221 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
2222 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
2223 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
2224 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2225 D_PRINT_DEFAULT },
2226 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2227 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2228 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2229 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
2230 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
2231 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2232 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
2233 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
2234 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
2235 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2236 D_PRINT_UNSIGNED_LONG_LONG },
2237 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
2238 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
2239 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
2240 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
2241 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
2242 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
2243 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
2244 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2245 D_PRINT_DEFAULT },
2248 CP_STATIC_IF_GLIBCPP_V3
2249 struct demangle_component *
2250 cplus_demangle_type (struct d_info *di)
2252 char peek;
2253 struct demangle_component *ret;
2254 int can_subst;
2256 /* The ABI specifies that when CV-qualifiers are used, the base type
2257 is substitutable, and the fully qualified type is substitutable,
2258 but the base type with a strict subset of the CV-qualifiers is
2259 not substitutable. The natural recursive implementation of the
2260 CV-qualifiers would cause subsets to be substitutable, so instead
2261 we pull them all off now.
2263 FIXME: The ABI says that order-insensitive vendor qualifiers
2264 should be handled in the same way, but we have no way to tell
2265 which vendor qualifiers are order-insensitive and which are
2266 order-sensitive. So we just assume that they are all
2267 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2268 __vector, and it treats it as order-sensitive when mangling
2269 names. */
2271 peek = d_peek_char (di);
2272 if (peek == 'r' || peek == 'V' || peek == 'K')
2274 struct demangle_component **pret;
2276 pret = d_cv_qualifiers (di, &ret, 0);
2277 if (pret == NULL)
2278 return NULL;
2279 if (d_peek_char (di) == 'F')
2281 /* cv-qualifiers before a function type apply to 'this',
2282 so avoid adding the unqualified function type to
2283 the substitution list. */
2284 *pret = d_function_type (di);
2286 else
2287 *pret = cplus_demangle_type (di);
2288 if (!*pret)
2289 return NULL;
2290 if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2291 || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
2293 /* Move the ref-qualifier outside the cv-qualifiers so that
2294 they are printed in the right order. */
2295 struct demangle_component *fn = d_left (*pret);
2296 d_left (*pret) = ret;
2297 ret = *pret;
2298 *pret = fn;
2300 if (! d_add_substitution (di, ret))
2301 return NULL;
2302 return ret;
2305 can_subst = 1;
2307 switch (peek)
2309 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2310 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2311 case 'o': case 's': case 't':
2312 case 'v': case 'w': case 'x': case 'y': case 'z':
2313 ret = d_make_builtin_type (di,
2314 &cplus_demangle_builtin_types[peek - 'a']);
2315 di->expansion += ret->u.s_builtin.type->len;
2316 can_subst = 0;
2317 d_advance (di, 1);
2318 break;
2320 case 'u':
2321 d_advance (di, 1);
2322 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2323 d_source_name (di), NULL);
2324 break;
2326 case 'F':
2327 ret = d_function_type (di);
2328 break;
2330 case '0': case '1': case '2': case '3': case '4':
2331 case '5': case '6': case '7': case '8': case '9':
2332 case 'N':
2333 case 'Z':
2334 ret = d_class_enum_type (di);
2335 break;
2337 case 'A':
2338 ret = d_array_type (di);
2339 break;
2341 case 'M':
2342 ret = d_pointer_to_member_type (di);
2343 break;
2345 case 'T':
2346 ret = d_template_param (di);
2347 if (d_peek_char (di) == 'I')
2349 /* This may be <template-template-param> <template-args>.
2350 If this is the type for a conversion operator, we can
2351 have a <template-template-param> here only by following
2352 a derivation like this:
2354 <nested-name>
2355 -> <template-prefix> <template-args>
2356 -> <prefix> <template-unqualified-name> <template-args>
2357 -> <unqualified-name> <template-unqualified-name> <template-args>
2358 -> <source-name> <template-unqualified-name> <template-args>
2359 -> <source-name> <operator-name> <template-args>
2360 -> <source-name> cv <type> <template-args>
2361 -> <source-name> cv <template-template-param> <template-args> <template-args>
2363 where the <template-args> is followed by another.
2364 Otherwise, we must have a derivation like this:
2366 <nested-name>
2367 -> <template-prefix> <template-args>
2368 -> <prefix> <template-unqualified-name> <template-args>
2369 -> <unqualified-name> <template-unqualified-name> <template-args>
2370 -> <source-name> <template-unqualified-name> <template-args>
2371 -> <source-name> <operator-name> <template-args>
2372 -> <source-name> cv <type> <template-args>
2373 -> <source-name> cv <template-param> <template-args>
2375 where we need to leave the <template-args> to be processed
2376 by d_prefix (following the <template-prefix>).
2378 The <template-template-param> part is a substitution
2379 candidate. */
2380 if (! di->is_conversion)
2382 if (! d_add_substitution (di, ret))
2383 return NULL;
2384 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2385 d_template_args (di));
2387 else
2389 struct demangle_component *args;
2390 struct d_info_checkpoint checkpoint;
2392 d_checkpoint (di, &checkpoint);
2393 args = d_template_args (di);
2394 if (d_peek_char (di) == 'I')
2396 if (! d_add_substitution (di, ret))
2397 return NULL;
2398 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2399 args);
2401 else
2402 d_backtrack (di, &checkpoint);
2405 break;
2407 case 'S':
2408 /* If this is a special substitution, then it is the start of
2409 <class-enum-type>. */
2411 char peek_next;
2413 peek_next = d_peek_next_char (di);
2414 if (IS_DIGIT (peek_next)
2415 || peek_next == '_'
2416 || IS_UPPER (peek_next))
2418 ret = d_substitution (di, 0);
2419 /* The substituted name may have been a template name and
2420 may be followed by tepmlate args. */
2421 if (d_peek_char (di) == 'I')
2422 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2423 d_template_args (di));
2424 else
2425 can_subst = 0;
2427 else
2429 ret = d_class_enum_type (di);
2430 /* If the substitution was a complete type, then it is not
2431 a new substitution candidate. However, if the
2432 substitution was followed by template arguments, then
2433 the whole thing is a substitution candidate. */
2434 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2435 can_subst = 0;
2438 break;
2440 case 'O':
2441 d_advance (di, 1);
2442 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2443 cplus_demangle_type (di), NULL);
2444 break;
2446 case 'P':
2447 d_advance (di, 1);
2448 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2449 cplus_demangle_type (di), NULL);
2450 break;
2452 case 'R':
2453 d_advance (di, 1);
2454 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2455 cplus_demangle_type (di), NULL);
2456 break;
2458 case 'C':
2459 d_advance (di, 1);
2460 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2461 cplus_demangle_type (di), NULL);
2462 break;
2464 case 'G':
2465 d_advance (di, 1);
2466 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2467 cplus_demangle_type (di), NULL);
2468 break;
2470 case 'U':
2471 d_advance (di, 1);
2472 ret = d_source_name (di);
2473 if (d_peek_char (di) == 'I')
2474 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2475 d_template_args (di));
2476 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2477 cplus_demangle_type (di), ret);
2478 break;
2480 case 'D':
2481 can_subst = 0;
2482 d_advance (di, 1);
2483 peek = d_next_char (di);
2484 switch (peek)
2486 case 'T':
2487 case 't':
2488 /* decltype (expression) */
2489 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2490 d_expression (di), NULL);
2491 if (ret && d_next_char (di) != 'E')
2492 ret = NULL;
2493 can_subst = 1;
2494 break;
2496 case 'p':
2497 /* Pack expansion. */
2498 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2499 cplus_demangle_type (di), NULL);
2500 can_subst = 1;
2501 break;
2503 case 'a':
2504 /* auto */
2505 ret = d_make_name (di, "auto", 4);
2506 break;
2508 case 'f':
2509 /* 32-bit decimal floating point */
2510 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2511 di->expansion += ret->u.s_builtin.type->len;
2512 break;
2513 case 'd':
2514 /* 64-bit DFP */
2515 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2516 di->expansion += ret->u.s_builtin.type->len;
2517 break;
2518 case 'e':
2519 /* 128-bit DFP */
2520 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2521 di->expansion += ret->u.s_builtin.type->len;
2522 break;
2523 case 'h':
2524 /* 16-bit half-precision FP */
2525 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2526 di->expansion += ret->u.s_builtin.type->len;
2527 break;
2528 case 's':
2529 /* char16_t */
2530 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2531 di->expansion += ret->u.s_builtin.type->len;
2532 break;
2533 case 'i':
2534 /* char32_t */
2535 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2536 di->expansion += ret->u.s_builtin.type->len;
2537 break;
2539 case 'F':
2540 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2541 ret = d_make_empty (di);
2542 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2543 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2544 /* For demangling we don't care about the bits. */
2545 d_number (di);
2546 ret->u.s_fixed.length = cplus_demangle_type (di);
2547 if (ret->u.s_fixed.length == NULL)
2548 return NULL;
2549 d_number (di);
2550 peek = d_next_char (di);
2551 ret->u.s_fixed.sat = (peek == 's');
2552 break;
2554 case 'v':
2555 ret = d_vector_type (di);
2556 can_subst = 1;
2557 break;
2559 case 'n':
2560 /* decltype(nullptr) */
2561 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2562 di->expansion += ret->u.s_builtin.type->len;
2563 break;
2565 default:
2566 return NULL;
2568 break;
2570 default:
2571 return NULL;
2574 if (can_subst)
2576 if (! d_add_substitution (di, ret))
2577 return NULL;
2580 return ret;
2583 /* <CV-qualifiers> ::= [r] [V] [K] */
2585 static struct demangle_component **
2586 d_cv_qualifiers (struct d_info *di,
2587 struct demangle_component **pret, int member_fn)
2589 struct demangle_component **pstart;
2590 char peek;
2592 pstart = pret;
2593 peek = d_peek_char (di);
2594 while (peek == 'r' || peek == 'V' || peek == 'K')
2596 enum demangle_component_type t;
2598 d_advance (di, 1);
2599 if (peek == 'r')
2601 t = (member_fn
2602 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2603 : DEMANGLE_COMPONENT_RESTRICT);
2604 di->expansion += sizeof "restrict";
2606 else if (peek == 'V')
2608 t = (member_fn
2609 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2610 : DEMANGLE_COMPONENT_VOLATILE);
2611 di->expansion += sizeof "volatile";
2613 else
2615 t = (member_fn
2616 ? DEMANGLE_COMPONENT_CONST_THIS
2617 : DEMANGLE_COMPONENT_CONST);
2618 di->expansion += sizeof "const";
2621 *pret = d_make_comp (di, t, NULL, NULL);
2622 if (*pret == NULL)
2623 return NULL;
2624 pret = &d_left (*pret);
2626 peek = d_peek_char (di);
2629 if (!member_fn && peek == 'F')
2631 while (pstart != pret)
2633 switch ((*pstart)->type)
2635 case DEMANGLE_COMPONENT_RESTRICT:
2636 (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
2637 break;
2638 case DEMANGLE_COMPONENT_VOLATILE:
2639 (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
2640 break;
2641 case DEMANGLE_COMPONENT_CONST:
2642 (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
2643 break;
2644 default:
2645 break;
2647 pstart = &d_left (*pstart);
2651 return pret;
2654 /* <ref-qualifier> ::= R
2655 ::= O */
2657 static struct demangle_component *
2658 d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2660 struct demangle_component *ret = sub;
2661 char peek;
2663 peek = d_peek_char (di);
2664 if (peek == 'R' || peek == 'O')
2666 enum demangle_component_type t;
2667 if (peek == 'R')
2669 t = DEMANGLE_COMPONENT_REFERENCE_THIS;
2670 di->expansion += sizeof "&";
2672 else
2674 t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
2675 di->expansion += sizeof "&&";
2677 d_advance (di, 1);
2679 ret = d_make_comp (di, t, ret, NULL);
2682 return ret;
2685 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
2687 static struct demangle_component *
2688 d_function_type (struct d_info *di)
2690 struct demangle_component *ret;
2692 if (! d_check_char (di, 'F'))
2693 return NULL;
2694 if (d_peek_char (di) == 'Y')
2696 /* Function has C linkage. We don't print this information.
2697 FIXME: We should print it in verbose mode. */
2698 d_advance (di, 1);
2700 ret = d_bare_function_type (di, 1);
2701 ret = d_ref_qualifier (di, ret);
2703 if (! d_check_char (di, 'E'))
2704 return NULL;
2705 return ret;
2708 /* <type>+ */
2710 static struct demangle_component *
2711 d_parmlist (struct d_info *di)
2713 struct demangle_component *tl;
2714 struct demangle_component **ptl;
2716 tl = NULL;
2717 ptl = &tl;
2718 while (1)
2720 struct demangle_component *type;
2722 char peek = d_peek_char (di);
2723 if (peek == '\0' || peek == 'E' || peek == '.')
2724 break;
2725 if ((peek == 'R' || peek == 'O')
2726 && d_peek_next_char (di) == 'E')
2727 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2728 break;
2729 type = cplus_demangle_type (di);
2730 if (type == NULL)
2731 return NULL;
2732 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2733 if (*ptl == NULL)
2734 return NULL;
2735 ptl = &d_right (*ptl);
2738 /* There should be at least one parameter type besides the optional
2739 return type. A function which takes no arguments will have a
2740 single parameter type void. */
2741 if (tl == NULL)
2742 return NULL;
2744 /* If we have a single parameter type void, omit it. */
2745 if (d_right (tl) == NULL
2746 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2747 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2749 di->expansion -= d_left (tl)->u.s_builtin.type->len;
2750 d_left (tl) = NULL;
2753 return tl;
2756 /* <bare-function-type> ::= [J]<type>+ */
2758 static struct demangle_component *
2759 d_bare_function_type (struct d_info *di, int has_return_type)
2761 struct demangle_component *return_type;
2762 struct demangle_component *tl;
2763 char peek;
2765 /* Detect special qualifier indicating that the first argument
2766 is the return type. */
2767 peek = d_peek_char (di);
2768 if (peek == 'J')
2770 d_advance (di, 1);
2771 has_return_type = 1;
2774 if (has_return_type)
2776 return_type = cplus_demangle_type (di);
2777 if (return_type == NULL)
2778 return NULL;
2780 else
2781 return_type = NULL;
2783 tl = d_parmlist (di);
2784 if (tl == NULL)
2785 return NULL;
2787 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2788 return_type, tl);
2791 /* <class-enum-type> ::= <name> */
2793 static struct demangle_component *
2794 d_class_enum_type (struct d_info *di)
2796 return d_name (di);
2799 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2800 ::= A [<(dimension) expression>] _ <(element) type>
2803 static struct demangle_component *
2804 d_array_type (struct d_info *di)
2806 char peek;
2807 struct demangle_component *dim;
2809 if (! d_check_char (di, 'A'))
2810 return NULL;
2812 peek = d_peek_char (di);
2813 if (peek == '_')
2814 dim = NULL;
2815 else if (IS_DIGIT (peek))
2817 const char *s;
2819 s = d_str (di);
2822 d_advance (di, 1);
2823 peek = d_peek_char (di);
2825 while (IS_DIGIT (peek));
2826 dim = d_make_name (di, s, d_str (di) - s);
2827 if (dim == NULL)
2828 return NULL;
2830 else
2832 dim = d_expression (di);
2833 if (dim == NULL)
2834 return NULL;
2837 if (! d_check_char (di, '_'))
2838 return NULL;
2840 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2841 cplus_demangle_type (di));
2844 /* <vector-type> ::= Dv <number> _ <type>
2845 ::= Dv _ <expression> _ <type> */
2847 static struct demangle_component *
2848 d_vector_type (struct d_info *di)
2850 char peek;
2851 struct demangle_component *dim;
2853 peek = d_peek_char (di);
2854 if (peek == '_')
2856 d_advance (di, 1);
2857 dim = d_expression (di);
2859 else
2860 dim = d_number_component (di);
2862 if (dim == NULL)
2863 return NULL;
2865 if (! d_check_char (di, '_'))
2866 return NULL;
2868 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
2869 cplus_demangle_type (di));
2872 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2874 static struct demangle_component *
2875 d_pointer_to_member_type (struct d_info *di)
2877 struct demangle_component *cl;
2878 struct demangle_component *mem;
2880 if (! d_check_char (di, 'M'))
2881 return NULL;
2883 cl = cplus_demangle_type (di);
2884 if (cl == NULL)
2885 return NULL;
2887 /* The ABI says, "The type of a non-static member function is considered
2888 to be different, for the purposes of substitution, from the type of a
2889 namespace-scope or static member function whose type appears
2890 similar. The types of two non-static member functions are considered
2891 to be different, for the purposes of substitution, if the functions
2892 are members of different classes. In other words, for the purposes of
2893 substitution, the class of which the function is a member is
2894 considered part of the type of function."
2896 For a pointer to member function, this call to cplus_demangle_type
2897 will end up adding a (possibly qualified) non-member function type to
2898 the substitution table, which is not correct; however, the member
2899 function type will never be used in a substitution, so putting the
2900 wrong type in the substitution table is harmless. */
2902 mem = cplus_demangle_type (di);
2903 if (mem == NULL)
2904 return NULL;
2906 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2909 /* <non-negative number> _ */
2911 static long
2912 d_compact_number (struct d_info *di)
2914 long num;
2915 if (d_peek_char (di) == '_')
2916 num = 0;
2917 else if (d_peek_char (di) == 'n')
2918 return -1;
2919 else
2920 num = d_number (di) + 1;
2922 if (! d_check_char (di, '_'))
2923 return -1;
2924 return num;
2927 /* <template-param> ::= T_
2928 ::= T <(parameter-2 non-negative) number> _
2931 static struct demangle_component *
2932 d_template_param (struct d_info *di)
2934 long param;
2936 if (! d_check_char (di, 'T'))
2937 return NULL;
2939 param = d_compact_number (di);
2940 if (param < 0)
2941 return NULL;
2943 ++di->did_subs;
2945 return d_make_template_param (di, param);
2948 /* <template-args> ::= I <template-arg>+ E */
2950 static struct demangle_component *
2951 d_template_args (struct d_info *di)
2953 struct demangle_component *hold_last_name;
2954 struct demangle_component *al;
2955 struct demangle_component **pal;
2957 /* Preserve the last name we saw--don't let the template arguments
2958 clobber it, as that would give us the wrong name for a subsequent
2959 constructor or destructor. */
2960 hold_last_name = di->last_name;
2962 if (d_peek_char (di) != 'I'
2963 && d_peek_char (di) != 'J')
2964 return NULL;
2965 d_advance (di, 1);
2967 if (d_peek_char (di) == 'E')
2969 /* An argument pack can be empty. */
2970 d_advance (di, 1);
2971 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2974 al = NULL;
2975 pal = &al;
2976 while (1)
2978 struct demangle_component *a;
2980 a = d_template_arg (di);
2981 if (a == NULL)
2982 return NULL;
2984 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2985 if (*pal == NULL)
2986 return NULL;
2987 pal = &d_right (*pal);
2989 if (d_peek_char (di) == 'E')
2991 d_advance (di, 1);
2992 break;
2996 di->last_name = hold_last_name;
2998 return al;
3001 /* <template-arg> ::= <type>
3002 ::= X <expression> E
3003 ::= <expr-primary>
3006 static struct demangle_component *
3007 d_template_arg (struct d_info *di)
3009 struct demangle_component *ret;
3011 switch (d_peek_char (di))
3013 case 'X':
3014 d_advance (di, 1);
3015 ret = d_expression (di);
3016 if (! d_check_char (di, 'E'))
3017 return NULL;
3018 return ret;
3020 case 'L':
3021 return d_expr_primary (di);
3023 case 'I':
3024 case 'J':
3025 /* An argument pack. */
3026 return d_template_args (di);
3028 default:
3029 return cplus_demangle_type (di);
3033 /* Parse a sequence of expressions until we hit the terminator
3034 character. */
3036 static struct demangle_component *
3037 d_exprlist (struct d_info *di, char terminator)
3039 struct demangle_component *list = NULL;
3040 struct demangle_component **p = &list;
3042 if (d_peek_char (di) == terminator)
3044 d_advance (di, 1);
3045 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
3048 while (1)
3050 struct demangle_component *arg = d_expression (di);
3051 if (arg == NULL)
3052 return NULL;
3054 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
3055 if (*p == NULL)
3056 return NULL;
3057 p = &d_right (*p);
3059 if (d_peek_char (di) == terminator)
3061 d_advance (di, 1);
3062 break;
3066 return list;
3069 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3070 dynamic_cast, static_cast or reinterpret_cast. */
3072 static int
3073 op_is_new_cast (struct demangle_component *op)
3075 const char *code = op->u.s_operator.op->code;
3076 return (code[1] == 'c'
3077 && (code[0] == 's' || code[0] == 'd'
3078 || code[0] == 'c' || code[0] == 'r'));
3081 /* <expression> ::= <(unary) operator-name> <expression>
3082 ::= <(binary) operator-name> <expression> <expression>
3083 ::= <(trinary) operator-name> <expression> <expression> <expression>
3084 ::= cl <expression>+ E
3085 ::= st <type>
3086 ::= <template-param>
3087 ::= sr <type> <unqualified-name>
3088 ::= sr <type> <unqualified-name> <template-args>
3089 ::= <expr-primary>
3092 static inline struct demangle_component *
3093 d_expression_1 (struct d_info *di)
3095 char peek;
3097 peek = d_peek_char (di);
3098 if (peek == 'L')
3099 return d_expr_primary (di);
3100 else if (peek == 'T')
3101 return d_template_param (di);
3102 else if (peek == 's' && d_peek_next_char (di) == 'r')
3104 struct demangle_component *type;
3105 struct demangle_component *name;
3107 d_advance (di, 2);
3108 type = cplus_demangle_type (di);
3109 name = d_unqualified_name (di);
3110 if (d_peek_char (di) != 'I')
3111 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
3112 else
3113 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
3114 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3115 d_template_args (di)));
3117 else if (peek == 's' && d_peek_next_char (di) == 'p')
3119 d_advance (di, 2);
3120 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
3121 d_expression_1 (di), NULL);
3123 else if (peek == 'f' && d_peek_next_char (di) == 'p')
3125 /* Function parameter used in a late-specified return type. */
3126 int index;
3127 d_advance (di, 2);
3128 if (d_peek_char (di) == 'T')
3130 /* 'this' parameter. */
3131 d_advance (di, 1);
3132 index = 0;
3134 else
3136 index = d_compact_number (di) + 1;
3137 if (index == 0)
3138 return NULL;
3140 return d_make_function_param (di, index);
3142 else if (IS_DIGIT (peek)
3143 || (peek == 'o' && d_peek_next_char (di) == 'n'))
3145 /* We can get an unqualified name as an expression in the case of
3146 a dependent function call, i.e. decltype(f(t)). */
3147 struct demangle_component *name;
3149 if (peek == 'o')
3150 /* operator-function-id, i.e. operator+(t). */
3151 d_advance (di, 2);
3153 name = d_unqualified_name (di);
3154 if (name == NULL)
3155 return NULL;
3156 if (d_peek_char (di) == 'I')
3157 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3158 d_template_args (di));
3159 else
3160 return name;
3162 else if ((peek == 'i' || peek == 't')
3163 && d_peek_next_char (di) == 'l')
3165 /* Brace-enclosed initializer list, untyped or typed. */
3166 struct demangle_component *type = NULL;
3167 if (peek == 't')
3168 type = cplus_demangle_type (di);
3169 d_advance (di, 2);
3170 return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
3171 type, d_exprlist (di, 'E'));
3173 else
3175 struct demangle_component *op;
3176 const char *code = NULL;
3177 int args;
3179 op = d_operator_name (di);
3180 if (op == NULL)
3181 return NULL;
3183 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
3185 code = op->u.s_operator.op->code;
3186 di->expansion += op->u.s_operator.op->len - 2;
3187 if (strcmp (code, "st") == 0)
3188 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3189 cplus_demangle_type (di));
3192 switch (op->type)
3194 default:
3195 return NULL;
3196 case DEMANGLE_COMPONENT_OPERATOR:
3197 args = op->u.s_operator.op->args;
3198 break;
3199 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3200 args = op->u.s_extended_operator.args;
3201 break;
3202 case DEMANGLE_COMPONENT_CAST:
3203 args = 1;
3204 break;
3207 switch (args)
3209 case 0:
3210 return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3212 case 1:
3214 struct demangle_component *operand;
3215 int suffix = 0;
3217 if (code && (code[0] == 'p' || code[0] == 'm')
3218 && code[1] == code[0])
3219 /* pp_ and mm_ are the prefix variants. */
3220 suffix = !d_check_char (di, '_');
3222 if (op->type == DEMANGLE_COMPONENT_CAST
3223 && d_check_char (di, '_'))
3224 operand = d_exprlist (di, 'E');
3225 else
3226 operand = d_expression_1 (di);
3228 if (suffix)
3229 /* Indicate the suffix variant for d_print_comp. */
3230 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3231 d_make_comp (di,
3232 DEMANGLE_COMPONENT_BINARY_ARGS,
3233 operand, operand));
3234 else
3235 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3236 operand);
3238 case 2:
3240 struct demangle_component *left;
3241 struct demangle_component *right;
3243 if (op_is_new_cast (op))
3244 left = cplus_demangle_type (di);
3245 else
3246 left = d_expression_1 (di);
3247 if (!strcmp (code, "cl"))
3248 right = d_exprlist (di, 'E');
3249 else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3251 right = d_unqualified_name (di);
3252 if (d_peek_char (di) == 'I')
3253 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3254 right, d_template_args (di));
3256 else
3257 right = d_expression_1 (di);
3259 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3260 d_make_comp (di,
3261 DEMANGLE_COMPONENT_BINARY_ARGS,
3262 left, right));
3264 case 3:
3266 struct demangle_component *first;
3267 struct demangle_component *second;
3268 struct demangle_component *third;
3270 if (!strcmp (code, "qu"))
3272 /* ?: expression. */
3273 first = d_expression_1 (di);
3274 second = d_expression_1 (di);
3275 third = d_expression_1 (di);
3277 else if (code[0] == 'n')
3279 /* new-expression. */
3280 if (code[1] != 'w' && code[1] != 'a')
3281 return NULL;
3282 first = d_exprlist (di, '_');
3283 second = cplus_demangle_type (di);
3284 if (d_peek_char (di) == 'E')
3286 d_advance (di, 1);
3287 third = NULL;
3289 else if (d_peek_char (di) == 'p'
3290 && d_peek_next_char (di) == 'i')
3292 /* Parenthesized initializer. */
3293 d_advance (di, 2);
3294 third = d_exprlist (di, 'E');
3296 else if (d_peek_char (di) == 'i'
3297 && d_peek_next_char (di) == 'l')
3298 /* initializer-list. */
3299 third = d_expression_1 (di);
3300 else
3301 return NULL;
3303 else
3304 return NULL;
3305 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3306 d_make_comp (di,
3307 DEMANGLE_COMPONENT_TRINARY_ARG1,
3308 first,
3309 d_make_comp (di,
3310 DEMANGLE_COMPONENT_TRINARY_ARG2,
3311 second, third)));
3313 default:
3314 return NULL;
3319 static struct demangle_component *
3320 d_expression (struct d_info *di)
3322 struct demangle_component *ret;
3323 int was_expression = di->is_expression;
3325 di->is_expression = 1;
3326 ret = d_expression_1 (di);
3327 di->is_expression = was_expression;
3328 return ret;
3331 /* <expr-primary> ::= L <type> <(value) number> E
3332 ::= L <type> <(value) float> E
3333 ::= L <mangled-name> E
3336 static struct demangle_component *
3337 d_expr_primary (struct d_info *di)
3339 struct demangle_component *ret;
3341 if (! d_check_char (di, 'L'))
3342 return NULL;
3343 if (d_peek_char (di) == '_'
3344 /* Workaround for G++ bug; see comment in write_template_arg. */
3345 || d_peek_char (di) == 'Z')
3346 ret = cplus_demangle_mangled_name (di, 0);
3347 else
3349 struct demangle_component *type;
3350 enum demangle_component_type t;
3351 const char *s;
3353 type = cplus_demangle_type (di);
3354 if (type == NULL)
3355 return NULL;
3357 /* If we have a type we know how to print, we aren't going to
3358 print the type name itself. */
3359 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3360 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3361 di->expansion -= type->u.s_builtin.type->len;
3363 /* Rather than try to interpret the literal value, we just
3364 collect it as a string. Note that it's possible to have a
3365 floating point literal here. The ABI specifies that the
3366 format of such literals is machine independent. That's fine,
3367 but what's not fine is that versions of g++ up to 3.2 with
3368 -fabi-version=1 used upper case letters in the hex constant,
3369 and dumped out gcc's internal representation. That makes it
3370 hard to tell where the constant ends, and hard to dump the
3371 constant in any readable form anyhow. We don't attempt to
3372 handle these cases. */
3374 t = DEMANGLE_COMPONENT_LITERAL;
3375 if (d_peek_char (di) == 'n')
3377 t = DEMANGLE_COMPONENT_LITERAL_NEG;
3378 d_advance (di, 1);
3380 s = d_str (di);
3381 while (d_peek_char (di) != 'E')
3383 if (d_peek_char (di) == '\0')
3384 return NULL;
3385 d_advance (di, 1);
3387 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
3389 if (! d_check_char (di, 'E'))
3390 return NULL;
3391 return ret;
3394 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3395 ::= Z <(function) encoding> E s [<discriminator>]
3396 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3399 static struct demangle_component *
3400 d_local_name (struct d_info *di)
3402 struct demangle_component *function;
3404 if (! d_check_char (di, 'Z'))
3405 return NULL;
3407 function = d_encoding (di, 0);
3409 if (! d_check_char (di, 'E'))
3410 return NULL;
3412 if (d_peek_char (di) == 's')
3414 d_advance (di, 1);
3415 if (! d_discriminator (di))
3416 return NULL;
3417 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
3418 d_make_name (di, "string literal",
3419 sizeof "string literal" - 1));
3421 else
3423 struct demangle_component *name;
3424 int num = -1;
3426 if (d_peek_char (di) == 'd')
3428 /* Default argument scope: d <number> _. */
3429 d_advance (di, 1);
3430 num = d_compact_number (di);
3431 if (num < 0)
3432 return NULL;
3435 name = d_name (di);
3436 if (name)
3437 switch (name->type)
3439 /* Lambdas and unnamed types have internal discriminators. */
3440 case DEMANGLE_COMPONENT_LAMBDA:
3441 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3442 break;
3443 default:
3444 if (! d_discriminator (di))
3445 return NULL;
3447 if (num >= 0)
3448 name = d_make_default_arg (di, num, name);
3449 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3453 /* <discriminator> ::= _ <(non-negative) number>
3455 We demangle the discriminator, but we don't print it out. FIXME:
3456 We should print it out in verbose mode. */
3458 static int
3459 d_discriminator (struct d_info *di)
3461 long discrim;
3463 if (d_peek_char (di) != '_')
3464 return 1;
3465 d_advance (di, 1);
3466 discrim = d_number (di);
3467 if (discrim < 0)
3468 return 0;
3469 return 1;
3472 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3474 static struct demangle_component *
3475 d_lambda (struct d_info *di)
3477 struct demangle_component *tl;
3478 struct demangle_component *ret;
3479 int num;
3481 if (! d_check_char (di, 'U'))
3482 return NULL;
3483 if (! d_check_char (di, 'l'))
3484 return NULL;
3486 tl = d_parmlist (di);
3487 if (tl == NULL)
3488 return NULL;
3490 if (! d_check_char (di, 'E'))
3491 return NULL;
3493 num = d_compact_number (di);
3494 if (num < 0)
3495 return NULL;
3497 ret = d_make_empty (di);
3498 if (ret)
3500 ret->type = DEMANGLE_COMPONENT_LAMBDA;
3501 ret->u.s_unary_num.sub = tl;
3502 ret->u.s_unary_num.num = num;
3505 if (! d_add_substitution (di, ret))
3506 return NULL;
3508 return ret;
3511 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3513 static struct demangle_component *
3514 d_unnamed_type (struct d_info *di)
3516 struct demangle_component *ret;
3517 long num;
3519 if (! d_check_char (di, 'U'))
3520 return NULL;
3521 if (! d_check_char (di, 't'))
3522 return NULL;
3524 num = d_compact_number (di);
3525 if (num < 0)
3526 return NULL;
3528 ret = d_make_empty (di);
3529 if (ret)
3531 ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3532 ret->u.s_number.number = num;
3535 if (! d_add_substitution (di, ret))
3536 return NULL;
3538 return ret;
3541 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3544 static struct demangle_component *
3545 d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3547 const char *suffix = d_str (di);
3548 const char *pend = suffix;
3549 struct demangle_component *n;
3551 if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3553 pend += 2;
3554 while (IS_LOWER (*pend) || *pend == '_')
3555 ++pend;
3557 while (*pend == '.' && IS_DIGIT (pend[1]))
3559 pend += 2;
3560 while (IS_DIGIT (*pend))
3561 ++pend;
3563 d_advance (di, pend - suffix);
3564 n = d_make_name (di, suffix, pend - suffix);
3565 return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3568 /* Add a new substitution. */
3570 static int
3571 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3573 if (dc == NULL)
3574 return 0;
3575 if (di->next_sub >= di->num_subs)
3576 return 0;
3577 di->subs[di->next_sub] = dc;
3578 ++di->next_sub;
3579 return 1;
3582 /* <substitution> ::= S <seq-id> _
3583 ::= S_
3584 ::= St
3585 ::= Sa
3586 ::= Sb
3587 ::= Ss
3588 ::= Si
3589 ::= So
3590 ::= Sd
3592 If PREFIX is non-zero, then this type is being used as a prefix in
3593 a qualified name. In this case, for the standard substitutions, we
3594 need to check whether we are being used as a prefix for a
3595 constructor or destructor, and return a full template name.
3596 Otherwise we will get something like std::iostream::~iostream()
3597 which does not correspond particularly well to any function which
3598 actually appears in the source.
3601 static const struct d_standard_sub_info standard_subs[] =
3603 { 't', NL ("std"),
3604 NL ("std"),
3605 NULL, 0 },
3606 { 'a', NL ("std::allocator"),
3607 NL ("std::allocator"),
3608 NL ("allocator") },
3609 { 'b', NL ("std::basic_string"),
3610 NL ("std::basic_string"),
3611 NL ("basic_string") },
3612 { 's', NL ("std::string"),
3613 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3614 NL ("basic_string") },
3615 { 'i', NL ("std::istream"),
3616 NL ("std::basic_istream<char, std::char_traits<char> >"),
3617 NL ("basic_istream") },
3618 { 'o', NL ("std::ostream"),
3619 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3620 NL ("basic_ostream") },
3621 { 'd', NL ("std::iostream"),
3622 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3623 NL ("basic_iostream") }
3626 static struct demangle_component *
3627 d_substitution (struct d_info *di, int prefix)
3629 char c;
3631 if (! d_check_char (di, 'S'))
3632 return NULL;
3634 c = d_next_char (di);
3635 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3637 unsigned int id;
3639 id = 0;
3640 if (c != '_')
3644 unsigned int new_id;
3646 if (IS_DIGIT (c))
3647 new_id = id * 36 + c - '0';
3648 else if (IS_UPPER (c))
3649 new_id = id * 36 + c - 'A' + 10;
3650 else
3651 return NULL;
3652 if (new_id < id)
3653 return NULL;
3654 id = new_id;
3655 c = d_next_char (di);
3657 while (c != '_');
3659 ++id;
3662 if (id >= (unsigned int) di->next_sub)
3663 return NULL;
3665 ++di->did_subs;
3667 return di->subs[id];
3669 else
3671 int verbose;
3672 const struct d_standard_sub_info *p;
3673 const struct d_standard_sub_info *pend;
3675 verbose = (di->options & DMGL_VERBOSE) != 0;
3676 if (! verbose && prefix)
3678 char peek;
3680 peek = d_peek_char (di);
3681 if (peek == 'C' || peek == 'D')
3682 verbose = 1;
3685 pend = (&standard_subs[0]
3686 + sizeof standard_subs / sizeof standard_subs[0]);
3687 for (p = &standard_subs[0]; p < pend; ++p)
3689 if (c == p->code)
3691 const char *s;
3692 int len;
3693 struct demangle_component *c;
3695 if (p->set_last_name != NULL)
3696 di->last_name = d_make_sub (di, p->set_last_name,
3697 p->set_last_name_len);
3698 if (verbose)
3700 s = p->full_expansion;
3701 len = p->full_len;
3703 else
3705 s = p->simple_expansion;
3706 len = p->simple_len;
3708 di->expansion += len;
3709 c = d_make_sub (di, s, len);
3710 if (d_peek_char (di) == 'B')
3712 /* If there are ABI tags on the abbreviation, it becomes
3713 a substitution candidate. */
3714 c = d_abi_tags (di, c);
3715 d_add_substitution (di, c);
3717 return c;
3721 return NULL;
3725 static void
3726 d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
3728 checkpoint->n = di->n;
3729 checkpoint->next_comp = di->next_comp;
3730 checkpoint->next_sub = di->next_sub;
3731 checkpoint->did_subs = di->did_subs;
3732 checkpoint->expansion = di->expansion;
3735 static void
3736 d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
3738 di->n = checkpoint->n;
3739 di->next_comp = checkpoint->next_comp;
3740 di->next_sub = checkpoint->next_sub;
3741 di->did_subs = checkpoint->did_subs;
3742 di->expansion = checkpoint->expansion;
3745 /* Initialize a growable string. */
3747 static void
3748 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3750 dgs->buf = NULL;
3751 dgs->len = 0;
3752 dgs->alc = 0;
3753 dgs->allocation_failure = 0;
3755 if (estimate > 0)
3756 d_growable_string_resize (dgs, estimate);
3759 /* Grow a growable string to a given size. */
3761 static inline void
3762 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3764 size_t newalc;
3765 char *newbuf;
3767 if (dgs->allocation_failure)
3768 return;
3770 /* Start allocation at two bytes to avoid any possibility of confusion
3771 with the special value of 1 used as a return in *palc to indicate
3772 allocation failures. */
3773 newalc = dgs->alc > 0 ? dgs->alc : 2;
3774 while (newalc < need)
3775 newalc <<= 1;
3777 newbuf = (char *) realloc (dgs->buf, newalc);
3778 if (newbuf == NULL)
3780 free (dgs->buf);
3781 dgs->buf = NULL;
3782 dgs->len = 0;
3783 dgs->alc = 0;
3784 dgs->allocation_failure = 1;
3785 return;
3787 dgs->buf = newbuf;
3788 dgs->alc = newalc;
3791 /* Append a buffer to a growable string. */
3793 static inline void
3794 d_growable_string_append_buffer (struct d_growable_string *dgs,
3795 const char *s, size_t l)
3797 size_t need;
3799 need = dgs->len + l + 1;
3800 if (need > dgs->alc)
3801 d_growable_string_resize (dgs, need);
3803 if (dgs->allocation_failure)
3804 return;
3806 memcpy (dgs->buf + dgs->len, s, l);
3807 dgs->buf[dgs->len + l] = '\0';
3808 dgs->len += l;
3811 /* Bridge growable strings to the callback mechanism. */
3813 static void
3814 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3816 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3818 d_growable_string_append_buffer (dgs, s, l);
3821 /* Walk the tree, counting the number of templates encountered, and
3822 the number of times a scope might be saved. These counts will be
3823 used to allocate data structures for d_print_comp, so the logic
3824 here must mirror the logic d_print_comp will use. It is not
3825 important that the resulting numbers are exact, so long as they
3826 are larger than the actual numbers encountered. */
3828 static void
3829 d_count_templates_scopes (int *num_templates, int *num_scopes,
3830 const struct demangle_component *dc)
3832 if (dc == NULL)
3833 return;
3835 switch (dc->type)
3837 case DEMANGLE_COMPONENT_NAME:
3838 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3839 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3840 case DEMANGLE_COMPONENT_SUB_STD:
3841 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3842 case DEMANGLE_COMPONENT_OPERATOR:
3843 case DEMANGLE_COMPONENT_CHARACTER:
3844 case DEMANGLE_COMPONENT_NUMBER:
3845 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3846 break;
3848 case DEMANGLE_COMPONENT_TEMPLATE:
3849 (*num_templates)++;
3850 goto recurse_left_right;
3852 case DEMANGLE_COMPONENT_REFERENCE:
3853 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3854 if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
3855 (*num_scopes)++;
3856 goto recurse_left_right;
3858 case DEMANGLE_COMPONENT_QUAL_NAME:
3859 case DEMANGLE_COMPONENT_LOCAL_NAME:
3860 case DEMANGLE_COMPONENT_TYPED_NAME:
3861 case DEMANGLE_COMPONENT_VTABLE:
3862 case DEMANGLE_COMPONENT_VTT:
3863 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3864 case DEMANGLE_COMPONENT_TYPEINFO:
3865 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3866 case DEMANGLE_COMPONENT_TYPEINFO_FN:
3867 case DEMANGLE_COMPONENT_THUNK:
3868 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3869 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3870 case DEMANGLE_COMPONENT_JAVA_CLASS:
3871 case DEMANGLE_COMPONENT_GUARD:
3872 case DEMANGLE_COMPONENT_TLS_INIT:
3873 case DEMANGLE_COMPONENT_TLS_WRAPPER:
3874 case DEMANGLE_COMPONENT_REFTEMP:
3875 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3876 case DEMANGLE_COMPONENT_RESTRICT:
3877 case DEMANGLE_COMPONENT_VOLATILE:
3878 case DEMANGLE_COMPONENT_CONST:
3879 case DEMANGLE_COMPONENT_RESTRICT_THIS:
3880 case DEMANGLE_COMPONENT_VOLATILE_THIS:
3881 case DEMANGLE_COMPONENT_CONST_THIS:
3882 case DEMANGLE_COMPONENT_REFERENCE_THIS:
3883 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
3884 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3885 case DEMANGLE_COMPONENT_POINTER:
3886 case DEMANGLE_COMPONENT_COMPLEX:
3887 case DEMANGLE_COMPONENT_IMAGINARY:
3888 case DEMANGLE_COMPONENT_VENDOR_TYPE:
3889 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3890 case DEMANGLE_COMPONENT_ARRAY_TYPE:
3891 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3892 case DEMANGLE_COMPONENT_VECTOR_TYPE:
3893 case DEMANGLE_COMPONENT_ARGLIST:
3894 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
3895 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
3896 case DEMANGLE_COMPONENT_CAST:
3897 case DEMANGLE_COMPONENT_NULLARY:
3898 case DEMANGLE_COMPONENT_UNARY:
3899 case DEMANGLE_COMPONENT_BINARY:
3900 case DEMANGLE_COMPONENT_BINARY_ARGS:
3901 case DEMANGLE_COMPONENT_TRINARY:
3902 case DEMANGLE_COMPONENT_TRINARY_ARG1:
3903 case DEMANGLE_COMPONENT_TRINARY_ARG2:
3904 case DEMANGLE_COMPONENT_LITERAL:
3905 case DEMANGLE_COMPONENT_LITERAL_NEG:
3906 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
3907 case DEMANGLE_COMPONENT_COMPOUND_NAME:
3908 case DEMANGLE_COMPONENT_DECLTYPE:
3909 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
3910 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
3911 case DEMANGLE_COMPONENT_PACK_EXPANSION:
3912 case DEMANGLE_COMPONENT_TAGGED_NAME:
3913 case DEMANGLE_COMPONENT_CLONE:
3914 recurse_left_right:
3915 d_count_templates_scopes (num_templates, num_scopes,
3916 d_left (dc));
3917 d_count_templates_scopes (num_templates, num_scopes,
3918 d_right (dc));
3919 break;
3921 case DEMANGLE_COMPONENT_CTOR:
3922 d_count_templates_scopes (num_templates, num_scopes,
3923 dc->u.s_ctor.name);
3924 break;
3926 case DEMANGLE_COMPONENT_DTOR:
3927 d_count_templates_scopes (num_templates, num_scopes,
3928 dc->u.s_dtor.name);
3929 break;
3931 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3932 d_count_templates_scopes (num_templates, num_scopes,
3933 dc->u.s_extended_operator.name);
3934 break;
3936 case DEMANGLE_COMPONENT_FIXED_TYPE:
3937 d_count_templates_scopes (num_templates, num_scopes,
3938 dc->u.s_fixed.length);
3939 break;
3941 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
3942 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
3943 d_count_templates_scopes (num_templates, num_scopes,
3944 d_left (dc));
3945 break;
3947 case DEMANGLE_COMPONENT_LAMBDA:
3948 case DEMANGLE_COMPONENT_DEFAULT_ARG:
3949 d_count_templates_scopes (num_templates, num_scopes,
3950 dc->u.s_unary_num.sub);
3951 break;
3955 /* Initialize a print information structure. */
3957 static void
3958 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
3959 void *opaque, const struct demangle_component *dc)
3961 dpi->len = 0;
3962 dpi->last_char = '\0';
3963 dpi->templates = NULL;
3964 dpi->modifiers = NULL;
3965 dpi->pack_index = 0;
3966 dpi->flush_count = 0;
3968 dpi->callback = callback;
3969 dpi->opaque = opaque;
3971 dpi->demangle_failure = 0;
3973 dpi->component_stack = NULL;
3975 dpi->saved_scopes = NULL;
3976 dpi->next_saved_scope = 0;
3977 dpi->num_saved_scopes = 0;
3979 dpi->copy_templates = NULL;
3980 dpi->next_copy_template = 0;
3981 dpi->num_copy_templates = 0;
3983 d_count_templates_scopes (&dpi->num_copy_templates,
3984 &dpi->num_saved_scopes, dc);
3985 dpi->num_copy_templates *= dpi->num_saved_scopes;
3987 dpi->current_template = NULL;
3990 /* Indicate that an error occurred during printing, and test for error. */
3992 static inline void
3993 d_print_error (struct d_print_info *dpi)
3995 dpi->demangle_failure = 1;
3998 static inline int
3999 d_print_saw_error (struct d_print_info *dpi)
4001 return dpi->demangle_failure != 0;
4004 /* Flush buffered characters to the callback. */
4006 static inline void
4007 d_print_flush (struct d_print_info *dpi)
4009 dpi->buf[dpi->len] = '\0';
4010 dpi->callback (dpi->buf, dpi->len, dpi->opaque);
4011 dpi->len = 0;
4012 dpi->flush_count++;
4015 /* Append characters and buffers for printing. */
4017 static inline void
4018 d_append_char (struct d_print_info *dpi, char c)
4020 if (dpi->len == sizeof (dpi->buf) - 1)
4021 d_print_flush (dpi);
4023 dpi->buf[dpi->len++] = c;
4024 dpi->last_char = c;
4027 static inline void
4028 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4030 size_t i;
4032 for (i = 0; i < l; i++)
4033 d_append_char (dpi, s[i]);
4036 static inline void
4037 d_append_string (struct d_print_info *dpi, const char *s)
4039 d_append_buffer (dpi, s, strlen (s));
4042 static inline void
4043 d_append_num (struct d_print_info *dpi, long l)
4045 char buf[25];
4046 sprintf (buf,"%ld", l);
4047 d_append_string (dpi, buf);
4050 static inline char
4051 d_last_char (struct d_print_info *dpi)
4053 return dpi->last_char;
4056 /* Turn components into a human readable string. OPTIONS is the
4057 options bits passed to the demangler. DC is the tree to print.
4058 CALLBACK is a function to call to flush demangled string segments
4059 as they fill the intermediate buffer, and OPAQUE is a generalized
4060 callback argument. On success, this returns 1. On failure,
4061 it returns 0, indicating a bad parse. It does not use heap
4062 memory to build an output string, so cannot encounter memory
4063 allocation failure. */
4065 CP_STATIC_IF_GLIBCPP_V3
4067 cplus_demangle_print_callback (int options,
4068 const struct demangle_component *dc,
4069 demangle_callbackref callback, void *opaque)
4071 struct d_print_info dpi;
4073 d_print_init (&dpi, callback, opaque, dc);
4076 #ifdef CP_DYNAMIC_ARRAYS
4077 __extension__ struct d_saved_scope scopes[dpi.num_saved_scopes];
4078 __extension__ struct d_print_template temps[dpi.num_copy_templates];
4080 dpi.saved_scopes = scopes;
4081 dpi.copy_templates = temps;
4082 #else
4083 dpi.saved_scopes = alloca (dpi.num_saved_scopes
4084 * sizeof (*dpi.saved_scopes));
4085 dpi.copy_templates = alloca (dpi.num_copy_templates
4086 * sizeof (*dpi.copy_templates));
4087 #endif
4089 d_print_comp (&dpi, options, dc);
4092 d_print_flush (&dpi);
4094 return ! d_print_saw_error (&dpi);
4097 /* Turn components into a human readable string. OPTIONS is the
4098 options bits passed to the demangler. DC is the tree to print.
4099 ESTIMATE is a guess at the length of the result. This returns a
4100 string allocated by malloc, or NULL on error. On success, this
4101 sets *PALC to the size of the allocated buffer. On failure, this
4102 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4103 failure. */
4105 CP_STATIC_IF_GLIBCPP_V3
4106 char *
4107 cplus_demangle_print (int options, const struct demangle_component *dc,
4108 int estimate, size_t *palc)
4110 struct d_growable_string dgs;
4112 d_growable_string_init (&dgs, estimate);
4114 if (! cplus_demangle_print_callback (options, dc,
4115 d_growable_string_callback_adapter,
4116 &dgs))
4118 free (dgs.buf);
4119 *palc = 0;
4120 return NULL;
4123 *palc = dgs.allocation_failure ? 1 : dgs.alc;
4124 return dgs.buf;
4127 /* Returns the I'th element of the template arglist ARGS, or NULL on
4128 failure. */
4130 static struct demangle_component *
4131 d_index_template_argument (struct demangle_component *args, int i)
4133 struct demangle_component *a;
4135 for (a = args;
4136 a != NULL;
4137 a = d_right (a))
4139 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4140 return NULL;
4141 if (i <= 0)
4142 break;
4143 --i;
4145 if (i != 0 || a == NULL)
4146 return NULL;
4148 return d_left (a);
4151 /* Returns the template argument from the current context indicated by DC,
4152 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4154 static struct demangle_component *
4155 d_lookup_template_argument (struct d_print_info *dpi,
4156 const struct demangle_component *dc)
4158 if (dpi->templates == NULL)
4160 d_print_error (dpi);
4161 return NULL;
4164 return d_index_template_argument
4165 (d_right (dpi->templates->template_decl),
4166 dc->u.s_number.number);
4169 /* Returns a template argument pack used in DC (any will do), or NULL. */
4171 static struct demangle_component *
4172 d_find_pack (struct d_print_info *dpi,
4173 const struct demangle_component *dc)
4175 struct demangle_component *a;
4176 if (dc == NULL)
4177 return NULL;
4179 switch (dc->type)
4181 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4182 a = d_lookup_template_argument (dpi, dc);
4183 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4184 return a;
4185 return NULL;
4187 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4188 return NULL;
4190 case DEMANGLE_COMPONENT_LAMBDA:
4191 case DEMANGLE_COMPONENT_NAME:
4192 case DEMANGLE_COMPONENT_TAGGED_NAME:
4193 case DEMANGLE_COMPONENT_OPERATOR:
4194 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4195 case DEMANGLE_COMPONENT_SUB_STD:
4196 case DEMANGLE_COMPONENT_CHARACTER:
4197 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4198 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4199 return NULL;
4201 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4202 return d_find_pack (dpi, dc->u.s_extended_operator.name);
4203 case DEMANGLE_COMPONENT_CTOR:
4204 return d_find_pack (dpi, dc->u.s_ctor.name);
4205 case DEMANGLE_COMPONENT_DTOR:
4206 return d_find_pack (dpi, dc->u.s_dtor.name);
4208 default:
4209 a = d_find_pack (dpi, d_left (dc));
4210 if (a)
4211 return a;
4212 return d_find_pack (dpi, d_right (dc));
4216 /* Returns the length of the template argument pack DC. */
4218 static int
4219 d_pack_length (const struct demangle_component *dc)
4221 int count = 0;
4222 while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4223 && d_left (dc) != NULL)
4225 ++count;
4226 dc = d_right (dc);
4228 return count;
4231 /* DC is a component of a mangled expression. Print it, wrapped in parens
4232 if needed. */
4234 static void
4235 d_print_subexpr (struct d_print_info *dpi, int options,
4236 const struct demangle_component *dc)
4238 int simple = 0;
4239 if (dc->type == DEMANGLE_COMPONENT_NAME
4240 || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
4241 || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
4242 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
4243 simple = 1;
4244 if (!simple)
4245 d_append_char (dpi, '(');
4246 d_print_comp (dpi, options, dc);
4247 if (!simple)
4248 d_append_char (dpi, ')');
4251 /* Save the current scope. */
4253 static void
4254 d_save_scope (struct d_print_info *dpi,
4255 const struct demangle_component *container)
4257 struct d_saved_scope *scope;
4258 struct d_print_template *src, **link;
4260 if (dpi->next_saved_scope >= dpi->num_saved_scopes)
4262 d_print_error (dpi);
4263 return;
4265 scope = &dpi->saved_scopes[dpi->next_saved_scope];
4266 dpi->next_saved_scope++;
4268 scope->container = container;
4269 link = &scope->templates;
4271 for (src = dpi->templates; src != NULL; src = src->next)
4273 struct d_print_template *dst;
4275 if (dpi->next_copy_template >= dpi->num_copy_templates)
4277 d_print_error (dpi);
4278 return;
4280 dst = &dpi->copy_templates[dpi->next_copy_template];
4281 dpi->next_copy_template++;
4283 dst->template_decl = src->template_decl;
4284 *link = dst;
4285 link = &dst->next;
4288 *link = NULL;
4291 /* Attempt to locate a previously saved scope. Returns NULL if no
4292 corresponding saved scope was found. */
4294 static struct d_saved_scope *
4295 d_get_saved_scope (struct d_print_info *dpi,
4296 const struct demangle_component *container)
4298 int i;
4300 for (i = 0; i < dpi->next_saved_scope; i++)
4301 if (dpi->saved_scopes[i].container == container)
4302 return &dpi->saved_scopes[i];
4304 return NULL;
4307 /* Subroutine to handle components. */
4309 static void
4310 d_print_comp_inner (struct d_print_info *dpi, int options,
4311 const struct demangle_component *dc)
4313 /* Magic variable to let reference smashing skip over the next modifier
4314 without needing to modify *dc. */
4315 const struct demangle_component *mod_inner = NULL;
4317 /* Variable used to store the current templates while a previously
4318 captured scope is used. */
4319 struct d_print_template *saved_templates;
4321 /* Nonzero if templates have been stored in the above variable. */
4322 int need_template_restore = 0;
4324 if (dc == NULL)
4326 d_print_error (dpi);
4327 return;
4329 if (d_print_saw_error (dpi))
4330 return;
4332 switch (dc->type)
4334 case DEMANGLE_COMPONENT_NAME:
4335 if ((options & DMGL_JAVA) == 0)
4336 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
4337 else
4338 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
4339 return;
4341 case DEMANGLE_COMPONENT_TAGGED_NAME:
4342 d_print_comp (dpi, options, d_left (dc));
4343 d_append_string (dpi, "[abi:");
4344 d_print_comp (dpi, options, d_right (dc));
4345 d_append_char (dpi, ']');
4346 return;
4348 case DEMANGLE_COMPONENT_QUAL_NAME:
4349 case DEMANGLE_COMPONENT_LOCAL_NAME:
4350 d_print_comp (dpi, options, d_left (dc));
4351 if ((options & DMGL_JAVA) == 0)
4352 d_append_string (dpi, "::");
4353 else
4354 d_append_char (dpi, '.');
4356 struct demangle_component *local_name = d_right (dc);
4357 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4359 d_append_string (dpi, "{default arg#");
4360 d_append_num (dpi, local_name->u.s_unary_num.num + 1);
4361 d_append_string (dpi, "}::");
4362 local_name = local_name->u.s_unary_num.sub;
4364 d_print_comp (dpi, options, local_name);
4366 return;
4368 case DEMANGLE_COMPONENT_TYPED_NAME:
4370 struct d_print_mod *hold_modifiers;
4371 struct demangle_component *typed_name;
4372 struct d_print_mod adpm[4];
4373 unsigned int i;
4374 struct d_print_template dpt;
4376 /* Pass the name down to the type so that it can be printed in
4377 the right place for the type. We also have to pass down
4378 any CV-qualifiers, which apply to the this parameter. */
4379 hold_modifiers = dpi->modifiers;
4380 dpi->modifiers = 0;
4381 i = 0;
4382 typed_name = d_left (dc);
4383 while (typed_name != NULL)
4385 if (i >= sizeof adpm / sizeof adpm[0])
4387 d_print_error (dpi);
4388 return;
4391 adpm[i].next = dpi->modifiers;
4392 dpi->modifiers = &adpm[i];
4393 adpm[i].mod = typed_name;
4394 adpm[i].printed = 0;
4395 adpm[i].templates = dpi->templates;
4396 ++i;
4398 if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
4399 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
4400 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS
4401 && typed_name->type != DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
4402 && typed_name->type != DEMANGLE_COMPONENT_REFERENCE_THIS)
4403 break;
4405 typed_name = d_left (typed_name);
4408 if (typed_name == NULL)
4410 d_print_error (dpi);
4411 return;
4414 /* If typed_name is a template, then it applies to the
4415 function type as well. */
4416 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4418 dpt.next = dpi->templates;
4419 dpi->templates = &dpt;
4420 dpt.template_decl = typed_name;
4423 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4424 there may be CV-qualifiers on its right argument which
4425 really apply here; this happens when parsing a class which
4426 is local to a function. */
4427 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4429 struct demangle_component *local_name;
4431 local_name = d_right (typed_name);
4432 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4433 local_name = local_name->u.s_unary_num.sub;
4434 while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4435 || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4436 || local_name->type == DEMANGLE_COMPONENT_CONST_THIS
4437 || local_name->type == DEMANGLE_COMPONENT_REFERENCE_THIS
4438 || (local_name->type
4439 == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))
4441 if (i >= sizeof adpm / sizeof adpm[0])
4443 d_print_error (dpi);
4444 return;
4447 adpm[i] = adpm[i - 1];
4448 adpm[i].next = &adpm[i - 1];
4449 dpi->modifiers = &adpm[i];
4451 adpm[i - 1].mod = local_name;
4452 adpm[i - 1].printed = 0;
4453 adpm[i - 1].templates = dpi->templates;
4454 ++i;
4456 local_name = d_left (local_name);
4460 d_print_comp (dpi, options, d_right (dc));
4462 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4463 dpi->templates = dpt.next;
4465 /* If the modifiers didn't get printed by the type, print them
4466 now. */
4467 while (i > 0)
4469 --i;
4470 if (! adpm[i].printed)
4472 d_append_char (dpi, ' ');
4473 d_print_mod (dpi, options, adpm[i].mod);
4477 dpi->modifiers = hold_modifiers;
4479 return;
4482 case DEMANGLE_COMPONENT_TEMPLATE:
4484 struct d_print_mod *hold_dpm;
4485 struct demangle_component *dcl;
4486 const struct demangle_component *hold_current;
4488 /* This template may need to be referenced by a cast operator
4489 contained in its subtree. */
4490 hold_current = dpi->current_template;
4491 dpi->current_template = dc;
4493 /* Don't push modifiers into a template definition. Doing so
4494 could give the wrong definition for a template argument.
4495 Instead, treat the template essentially as a name. */
4497 hold_dpm = dpi->modifiers;
4498 dpi->modifiers = NULL;
4500 dcl = d_left (dc);
4502 if ((options & DMGL_JAVA) != 0
4503 && dcl->type == DEMANGLE_COMPONENT_NAME
4504 && dcl->u.s_name.len == 6
4505 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
4507 /* Special-case Java arrays, so that JArray<TYPE> appears
4508 instead as TYPE[]. */
4510 d_print_comp (dpi, options, d_right (dc));
4511 d_append_string (dpi, "[]");
4513 else
4515 d_print_comp (dpi, options, dcl);
4516 if (d_last_char (dpi) == '<')
4517 d_append_char (dpi, ' ');
4518 d_append_char (dpi, '<');
4519 d_print_comp (dpi, options, d_right (dc));
4520 /* Avoid generating two consecutive '>' characters, to avoid
4521 the C++ syntactic ambiguity. */
4522 if (d_last_char (dpi) == '>')
4523 d_append_char (dpi, ' ');
4524 d_append_char (dpi, '>');
4527 dpi->modifiers = hold_dpm;
4528 dpi->current_template = hold_current;
4530 return;
4533 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4535 struct d_print_template *hold_dpt;
4536 struct demangle_component *a = d_lookup_template_argument (dpi, dc);
4538 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4539 a = d_index_template_argument (a, dpi->pack_index);
4541 if (a == NULL)
4543 d_print_error (dpi);
4544 return;
4547 /* While processing this parameter, we need to pop the list of
4548 templates. This is because the template parameter may
4549 itself be a reference to a parameter of an outer
4550 template. */
4552 hold_dpt = dpi->templates;
4553 dpi->templates = hold_dpt->next;
4555 d_print_comp (dpi, options, a);
4557 dpi->templates = hold_dpt;
4559 return;
4562 case DEMANGLE_COMPONENT_CTOR:
4563 d_print_comp (dpi, options, dc->u.s_ctor.name);
4564 return;
4566 case DEMANGLE_COMPONENT_DTOR:
4567 d_append_char (dpi, '~');
4568 d_print_comp (dpi, options, dc->u.s_dtor.name);
4569 return;
4571 case DEMANGLE_COMPONENT_VTABLE:
4572 d_append_string (dpi, "vtable for ");
4573 d_print_comp (dpi, options, d_left (dc));
4574 return;
4576 case DEMANGLE_COMPONENT_VTT:
4577 d_append_string (dpi, "VTT for ");
4578 d_print_comp (dpi, options, d_left (dc));
4579 return;
4581 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4582 d_append_string (dpi, "construction vtable for ");
4583 d_print_comp (dpi, options, d_left (dc));
4584 d_append_string (dpi, "-in-");
4585 d_print_comp (dpi, options, d_right (dc));
4586 return;
4588 case DEMANGLE_COMPONENT_TYPEINFO:
4589 d_append_string (dpi, "typeinfo for ");
4590 d_print_comp (dpi, options, d_left (dc));
4591 return;
4593 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4594 d_append_string (dpi, "typeinfo name for ");
4595 d_print_comp (dpi, options, d_left (dc));
4596 return;
4598 case DEMANGLE_COMPONENT_TYPEINFO_FN:
4599 d_append_string (dpi, "typeinfo fn for ");
4600 d_print_comp (dpi, options, d_left (dc));
4601 return;
4603 case DEMANGLE_COMPONENT_THUNK:
4604 d_append_string (dpi, "non-virtual thunk to ");
4605 d_print_comp (dpi, options, d_left (dc));
4606 return;
4608 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4609 d_append_string (dpi, "virtual thunk to ");
4610 d_print_comp (dpi, options, d_left (dc));
4611 return;
4613 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4614 d_append_string (dpi, "covariant return thunk to ");
4615 d_print_comp (dpi, options, d_left (dc));
4616 return;
4618 case DEMANGLE_COMPONENT_JAVA_CLASS:
4619 d_append_string (dpi, "java Class for ");
4620 d_print_comp (dpi, options, d_left (dc));
4621 return;
4623 case DEMANGLE_COMPONENT_GUARD:
4624 d_append_string (dpi, "guard variable for ");
4625 d_print_comp (dpi, options, d_left (dc));
4626 return;
4628 case DEMANGLE_COMPONENT_TLS_INIT:
4629 d_append_string (dpi, "TLS init function for ");
4630 d_print_comp (dpi, options, d_left (dc));
4631 return;
4633 case DEMANGLE_COMPONENT_TLS_WRAPPER:
4634 d_append_string (dpi, "TLS wrapper function for ");
4635 d_print_comp (dpi, options, d_left (dc));
4636 return;
4638 case DEMANGLE_COMPONENT_REFTEMP:
4639 d_append_string (dpi, "reference temporary #");
4640 d_print_comp (dpi, options, d_right (dc));
4641 d_append_string (dpi, " for ");
4642 d_print_comp (dpi, options, d_left (dc));
4643 return;
4645 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4646 d_append_string (dpi, "hidden alias for ");
4647 d_print_comp (dpi, options, d_left (dc));
4648 return;
4650 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4651 d_append_string (dpi, "transaction clone for ");
4652 d_print_comp (dpi, options, d_left (dc));
4653 return;
4655 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4656 d_append_string (dpi, "non-transaction clone for ");
4657 d_print_comp (dpi, options, d_left (dc));
4658 return;
4660 case DEMANGLE_COMPONENT_SUB_STD:
4661 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
4662 return;
4664 case DEMANGLE_COMPONENT_RESTRICT:
4665 case DEMANGLE_COMPONENT_VOLATILE:
4666 case DEMANGLE_COMPONENT_CONST:
4668 struct d_print_mod *pdpm;
4670 /* When printing arrays, it's possible to have cases where the
4671 same CV-qualifier gets pushed on the stack multiple times.
4672 We only need to print it once. */
4674 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
4676 if (! pdpm->printed)
4678 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
4679 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
4680 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
4681 break;
4682 if (pdpm->mod->type == dc->type)
4684 d_print_comp (dpi, options, d_left (dc));
4685 return;
4690 goto modifier;
4692 case DEMANGLE_COMPONENT_REFERENCE:
4693 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4695 /* Handle reference smashing: & + && = &. */
4696 const struct demangle_component *sub = d_left (dc);
4697 if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
4699 struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
4700 struct demangle_component *a;
4702 if (scope == NULL)
4704 /* This is the first time SUB has been traversed.
4705 We need to capture the current templates so
4706 they can be restored if SUB is reentered as a
4707 substitution. */
4708 d_save_scope (dpi, sub);
4709 if (d_print_saw_error (dpi))
4710 return;
4712 else
4714 const struct d_component_stack *dcse;
4715 int found_self_or_parent = 0;
4717 /* This traversal is reentering SUB as a substition.
4718 If we are not beneath SUB or DC in the tree then we
4719 need to restore SUB's template stack temporarily. */
4720 for (dcse = dpi->component_stack; dcse != NULL;
4721 dcse = dcse->parent)
4723 if (dcse->dc == sub
4724 || (dcse->dc == dc
4725 && dcse != dpi->component_stack))
4727 found_self_or_parent = 1;
4728 break;
4732 if (!found_self_or_parent)
4734 saved_templates = dpi->templates;
4735 dpi->templates = scope->templates;
4736 need_template_restore = 1;
4740 a = d_lookup_template_argument (dpi, sub);
4741 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4742 a = d_index_template_argument (a, dpi->pack_index);
4744 if (a == NULL)
4746 if (need_template_restore)
4747 dpi->templates = saved_templates;
4749 d_print_error (dpi);
4750 return;
4753 sub = a;
4756 if (sub->type == DEMANGLE_COMPONENT_REFERENCE
4757 || sub->type == dc->type)
4758 dc = sub;
4759 else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
4760 mod_inner = d_left (sub);
4762 /* Fall through. */
4764 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4765 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4766 case DEMANGLE_COMPONENT_CONST_THIS:
4767 case DEMANGLE_COMPONENT_REFERENCE_THIS:
4768 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
4769 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4770 case DEMANGLE_COMPONENT_POINTER:
4771 case DEMANGLE_COMPONENT_COMPLEX:
4772 case DEMANGLE_COMPONENT_IMAGINARY:
4773 modifier:
4775 /* We keep a list of modifiers on the stack. */
4776 struct d_print_mod dpm;
4778 dpm.next = dpi->modifiers;
4779 dpi->modifiers = &dpm;
4780 dpm.mod = dc;
4781 dpm.printed = 0;
4782 dpm.templates = dpi->templates;
4784 if (!mod_inner)
4785 mod_inner = d_left (dc);
4787 d_print_comp (dpi, options, mod_inner);
4789 /* If the modifier didn't get printed by the type, print it
4790 now. */
4791 if (! dpm.printed)
4792 d_print_mod (dpi, options, dc);
4794 dpi->modifiers = dpm.next;
4796 if (need_template_restore)
4797 dpi->templates = saved_templates;
4799 return;
4802 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4803 if ((options & DMGL_JAVA) == 0)
4804 d_append_buffer (dpi, dc->u.s_builtin.type->name,
4805 dc->u.s_builtin.type->len);
4806 else
4807 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
4808 dc->u.s_builtin.type->java_len);
4809 return;
4811 case DEMANGLE_COMPONENT_VENDOR_TYPE:
4812 d_print_comp (dpi, options, d_left (dc));
4813 return;
4815 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4817 if ((options & DMGL_RET_POSTFIX) != 0)
4818 d_print_function_type (dpi,
4819 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4820 dc, dpi->modifiers);
4822 /* Print return type if present */
4823 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
4824 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4825 d_left (dc));
4826 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
4828 struct d_print_mod dpm;
4830 /* We must pass this type down as a modifier in order to
4831 print it in the right location. */
4832 dpm.next = dpi->modifiers;
4833 dpi->modifiers = &dpm;
4834 dpm.mod = dc;
4835 dpm.printed = 0;
4836 dpm.templates = dpi->templates;
4838 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4839 d_left (dc));
4841 dpi->modifiers = dpm.next;
4843 if (dpm.printed)
4844 return;
4846 /* In standard prefix notation, there is a space between the
4847 return type and the function signature. */
4848 if ((options & DMGL_RET_POSTFIX) == 0)
4849 d_append_char (dpi, ' ');
4852 if ((options & DMGL_RET_POSTFIX) == 0)
4853 d_print_function_type (dpi,
4854 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4855 dc, dpi->modifiers);
4857 return;
4860 case DEMANGLE_COMPONENT_ARRAY_TYPE:
4862 struct d_print_mod *hold_modifiers;
4863 struct d_print_mod adpm[4];
4864 unsigned int i;
4865 struct d_print_mod *pdpm;
4867 /* We must pass this type down as a modifier in order to print
4868 multi-dimensional arrays correctly. If the array itself is
4869 CV-qualified, we act as though the element type were
4870 CV-qualified. We do this by copying the modifiers down
4871 rather than fiddling pointers, so that we don't wind up
4872 with a d_print_mod higher on the stack pointing into our
4873 stack frame after we return. */
4875 hold_modifiers = dpi->modifiers;
4877 adpm[0].next = hold_modifiers;
4878 dpi->modifiers = &adpm[0];
4879 adpm[0].mod = dc;
4880 adpm[0].printed = 0;
4881 adpm[0].templates = dpi->templates;
4883 i = 1;
4884 pdpm = hold_modifiers;
4885 while (pdpm != NULL
4886 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
4887 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
4888 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
4890 if (! pdpm->printed)
4892 if (i >= sizeof adpm / sizeof adpm[0])
4894 d_print_error (dpi);
4895 return;
4898 adpm[i] = *pdpm;
4899 adpm[i].next = dpi->modifiers;
4900 dpi->modifiers = &adpm[i];
4901 pdpm->printed = 1;
4902 ++i;
4905 pdpm = pdpm->next;
4908 d_print_comp (dpi, options, d_right (dc));
4910 dpi->modifiers = hold_modifiers;
4912 if (adpm[0].printed)
4913 return;
4915 while (i > 1)
4917 --i;
4918 d_print_mod (dpi, options, adpm[i].mod);
4921 d_print_array_type (dpi, options, dc, dpi->modifiers);
4923 return;
4926 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4927 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4929 struct d_print_mod dpm;
4931 dpm.next = dpi->modifiers;
4932 dpi->modifiers = &dpm;
4933 dpm.mod = dc;
4934 dpm.printed = 0;
4935 dpm.templates = dpi->templates;
4937 d_print_comp (dpi, options, d_right (dc));
4939 /* If the modifier didn't get printed by the type, print it
4940 now. */
4941 if (! dpm.printed)
4942 d_print_mod (dpi, options, dc);
4944 dpi->modifiers = dpm.next;
4946 return;
4949 case DEMANGLE_COMPONENT_FIXED_TYPE:
4950 if (dc->u.s_fixed.sat)
4951 d_append_string (dpi, "_Sat ");
4952 /* Don't print "int _Accum". */
4953 if (dc->u.s_fixed.length->u.s_builtin.type
4954 != &cplus_demangle_builtin_types['i'-'a'])
4956 d_print_comp (dpi, options, dc->u.s_fixed.length);
4957 d_append_char (dpi, ' ');
4959 if (dc->u.s_fixed.accum)
4960 d_append_string (dpi, "_Accum");
4961 else
4962 d_append_string (dpi, "_Fract");
4963 return;
4965 case DEMANGLE_COMPONENT_ARGLIST:
4966 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4967 if (d_left (dc) != NULL)
4968 d_print_comp (dpi, options, d_left (dc));
4969 if (d_right (dc) != NULL)
4971 size_t len;
4972 unsigned long int flush_count;
4973 /* Make sure ", " isn't flushed by d_append_string, otherwise
4974 dpi->len -= 2 wouldn't work. */
4975 if (dpi->len >= sizeof (dpi->buf) - 2)
4976 d_print_flush (dpi);
4977 d_append_string (dpi, ", ");
4978 len = dpi->len;
4979 flush_count = dpi->flush_count;
4980 d_print_comp (dpi, options, d_right (dc));
4981 /* If that didn't print anything (which can happen with empty
4982 template argument packs), remove the comma and space. */
4983 if (dpi->flush_count == flush_count && dpi->len == len)
4984 dpi->len -= 2;
4986 return;
4988 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4990 struct demangle_component *type = d_left (dc);
4991 struct demangle_component *list = d_right (dc);
4993 if (type)
4994 d_print_comp (dpi, options, type);
4995 d_append_char (dpi, '{');
4996 d_print_comp (dpi, options, list);
4997 d_append_char (dpi, '}');
4999 return;
5001 case DEMANGLE_COMPONENT_OPERATOR:
5003 const struct demangle_operator_info *op = dc->u.s_operator.op;
5004 int len = op->len;
5006 d_append_string (dpi, "operator");
5007 /* Add a space before new/delete. */
5008 if (IS_LOWER (op->name[0]))
5009 d_append_char (dpi, ' ');
5010 /* Omit a trailing space. */
5011 if (op->name[len-1] == ' ')
5012 --len;
5013 d_append_buffer (dpi, op->name, len);
5014 return;
5017 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
5018 d_append_string (dpi, "operator ");
5019 d_print_comp (dpi, options, dc->u.s_extended_operator.name);
5020 return;
5022 case DEMANGLE_COMPONENT_CAST:
5023 d_append_string (dpi, "operator ");
5024 d_print_cast (dpi, options, dc);
5025 return;
5027 case DEMANGLE_COMPONENT_NULLARY:
5028 d_print_expr_op (dpi, options, d_left (dc));
5029 return;
5031 case DEMANGLE_COMPONENT_UNARY:
5033 struct demangle_component *op = d_left (dc);
5034 struct demangle_component *operand = d_right (dc);
5035 const char *code = NULL;
5037 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
5039 code = op->u.s_operator.op->code;
5040 if (!strcmp (code, "ad"))
5042 /* Don't print the argument list for the address of a
5043 function. */
5044 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
5045 && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
5046 && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5047 operand = d_left (operand);
5049 if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
5051 /* This indicates a suffix operator. */
5052 operand = d_left (operand);
5053 d_print_subexpr (dpi, options, operand);
5054 d_print_expr_op (dpi, options, op);
5055 return;
5059 if (op->type != DEMANGLE_COMPONENT_CAST)
5060 d_print_expr_op (dpi, options, op);
5061 else
5063 d_append_char (dpi, '(');
5064 d_print_cast (dpi, options, op);
5065 d_append_char (dpi, ')');
5067 if (code && !strcmp (code, "gs"))
5068 /* Avoid parens after '::'. */
5069 d_print_comp (dpi, options, operand);
5070 else if (code && !strcmp (code, "st"))
5071 /* Always print parens for sizeof (type). */
5073 d_append_char (dpi, '(');
5074 d_print_comp (dpi, options, operand);
5075 d_append_char (dpi, ')');
5077 else
5078 d_print_subexpr (dpi, options, operand);
5080 return;
5082 case DEMANGLE_COMPONENT_BINARY:
5083 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
5085 d_print_error (dpi);
5086 return;
5089 if (op_is_new_cast (d_left (dc)))
5091 d_print_expr_op (dpi, options, d_left (dc));
5092 d_append_char (dpi, '<');
5093 d_print_comp (dpi, options, d_left (d_right (dc)));
5094 d_append_string (dpi, ">(");
5095 d_print_comp (dpi, options, d_right (d_right (dc)));
5096 d_append_char (dpi, ')');
5097 return;
5100 /* We wrap an expression which uses the greater-than operator in
5101 an extra layer of parens so that it does not get confused
5102 with the '>' which ends the template parameters. */
5103 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5104 && d_left (dc)->u.s_operator.op->len == 1
5105 && d_left (dc)->u.s_operator.op->name[0] == '>')
5106 d_append_char (dpi, '(');
5108 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
5109 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
5111 /* Function call used in an expression should not have printed types
5112 of the function arguments. Values of the function arguments still
5113 get printed below. */
5115 const struct demangle_component *func = d_left (d_right (dc));
5117 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5118 d_print_error (dpi);
5119 d_print_subexpr (dpi, options, d_left (func));
5121 else
5122 d_print_subexpr (dpi, options, d_left (d_right (dc)));
5123 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
5125 d_append_char (dpi, '[');
5126 d_print_comp (dpi, options, d_right (d_right (dc)));
5127 d_append_char (dpi, ']');
5129 else
5131 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
5132 d_print_expr_op (dpi, options, d_left (dc));
5133 d_print_subexpr (dpi, options, d_right (d_right (dc)));
5136 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5137 && d_left (dc)->u.s_operator.op->len == 1
5138 && d_left (dc)->u.s_operator.op->name[0] == '>')
5139 d_append_char (dpi, ')');
5141 return;
5143 case DEMANGLE_COMPONENT_BINARY_ARGS:
5144 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5145 d_print_error (dpi);
5146 return;
5148 case DEMANGLE_COMPONENT_TRINARY:
5149 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
5150 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
5152 d_print_error (dpi);
5153 return;
5156 struct demangle_component *op = d_left (dc);
5157 struct demangle_component *first = d_left (d_right (dc));
5158 struct demangle_component *second = d_left (d_right (d_right (dc)));
5159 struct demangle_component *third = d_right (d_right (d_right (dc)));
5161 if (!strcmp (op->u.s_operator.op->code, "qu"))
5163 d_print_subexpr (dpi, options, first);
5164 d_print_expr_op (dpi, options, op);
5165 d_print_subexpr (dpi, options, second);
5166 d_append_string (dpi, " : ");
5167 d_print_subexpr (dpi, options, third);
5169 else
5171 d_append_string (dpi, "new ");
5172 if (d_left (first) != NULL)
5174 d_print_subexpr (dpi, options, first);
5175 d_append_char (dpi, ' ');
5177 d_print_comp (dpi, options, second);
5178 if (third)
5179 d_print_subexpr (dpi, options, third);
5182 return;
5184 case DEMANGLE_COMPONENT_TRINARY_ARG1:
5185 case DEMANGLE_COMPONENT_TRINARY_ARG2:
5186 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5187 d_print_error (dpi);
5188 return;
5190 case DEMANGLE_COMPONENT_LITERAL:
5191 case DEMANGLE_COMPONENT_LITERAL_NEG:
5193 enum d_builtin_type_print tp;
5195 /* For some builtin types, produce simpler output. */
5196 tp = D_PRINT_DEFAULT;
5197 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
5199 tp = d_left (dc)->u.s_builtin.type->print;
5200 switch (tp)
5202 case D_PRINT_INT:
5203 case D_PRINT_UNSIGNED:
5204 case D_PRINT_LONG:
5205 case D_PRINT_UNSIGNED_LONG:
5206 case D_PRINT_LONG_LONG:
5207 case D_PRINT_UNSIGNED_LONG_LONG:
5208 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
5210 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5211 d_append_char (dpi, '-');
5212 d_print_comp (dpi, options, d_right (dc));
5213 switch (tp)
5215 default:
5216 break;
5217 case D_PRINT_UNSIGNED:
5218 d_append_char (dpi, 'u');
5219 break;
5220 case D_PRINT_LONG:
5221 d_append_char (dpi, 'l');
5222 break;
5223 case D_PRINT_UNSIGNED_LONG:
5224 d_append_string (dpi, "ul");
5225 break;
5226 case D_PRINT_LONG_LONG:
5227 d_append_string (dpi, "ll");
5228 break;
5229 case D_PRINT_UNSIGNED_LONG_LONG:
5230 d_append_string (dpi, "ull");
5231 break;
5233 return;
5235 break;
5237 case D_PRINT_BOOL:
5238 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
5239 && d_right (dc)->u.s_name.len == 1
5240 && dc->type == DEMANGLE_COMPONENT_LITERAL)
5242 switch (d_right (dc)->u.s_name.s[0])
5244 case '0':
5245 d_append_string (dpi, "false");
5246 return;
5247 case '1':
5248 d_append_string (dpi, "true");
5249 return;
5250 default:
5251 break;
5254 break;
5256 default:
5257 break;
5261 d_append_char (dpi, '(');
5262 d_print_comp (dpi, options, d_left (dc));
5263 d_append_char (dpi, ')');
5264 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5265 d_append_char (dpi, '-');
5266 if (tp == D_PRINT_FLOAT)
5267 d_append_char (dpi, '[');
5268 d_print_comp (dpi, options, d_right (dc));
5269 if (tp == D_PRINT_FLOAT)
5270 d_append_char (dpi, ']');
5272 return;
5274 case DEMANGLE_COMPONENT_NUMBER:
5275 d_append_num (dpi, dc->u.s_number.number);
5276 return;
5278 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
5279 d_append_string (dpi, "java resource ");
5280 d_print_comp (dpi, options, d_left (dc));
5281 return;
5283 case DEMANGLE_COMPONENT_COMPOUND_NAME:
5284 d_print_comp (dpi, options, d_left (dc));
5285 d_print_comp (dpi, options, d_right (dc));
5286 return;
5288 case DEMANGLE_COMPONENT_CHARACTER:
5289 d_append_char (dpi, dc->u.s_character.character);
5290 return;
5292 case DEMANGLE_COMPONENT_DECLTYPE:
5293 d_append_string (dpi, "decltype (");
5294 d_print_comp (dpi, options, d_left (dc));
5295 d_append_char (dpi, ')');
5296 return;
5298 case DEMANGLE_COMPONENT_PACK_EXPANSION:
5300 int len;
5301 int i;
5302 struct demangle_component *a = d_find_pack (dpi, d_left (dc));
5303 if (a == NULL)
5305 /* d_find_pack won't find anything if the only packs involved
5306 in this expansion are function parameter packs; in that
5307 case, just print the pattern and "...". */
5308 d_print_subexpr (dpi, options, d_left (dc));
5309 d_append_string (dpi, "...");
5310 return;
5313 len = d_pack_length (a);
5314 dc = d_left (dc);
5315 for (i = 0; i < len; ++i)
5317 dpi->pack_index = i;
5318 d_print_comp (dpi, options, dc);
5319 if (i < len-1)
5320 d_append_string (dpi, ", ");
5323 return;
5325 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
5327 long num = dc->u.s_number.number;
5328 if (num == 0)
5329 d_append_string (dpi, "this");
5330 else
5332 d_append_string (dpi, "{parm#");
5333 d_append_num (dpi, num);
5334 d_append_char (dpi, '}');
5337 return;
5339 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
5340 d_append_string (dpi, "global constructors keyed to ");
5341 d_print_comp (dpi, options, dc->u.s_binary.left);
5342 return;
5344 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
5345 d_append_string (dpi, "global destructors keyed to ");
5346 d_print_comp (dpi, options, dc->u.s_binary.left);
5347 return;
5349 case DEMANGLE_COMPONENT_LAMBDA:
5350 d_append_string (dpi, "{lambda(");
5351 d_print_comp (dpi, options, dc->u.s_unary_num.sub);
5352 d_append_string (dpi, ")#");
5353 d_append_num (dpi, dc->u.s_unary_num.num + 1);
5354 d_append_char (dpi, '}');
5355 return;
5357 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
5358 d_append_string (dpi, "{unnamed type#");
5359 d_append_num (dpi, dc->u.s_number.number + 1);
5360 d_append_char (dpi, '}');
5361 return;
5363 case DEMANGLE_COMPONENT_CLONE:
5364 d_print_comp (dpi, options, d_left (dc));
5365 d_append_string (dpi, " [clone ");
5366 d_print_comp (dpi, options, d_right (dc));
5367 d_append_char (dpi, ']');
5368 return;
5370 default:
5371 d_print_error (dpi);
5372 return;
5376 static void
5377 d_print_comp (struct d_print_info *dpi, int options,
5378 const struct demangle_component *dc)
5380 struct d_component_stack self;
5382 self.dc = dc;
5383 self.parent = dpi->component_stack;
5384 dpi->component_stack = &self;
5386 d_print_comp_inner (dpi, options, dc);
5388 dpi->component_stack = self.parent;
5391 /* Print a Java dentifier. For Java we try to handle encoded extended
5392 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5393 so we don't it for C++. Characters are encoded as
5394 __U<hex-char>+_. */
5396 static void
5397 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
5399 const char *p;
5400 const char *end;
5402 end = name + len;
5403 for (p = name; p < end; ++p)
5405 if (end - p > 3
5406 && p[0] == '_'
5407 && p[1] == '_'
5408 && p[2] == 'U')
5410 unsigned long c;
5411 const char *q;
5413 c = 0;
5414 for (q = p + 3; q < end; ++q)
5416 int dig;
5418 if (IS_DIGIT (*q))
5419 dig = *q - '0';
5420 else if (*q >= 'A' && *q <= 'F')
5421 dig = *q - 'A' + 10;
5422 else if (*q >= 'a' && *q <= 'f')
5423 dig = *q - 'a' + 10;
5424 else
5425 break;
5427 c = c * 16 + dig;
5429 /* If the Unicode character is larger than 256, we don't try
5430 to deal with it here. FIXME. */
5431 if (q < end && *q == '_' && c < 256)
5433 d_append_char (dpi, c);
5434 p = q;
5435 continue;
5439 d_append_char (dpi, *p);
5443 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5444 qualifiers on this after printing a function. */
5446 static void
5447 d_print_mod_list (struct d_print_info *dpi, int options,
5448 struct d_print_mod *mods, int suffix)
5450 struct d_print_template *hold_dpt;
5452 if (mods == NULL || d_print_saw_error (dpi))
5453 return;
5455 if (mods->printed
5456 || (! suffix
5457 && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
5458 || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
5459 || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS
5460 || mods->mod->type == DEMANGLE_COMPONENT_REFERENCE_THIS
5461 || (mods->mod->type
5462 == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))))
5464 d_print_mod_list (dpi, options, mods->next, suffix);
5465 return;
5468 mods->printed = 1;
5470 hold_dpt = dpi->templates;
5471 dpi->templates = mods->templates;
5473 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5475 d_print_function_type (dpi, options, mods->mod, mods->next);
5476 dpi->templates = hold_dpt;
5477 return;
5479 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5481 d_print_array_type (dpi, options, mods->mod, mods->next);
5482 dpi->templates = hold_dpt;
5483 return;
5485 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
5487 struct d_print_mod *hold_modifiers;
5488 struct demangle_component *dc;
5490 /* When this is on the modifier stack, we have pulled any
5491 qualifiers off the right argument already. Otherwise, we
5492 print it as usual, but don't let the left argument see any
5493 modifiers. */
5495 hold_modifiers = dpi->modifiers;
5496 dpi->modifiers = NULL;
5497 d_print_comp (dpi, options, d_left (mods->mod));
5498 dpi->modifiers = hold_modifiers;
5500 if ((options & DMGL_JAVA) == 0)
5501 d_append_string (dpi, "::");
5502 else
5503 d_append_char (dpi, '.');
5505 dc = d_right (mods->mod);
5507 if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
5509 d_append_string (dpi, "{default arg#");
5510 d_append_num (dpi, dc->u.s_unary_num.num + 1);
5511 d_append_string (dpi, "}::");
5512 dc = dc->u.s_unary_num.sub;
5515 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
5516 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
5517 || dc->type == DEMANGLE_COMPONENT_CONST_THIS
5518 || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
5519 || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
5520 dc = d_left (dc);
5522 d_print_comp (dpi, options, dc);
5524 dpi->templates = hold_dpt;
5525 return;
5528 d_print_mod (dpi, options, mods->mod);
5530 dpi->templates = hold_dpt;
5532 d_print_mod_list (dpi, options, mods->next, suffix);
5535 /* Print a modifier. */
5537 static void
5538 d_print_mod (struct d_print_info *dpi, int options,
5539 const struct demangle_component *mod)
5541 switch (mod->type)
5543 case DEMANGLE_COMPONENT_RESTRICT:
5544 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5545 d_append_string (dpi, " restrict");
5546 return;
5547 case DEMANGLE_COMPONENT_VOLATILE:
5548 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5549 d_append_string (dpi, " volatile");
5550 return;
5551 case DEMANGLE_COMPONENT_CONST:
5552 case DEMANGLE_COMPONENT_CONST_THIS:
5553 d_append_string (dpi, " const");
5554 return;
5555 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5556 d_append_char (dpi, ' ');
5557 d_print_comp (dpi, options, d_right (mod));
5558 return;
5559 case DEMANGLE_COMPONENT_POINTER:
5560 /* There is no pointer symbol in Java. */
5561 if ((options & DMGL_JAVA) == 0)
5562 d_append_char (dpi, '*');
5563 return;
5564 case DEMANGLE_COMPONENT_REFERENCE_THIS:
5565 /* For the ref-qualifier, put a space before the &. */
5566 d_append_char (dpi, ' ');
5567 case DEMANGLE_COMPONENT_REFERENCE:
5568 d_append_char (dpi, '&');
5569 return;
5570 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5571 d_append_char (dpi, ' ');
5572 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5573 d_append_string (dpi, "&&");
5574 return;
5575 case DEMANGLE_COMPONENT_COMPLEX:
5576 d_append_string (dpi, "complex ");
5577 return;
5578 case DEMANGLE_COMPONENT_IMAGINARY:
5579 d_append_string (dpi, "imaginary ");
5580 return;
5581 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5582 if (d_last_char (dpi) != '(')
5583 d_append_char (dpi, ' ');
5584 d_print_comp (dpi, options, d_left (mod));
5585 d_append_string (dpi, "::*");
5586 return;
5587 case DEMANGLE_COMPONENT_TYPED_NAME:
5588 d_print_comp (dpi, options, d_left (mod));
5589 return;
5590 case DEMANGLE_COMPONENT_VECTOR_TYPE:
5591 d_append_string (dpi, " __vector(");
5592 d_print_comp (dpi, options, d_left (mod));
5593 d_append_char (dpi, ')');
5594 return;
5596 default:
5597 /* Otherwise, we have something that won't go back on the
5598 modifier stack, so we can just print it. */
5599 d_print_comp (dpi, options, mod);
5600 return;
5604 /* Print a function type, except for the return type. */
5606 static void
5607 d_print_function_type (struct d_print_info *dpi, int options,
5608 const struct demangle_component *dc,
5609 struct d_print_mod *mods)
5611 int need_paren;
5612 int need_space;
5613 struct d_print_mod *p;
5614 struct d_print_mod *hold_modifiers;
5616 need_paren = 0;
5617 need_space = 0;
5618 for (p = mods; p != NULL; p = p->next)
5620 if (p->printed)
5621 break;
5623 switch (p->mod->type)
5625 case DEMANGLE_COMPONENT_POINTER:
5626 case DEMANGLE_COMPONENT_REFERENCE:
5627 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5628 need_paren = 1;
5629 break;
5630 case DEMANGLE_COMPONENT_RESTRICT:
5631 case DEMANGLE_COMPONENT_VOLATILE:
5632 case DEMANGLE_COMPONENT_CONST:
5633 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5634 case DEMANGLE_COMPONENT_COMPLEX:
5635 case DEMANGLE_COMPONENT_IMAGINARY:
5636 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5637 need_space = 1;
5638 need_paren = 1;
5639 break;
5640 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5641 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5642 case DEMANGLE_COMPONENT_CONST_THIS:
5643 case DEMANGLE_COMPONENT_REFERENCE_THIS:
5644 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5645 break;
5646 default:
5647 break;
5649 if (need_paren)
5650 break;
5653 if (need_paren)
5655 if (! need_space)
5657 if (d_last_char (dpi) != '('
5658 && d_last_char (dpi) != '*')
5659 need_space = 1;
5661 if (need_space && d_last_char (dpi) != ' ')
5662 d_append_char (dpi, ' ');
5663 d_append_char (dpi, '(');
5666 hold_modifiers = dpi->modifiers;
5667 dpi->modifiers = NULL;
5669 d_print_mod_list (dpi, options, mods, 0);
5671 if (need_paren)
5672 d_append_char (dpi, ')');
5674 d_append_char (dpi, '(');
5676 if (d_right (dc) != NULL)
5677 d_print_comp (dpi, options, d_right (dc));
5679 d_append_char (dpi, ')');
5681 d_print_mod_list (dpi, options, mods, 1);
5683 dpi->modifiers = hold_modifiers;
5686 /* Print an array type, except for the element type. */
5688 static void
5689 d_print_array_type (struct d_print_info *dpi, int options,
5690 const struct demangle_component *dc,
5691 struct d_print_mod *mods)
5693 int need_space;
5695 need_space = 1;
5696 if (mods != NULL)
5698 int need_paren;
5699 struct d_print_mod *p;
5701 need_paren = 0;
5702 for (p = mods; p != NULL; p = p->next)
5704 if (! p->printed)
5706 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5708 need_space = 0;
5709 break;
5711 else
5713 need_paren = 1;
5714 need_space = 1;
5715 break;
5720 if (need_paren)
5721 d_append_string (dpi, " (");
5723 d_print_mod_list (dpi, options, mods, 0);
5725 if (need_paren)
5726 d_append_char (dpi, ')');
5729 if (need_space)
5730 d_append_char (dpi, ' ');
5732 d_append_char (dpi, '[');
5734 if (d_left (dc) != NULL)
5735 d_print_comp (dpi, options, d_left (dc));
5737 d_append_char (dpi, ']');
5740 /* Print an operator in an expression. */
5742 static void
5743 d_print_expr_op (struct d_print_info *dpi, int options,
5744 const struct demangle_component *dc)
5746 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
5747 d_append_buffer (dpi, dc->u.s_operator.op->name,
5748 dc->u.s_operator.op->len);
5749 else
5750 d_print_comp (dpi, options, dc);
5753 /* Print a cast. */
5755 static void
5756 d_print_cast (struct d_print_info *dpi, int options,
5757 const struct demangle_component *dc)
5759 struct d_print_template dpt;
5761 /* For a cast operator, we need the template parameters from
5762 the enclosing template in scope for processing the type. */
5763 if (dpi->current_template != NULL)
5765 dpt.next = dpi->templates;
5766 dpi->templates = &dpt;
5767 dpt.template_decl = dpi->current_template;
5770 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
5772 d_print_comp (dpi, options, d_left (dc));
5773 if (dpi->current_template != NULL)
5774 dpi->templates = dpt.next;
5776 else
5778 d_print_comp (dpi, options, d_left (d_left (dc)));
5780 /* For a templated cast operator, we need to remove the template
5781 parameters from scope after printing the operator name,
5782 so we need to handle the template printing here. */
5783 if (dpi->current_template != NULL)
5784 dpi->templates = dpt.next;
5786 if (d_last_char (dpi) == '<')
5787 d_append_char (dpi, ' ');
5788 d_append_char (dpi, '<');
5789 d_print_comp (dpi, options, d_right (d_left (dc)));
5790 /* Avoid generating two consecutive '>' characters, to avoid
5791 the C++ syntactic ambiguity. */
5792 if (d_last_char (dpi) == '>')
5793 d_append_char (dpi, ' ');
5794 d_append_char (dpi, '>');
5798 /* Initialize the information structure we use to pass around
5799 information. */
5801 CP_STATIC_IF_GLIBCPP_V3
5802 void
5803 cplus_demangle_init_info (const char *mangled, int options, size_t len,
5804 struct d_info *di)
5806 di->s = mangled;
5807 di->send = mangled + len;
5808 di->options = options;
5810 di->n = mangled;
5812 /* We can not need more components than twice the number of chars in
5813 the mangled string. Most components correspond directly to
5814 chars, but the ARGLIST types are exceptions. */
5815 di->num_comps = 2 * len;
5816 di->next_comp = 0;
5818 /* Similarly, we can not need more substitutions than there are
5819 chars in the mangled string. */
5820 di->num_subs = len;
5821 di->next_sub = 0;
5822 di->did_subs = 0;
5824 di->last_name = NULL;
5826 di->expansion = 0;
5827 di->is_expression = 0;
5828 di->is_conversion = 0;
5831 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
5832 mangled name, return strings in repeated callback giving the demangled
5833 name. OPTIONS is the usual libiberty demangler options. On success,
5834 this returns 1. On failure, returns 0. */
5836 static int
5837 d_demangle_callback (const char *mangled, int options,
5838 demangle_callbackref callback, void *opaque)
5840 enum
5842 DCT_TYPE,
5843 DCT_MANGLED,
5844 DCT_GLOBAL_CTORS,
5845 DCT_GLOBAL_DTORS
5847 type;
5848 struct d_info di;
5849 struct demangle_component *dc;
5850 int status;
5852 if (mangled[0] == '_' && mangled[1] == 'Z')
5853 type = DCT_MANGLED;
5854 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
5855 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
5856 && (mangled[9] == 'D' || mangled[9] == 'I')
5857 && mangled[10] == '_')
5858 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
5859 else
5861 if ((options & DMGL_TYPES) == 0)
5862 return 0;
5863 type = DCT_TYPE;
5866 cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
5869 #ifdef CP_DYNAMIC_ARRAYS
5870 __extension__ struct demangle_component comps[di.num_comps];
5871 __extension__ struct demangle_component *subs[di.num_subs];
5873 di.comps = comps;
5874 di.subs = subs;
5875 #else
5876 di.comps = alloca (di.num_comps * sizeof (*di.comps));
5877 di.subs = alloca (di.num_subs * sizeof (*di.subs));
5878 #endif
5880 switch (type)
5882 case DCT_TYPE:
5883 dc = cplus_demangle_type (&di);
5884 break;
5885 case DCT_MANGLED:
5886 dc = cplus_demangle_mangled_name (&di, 1);
5887 break;
5888 case DCT_GLOBAL_CTORS:
5889 case DCT_GLOBAL_DTORS:
5890 d_advance (&di, 11);
5891 dc = d_make_comp (&di,
5892 (type == DCT_GLOBAL_CTORS
5893 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
5894 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
5895 d_make_demangle_mangled_name (&di, d_str (&di)),
5896 NULL);
5897 d_advance (&di, strlen (d_str (&di)));
5898 break;
5899 default:
5900 abort (); /* We have listed all the cases. */
5903 /* If DMGL_PARAMS is set, then if we didn't consume the entire
5904 mangled string, then we didn't successfully demangle it. If
5905 DMGL_PARAMS is not set, we didn't look at the trailing
5906 parameters. */
5907 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
5908 dc = NULL;
5910 #ifdef CP_DEMANGLE_DEBUG
5911 d_dump (dc, 0);
5912 #endif
5914 status = (dc != NULL)
5915 ? cplus_demangle_print_callback (options, dc, callback, opaque)
5916 : 0;
5919 return status;
5922 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
5923 name, return a buffer allocated with malloc holding the demangled
5924 name. OPTIONS is the usual libiberty demangler options. On
5925 success, this sets *PALC to the allocated size of the returned
5926 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
5927 a memory allocation failure, and returns NULL. */
5929 static char *
5930 d_demangle (const char *mangled, int options, size_t *palc)
5932 struct d_growable_string dgs;
5933 int status;
5935 d_growable_string_init (&dgs, 0);
5937 status = d_demangle_callback (mangled, options,
5938 d_growable_string_callback_adapter, &dgs);
5939 if (status == 0)
5941 free (dgs.buf);
5942 *palc = 0;
5943 return NULL;
5946 *palc = dgs.allocation_failure ? 1 : dgs.alc;
5947 return dgs.buf;
5950 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
5952 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
5954 /* ia64 ABI-mandated entry point in the C++ runtime library for
5955 performing demangling. MANGLED_NAME is a NUL-terminated character
5956 string containing the name to be demangled.
5958 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
5959 *LENGTH bytes, into which the demangled name is stored. If
5960 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
5961 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
5962 is placed in a region of memory allocated with malloc.
5964 If LENGTH is non-NULL, the length of the buffer containing the
5965 demangled name, is placed in *LENGTH.
5967 The return value is a pointer to the start of the NUL-terminated
5968 demangled name, or NULL if the demangling fails. The caller is
5969 responsible for deallocating this memory using free.
5971 *STATUS is set to one of the following values:
5972 0: The demangling operation succeeded.
5973 -1: A memory allocation failure occurred.
5974 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5975 -3: One of the arguments is invalid.
5977 The demangling is performed using the C++ ABI mangling rules, with
5978 GNU extensions. */
5980 char *
5981 __cxa_demangle (const char *mangled_name, char *output_buffer,
5982 size_t *length, int *status)
5984 char *demangled;
5985 size_t alc;
5987 if (mangled_name == NULL)
5989 if (status != NULL)
5990 *status = -3;
5991 return NULL;
5994 if (output_buffer != NULL && length == NULL)
5996 if (status != NULL)
5997 *status = -3;
5998 return NULL;
6001 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
6003 if (demangled == NULL)
6005 if (status != NULL)
6007 if (alc == 1)
6008 *status = -1;
6009 else
6010 *status = -2;
6012 return NULL;
6015 if (output_buffer == NULL)
6017 if (length != NULL)
6018 *length = alc;
6020 else
6022 if (strlen (demangled) < *length)
6024 strcpy (output_buffer, demangled);
6025 free (demangled);
6026 demangled = output_buffer;
6028 else
6030 free (output_buffer);
6031 *length = alc;
6035 if (status != NULL)
6036 *status = 0;
6038 return demangled;
6041 extern int __gcclibcxx_demangle_callback (const char *,
6042 void (*)
6043 (const char *, size_t, void *),
6044 void *);
6046 /* Alternative, allocationless entry point in the C++ runtime library
6047 for performing demangling. MANGLED_NAME is a NUL-terminated character
6048 string containing the name to be demangled.
6050 CALLBACK is a callback function, called with demangled string
6051 segments as demangling progresses; it is called at least once,
6052 but may be called more than once. OPAQUE is a generalized pointer
6053 used as a callback argument.
6055 The return code is one of the following values, equivalent to
6056 the STATUS values of __cxa_demangle() (excluding -1, since this
6057 function performs no memory allocations):
6058 0: The demangling operation succeeded.
6059 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6060 -3: One of the arguments is invalid.
6062 The demangling is performed using the C++ ABI mangling rules, with
6063 GNU extensions. */
6066 __gcclibcxx_demangle_callback (const char *mangled_name,
6067 void (*callback) (const char *, size_t, void *),
6068 void *opaque)
6070 int status;
6072 if (mangled_name == NULL || callback == NULL)
6073 return -3;
6075 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
6076 callback, opaque);
6077 if (status == 0)
6078 return -2;
6080 return 0;
6083 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6085 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6086 mangled name, return a buffer allocated with malloc holding the
6087 demangled name. Otherwise, return NULL. */
6089 char *
6090 cplus_demangle_v3 (const char *mangled, int options)
6092 size_t alc;
6094 return d_demangle (mangled, options, &alc);
6098 cplus_demangle_v3_callback (const char *mangled, int options,
6099 demangle_callbackref callback, void *opaque)
6101 return d_demangle_callback (mangled, options, callback, opaque);
6104 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6105 conventions, but the output formatting is a little different.
6106 This instructs the C++ demangler not to emit pointer characters ("*"), to
6107 use Java's namespace separator symbol ("." instead of "::"), and to output
6108 JArray<TYPE> as TYPE[]. */
6110 char *
6111 java_demangle_v3 (const char *mangled)
6113 size_t alc;
6115 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
6119 java_demangle_v3_callback (const char *mangled,
6120 demangle_callbackref callback, void *opaque)
6122 return d_demangle_callback (mangled,
6123 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
6124 callback, opaque);
6127 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6129 #ifndef IN_GLIBCPP_V3
6131 /* Demangle a string in order to find out whether it is a constructor
6132 or destructor. Return non-zero on success. Set *CTOR_KIND and
6133 *DTOR_KIND appropriately. */
6135 static int
6136 is_ctor_or_dtor (const char *mangled,
6137 enum gnu_v3_ctor_kinds *ctor_kind,
6138 enum gnu_v3_dtor_kinds *dtor_kind)
6140 struct d_info di;
6141 struct demangle_component *dc;
6142 int ret;
6144 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
6145 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
6147 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
6150 #ifdef CP_DYNAMIC_ARRAYS
6151 __extension__ struct demangle_component comps[di.num_comps];
6152 __extension__ struct demangle_component *subs[di.num_subs];
6154 di.comps = comps;
6155 di.subs = subs;
6156 #else
6157 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6158 di.subs = alloca (di.num_subs * sizeof (*di.subs));
6159 #endif
6161 dc = cplus_demangle_mangled_name (&di, 1);
6163 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6164 to demangle the entire string. */
6166 ret = 0;
6167 while (dc != NULL)
6169 switch (dc->type)
6171 /* These cannot appear on a constructor or destructor. */
6172 case DEMANGLE_COMPONENT_RESTRICT_THIS:
6173 case DEMANGLE_COMPONENT_VOLATILE_THIS:
6174 case DEMANGLE_COMPONENT_CONST_THIS:
6175 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6176 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6177 default:
6178 dc = NULL;
6179 break;
6180 case DEMANGLE_COMPONENT_TYPED_NAME:
6181 case DEMANGLE_COMPONENT_TEMPLATE:
6182 dc = d_left (dc);
6183 break;
6184 case DEMANGLE_COMPONENT_QUAL_NAME:
6185 case DEMANGLE_COMPONENT_LOCAL_NAME:
6186 dc = d_right (dc);
6187 break;
6188 case DEMANGLE_COMPONENT_CTOR:
6189 *ctor_kind = dc->u.s_ctor.kind;
6190 ret = 1;
6191 dc = NULL;
6192 break;
6193 case DEMANGLE_COMPONENT_DTOR:
6194 *dtor_kind = dc->u.s_dtor.kind;
6195 ret = 1;
6196 dc = NULL;
6197 break;
6202 return ret;
6205 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6206 name. A non-zero return indicates the type of constructor. */
6208 enum gnu_v3_ctor_kinds
6209 is_gnu_v3_mangled_ctor (const char *name)
6211 enum gnu_v3_ctor_kinds ctor_kind;
6212 enum gnu_v3_dtor_kinds dtor_kind;
6214 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6215 return (enum gnu_v3_ctor_kinds) 0;
6216 return ctor_kind;
6220 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6221 name. A non-zero return indicates the type of destructor. */
6223 enum gnu_v3_dtor_kinds
6224 is_gnu_v3_mangled_dtor (const char *name)
6226 enum gnu_v3_ctor_kinds ctor_kind;
6227 enum gnu_v3_dtor_kinds dtor_kind;
6229 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6230 return (enum gnu_v3_dtor_kinds) 0;
6231 return dtor_kind;
6234 #endif /* IN_GLIBCPP_V3 */
6236 #ifdef STANDALONE_DEMANGLER
6238 #include "getopt.h"
6239 #include "dyn-string.h"
6241 static void print_usage (FILE* fp, int exit_value);
6243 #define IS_ALPHA(CHAR) \
6244 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6245 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6247 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6248 #define is_mangled_char(CHAR) \
6249 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6250 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6252 /* The name of this program, as invoked. */
6253 const char* program_name;
6255 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6257 static void
6258 print_usage (FILE* fp, int exit_value)
6260 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
6261 fprintf (fp, "Options:\n");
6262 fprintf (fp, " -h,--help Display this message.\n");
6263 fprintf (fp, " -p,--no-params Don't display function parameters\n");
6264 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
6265 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6267 exit (exit_value);
6270 /* Option specification for getopt_long. */
6271 static const struct option long_options[] =
6273 { "help", no_argument, NULL, 'h' },
6274 { "no-params", no_argument, NULL, 'p' },
6275 { "verbose", no_argument, NULL, 'v' },
6276 { NULL, no_argument, NULL, 0 },
6279 /* Main entry for a demangling filter executable. It will demangle
6280 its command line arguments, if any. If none are provided, it will
6281 filter stdin to stdout, replacing any recognized mangled C++ names
6282 with their demangled equivalents. */
6285 main (int argc, char *argv[])
6287 int i;
6288 int opt_char;
6289 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
6291 /* Use the program name of this program, as invoked. */
6292 program_name = argv[0];
6294 /* Parse options. */
6297 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
6298 switch (opt_char)
6300 case '?': /* Unrecognized option. */
6301 print_usage (stderr, 1);
6302 break;
6304 case 'h':
6305 print_usage (stdout, 0);
6306 break;
6308 case 'p':
6309 options &= ~ DMGL_PARAMS;
6310 break;
6312 case 'v':
6313 options |= DMGL_VERBOSE;
6314 break;
6317 while (opt_char != -1);
6319 if (optind == argc)
6320 /* No command line arguments were provided. Filter stdin. */
6322 dyn_string_t mangled = dyn_string_new (3);
6323 char *s;
6325 /* Read all of input. */
6326 while (!feof (stdin))
6328 char c;
6330 /* Pile characters into mangled until we hit one that can't
6331 occur in a mangled name. */
6332 c = getchar ();
6333 while (!feof (stdin) && is_mangled_char (c))
6335 dyn_string_append_char (mangled, c);
6336 if (feof (stdin))
6337 break;
6338 c = getchar ();
6341 if (dyn_string_length (mangled) > 0)
6343 #ifdef IN_GLIBCPP_V3
6344 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
6345 #else
6346 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
6347 #endif
6349 if (s != NULL)
6351 fputs (s, stdout);
6352 free (s);
6354 else
6356 /* It might not have been a mangled name. Print the
6357 original text. */
6358 fputs (dyn_string_buf (mangled), stdout);
6361 dyn_string_clear (mangled);
6364 /* If we haven't hit EOF yet, we've read one character that
6365 can't occur in a mangled name, so print it out. */
6366 if (!feof (stdin))
6367 putchar (c);
6370 dyn_string_delete (mangled);
6372 else
6373 /* Demangle command line arguments. */
6375 /* Loop over command line arguments. */
6376 for (i = optind; i < argc; ++i)
6378 char *s;
6379 #ifdef IN_GLIBCPP_V3
6380 int status;
6381 #endif
6383 /* Attempt to demangle. */
6384 #ifdef IN_GLIBCPP_V3
6385 s = __cxa_demangle (argv[i], NULL, NULL, &status);
6386 #else
6387 s = cplus_demangle_v3 (argv[i], options);
6388 #endif
6390 /* If it worked, print the demangled name. */
6391 if (s != NULL)
6393 printf ("%s\n", s);
6394 free (s);
6396 else
6398 #ifdef IN_GLIBCPP_V3
6399 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
6400 #else
6401 fprintf (stderr, "Failed: %s\n", argv[i]);
6402 #endif
6407 return 0;
6410 #endif /* STANDALONE_DEMANGLER */