Daily bump.
[official-gcc.git] / libiberty / cp-demangle.c
blob33490f60285467c104bc3eca98ed9815ea28ed00
1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
7 This file is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
19 executable.)
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
31 /* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
33 https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
35 This code was written while looking at the demangler written by
36 Alex Samuel <samuel@codesourcery.com>.
38 This code first pulls the mangled name apart into a list of
39 components, and then walks the list generating the demangled
40 name.
42 This file will normally define the following functions, q.v.:
43 char *cplus_demangle_v3(const char *mangled, int options)
44 char *java_demangle_v3(const char *mangled)
45 int cplus_demangle_v3_callback(const char *mangled, int options,
46 demangle_callbackref callback)
47 int java_demangle_v3_callback(const char *mangled,
48 demangle_callbackref callback)
49 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
50 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
52 Also, the interface to the component list is public, and defined in
53 demangle.h. The interface consists of these types, which are
54 defined in demangle.h:
55 enum demangle_component_type
56 struct demangle_component
57 demangle_callbackref
58 and these functions defined in this file:
59 cplus_demangle_fill_name
60 cplus_demangle_fill_extended_operator
61 cplus_demangle_fill_ctor
62 cplus_demangle_fill_dtor
63 cplus_demangle_print
64 cplus_demangle_print_callback
65 and other functions defined in the file cp-demint.c.
67 This file also defines some other functions and variables which are
68 only to be used by the file cp-demint.c.
70 Preprocessor macros you can define while compiling this file:
72 IN_LIBGCC2
73 If defined, this file defines the following functions, q.v.:
74 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
75 int *status)
76 int __gcclibcxx_demangle_callback (const char *,
77 void (*)
78 (const char *, size_t, void *),
79 void *)
80 instead of cplus_demangle_v3[_callback]() and
81 java_demangle_v3[_callback]().
83 IN_GLIBCPP_V3
84 If defined, this file defines only __cxa_demangle() and
85 __gcclibcxx_demangle_callback(), and no other publically visible
86 functions or variables.
88 STANDALONE_DEMANGLER
89 If defined, this file defines a main() function which demangles
90 any arguments, or, if none, demangles stdin.
92 CP_DEMANGLE_DEBUG
93 If defined, turns on debugging mode, which prints information on
94 stdout about the mangled string. This is not generally useful.
96 CHECK_DEMANGLER
97 If defined, additional sanity checks will be performed. It will
98 cause some slowdown, but will allow to catch out-of-bound access
99 errors earlier. This macro is intended for testing and debugging. */
101 #if defined (_AIX) && !defined (__GNUC__)
102 #pragma alloca
103 #endif
105 #ifdef HAVE_CONFIG_H
106 #include "config.h"
107 #endif
109 #include <stdio.h>
111 #ifdef HAVE_STDLIB_H
112 #include <stdlib.h>
113 #endif
114 #ifdef HAVE_STRING_H
115 #include <string.h>
116 #endif
118 #ifdef HAVE_ALLOCA_H
119 # include <alloca.h>
120 #else
121 # ifndef alloca
122 # ifdef __GNUC__
123 # define alloca __builtin_alloca
124 # else
125 extern char *alloca ();
126 # endif /* __GNUC__ */
127 # endif /* alloca */
128 #endif /* HAVE_ALLOCA_H */
130 #ifdef HAVE_LIMITS_H
131 #include <limits.h>
132 #endif
133 #ifndef INT_MAX
134 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
135 #endif
137 #include "ansidecl.h"
138 #include "libiberty.h"
139 #include "demangle.h"
140 #include "cp-demangle.h"
142 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
143 also rename them via #define to avoid compiler errors when the
144 static definition conflicts with the extern declaration in a header
145 file. */
146 #ifdef IN_GLIBCPP_V3
148 #define CP_STATIC_IF_GLIBCPP_V3 static
150 #define cplus_demangle_fill_name d_fill_name
151 static int d_fill_name (struct demangle_component *, const char *, int);
153 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
154 static int
155 d_fill_extended_operator (struct demangle_component *, int,
156 struct demangle_component *);
158 #define cplus_demangle_fill_ctor d_fill_ctor
159 static int
160 d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
161 struct demangle_component *);
163 #define cplus_demangle_fill_dtor d_fill_dtor
164 static int
165 d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
166 struct demangle_component *);
168 #define cplus_demangle_mangled_name d_mangled_name
169 static struct demangle_component *d_mangled_name (struct d_info *, int);
171 #define cplus_demangle_type d_type
172 static struct demangle_component *d_type (struct d_info *);
174 #define cplus_demangle_print d_print
175 static char *d_print (int, struct demangle_component *, int, size_t *);
177 #define cplus_demangle_print_callback d_print_callback
178 static int d_print_callback (int, struct demangle_component *,
179 demangle_callbackref, void *);
181 #define cplus_demangle_init_info d_init_info
182 static void d_init_info (const char *, int, size_t, struct d_info *);
184 #else /* ! defined(IN_GLIBCPP_V3) */
185 #define CP_STATIC_IF_GLIBCPP_V3
186 #endif /* ! defined(IN_GLIBCPP_V3) */
188 /* See if the compiler supports dynamic arrays. */
190 #ifdef __GNUC__
191 #define CP_DYNAMIC_ARRAYS
192 #else
193 #ifdef __STDC__
194 #ifdef __STDC_VERSION__
195 #if __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__
196 #define CP_DYNAMIC_ARRAYS
197 #endif /* __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ */
198 #endif /* defined (__STDC_VERSION__) */
199 #endif /* defined (__STDC__) */
200 #endif /* ! defined (__GNUC__) */
202 /* We avoid pulling in the ctype tables, to prevent pulling in
203 additional unresolved symbols when this code is used in a library.
204 FIXME: Is this really a valid reason? This comes from the original
205 V3 demangler code.
207 As of this writing this file has the following undefined references
208 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
209 strcat, strlen. */
211 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
212 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
213 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
215 /* The prefix prepended by GCC to an identifier represnting the
216 anonymous namespace. */
217 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
218 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
219 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
221 /* Information we keep for the standard substitutions. */
223 struct d_standard_sub_info
225 /* The code for this substitution. */
226 char code;
227 /* The simple string it expands to. */
228 const char *simple_expansion;
229 /* The length of the simple expansion. */
230 int simple_len;
231 /* The results of a full, verbose, expansion. This is used when
232 qualifying a constructor/destructor, or when in verbose mode. */
233 const char *full_expansion;
234 /* The length of the full expansion. */
235 int full_len;
236 /* What to set the last_name field of d_info to; NULL if we should
237 not set it. This is only relevant when qualifying a
238 constructor/destructor. */
239 const char *set_last_name;
240 /* The length of set_last_name. */
241 int set_last_name_len;
244 /* Accessors for subtrees of struct demangle_component. */
246 #define d_left(dc) ((dc)->u.s_binary.left)
247 #define d_right(dc) ((dc)->u.s_binary.right)
249 /* A list of templates. This is used while printing. */
251 struct d_print_template
253 /* Next template on the list. */
254 struct d_print_template *next;
255 /* This template. */
256 const struct demangle_component *template_decl;
259 /* A list of type modifiers. This is used while printing. */
261 struct d_print_mod
263 /* Next modifier on the list. These are in the reverse of the order
264 in which they appeared in the mangled string. */
265 struct d_print_mod *next;
266 /* The modifier. */
267 struct demangle_component *mod;
268 /* Whether this modifier was printed. */
269 int printed;
270 /* The list of templates which applies to this modifier. */
271 struct d_print_template *templates;
274 /* We use these structures to hold information during printing. */
276 struct d_growable_string
278 /* Buffer holding the result. */
279 char *buf;
280 /* Current length of data in buffer. */
281 size_t len;
282 /* Allocated size of buffer. */
283 size_t alc;
284 /* Set to 1 if we had a memory allocation failure. */
285 int allocation_failure;
288 /* Stack of components, innermost first, used to avoid loops. */
290 struct d_component_stack
292 /* This component. */
293 const struct demangle_component *dc;
294 /* This component's parent. */
295 const struct d_component_stack *parent;
298 /* A demangle component and some scope captured when it was first
299 traversed. */
301 struct d_saved_scope
303 /* The component whose scope this is. */
304 const struct demangle_component *container;
305 /* The list of templates, if any, that was current when this
306 scope was captured. */
307 struct d_print_template *templates;
310 /* Checkpoint structure to allow backtracking. This holds copies
311 of the fields of struct d_info that need to be restored
312 if a trial parse needs to be backtracked over. */
314 struct d_info_checkpoint
316 const char *n;
317 int next_comp;
318 int next_sub;
319 int expansion;
322 /* Maximum number of times d_print_comp may be called recursively. */
323 #define MAX_RECURSION_COUNT 1024
325 enum { D_PRINT_BUFFER_LENGTH = 256 };
326 struct d_print_info
328 /* Fixed-length allocated buffer for demangled data, flushed to the
329 callback with a NUL termination once full. */
330 char buf[D_PRINT_BUFFER_LENGTH];
331 /* Current length of data in buffer. */
332 size_t len;
333 /* The last character printed, saved individually so that it survives
334 any buffer flush. */
335 char last_char;
336 /* Callback function to handle demangled buffer flush. */
337 demangle_callbackref callback;
338 /* Opaque callback argument. */
339 void *opaque;
340 /* The current list of templates, if any. */
341 struct d_print_template *templates;
342 /* The current list of modifiers (e.g., pointer, reference, etc.),
343 if any. */
344 struct d_print_mod *modifiers;
345 /* Set to 1 if we saw a demangling error. */
346 int demangle_failure;
347 /* Number of times d_print_comp was recursively called. Should not
348 be bigger than MAX_RECURSION_COUNT. */
349 int recursion;
350 /* Non-zero if we're printing a lambda argument. A template
351 parameter reference actually means 'auto'. */
352 int is_lambda_arg;
353 /* The current index into any template argument packs we are using
354 for printing, or -1 to print the whole pack. */
355 int pack_index;
356 /* Number of d_print_flush calls so far. */
357 unsigned long int flush_count;
358 /* Stack of components, innermost first, used to avoid loops. */
359 const struct d_component_stack *component_stack;
360 /* Array of saved scopes for evaluating substitutions. */
361 struct d_saved_scope *saved_scopes;
362 /* Index of the next unused saved scope in the above array. */
363 int next_saved_scope;
364 /* Number of saved scopes in the above array. */
365 int num_saved_scopes;
366 /* Array of templates for saving into scopes. */
367 struct d_print_template *copy_templates;
368 /* Index of the next unused copy template in the above array. */
369 int next_copy_template;
370 /* Number of copy templates in the above array. */
371 int num_copy_templates;
372 /* The nearest enclosing template, if any. */
373 const struct demangle_component *current_template;
376 #ifdef CP_DEMANGLE_DEBUG
377 static void d_dump (struct demangle_component *, int);
378 #endif
380 static struct demangle_component *
381 d_make_empty (struct d_info *);
383 static struct demangle_component *
384 d_make_comp (struct d_info *, enum demangle_component_type,
385 struct demangle_component *,
386 struct demangle_component *);
388 static struct demangle_component *
389 d_make_name (struct d_info *, const char *, int);
391 static struct demangle_component *
392 d_make_demangle_mangled_name (struct d_info *, const char *);
394 static struct demangle_component *
395 d_make_builtin_type (struct d_info *,
396 const struct demangle_builtin_type_info *);
398 static struct demangle_component *
399 d_make_operator (struct d_info *,
400 const struct demangle_operator_info *);
402 static struct demangle_component *
403 d_make_extended_operator (struct d_info *, int,
404 struct demangle_component *);
406 static struct demangle_component *
407 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
408 struct demangle_component *);
410 static struct demangle_component *
411 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
412 struct demangle_component *);
414 static struct demangle_component *
415 d_make_template_param (struct d_info *, int);
417 static struct demangle_component *
418 d_make_sub (struct d_info *, const char *, int);
420 static int
421 has_return_type (struct demangle_component *);
423 static int
424 is_ctor_dtor_or_conversion (struct demangle_component *);
426 static struct demangle_component *d_encoding (struct d_info *, int);
428 static struct demangle_component *d_name (struct d_info *);
430 static struct demangle_component *d_nested_name (struct d_info *);
432 static struct demangle_component *d_prefix (struct d_info *, int);
434 static struct demangle_component *d_unqualified_name (struct d_info *);
436 static struct demangle_component *d_source_name (struct d_info *);
438 static int d_number (struct d_info *);
440 static struct demangle_component *d_identifier (struct d_info *, int);
442 static struct demangle_component *d_operator_name (struct d_info *);
444 static struct demangle_component *d_special_name (struct d_info *);
446 static struct demangle_component *d_parmlist (struct d_info *);
448 static int d_call_offset (struct d_info *, int);
450 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
452 static struct demangle_component **
453 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
455 static struct demangle_component *
456 d_ref_qualifier (struct d_info *, struct demangle_component *);
458 static struct demangle_component *
459 d_function_type (struct d_info *);
461 static struct demangle_component *
462 d_bare_function_type (struct d_info *, int);
464 static struct demangle_component *
465 d_class_enum_type (struct d_info *);
467 static struct demangle_component *d_array_type (struct d_info *);
469 static struct demangle_component *d_vector_type (struct d_info *);
471 static struct demangle_component *
472 d_pointer_to_member_type (struct d_info *);
474 static struct demangle_component *
475 d_template_param (struct d_info *);
477 static struct demangle_component *d_template_args (struct d_info *);
478 static struct demangle_component *d_template_args_1 (struct d_info *);
480 static struct demangle_component *
481 d_template_arg (struct d_info *);
483 static struct demangle_component *d_expression (struct d_info *);
485 static struct demangle_component *d_expr_primary (struct d_info *);
487 static struct demangle_component *d_local_name (struct d_info *);
489 static int d_discriminator (struct d_info *);
491 static struct demangle_component *d_lambda (struct d_info *);
493 static struct demangle_component *d_unnamed_type (struct d_info *);
495 static struct demangle_component *
496 d_clone_suffix (struct d_info *, struct demangle_component *);
498 static int
499 d_add_substitution (struct d_info *, struct demangle_component *);
501 static struct demangle_component *d_substitution (struct d_info *, int);
503 static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
505 static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
507 static void d_growable_string_init (struct d_growable_string *, size_t);
509 static inline void
510 d_growable_string_resize (struct d_growable_string *, size_t);
512 static inline void
513 d_growable_string_append_buffer (struct d_growable_string *,
514 const char *, size_t);
515 static void
516 d_growable_string_callback_adapter (const char *, size_t, void *);
518 static void
519 d_print_init (struct d_print_info *, demangle_callbackref, void *,
520 struct demangle_component *);
522 static inline void d_print_error (struct d_print_info *);
524 static inline int d_print_saw_error (struct d_print_info *);
526 static inline void d_print_flush (struct d_print_info *);
528 static inline void d_append_char (struct d_print_info *, char);
530 static inline void d_append_buffer (struct d_print_info *,
531 const char *, size_t);
533 static inline void d_append_string (struct d_print_info *, const char *);
535 static inline char d_last_char (struct d_print_info *);
537 static void
538 d_print_comp (struct d_print_info *, int, struct demangle_component *);
540 static void
541 d_print_java_identifier (struct d_print_info *, const char *, int);
543 static void
544 d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
546 static void
547 d_print_mod (struct d_print_info *, int, struct demangle_component *);
549 static void
550 d_print_function_type (struct d_print_info *, int,
551 struct demangle_component *,
552 struct d_print_mod *);
554 static void
555 d_print_array_type (struct d_print_info *, int,
556 struct demangle_component *,
557 struct d_print_mod *);
559 static void
560 d_print_expr_op (struct d_print_info *, int, struct demangle_component *);
562 static void d_print_cast (struct d_print_info *, int,
563 struct demangle_component *);
564 static void d_print_conversion (struct d_print_info *, int,
565 struct demangle_component *);
567 static int d_demangle_callback (const char *, int,
568 demangle_callbackref, void *);
569 static char *d_demangle (const char *, int, size_t *);
571 #define FNQUAL_COMPONENT_CASE \
572 case DEMANGLE_COMPONENT_RESTRICT_THIS: \
573 case DEMANGLE_COMPONENT_VOLATILE_THIS: \
574 case DEMANGLE_COMPONENT_CONST_THIS: \
575 case DEMANGLE_COMPONENT_REFERENCE_THIS: \
576 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \
577 case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \
578 case DEMANGLE_COMPONENT_NOEXCEPT: \
579 case DEMANGLE_COMPONENT_THROW_SPEC
581 /* True iff TYPE is a demangling component representing a
582 function-type-qualifier. */
584 static int
585 is_fnqual_component_type (enum demangle_component_type type)
587 switch (type)
589 FNQUAL_COMPONENT_CASE:
590 return 1;
591 default:
592 break;
594 return 0;
598 #ifdef CP_DEMANGLE_DEBUG
600 static void
601 d_dump (struct demangle_component *dc, int indent)
603 int i;
605 if (dc == NULL)
607 if (indent == 0)
608 printf ("failed demangling\n");
609 return;
612 for (i = 0; i < indent; ++i)
613 putchar (' ');
615 switch (dc->type)
617 case DEMANGLE_COMPONENT_NAME:
618 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
619 return;
620 case DEMANGLE_COMPONENT_TAGGED_NAME:
621 printf ("tagged name\n");
622 d_dump (dc->u.s_binary.left, indent + 2);
623 d_dump (dc->u.s_binary.right, indent + 2);
624 return;
625 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
626 printf ("template parameter %ld\n", dc->u.s_number.number);
627 return;
628 case DEMANGLE_COMPONENT_TPARM_OBJ:
629 printf ("template parameter object\n");
630 break;
631 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
632 printf ("function parameter %ld\n", dc->u.s_number.number);
633 return;
634 case DEMANGLE_COMPONENT_CTOR:
635 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
636 d_dump (dc->u.s_ctor.name, indent + 2);
637 return;
638 case DEMANGLE_COMPONENT_DTOR:
639 printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
640 d_dump (dc->u.s_dtor.name, indent + 2);
641 return;
642 case DEMANGLE_COMPONENT_SUB_STD:
643 printf ("standard substitution %s\n", dc->u.s_string.string);
644 return;
645 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
646 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
647 return;
648 case DEMANGLE_COMPONENT_OPERATOR:
649 printf ("operator %s\n", dc->u.s_operator.op->name);
650 return;
651 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
652 printf ("extended operator with %d args\n",
653 dc->u.s_extended_operator.args);
654 d_dump (dc->u.s_extended_operator.name, indent + 2);
655 return;
657 case DEMANGLE_COMPONENT_QUAL_NAME:
658 printf ("qualified name\n");
659 break;
660 case DEMANGLE_COMPONENT_LOCAL_NAME:
661 printf ("local name\n");
662 break;
663 case DEMANGLE_COMPONENT_TYPED_NAME:
664 printf ("typed name\n");
665 break;
666 case DEMANGLE_COMPONENT_TEMPLATE:
667 printf ("template\n");
668 break;
669 case DEMANGLE_COMPONENT_VTABLE:
670 printf ("vtable\n");
671 break;
672 case DEMANGLE_COMPONENT_VTT:
673 printf ("VTT\n");
674 break;
675 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
676 printf ("construction vtable\n");
677 break;
678 case DEMANGLE_COMPONENT_TYPEINFO:
679 printf ("typeinfo\n");
680 break;
681 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
682 printf ("typeinfo name\n");
683 break;
684 case DEMANGLE_COMPONENT_TYPEINFO_FN:
685 printf ("typeinfo function\n");
686 break;
687 case DEMANGLE_COMPONENT_THUNK:
688 printf ("thunk\n");
689 break;
690 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
691 printf ("virtual thunk\n");
692 break;
693 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
694 printf ("covariant thunk\n");
695 break;
696 case DEMANGLE_COMPONENT_JAVA_CLASS:
697 printf ("java class\n");
698 break;
699 case DEMANGLE_COMPONENT_GUARD:
700 printf ("guard\n");
701 break;
702 case DEMANGLE_COMPONENT_REFTEMP:
703 printf ("reference temporary\n");
704 break;
705 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
706 printf ("hidden alias\n");
707 break;
708 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
709 printf ("transaction clone\n");
710 break;
711 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
712 printf ("non-transaction clone\n");
713 break;
714 case DEMANGLE_COMPONENT_RESTRICT:
715 printf ("restrict\n");
716 break;
717 case DEMANGLE_COMPONENT_VOLATILE:
718 printf ("volatile\n");
719 break;
720 case DEMANGLE_COMPONENT_CONST:
721 printf ("const\n");
722 break;
723 case DEMANGLE_COMPONENT_RESTRICT_THIS:
724 printf ("restrict this\n");
725 break;
726 case DEMANGLE_COMPONENT_VOLATILE_THIS:
727 printf ("volatile this\n");
728 break;
729 case DEMANGLE_COMPONENT_CONST_THIS:
730 printf ("const this\n");
731 break;
732 case DEMANGLE_COMPONENT_REFERENCE_THIS:
733 printf ("reference this\n");
734 break;
735 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
736 printf ("rvalue reference this\n");
737 break;
738 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
739 printf ("transaction_safe this\n");
740 break;
741 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
742 printf ("vendor type qualifier\n");
743 break;
744 case DEMANGLE_COMPONENT_POINTER:
745 printf ("pointer\n");
746 break;
747 case DEMANGLE_COMPONENT_REFERENCE:
748 printf ("reference\n");
749 break;
750 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
751 printf ("rvalue reference\n");
752 break;
753 case DEMANGLE_COMPONENT_COMPLEX:
754 printf ("complex\n");
755 break;
756 case DEMANGLE_COMPONENT_IMAGINARY:
757 printf ("imaginary\n");
758 break;
759 case DEMANGLE_COMPONENT_VENDOR_TYPE:
760 printf ("vendor type\n");
761 break;
762 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
763 printf ("function type\n");
764 break;
765 case DEMANGLE_COMPONENT_ARRAY_TYPE:
766 printf ("array type\n");
767 break;
768 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
769 printf ("pointer to member type\n");
770 break;
771 case DEMANGLE_COMPONENT_FIXED_TYPE:
772 printf ("fixed-point type, accum? %d, sat? %d\n",
773 dc->u.s_fixed.accum, dc->u.s_fixed.sat);
774 d_dump (dc->u.s_fixed.length, indent + 2);
775 break;
776 case DEMANGLE_COMPONENT_ARGLIST:
777 printf ("argument list\n");
778 break;
779 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
780 printf ("template argument list\n");
781 break;
782 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
783 printf ("initializer list\n");
784 break;
785 case DEMANGLE_COMPONENT_CAST:
786 printf ("cast\n");
787 break;
788 case DEMANGLE_COMPONENT_CONVERSION:
789 printf ("conversion operator\n");
790 break;
791 case DEMANGLE_COMPONENT_NULLARY:
792 printf ("nullary operator\n");
793 break;
794 case DEMANGLE_COMPONENT_UNARY:
795 printf ("unary operator\n");
796 break;
797 case DEMANGLE_COMPONENT_BINARY:
798 printf ("binary operator\n");
799 break;
800 case DEMANGLE_COMPONENT_BINARY_ARGS:
801 printf ("binary operator arguments\n");
802 break;
803 case DEMANGLE_COMPONENT_TRINARY:
804 printf ("trinary operator\n");
805 break;
806 case DEMANGLE_COMPONENT_TRINARY_ARG1:
807 printf ("trinary operator arguments 1\n");
808 break;
809 case DEMANGLE_COMPONENT_TRINARY_ARG2:
810 printf ("trinary operator arguments 1\n");
811 break;
812 case DEMANGLE_COMPONENT_LITERAL:
813 printf ("literal\n");
814 break;
815 case DEMANGLE_COMPONENT_LITERAL_NEG:
816 printf ("negative literal\n");
817 break;
818 case DEMANGLE_COMPONENT_VENDOR_EXPR:
819 printf ("vendor expression\n");
820 break;
821 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
822 printf ("java resource\n");
823 break;
824 case DEMANGLE_COMPONENT_COMPOUND_NAME:
825 printf ("compound name\n");
826 break;
827 case DEMANGLE_COMPONENT_CHARACTER:
828 printf ("character '%c'\n", dc->u.s_character.character);
829 return;
830 case DEMANGLE_COMPONENT_NUMBER:
831 printf ("number %ld\n", dc->u.s_number.number);
832 return;
833 case DEMANGLE_COMPONENT_DECLTYPE:
834 printf ("decltype\n");
835 break;
836 case DEMANGLE_COMPONENT_PACK_EXPANSION:
837 printf ("pack expansion\n");
838 break;
839 case DEMANGLE_COMPONENT_TLS_INIT:
840 printf ("tls init function\n");
841 break;
842 case DEMANGLE_COMPONENT_TLS_WRAPPER:
843 printf ("tls wrapper function\n");
844 break;
845 case DEMANGLE_COMPONENT_DEFAULT_ARG:
846 printf ("default argument %d\n", dc->u.s_unary_num.num);
847 d_dump (dc->u.s_unary_num.sub, indent+2);
848 return;
849 case DEMANGLE_COMPONENT_LAMBDA:
850 printf ("lambda %d\n", dc->u.s_unary_num.num);
851 d_dump (dc->u.s_unary_num.sub, indent+2);
852 return;
855 d_dump (d_left (dc), indent + 2);
856 d_dump (d_right (dc), indent + 2);
859 #endif /* CP_DEMANGLE_DEBUG */
861 /* Fill in a DEMANGLE_COMPONENT_NAME. */
863 CP_STATIC_IF_GLIBCPP_V3
865 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
867 if (p == NULL || s == NULL || len <= 0)
868 return 0;
869 p->d_printing = 0;
870 p->d_counting = 0;
871 p->type = DEMANGLE_COMPONENT_NAME;
872 p->u.s_name.s = s;
873 p->u.s_name.len = len;
874 return 1;
877 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
879 CP_STATIC_IF_GLIBCPP_V3
881 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
882 struct demangle_component *name)
884 if (p == NULL || args < 0 || name == NULL)
885 return 0;
886 p->d_printing = 0;
887 p->d_counting = 0;
888 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
889 p->u.s_extended_operator.args = args;
890 p->u.s_extended_operator.name = name;
891 return 1;
894 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
896 CP_STATIC_IF_GLIBCPP_V3
898 cplus_demangle_fill_ctor (struct demangle_component *p,
899 enum gnu_v3_ctor_kinds kind,
900 struct demangle_component *name)
902 if (p == NULL
903 || name == NULL
904 || (int) kind < gnu_v3_complete_object_ctor
905 || (int) kind > gnu_v3_object_ctor_group)
906 return 0;
907 p->d_printing = 0;
908 p->d_counting = 0;
909 p->type = DEMANGLE_COMPONENT_CTOR;
910 p->u.s_ctor.kind = kind;
911 p->u.s_ctor.name = name;
912 return 1;
915 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
917 CP_STATIC_IF_GLIBCPP_V3
919 cplus_demangle_fill_dtor (struct demangle_component *p,
920 enum gnu_v3_dtor_kinds kind,
921 struct demangle_component *name)
923 if (p == NULL
924 || name == NULL
925 || (int) kind < gnu_v3_deleting_dtor
926 || (int) kind > gnu_v3_object_dtor_group)
927 return 0;
928 p->d_printing = 0;
929 p->d_counting = 0;
930 p->type = DEMANGLE_COMPONENT_DTOR;
931 p->u.s_dtor.kind = kind;
932 p->u.s_dtor.name = name;
933 return 1;
936 /* Add a new component. */
938 static struct demangle_component *
939 d_make_empty (struct d_info *di)
941 struct demangle_component *p;
943 if (di->next_comp >= di->num_comps)
944 return NULL;
945 p = &di->comps[di->next_comp];
946 p->d_printing = 0;
947 p->d_counting = 0;
948 ++di->next_comp;
949 return p;
952 /* Add a new generic component. */
954 static struct demangle_component *
955 d_make_comp (struct d_info *di, enum demangle_component_type type,
956 struct demangle_component *left,
957 struct demangle_component *right)
959 struct demangle_component *p;
961 /* We check for errors here. A typical error would be a NULL return
962 from a subroutine. We catch those here, and return NULL
963 upward. */
964 switch (type)
966 /* These types require two parameters. */
967 case DEMANGLE_COMPONENT_QUAL_NAME:
968 case DEMANGLE_COMPONENT_LOCAL_NAME:
969 case DEMANGLE_COMPONENT_TYPED_NAME:
970 case DEMANGLE_COMPONENT_TAGGED_NAME:
971 case DEMANGLE_COMPONENT_TEMPLATE:
972 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
973 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
974 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
975 case DEMANGLE_COMPONENT_UNARY:
976 case DEMANGLE_COMPONENT_BINARY:
977 case DEMANGLE_COMPONENT_BINARY_ARGS:
978 case DEMANGLE_COMPONENT_TRINARY:
979 case DEMANGLE_COMPONENT_TRINARY_ARG1:
980 case DEMANGLE_COMPONENT_LITERAL:
981 case DEMANGLE_COMPONENT_LITERAL_NEG:
982 case DEMANGLE_COMPONENT_VENDOR_EXPR:
983 case DEMANGLE_COMPONENT_COMPOUND_NAME:
984 case DEMANGLE_COMPONENT_VECTOR_TYPE:
985 case DEMANGLE_COMPONENT_CLONE:
986 if (left == NULL || right == NULL)
987 return NULL;
988 break;
990 /* These types only require one parameter. */
991 case DEMANGLE_COMPONENT_VTABLE:
992 case DEMANGLE_COMPONENT_VTT:
993 case DEMANGLE_COMPONENT_TYPEINFO:
994 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
995 case DEMANGLE_COMPONENT_TYPEINFO_FN:
996 case DEMANGLE_COMPONENT_THUNK:
997 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
998 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
999 case DEMANGLE_COMPONENT_JAVA_CLASS:
1000 case DEMANGLE_COMPONENT_GUARD:
1001 case DEMANGLE_COMPONENT_TLS_INIT:
1002 case DEMANGLE_COMPONENT_TLS_WRAPPER:
1003 case DEMANGLE_COMPONENT_REFTEMP:
1004 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
1005 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
1006 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
1007 case DEMANGLE_COMPONENT_POINTER:
1008 case DEMANGLE_COMPONENT_REFERENCE:
1009 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
1010 case DEMANGLE_COMPONENT_COMPLEX:
1011 case DEMANGLE_COMPONENT_IMAGINARY:
1012 case DEMANGLE_COMPONENT_VENDOR_TYPE:
1013 case DEMANGLE_COMPONENT_CAST:
1014 case DEMANGLE_COMPONENT_CONVERSION:
1015 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
1016 case DEMANGLE_COMPONENT_DECLTYPE:
1017 case DEMANGLE_COMPONENT_PACK_EXPANSION:
1018 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
1019 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
1020 case DEMANGLE_COMPONENT_NULLARY:
1021 case DEMANGLE_COMPONENT_TRINARY_ARG2:
1022 case DEMANGLE_COMPONENT_TPARM_OBJ:
1023 if (left == NULL)
1024 return NULL;
1025 break;
1027 /* This needs a right parameter, but the left parameter can be
1028 empty. */
1029 case DEMANGLE_COMPONENT_ARRAY_TYPE:
1030 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
1031 if (right == NULL)
1032 return NULL;
1033 break;
1035 /* These are allowed to have no parameters--in some cases they
1036 will be filled in later. */
1037 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
1038 case DEMANGLE_COMPONENT_RESTRICT:
1039 case DEMANGLE_COMPONENT_VOLATILE:
1040 case DEMANGLE_COMPONENT_CONST:
1041 case DEMANGLE_COMPONENT_ARGLIST:
1042 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
1043 FNQUAL_COMPONENT_CASE:
1044 break;
1046 /* Other types should not be seen here. */
1047 default:
1048 return NULL;
1051 p = d_make_empty (di);
1052 if (p != NULL)
1054 p->type = type;
1055 p->u.s_binary.left = left;
1056 p->u.s_binary.right = right;
1058 return p;
1061 /* Add a new demangle mangled name component. */
1063 static struct demangle_component *
1064 d_make_demangle_mangled_name (struct d_info *di, const char *s)
1066 if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
1067 return d_make_name (di, s, strlen (s));
1068 d_advance (di, 2);
1069 return d_encoding (di, 0);
1072 /* Add a new name component. */
1074 static struct demangle_component *
1075 d_make_name (struct d_info *di, const char *s, int len)
1077 struct demangle_component *p;
1079 p = d_make_empty (di);
1080 if (! cplus_demangle_fill_name (p, s, len))
1081 return NULL;
1082 return p;
1085 /* Add a new builtin type component. */
1087 static struct demangle_component *
1088 d_make_builtin_type (struct d_info *di,
1089 const struct demangle_builtin_type_info *type)
1091 struct demangle_component *p;
1093 if (type == NULL)
1094 return NULL;
1095 p = d_make_empty (di);
1096 if (p != NULL)
1098 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
1099 p->u.s_builtin.type = type;
1101 return p;
1104 /* Add a new operator component. */
1106 static struct demangle_component *
1107 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
1109 struct demangle_component *p;
1111 p = d_make_empty (di);
1112 if (p != NULL)
1114 p->type = DEMANGLE_COMPONENT_OPERATOR;
1115 p->u.s_operator.op = op;
1117 return p;
1120 /* Add a new extended operator component. */
1122 static struct demangle_component *
1123 d_make_extended_operator (struct d_info *di, int args,
1124 struct demangle_component *name)
1126 struct demangle_component *p;
1128 p = d_make_empty (di);
1129 if (! cplus_demangle_fill_extended_operator (p, args, name))
1130 return NULL;
1131 return p;
1134 static struct demangle_component *
1135 d_make_default_arg (struct d_info *di, int num,
1136 struct demangle_component *sub)
1138 struct demangle_component *p = d_make_empty (di);
1139 if (p)
1141 p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
1142 p->u.s_unary_num.num = num;
1143 p->u.s_unary_num.sub = sub;
1145 return p;
1148 /* Add a new constructor component. */
1150 static struct demangle_component *
1151 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
1152 struct demangle_component *name)
1154 struct demangle_component *p;
1156 p = d_make_empty (di);
1157 if (! cplus_demangle_fill_ctor (p, kind, name))
1158 return NULL;
1159 return p;
1162 /* Add a new destructor component. */
1164 static struct demangle_component *
1165 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
1166 struct demangle_component *name)
1168 struct demangle_component *p;
1170 p = d_make_empty (di);
1171 if (! cplus_demangle_fill_dtor (p, kind, name))
1172 return NULL;
1173 return p;
1176 /* Add a new template parameter. */
1178 static struct demangle_component *
1179 d_make_template_param (struct d_info *di, int i)
1181 struct demangle_component *p;
1183 p = d_make_empty (di);
1184 if (p != NULL)
1186 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
1187 p->u.s_number.number = i;
1189 return p;
1192 /* Add a new function parameter. */
1194 static struct demangle_component *
1195 d_make_function_param (struct d_info *di, int i)
1197 struct demangle_component *p;
1199 p = d_make_empty (di);
1200 if (p != NULL)
1202 p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1203 p->u.s_number.number = i;
1205 return p;
1208 /* Add a new standard substitution component. */
1210 static struct demangle_component *
1211 d_make_sub (struct d_info *di, const char *name, int len)
1213 struct demangle_component *p;
1215 p = d_make_empty (di);
1216 if (p != NULL)
1218 p->type = DEMANGLE_COMPONENT_SUB_STD;
1219 p->u.s_string.string = name;
1220 p->u.s_string.len = len;
1222 return p;
1225 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1227 TOP_LEVEL is non-zero when called at the top level. */
1229 CP_STATIC_IF_GLIBCPP_V3
1230 struct demangle_component *
1231 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1233 struct demangle_component *p;
1235 if (! d_check_char (di, '_')
1236 /* Allow missing _ if not at toplevel to work around a
1237 bug in G++ abi-version=2 mangling; see the comment in
1238 write_template_arg. */
1239 && top_level)
1240 return NULL;
1241 if (! d_check_char (di, 'Z'))
1242 return NULL;
1243 p = d_encoding (di, top_level);
1245 /* If at top level and parsing parameters, check for a clone
1246 suffix. */
1247 if (top_level && (di->options & DMGL_PARAMS) != 0)
1248 while (d_peek_char (di) == '.'
1249 && (IS_LOWER (d_peek_next_char (di))
1250 || d_peek_next_char (di) == '_'
1251 || IS_DIGIT (d_peek_next_char (di))))
1252 p = d_clone_suffix (di, p);
1254 return p;
1257 /* Return whether a function should have a return type. The argument
1258 is the function name, which may be qualified in various ways. The
1259 rules are that template functions have return types with some
1260 exceptions, function types which are not part of a function name
1261 mangling have return types with some exceptions, and non-template
1262 function names do not have return types. The exceptions are that
1263 constructors, destructors, and conversion operators do not have
1264 return types. */
1266 static int
1267 has_return_type (struct demangle_component *dc)
1269 if (dc == NULL)
1270 return 0;
1271 switch (dc->type)
1273 default:
1274 return 0;
1275 case DEMANGLE_COMPONENT_LOCAL_NAME:
1276 return has_return_type (d_right (dc));
1277 case DEMANGLE_COMPONENT_TEMPLATE:
1278 return ! is_ctor_dtor_or_conversion (d_left (dc));
1279 FNQUAL_COMPONENT_CASE:
1280 return has_return_type (d_left (dc));
1284 /* Return whether a name is a constructor, a destructor, or a
1285 conversion operator. */
1287 static int
1288 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1290 if (dc == NULL)
1291 return 0;
1292 switch (dc->type)
1294 default:
1295 return 0;
1296 case DEMANGLE_COMPONENT_QUAL_NAME:
1297 case DEMANGLE_COMPONENT_LOCAL_NAME:
1298 return is_ctor_dtor_or_conversion (d_right (dc));
1299 case DEMANGLE_COMPONENT_CTOR:
1300 case DEMANGLE_COMPONENT_DTOR:
1301 case DEMANGLE_COMPONENT_CONVERSION:
1302 return 1;
1306 /* <encoding> ::= <(function) name> <bare-function-type>
1307 ::= <(data) name>
1308 ::= <special-name>
1310 TOP_LEVEL is non-zero when called at the top level, in which case
1311 if DMGL_PARAMS is not set we do not demangle the function
1312 parameters. We only set this at the top level, because otherwise
1313 we would not correctly demangle names in local scopes. */
1315 static struct demangle_component *
1316 d_encoding (struct d_info *di, int top_level)
1318 char peek = d_peek_char (di);
1319 struct demangle_component *dc;
1321 if (peek == 'G' || peek == 'T')
1322 dc = d_special_name (di);
1323 else
1325 dc = d_name (di);
1327 if (!dc)
1328 /* Failed already. */;
1329 else if (top_level && (di->options & DMGL_PARAMS) == 0)
1331 /* Strip off any initial CV-qualifiers, as they really apply
1332 to the `this' parameter, and they were not output by the
1333 v2 demangler without DMGL_PARAMS. */
1334 while (is_fnqual_component_type (dc->type))
1335 dc = d_left (dc);
1337 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1338 there may be function-qualifiers on its right argument which
1339 really apply here; this happens when parsing a class
1340 which is local to a function. */
1341 if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1343 while (d_right (dc) != NULL
1344 && is_fnqual_component_type (d_right (dc)->type))
1345 d_right (dc) = d_left (d_right (dc));
1347 if (d_right (dc) == NULL)
1348 dc = NULL;
1351 else
1353 peek = d_peek_char (di);
1354 if (peek != '\0' && peek != 'E')
1356 struct demangle_component *ftype;
1358 ftype = d_bare_function_type (di, has_return_type (dc));
1359 if (ftype)
1361 /* If this is a non-top-level local-name, clear the
1362 return type, so it doesn't confuse the user by
1363 being confused with the return type of whaever
1364 this is nested within. */
1365 if (!top_level && dc->type == DEMANGLE_COMPONENT_LOCAL_NAME
1366 && ftype->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
1367 d_left (ftype) = NULL;
1369 dc = d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME,
1370 dc, ftype);
1372 else
1373 dc = NULL;
1378 return dc;
1381 /* <tagged-name> ::= <name> B <source-name> */
1383 static struct demangle_component *
1384 d_abi_tags (struct d_info *di, struct demangle_component *dc)
1386 struct demangle_component *hold_last_name;
1387 char peek;
1389 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1390 hold_last_name = di->last_name;
1392 while (peek = d_peek_char (di),
1393 peek == 'B')
1395 struct demangle_component *tag;
1396 d_advance (di, 1);
1397 tag = d_source_name (di);
1398 dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
1401 di->last_name = hold_last_name;
1403 return dc;
1406 /* <name> ::= <nested-name>
1407 ::= <unscoped-name>
1408 ::= <unscoped-template-name> <template-args>
1409 ::= <local-name>
1411 <unscoped-name> ::= <unqualified-name>
1412 ::= St <unqualified-name>
1414 <unscoped-template-name> ::= <unscoped-name>
1415 ::= <substitution>
1418 static struct demangle_component *
1419 d_name (struct d_info *di)
1421 char peek = d_peek_char (di);
1422 struct demangle_component *dc;
1424 switch (peek)
1426 case 'N':
1427 return d_nested_name (di);
1429 case 'Z':
1430 return d_local_name (di);
1432 case 'U':
1433 return d_unqualified_name (di);
1435 case 'S':
1437 int subst;
1439 if (d_peek_next_char (di) != 't')
1441 dc = d_substitution (di, 0);
1442 subst = 1;
1444 else
1446 d_advance (di, 2);
1447 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1448 d_make_name (di, "std", 3),
1449 d_unqualified_name (di));
1450 di->expansion += 3;
1451 subst = 0;
1454 if (d_peek_char (di) != 'I')
1456 /* The grammar does not permit this case to occur if we
1457 called d_substitution() above (i.e., subst == 1). We
1458 don't bother to check. */
1460 else
1462 /* This is <template-args>, which means that we just saw
1463 <unscoped-template-name>, which is a substitution
1464 candidate if we didn't just get it from a
1465 substitution. */
1466 if (! subst)
1468 if (! d_add_substitution (di, dc))
1469 return NULL;
1471 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1472 d_template_args (di));
1475 return dc;
1478 case 'L':
1479 default:
1480 dc = d_unqualified_name (di);
1481 if (d_peek_char (di) == 'I')
1483 /* This is <template-args>, which means that we just saw
1484 <unscoped-template-name>, which is a substitution
1485 candidate. */
1486 if (! d_add_substitution (di, dc))
1487 return NULL;
1488 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1489 d_template_args (di));
1491 return dc;
1495 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1496 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1499 static struct demangle_component *
1500 d_nested_name (struct d_info *di)
1502 struct demangle_component *ret;
1503 struct demangle_component **pret;
1504 struct demangle_component *rqual;
1506 if (! d_check_char (di, 'N'))
1507 return NULL;
1509 pret = d_cv_qualifiers (di, &ret, 1);
1510 if (pret == NULL)
1511 return NULL;
1513 /* Parse the ref-qualifier now and then attach it
1514 once we have something to attach it to. */
1515 rqual = d_ref_qualifier (di, NULL);
1517 *pret = d_prefix (di, 1);
1518 if (*pret == NULL)
1519 return NULL;
1521 if (rqual)
1523 d_left (rqual) = ret;
1524 ret = rqual;
1527 if (! d_check_char (di, 'E'))
1528 return NULL;
1530 return ret;
1533 /* <prefix> ::= <prefix> <unqualified-name>
1534 ::= <template-prefix> <template-args>
1535 ::= <template-param>
1536 ::= <decltype>
1538 ::= <substitution>
1540 <template-prefix> ::= <prefix> <(template) unqualified-name>
1541 ::= <template-param>
1542 ::= <substitution>
1544 SUBST is true if we should add substitutions (as normal), false
1545 if not (in an unresolved-name). */
1547 static struct demangle_component *
1548 d_prefix (struct d_info *di, int subst)
1550 struct demangle_component *ret = NULL;
1552 while (1)
1554 char peek;
1555 enum demangle_component_type comb_type;
1556 struct demangle_component *dc;
1558 peek = d_peek_char (di);
1559 if (peek == '\0')
1560 return NULL;
1562 /* The older code accepts a <local-name> here, but I don't see
1563 that in the grammar. The older code does not accept a
1564 <template-param> here. */
1566 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1567 if (peek == 'D')
1569 char peek2 = d_peek_next_char (di);
1570 if (peek2 == 'T' || peek2 == 't')
1571 /* Decltype. */
1572 dc = cplus_demangle_type (di);
1573 else
1574 /* Destructor name. */
1575 dc = d_unqualified_name (di);
1577 else if (IS_DIGIT (peek)
1578 || IS_LOWER (peek)
1579 || peek == 'C'
1580 || peek == 'U'
1581 || peek == 'L')
1582 dc = d_unqualified_name (di);
1583 else if (peek == 'S')
1584 dc = d_substitution (di, 1);
1585 else if (peek == 'I')
1587 if (ret == NULL)
1588 return NULL;
1589 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1590 dc = d_template_args (di);
1592 else if (peek == 'T')
1593 dc = d_template_param (di);
1594 else if (peek == 'E')
1595 return ret;
1596 else if (peek == 'M')
1598 /* Initializer scope for a lambda. We don't need to represent
1599 this; the normal code will just treat the variable as a type
1600 scope, which gives appropriate output. */
1601 if (ret == NULL)
1602 return NULL;
1603 d_advance (di, 1);
1604 continue;
1606 else
1607 return NULL;
1609 if (ret == NULL)
1610 ret = dc;
1611 else
1612 ret = d_make_comp (di, comb_type, ret, dc);
1614 if (peek != 'S' && d_peek_char (di) != 'E' && subst)
1616 if (! d_add_substitution (di, ret))
1617 return NULL;
1622 /* <unqualified-name> ::= <operator-name>
1623 ::= <ctor-dtor-name>
1624 ::= <source-name>
1625 ::= <local-source-name>
1627 <local-source-name> ::= L <source-name> <discriminator>
1630 static struct demangle_component *
1631 d_unqualified_name (struct d_info *di)
1633 struct demangle_component *ret;
1634 char peek;
1636 peek = d_peek_char (di);
1637 if (IS_DIGIT (peek))
1638 ret = d_source_name (di);
1639 else if (IS_LOWER (peek))
1641 int was_expr = di->is_expression;
1642 if (peek == 'o' && d_peek_next_char (di) == 'n')
1644 d_advance (di, 2);
1645 /* Treat cv as naming a conversion operator. */
1646 di->is_expression = 0;
1648 ret = d_operator_name (di);
1649 di->is_expression = was_expr;
1650 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1652 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1653 if (!strcmp (ret->u.s_operator.op->code, "li"))
1654 ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
1655 d_source_name (di));
1658 else if (peek == 'C' || peek == 'D')
1659 ret = d_ctor_dtor_name (di);
1660 else if (peek == 'L')
1662 d_advance (di, 1);
1664 ret = d_source_name (di);
1665 if (ret == NULL)
1666 return NULL;
1667 if (! d_discriminator (di))
1668 return NULL;
1670 else if (peek == 'U')
1672 switch (d_peek_next_char (di))
1674 case 'l':
1675 ret = d_lambda (di);
1676 break;
1677 case 't':
1678 ret = d_unnamed_type (di);
1679 break;
1680 default:
1681 return NULL;
1684 else
1685 return NULL;
1687 if (d_peek_char (di) == 'B')
1688 ret = d_abi_tags (di, ret);
1689 return ret;
1692 /* <source-name> ::= <(positive length) number> <identifier> */
1694 static struct demangle_component *
1695 d_source_name (struct d_info *di)
1697 int len;
1698 struct demangle_component *ret;
1700 len = d_number (di);
1701 if (len <= 0)
1702 return NULL;
1703 ret = d_identifier (di, len);
1704 di->last_name = ret;
1705 return ret;
1708 /* number ::= [n] <(non-negative decimal integer)> */
1710 static int
1711 d_number (struct d_info *di)
1713 int negative;
1714 char peek;
1715 int ret;
1717 negative = 0;
1718 peek = d_peek_char (di);
1719 if (peek == 'n')
1721 negative = 1;
1722 d_advance (di, 1);
1723 peek = d_peek_char (di);
1726 ret = 0;
1727 while (1)
1729 if (! IS_DIGIT (peek))
1731 if (negative)
1732 ret = - ret;
1733 return ret;
1735 if (ret > ((INT_MAX - (peek - '0')) / 10))
1736 return -1;
1737 ret = ret * 10 + (peek - '0');
1738 d_advance (di, 1);
1739 peek = d_peek_char (di);
1743 /* Like d_number, but returns a demangle_component. */
1745 static struct demangle_component *
1746 d_number_component (struct d_info *di)
1748 struct demangle_component *ret = d_make_empty (di);
1749 if (ret)
1751 ret->type = DEMANGLE_COMPONENT_NUMBER;
1752 ret->u.s_number.number = d_number (di);
1754 return ret;
1757 /* identifier ::= <(unqualified source code identifier)> */
1759 static struct demangle_component *
1760 d_identifier (struct d_info *di, int len)
1762 const char *name;
1764 name = d_str (di);
1766 if (di->send - name < len)
1767 return NULL;
1769 d_advance (di, len);
1771 /* A Java mangled name may have a trailing '$' if it is a C++
1772 keyword. This '$' is not included in the length count. We just
1773 ignore the '$'. */
1774 if ((di->options & DMGL_JAVA) != 0
1775 && d_peek_char (di) == '$')
1776 d_advance (di, 1);
1778 /* Look for something which looks like a gcc encoding of an
1779 anonymous namespace, and replace it with a more user friendly
1780 name. */
1781 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1782 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1783 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1785 const char *s;
1787 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1788 if ((*s == '.' || *s == '_' || *s == '$')
1789 && s[1] == 'N')
1791 di->expansion -= len - sizeof "(anonymous namespace)";
1792 return d_make_name (di, "(anonymous namespace)",
1793 sizeof "(anonymous namespace)" - 1);
1797 return d_make_name (di, name, len);
1800 /* operator_name ::= many different two character encodings.
1801 ::= cv <type>
1802 ::= v <digit> <source-name>
1804 This list is sorted for binary search. */
1806 #define NL(s) s, (sizeof s) - 1
1808 CP_STATIC_IF_GLIBCPP_V3
1809 const struct demangle_operator_info cplus_demangle_operators[] =
1811 { "aN", NL ("&="), 2 },
1812 { "aS", NL ("="), 2 },
1813 { "aa", NL ("&&"), 2 },
1814 { "ad", NL ("&"), 1 },
1815 { "an", NL ("&"), 2 },
1816 { "at", NL ("alignof "), 1 },
1817 { "aw", NL ("co_await "), 1 },
1818 { "az", NL ("alignof "), 1 },
1819 { "cc", NL ("const_cast"), 2 },
1820 { "cl", NL ("()"), 2 },
1821 { "cm", NL (","), 2 },
1822 { "co", NL ("~"), 1 },
1823 { "dV", NL ("/="), 2 },
1824 { "dX", NL ("[...]="), 3 }, /* [expr...expr] = expr */
1825 { "da", NL ("delete[] "), 1 },
1826 { "dc", NL ("dynamic_cast"), 2 },
1827 { "de", NL ("*"), 1 },
1828 { "di", NL ("="), 2 }, /* .name = expr */
1829 { "dl", NL ("delete "), 1 },
1830 { "ds", NL (".*"), 2 },
1831 { "dt", NL ("."), 2 },
1832 { "dv", NL ("/"), 2 },
1833 { "dx", NL ("]="), 2 }, /* [expr] = expr */
1834 { "eO", NL ("^="), 2 },
1835 { "eo", NL ("^"), 2 },
1836 { "eq", NL ("=="), 2 },
1837 { "fL", NL ("..."), 3 },
1838 { "fR", NL ("..."), 3 },
1839 { "fl", NL ("..."), 2 },
1840 { "fr", NL ("..."), 2 },
1841 { "ge", NL (">="), 2 },
1842 { "gs", NL ("::"), 1 },
1843 { "gt", NL (">"), 2 },
1844 { "ix", NL ("[]"), 2 },
1845 { "lS", NL ("<<="), 2 },
1846 { "le", NL ("<="), 2 },
1847 { "li", NL ("operator\"\" "), 1 },
1848 { "ls", NL ("<<"), 2 },
1849 { "lt", NL ("<"), 2 },
1850 { "mI", NL ("-="), 2 },
1851 { "mL", NL ("*="), 2 },
1852 { "mi", NL ("-"), 2 },
1853 { "ml", NL ("*"), 2 },
1854 { "mm", NL ("--"), 1 },
1855 { "na", NL ("new[]"), 3 },
1856 { "ne", NL ("!="), 2 },
1857 { "ng", NL ("-"), 1 },
1858 { "nt", NL ("!"), 1 },
1859 { "nw", NL ("new"), 3 },
1860 { "oR", NL ("|="), 2 },
1861 { "oo", NL ("||"), 2 },
1862 { "or", NL ("|"), 2 },
1863 { "pL", NL ("+="), 2 },
1864 { "pl", NL ("+"), 2 },
1865 { "pm", NL ("->*"), 2 },
1866 { "pp", NL ("++"), 1 },
1867 { "ps", NL ("+"), 1 },
1868 { "pt", NL ("->"), 2 },
1869 { "qu", NL ("?"), 3 },
1870 { "rM", NL ("%="), 2 },
1871 { "rS", NL (">>="), 2 },
1872 { "rc", NL ("reinterpret_cast"), 2 },
1873 { "rm", NL ("%"), 2 },
1874 { "rs", NL (">>"), 2 },
1875 { "sP", NL ("sizeof..."), 1 },
1876 { "sZ", NL ("sizeof..."), 1 },
1877 { "sc", NL ("static_cast"), 2 },
1878 { "ss", NL ("<=>"), 2 },
1879 { "st", NL ("sizeof "), 1 },
1880 { "sz", NL ("sizeof "), 1 },
1881 { "tr", NL ("throw"), 0 },
1882 { "tw", NL ("throw "), 1 },
1883 { NULL, NULL, 0, 0 }
1886 static struct demangle_component *
1887 d_operator_name (struct d_info *di)
1889 char c1;
1890 char c2;
1892 c1 = d_next_char (di);
1893 c2 = d_next_char (di);
1894 if (c1 == 'v' && IS_DIGIT (c2))
1895 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1896 else if (c1 == 'c' && c2 == 'v')
1898 struct demangle_component *type;
1899 int was_conversion = di->is_conversion;
1900 struct demangle_component *res;
1902 di->is_conversion = ! di->is_expression;
1903 type = cplus_demangle_type (di);
1904 if (di->is_conversion)
1905 res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
1906 else
1907 res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
1908 di->is_conversion = was_conversion;
1909 return res;
1911 else
1913 /* LOW is the inclusive lower bound. */
1914 int low = 0;
1915 /* HIGH is the exclusive upper bound. We subtract one to ignore
1916 the sentinel at the end of the array. */
1917 int high = ((sizeof (cplus_demangle_operators)
1918 / sizeof (cplus_demangle_operators[0]))
1919 - 1);
1921 while (1)
1923 int i;
1924 const struct demangle_operator_info *p;
1926 i = low + (high - low) / 2;
1927 p = cplus_demangle_operators + i;
1929 if (c1 == p->code[0] && c2 == p->code[1])
1930 return d_make_operator (di, p);
1932 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1933 high = i;
1934 else
1935 low = i + 1;
1936 if (low == high)
1937 return NULL;
1942 static struct demangle_component *
1943 d_make_character (struct d_info *di, int c)
1945 struct demangle_component *p;
1946 p = d_make_empty (di);
1947 if (p != NULL)
1949 p->type = DEMANGLE_COMPONENT_CHARACTER;
1950 p->u.s_character.character = c;
1952 return p;
1955 static struct demangle_component *
1956 d_java_resource (struct d_info *di)
1958 struct demangle_component *p = NULL;
1959 struct demangle_component *next = NULL;
1960 int len, i;
1961 char c;
1962 const char *str;
1964 len = d_number (di);
1965 if (len <= 1)
1966 return NULL;
1968 /* Eat the leading '_'. */
1969 if (d_next_char (di) != '_')
1970 return NULL;
1971 len--;
1973 str = d_str (di);
1974 i = 0;
1976 while (len > 0)
1978 c = str[i];
1979 if (!c)
1980 return NULL;
1982 /* Each chunk is either a '$' escape... */
1983 if (c == '$')
1985 i++;
1986 switch (str[i++])
1988 case 'S':
1989 c = '/';
1990 break;
1991 case '_':
1992 c = '.';
1993 break;
1994 case '$':
1995 c = '$';
1996 break;
1997 default:
1998 return NULL;
2000 next = d_make_character (di, c);
2001 d_advance (di, i);
2002 str = d_str (di);
2003 len -= i;
2004 i = 0;
2005 if (next == NULL)
2006 return NULL;
2008 /* ... or a sequence of characters. */
2009 else
2011 while (i < len && str[i] && str[i] != '$')
2012 i++;
2014 next = d_make_name (di, str, i);
2015 d_advance (di, i);
2016 str = d_str (di);
2017 len -= i;
2018 i = 0;
2019 if (next == NULL)
2020 return NULL;
2023 if (p == NULL)
2024 p = next;
2025 else
2027 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
2028 if (p == NULL)
2029 return NULL;
2033 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
2035 return p;
2038 /* <special-name> ::= TV <type>
2039 ::= TT <type>
2040 ::= TI <type>
2041 ::= TS <type>
2042 ::= TA <template-arg>
2043 ::= GV <(object) name>
2044 ::= T <call-offset> <(base) encoding>
2045 ::= Tc <call-offset> <call-offset> <(base) encoding>
2046 Also g++ extensions:
2047 ::= TC <type> <(offset) number> _ <(base) type>
2048 ::= TF <type>
2049 ::= TJ <type>
2050 ::= GR <name>
2051 ::= GA <encoding>
2052 ::= Gr <resource name>
2053 ::= GTt <encoding>
2054 ::= GTn <encoding>
2057 static struct demangle_component *
2058 d_special_name (struct d_info *di)
2060 di->expansion += 20;
2061 if (d_check_char (di, 'T'))
2063 switch (d_next_char (di))
2065 case 'V':
2066 di->expansion -= 5;
2067 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
2068 cplus_demangle_type (di), NULL);
2069 case 'T':
2070 di->expansion -= 10;
2071 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
2072 cplus_demangle_type (di), NULL);
2073 case 'I':
2074 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
2075 cplus_demangle_type (di), NULL);
2076 case 'S':
2077 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
2078 cplus_demangle_type (di), NULL);
2080 case 'h':
2081 if (! d_call_offset (di, 'h'))
2082 return NULL;
2083 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
2084 d_encoding (di, 0), NULL);
2086 case 'v':
2087 if (! d_call_offset (di, 'v'))
2088 return NULL;
2089 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
2090 d_encoding (di, 0), NULL);
2092 case 'c':
2093 if (! d_call_offset (di, '\0'))
2094 return NULL;
2095 if (! d_call_offset (di, '\0'))
2096 return NULL;
2097 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
2098 d_encoding (di, 0), NULL);
2100 case 'C':
2102 struct demangle_component *derived_type;
2103 int offset;
2104 struct demangle_component *base_type;
2106 derived_type = cplus_demangle_type (di);
2107 offset = d_number (di);
2108 if (offset < 0)
2109 return NULL;
2110 if (! d_check_char (di, '_'))
2111 return NULL;
2112 base_type = cplus_demangle_type (di);
2113 /* We don't display the offset. FIXME: We should display
2114 it in verbose mode. */
2115 di->expansion += 5;
2116 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
2117 base_type, derived_type);
2120 case 'F':
2121 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
2122 cplus_demangle_type (di), NULL);
2123 case 'J':
2124 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
2125 cplus_demangle_type (di), NULL);
2127 case 'H':
2128 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
2129 d_name (di), NULL);
2131 case 'W':
2132 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
2133 d_name (di), NULL);
2135 case 'A':
2136 return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
2137 d_template_arg (di), NULL);
2139 default:
2140 return NULL;
2143 else if (d_check_char (di, 'G'))
2145 switch (d_next_char (di))
2147 case 'V':
2148 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
2149 d_name (di), NULL);
2151 case 'R':
2153 struct demangle_component *name = d_name (di);
2154 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
2155 d_number_component (di));
2158 case 'A':
2159 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
2160 d_encoding (di, 0), NULL);
2162 case 'T':
2163 switch (d_next_char (di))
2165 case 'n':
2166 return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
2167 d_encoding (di, 0), NULL);
2168 default:
2169 /* ??? The proposal is that other letters (such as 'h') stand
2170 for different variants of transaction cloning, such as
2171 compiling directly for hardware transaction support. But
2172 they still should all be transactional clones of some sort
2173 so go ahead and call them that. */
2174 case 't':
2175 return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
2176 d_encoding (di, 0), NULL);
2179 case 'r':
2180 return d_java_resource (di);
2182 default:
2183 return NULL;
2186 else
2187 return NULL;
2190 /* <call-offset> ::= h <nv-offset> _
2191 ::= v <v-offset> _
2193 <nv-offset> ::= <(offset) number>
2195 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2197 The C parameter, if not '\0', is a character we just read which is
2198 the start of the <call-offset>.
2200 We don't display the offset information anywhere. FIXME: We should
2201 display it in verbose mode. */
2203 static int
2204 d_call_offset (struct d_info *di, int c)
2206 if (c == '\0')
2207 c = d_next_char (di);
2209 if (c == 'h')
2210 d_number (di);
2211 else if (c == 'v')
2213 d_number (di);
2214 if (! d_check_char (di, '_'))
2215 return 0;
2216 d_number (di);
2218 else
2219 return 0;
2221 if (! d_check_char (di, '_'))
2222 return 0;
2224 return 1;
2227 /* <ctor-dtor-name> ::= C1
2228 ::= C2
2229 ::= C3
2230 ::= D0
2231 ::= D1
2232 ::= D2
2235 static struct demangle_component *
2236 d_ctor_dtor_name (struct d_info *di)
2238 if (di->last_name != NULL)
2240 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
2241 di->expansion += di->last_name->u.s_name.len;
2242 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
2243 di->expansion += di->last_name->u.s_string.len;
2245 switch (d_peek_char (di))
2247 case 'C':
2249 enum gnu_v3_ctor_kinds kind;
2250 int inheriting = 0;
2252 if (d_peek_next_char (di) == 'I')
2254 inheriting = 1;
2255 d_advance (di, 1);
2258 switch (d_peek_next_char (di))
2260 case '1':
2261 kind = gnu_v3_complete_object_ctor;
2262 break;
2263 case '2':
2264 kind = gnu_v3_base_object_ctor;
2265 break;
2266 case '3':
2267 kind = gnu_v3_complete_object_allocating_ctor;
2268 break;
2269 case '4':
2270 kind = gnu_v3_unified_ctor;
2271 break;
2272 case '5':
2273 kind = gnu_v3_object_ctor_group;
2274 break;
2275 default:
2276 return NULL;
2279 d_advance (di, 2);
2281 if (inheriting)
2282 cplus_demangle_type (di);
2284 return d_make_ctor (di, kind, di->last_name);
2287 case 'D':
2289 enum gnu_v3_dtor_kinds kind;
2291 switch (d_peek_next_char (di))
2293 case '0':
2294 kind = gnu_v3_deleting_dtor;
2295 break;
2296 case '1':
2297 kind = gnu_v3_complete_object_dtor;
2298 break;
2299 case '2':
2300 kind = gnu_v3_base_object_dtor;
2301 break;
2302 /* digit '3' is not used */
2303 case '4':
2304 kind = gnu_v3_unified_dtor;
2305 break;
2306 case '5':
2307 kind = gnu_v3_object_dtor_group;
2308 break;
2309 default:
2310 return NULL;
2312 d_advance (di, 2);
2313 return d_make_dtor (di, kind, di->last_name);
2316 default:
2317 return NULL;
2321 /* True iff we're looking at an order-insensitive type-qualifier, including
2322 function-type-qualifiers. */
2324 static int
2325 next_is_type_qual (struct d_info *di)
2327 char peek = d_peek_char (di);
2328 if (peek == 'r' || peek == 'V' || peek == 'K')
2329 return 1;
2330 if (peek == 'D')
2332 peek = d_peek_next_char (di);
2333 if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
2334 return 1;
2336 return 0;
2339 /* <type> ::= <builtin-type>
2340 ::= <function-type>
2341 ::= <class-enum-type>
2342 ::= <array-type>
2343 ::= <pointer-to-member-type>
2344 ::= <template-param>
2345 ::= <template-template-param> <template-args>
2346 ::= <substitution>
2347 ::= <CV-qualifiers> <type>
2348 ::= P <type>
2349 ::= R <type>
2350 ::= O <type> (C++0x)
2351 ::= C <type>
2352 ::= G <type>
2353 ::= U <source-name> <type>
2355 <builtin-type> ::= various one letter codes
2356 ::= u <source-name>
2359 CP_STATIC_IF_GLIBCPP_V3
2360 const struct demangle_builtin_type_info
2361 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
2363 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
2364 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
2365 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
2366 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
2367 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
2368 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
2369 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
2370 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
2371 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
2372 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
2373 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2374 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
2375 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
2376 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
2377 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2378 D_PRINT_DEFAULT },
2379 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2380 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2381 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2382 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
2383 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
2384 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2385 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
2386 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
2387 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
2388 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2389 D_PRINT_UNSIGNED_LONG_LONG },
2390 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
2391 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
2392 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
2393 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
2394 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
2395 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT },
2396 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
2397 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
2398 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2399 D_PRINT_DEFAULT },
2402 CP_STATIC_IF_GLIBCPP_V3
2403 struct demangle_component *
2404 cplus_demangle_type (struct d_info *di)
2406 char peek;
2407 struct demangle_component *ret;
2408 int can_subst;
2410 /* The ABI specifies that when CV-qualifiers are used, the base type
2411 is substitutable, and the fully qualified type is substitutable,
2412 but the base type with a strict subset of the CV-qualifiers is
2413 not substitutable. The natural recursive implementation of the
2414 CV-qualifiers would cause subsets to be substitutable, so instead
2415 we pull them all off now.
2417 FIXME: The ABI says that order-insensitive vendor qualifiers
2418 should be handled in the same way, but we have no way to tell
2419 which vendor qualifiers are order-insensitive and which are
2420 order-sensitive. So we just assume that they are all
2421 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2422 __vector, and it treats it as order-sensitive when mangling
2423 names. */
2425 if (next_is_type_qual (di))
2427 struct demangle_component **pret;
2429 pret = d_cv_qualifiers (di, &ret, 0);
2430 if (pret == NULL)
2431 return NULL;
2432 if (d_peek_char (di) == 'F')
2434 /* cv-qualifiers before a function type apply to 'this',
2435 so avoid adding the unqualified function type to
2436 the substitution list. */
2437 *pret = d_function_type (di);
2439 else
2440 *pret = cplus_demangle_type (di);
2441 if (!*pret)
2442 return NULL;
2443 if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2444 || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
2446 /* Move the ref-qualifier outside the cv-qualifiers so that
2447 they are printed in the right order. */
2448 struct demangle_component *fn = d_left (*pret);
2449 d_left (*pret) = ret;
2450 ret = *pret;
2451 *pret = fn;
2453 if (! d_add_substitution (di, ret))
2454 return NULL;
2455 return ret;
2458 can_subst = 1;
2460 peek = d_peek_char (di);
2461 switch (peek)
2463 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2464 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2465 case 'o': case 's': case 't':
2466 case 'v': case 'w': case 'x': case 'y': case 'z':
2467 ret = d_make_builtin_type (di,
2468 &cplus_demangle_builtin_types[peek - 'a']);
2469 di->expansion += ret->u.s_builtin.type->len;
2470 can_subst = 0;
2471 d_advance (di, 1);
2472 break;
2474 case 'u':
2475 d_advance (di, 1);
2476 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2477 d_source_name (di), NULL);
2478 break;
2480 case 'F':
2481 ret = d_function_type (di);
2482 break;
2484 case '0': case '1': case '2': case '3': case '4':
2485 case '5': case '6': case '7': case '8': case '9':
2486 case 'N':
2487 case 'Z':
2488 ret = d_class_enum_type (di);
2489 break;
2491 case 'A':
2492 ret = d_array_type (di);
2493 break;
2495 case 'M':
2496 ret = d_pointer_to_member_type (di);
2497 break;
2499 case 'T':
2500 ret = d_template_param (di);
2501 if (d_peek_char (di) == 'I')
2503 /* This may be <template-template-param> <template-args>.
2504 If this is the type for a conversion operator, we can
2505 have a <template-template-param> here only by following
2506 a derivation like this:
2508 <nested-name>
2509 -> <template-prefix> <template-args>
2510 -> <prefix> <template-unqualified-name> <template-args>
2511 -> <unqualified-name> <template-unqualified-name> <template-args>
2512 -> <source-name> <template-unqualified-name> <template-args>
2513 -> <source-name> <operator-name> <template-args>
2514 -> <source-name> cv <type> <template-args>
2515 -> <source-name> cv <template-template-param> <template-args> <template-args>
2517 where the <template-args> is followed by another.
2518 Otherwise, we must have a derivation like this:
2520 <nested-name>
2521 -> <template-prefix> <template-args>
2522 -> <prefix> <template-unqualified-name> <template-args>
2523 -> <unqualified-name> <template-unqualified-name> <template-args>
2524 -> <source-name> <template-unqualified-name> <template-args>
2525 -> <source-name> <operator-name> <template-args>
2526 -> <source-name> cv <type> <template-args>
2527 -> <source-name> cv <template-param> <template-args>
2529 where we need to leave the <template-args> to be processed
2530 by d_prefix (following the <template-prefix>).
2532 The <template-template-param> part is a substitution
2533 candidate. */
2534 if (! di->is_conversion)
2536 if (! d_add_substitution (di, ret))
2537 return NULL;
2538 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2539 d_template_args (di));
2541 else
2543 struct demangle_component *args;
2544 struct d_info_checkpoint checkpoint;
2546 d_checkpoint (di, &checkpoint);
2547 args = d_template_args (di);
2548 if (d_peek_char (di) == 'I')
2550 if (! d_add_substitution (di, ret))
2551 return NULL;
2552 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2553 args);
2555 else
2556 d_backtrack (di, &checkpoint);
2559 break;
2561 case 'S':
2562 /* If this is a special substitution, then it is the start of
2563 <class-enum-type>. */
2565 char peek_next;
2567 peek_next = d_peek_next_char (di);
2568 if (IS_DIGIT (peek_next)
2569 || peek_next == '_'
2570 || IS_UPPER (peek_next))
2572 ret = d_substitution (di, 0);
2573 /* The substituted name may have been a template name and
2574 may be followed by tepmlate args. */
2575 if (d_peek_char (di) == 'I')
2576 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2577 d_template_args (di));
2578 else
2579 can_subst = 0;
2581 else
2583 ret = d_class_enum_type (di);
2584 /* If the substitution was a complete type, then it is not
2585 a new substitution candidate. However, if the
2586 substitution was followed by template arguments, then
2587 the whole thing is a substitution candidate. */
2588 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2589 can_subst = 0;
2592 break;
2594 case 'O':
2595 d_advance (di, 1);
2596 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2597 cplus_demangle_type (di), NULL);
2598 break;
2600 case 'P':
2601 d_advance (di, 1);
2602 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2603 cplus_demangle_type (di), NULL);
2604 break;
2606 case 'R':
2607 d_advance (di, 1);
2608 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2609 cplus_demangle_type (di), NULL);
2610 break;
2612 case 'C':
2613 d_advance (di, 1);
2614 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2615 cplus_demangle_type (di), NULL);
2616 break;
2618 case 'G':
2619 d_advance (di, 1);
2620 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2621 cplus_demangle_type (di), NULL);
2622 break;
2624 case 'U':
2625 d_advance (di, 1);
2626 ret = d_source_name (di);
2627 if (d_peek_char (di) == 'I')
2628 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2629 d_template_args (di));
2630 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2631 cplus_demangle_type (di), ret);
2632 break;
2634 case 'D':
2635 can_subst = 0;
2636 d_advance (di, 1);
2637 peek = d_next_char (di);
2638 switch (peek)
2640 case 'T':
2641 case 't':
2642 /* decltype (expression) */
2643 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2644 d_expression (di), NULL);
2645 if (ret && d_next_char (di) != 'E')
2646 ret = NULL;
2647 can_subst = 1;
2648 break;
2650 case 'p':
2651 /* Pack expansion. */
2652 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2653 cplus_demangle_type (di), NULL);
2654 can_subst = 1;
2655 break;
2657 case 'a':
2658 /* auto */
2659 ret = d_make_name (di, "auto", 4);
2660 break;
2661 case 'c':
2662 /* decltype(auto) */
2663 ret = d_make_name (di, "decltype(auto)", 14);
2664 break;
2666 case 'f':
2667 /* 32-bit decimal floating point */
2668 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2669 di->expansion += ret->u.s_builtin.type->len;
2670 break;
2671 case 'd':
2672 /* 64-bit DFP */
2673 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2674 di->expansion += ret->u.s_builtin.type->len;
2675 break;
2676 case 'e':
2677 /* 128-bit DFP */
2678 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2679 di->expansion += ret->u.s_builtin.type->len;
2680 break;
2681 case 'h':
2682 /* 16-bit half-precision FP */
2683 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2684 di->expansion += ret->u.s_builtin.type->len;
2685 break;
2686 case 'u':
2687 /* char8_t */
2688 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2689 di->expansion += ret->u.s_builtin.type->len;
2690 break;
2691 case 's':
2692 /* char16_t */
2693 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2694 di->expansion += ret->u.s_builtin.type->len;
2695 break;
2696 case 'i':
2697 /* char32_t */
2698 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2699 di->expansion += ret->u.s_builtin.type->len;
2700 break;
2702 case 'F':
2703 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2704 ret = d_make_empty (di);
2705 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2706 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2707 /* For demangling we don't care about the bits. */
2708 d_number (di);
2709 ret->u.s_fixed.length = cplus_demangle_type (di);
2710 if (ret->u.s_fixed.length == NULL)
2711 return NULL;
2712 d_number (di);
2713 peek = d_next_char (di);
2714 ret->u.s_fixed.sat = (peek == 's');
2715 break;
2717 case 'v':
2718 ret = d_vector_type (di);
2719 can_subst = 1;
2720 break;
2722 case 'n':
2723 /* decltype(nullptr) */
2724 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]);
2725 di->expansion += ret->u.s_builtin.type->len;
2726 break;
2728 default:
2729 return NULL;
2731 break;
2733 default:
2734 return NULL;
2737 if (can_subst)
2739 if (! d_add_substitution (di, ret))
2740 return NULL;
2743 return ret;
2746 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2748 static struct demangle_component **
2749 d_cv_qualifiers (struct d_info *di,
2750 struct demangle_component **pret, int member_fn)
2752 struct demangle_component **pstart;
2753 char peek;
2755 pstart = pret;
2756 peek = d_peek_char (di);
2757 while (next_is_type_qual (di))
2759 enum demangle_component_type t;
2760 struct demangle_component *right = NULL;
2762 d_advance (di, 1);
2763 if (peek == 'r')
2765 t = (member_fn
2766 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2767 : DEMANGLE_COMPONENT_RESTRICT);
2768 di->expansion += sizeof "restrict";
2770 else if (peek == 'V')
2772 t = (member_fn
2773 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2774 : DEMANGLE_COMPONENT_VOLATILE);
2775 di->expansion += sizeof "volatile";
2777 else if (peek == 'K')
2779 t = (member_fn
2780 ? DEMANGLE_COMPONENT_CONST_THIS
2781 : DEMANGLE_COMPONENT_CONST);
2782 di->expansion += sizeof "const";
2784 else
2786 peek = d_next_char (di);
2787 if (peek == 'x')
2789 t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
2790 di->expansion += sizeof "transaction_safe";
2792 else if (peek == 'o'
2793 || peek == 'O')
2795 t = DEMANGLE_COMPONENT_NOEXCEPT;
2796 di->expansion += sizeof "noexcept";
2797 if (peek == 'O')
2799 right = d_expression (di);
2800 if (right == NULL)
2801 return NULL;
2802 if (! d_check_char (di, 'E'))
2803 return NULL;
2806 else if (peek == 'w')
2808 t = DEMANGLE_COMPONENT_THROW_SPEC;
2809 di->expansion += sizeof "throw";
2810 right = d_parmlist (di);
2811 if (right == NULL)
2812 return NULL;
2813 if (! d_check_char (di, 'E'))
2814 return NULL;
2816 else
2817 return NULL;
2820 *pret = d_make_comp (di, t, NULL, right);
2821 if (*pret == NULL)
2822 return NULL;
2823 pret = &d_left (*pret);
2825 peek = d_peek_char (di);
2828 if (!member_fn && peek == 'F')
2830 while (pstart != pret)
2832 switch ((*pstart)->type)
2834 case DEMANGLE_COMPONENT_RESTRICT:
2835 (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
2836 break;
2837 case DEMANGLE_COMPONENT_VOLATILE:
2838 (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
2839 break;
2840 case DEMANGLE_COMPONENT_CONST:
2841 (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
2842 break;
2843 default:
2844 break;
2846 pstart = &d_left (*pstart);
2850 return pret;
2853 /* <ref-qualifier> ::= R
2854 ::= O */
2856 static struct demangle_component *
2857 d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2859 struct demangle_component *ret = sub;
2860 char peek;
2862 peek = d_peek_char (di);
2863 if (peek == 'R' || peek == 'O')
2865 enum demangle_component_type t;
2866 if (peek == 'R')
2868 t = DEMANGLE_COMPONENT_REFERENCE_THIS;
2869 di->expansion += sizeof "&";
2871 else
2873 t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
2874 di->expansion += sizeof "&&";
2876 d_advance (di, 1);
2878 ret = d_make_comp (di, t, ret, NULL);
2881 return ret;
2884 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2886 static struct demangle_component *
2887 d_function_type (struct d_info *di)
2889 struct demangle_component *ret = NULL;
2891 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
2893 if (di->recursion_level > DEMANGLE_RECURSION_LIMIT)
2894 /* FIXME: There ought to be a way to report
2895 that the recursion limit has been reached. */
2896 return NULL;
2898 di->recursion_level ++;
2901 if (d_check_char (di, 'F'))
2903 if (d_peek_char (di) == 'Y')
2905 /* Function has C linkage. We don't print this information.
2906 FIXME: We should print it in verbose mode. */
2907 d_advance (di, 1);
2909 ret = d_bare_function_type (di, 1);
2910 ret = d_ref_qualifier (di, ret);
2912 if (! d_check_char (di, 'E'))
2913 ret = NULL;
2916 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
2917 di->recursion_level --;
2918 return ret;
2921 /* <type>+ */
2923 static struct demangle_component *
2924 d_parmlist (struct d_info *di)
2926 struct demangle_component *tl;
2927 struct demangle_component **ptl;
2929 tl = NULL;
2930 ptl = &tl;
2931 while (1)
2933 struct demangle_component *type;
2935 char peek = d_peek_char (di);
2936 if (peek == '\0' || peek == 'E' || peek == '.')
2937 break;
2938 if ((peek == 'R' || peek == 'O')
2939 && d_peek_next_char (di) == 'E')
2940 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2941 break;
2942 type = cplus_demangle_type (di);
2943 if (type == NULL)
2944 return NULL;
2945 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2946 if (*ptl == NULL)
2947 return NULL;
2948 ptl = &d_right (*ptl);
2951 /* There should be at least one parameter type besides the optional
2952 return type. A function which takes no arguments will have a
2953 single parameter type void. */
2954 if (tl == NULL)
2955 return NULL;
2957 /* If we have a single parameter type void, omit it. */
2958 if (d_right (tl) == NULL
2959 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2960 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2962 di->expansion -= d_left (tl)->u.s_builtin.type->len;
2963 d_left (tl) = NULL;
2966 return tl;
2969 /* <bare-function-type> ::= [J]<type>+ */
2971 static struct demangle_component *
2972 d_bare_function_type (struct d_info *di, int has_return_type)
2974 struct demangle_component *return_type;
2975 struct demangle_component *tl;
2976 char peek;
2978 /* Detect special qualifier indicating that the first argument
2979 is the return type. */
2980 peek = d_peek_char (di);
2981 if (peek == 'J')
2983 d_advance (di, 1);
2984 has_return_type = 1;
2987 if (has_return_type)
2989 return_type = cplus_demangle_type (di);
2990 if (return_type == NULL)
2991 return NULL;
2993 else
2994 return_type = NULL;
2996 tl = d_parmlist (di);
2997 if (tl == NULL)
2998 return NULL;
3000 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
3001 return_type, tl);
3004 /* <class-enum-type> ::= <name> */
3006 static struct demangle_component *
3007 d_class_enum_type (struct d_info *di)
3009 return d_name (di);
3012 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
3013 ::= A [<(dimension) expression>] _ <(element) type>
3016 static struct demangle_component *
3017 d_array_type (struct d_info *di)
3019 char peek;
3020 struct demangle_component *dim;
3022 if (! d_check_char (di, 'A'))
3023 return NULL;
3025 peek = d_peek_char (di);
3026 if (peek == '_')
3027 dim = NULL;
3028 else if (IS_DIGIT (peek))
3030 const char *s;
3032 s = d_str (di);
3035 d_advance (di, 1);
3036 peek = d_peek_char (di);
3038 while (IS_DIGIT (peek));
3039 dim = d_make_name (di, s, d_str (di) - s);
3040 if (dim == NULL)
3041 return NULL;
3043 else
3045 dim = d_expression (di);
3046 if (dim == NULL)
3047 return NULL;
3050 if (! d_check_char (di, '_'))
3051 return NULL;
3053 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
3054 cplus_demangle_type (di));
3057 /* <vector-type> ::= Dv <number> _ <type>
3058 ::= Dv _ <expression> _ <type> */
3060 static struct demangle_component *
3061 d_vector_type (struct d_info *di)
3063 char peek;
3064 struct demangle_component *dim;
3066 peek = d_peek_char (di);
3067 if (peek == '_')
3069 d_advance (di, 1);
3070 dim = d_expression (di);
3072 else
3073 dim = d_number_component (di);
3075 if (dim == NULL)
3076 return NULL;
3078 if (! d_check_char (di, '_'))
3079 return NULL;
3081 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
3082 cplus_demangle_type (di));
3085 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3087 static struct demangle_component *
3088 d_pointer_to_member_type (struct d_info *di)
3090 struct demangle_component *cl;
3091 struct demangle_component *mem;
3093 if (! d_check_char (di, 'M'))
3094 return NULL;
3096 cl = cplus_demangle_type (di);
3097 if (cl == NULL)
3098 return NULL;
3100 /* The ABI says, "The type of a non-static member function is considered
3101 to be different, for the purposes of substitution, from the type of a
3102 namespace-scope or static member function whose type appears
3103 similar. The types of two non-static member functions are considered
3104 to be different, for the purposes of substitution, if the functions
3105 are members of different classes. In other words, for the purposes of
3106 substitution, the class of which the function is a member is
3107 considered part of the type of function."
3109 For a pointer to member function, this call to cplus_demangle_type
3110 will end up adding a (possibly qualified) non-member function type to
3111 the substitution table, which is not correct; however, the member
3112 function type will never be used in a substitution, so putting the
3113 wrong type in the substitution table is harmless. */
3115 mem = cplus_demangle_type (di);
3116 if (mem == NULL)
3117 return NULL;
3119 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
3122 /* <non-negative number> _ */
3124 static int
3125 d_compact_number (struct d_info *di)
3127 int num;
3128 if (d_peek_char (di) == '_')
3129 num = 0;
3130 else if (d_peek_char (di) == 'n')
3131 return -1;
3132 else
3133 num = d_number (di) + 1;
3135 if (num < 0 || ! d_check_char (di, '_'))
3136 return -1;
3137 return num;
3140 /* <template-param> ::= T_
3141 ::= T <(parameter-2 non-negative) number> _
3144 static struct demangle_component *
3145 d_template_param (struct d_info *di)
3147 int param;
3149 if (! d_check_char (di, 'T'))
3150 return NULL;
3152 param = d_compact_number (di);
3153 if (param < 0)
3154 return NULL;
3156 return d_make_template_param (di, param);
3159 /* <template-args> ::= I <template-arg>+ E */
3161 static struct demangle_component *
3162 d_template_args (struct d_info *di)
3164 if (d_peek_char (di) != 'I'
3165 && d_peek_char (di) != 'J')
3166 return NULL;
3167 d_advance (di, 1);
3169 return d_template_args_1 (di);
3172 /* <template-arg>* E */
3174 static struct demangle_component *
3175 d_template_args_1 (struct d_info *di)
3177 struct demangle_component *hold_last_name;
3178 struct demangle_component *al;
3179 struct demangle_component **pal;
3181 /* Preserve the last name we saw--don't let the template arguments
3182 clobber it, as that would give us the wrong name for a subsequent
3183 constructor or destructor. */
3184 hold_last_name = di->last_name;
3186 if (d_peek_char (di) == 'E')
3188 /* An argument pack can be empty. */
3189 d_advance (di, 1);
3190 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
3193 al = NULL;
3194 pal = &al;
3195 while (1)
3197 struct demangle_component *a;
3199 a = d_template_arg (di);
3200 if (a == NULL)
3201 return NULL;
3203 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
3204 if (*pal == NULL)
3205 return NULL;
3206 pal = &d_right (*pal);
3208 if (d_peek_char (di) == 'E')
3210 d_advance (di, 1);
3211 break;
3215 di->last_name = hold_last_name;
3217 return al;
3220 /* <template-arg> ::= <type>
3221 ::= X <expression> E
3222 ::= <expr-primary>
3225 static struct demangle_component *
3226 d_template_arg (struct d_info *di)
3228 struct demangle_component *ret;
3230 switch (d_peek_char (di))
3232 case 'X':
3233 d_advance (di, 1);
3234 ret = d_expression (di);
3235 if (! d_check_char (di, 'E'))
3236 return NULL;
3237 return ret;
3239 case 'L':
3240 return d_expr_primary (di);
3242 case 'I':
3243 case 'J':
3244 /* An argument pack. */
3245 return d_template_args (di);
3247 default:
3248 return cplus_demangle_type (di);
3252 /* Parse a sequence of expressions until we hit the terminator
3253 character. */
3255 static struct demangle_component *
3256 d_exprlist (struct d_info *di, char terminator)
3258 struct demangle_component *list = NULL;
3259 struct demangle_component **p = &list;
3261 if (d_peek_char (di) == terminator)
3263 d_advance (di, 1);
3264 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
3267 while (1)
3269 struct demangle_component *arg = d_expression (di);
3270 if (arg == NULL)
3271 return NULL;
3273 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
3274 if (*p == NULL)
3275 return NULL;
3276 p = &d_right (*p);
3278 if (d_peek_char (di) == terminator)
3280 d_advance (di, 1);
3281 break;
3285 return list;
3288 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3289 dynamic_cast, static_cast or reinterpret_cast. */
3291 static int
3292 op_is_new_cast (struct demangle_component *op)
3294 const char *code = op->u.s_operator.op->code;
3295 return (code[1] == 'c'
3296 && (code[0] == 's' || code[0] == 'd'
3297 || code[0] == 'c' || code[0] == 'r'));
3300 /* <unresolved-name> ::= [gs] <base-unresolved-name> # x or (with "gs") ::x
3301 ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x
3302 # T::N::x /decltype(p)::N::x
3303 ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
3304 # A::x, N::y, A<T>::z; "gs" means leading "::"
3305 ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
3307 "gs" is handled elsewhere, as a unary operator. */
3309 static struct demangle_component *
3310 d_unresolved_name (struct d_info *di)
3312 struct demangle_component *type;
3313 struct demangle_component *name;
3314 char peek;
3316 /* Consume the "sr". */
3317 d_advance (di, 2);
3319 peek = d_peek_char (di);
3320 if (di->unresolved_name_state
3321 && (IS_DIGIT (peek)
3322 || IS_LOWER (peek)
3323 || peek == 'C'
3324 || peek == 'U'
3325 || peek == 'L'))
3327 /* The third production is ambiguous with the old unresolved-name syntax
3328 of <type> <base-unresolved-name>; in the old mangling, A::x was mangled
3329 as sr1A1x, now sr1AE1x. So we first try to demangle using the new
3330 mangling, then with the old if that fails. */
3331 di->unresolved_name_state = -1;
3332 type = d_prefix (di, 0);
3333 if (d_peek_char (di) == 'E')
3334 d_advance (di, 1);
3336 else
3337 type = cplus_demangle_type (di);
3338 name = d_unqualified_name (di);
3339 if (d_peek_char (di) == 'I')
3340 name = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3341 d_template_args (di));
3342 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
3345 /* <expression> ::= <(unary) operator-name> <expression>
3346 ::= <(binary) operator-name> <expression> <expression>
3347 ::= <(trinary) operator-name> <expression> <expression> <expression>
3348 ::= cl <expression>+ E
3349 ::= st <type>
3350 ::= <template-param>
3351 ::= u <source-name> <template-arg>* E # vendor extended expression
3352 ::= <unresolved-name>
3353 ::= <expr-primary>
3355 <braced-expression> ::= <expression>
3356 ::= di <field source-name> <braced-expression> # .name = expr
3357 ::= dx <index expression> <braced-expression> # [expr] = expr
3358 ::= dX <range begin expression> <range end expression> <braced-expression>
3359 # [expr ... expr] = expr
3362 static struct demangle_component *
3363 d_expression_1 (struct d_info *di)
3365 char peek;
3367 peek = d_peek_char (di);
3368 if (peek == 'L')
3369 return d_expr_primary (di);
3370 else if (peek == 'T')
3371 return d_template_param (di);
3372 else if (peek == 's' && d_peek_next_char (di) == 'r')
3373 return d_unresolved_name (di);
3374 else if (peek == 's' && d_peek_next_char (di) == 'p')
3376 d_advance (di, 2);
3377 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
3378 d_expression_1 (di), NULL);
3380 else if (peek == 'f' && d_peek_next_char (di) == 'p')
3382 /* Function parameter used in a late-specified return type. */
3383 int index;
3384 d_advance (di, 2);
3385 if (d_peek_char (di) == 'T')
3387 /* 'this' parameter. */
3388 d_advance (di, 1);
3389 index = 0;
3391 else
3393 index = d_compact_number (di);
3394 if (index == INT_MAX || index == -1)
3395 return NULL;
3396 index++;
3398 return d_make_function_param (di, index);
3400 else if (IS_DIGIT (peek)
3401 || (peek == 'o' && d_peek_next_char (di) == 'n'))
3403 /* We can get an unqualified name as an expression in the case of
3404 a dependent function call, i.e. decltype(f(t)). */
3405 struct demangle_component *name;
3407 if (peek == 'o')
3408 /* operator-function-id, i.e. operator+(t). */
3409 d_advance (di, 2);
3411 name = d_unqualified_name (di);
3412 if (name == NULL)
3413 return NULL;
3414 if (d_peek_char (di) == 'I')
3415 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3416 d_template_args (di));
3417 else
3418 return name;
3420 else if ((peek == 'i' || peek == 't')
3421 && d_peek_next_char (di) == 'l')
3423 /* Brace-enclosed initializer list, untyped or typed. */
3424 struct demangle_component *type = NULL;
3425 d_advance (di, 2);
3426 if (peek == 't')
3427 type = cplus_demangle_type (di);
3428 if (!d_peek_char (di) || !d_peek_next_char (di))
3429 return NULL;
3430 return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
3431 type, d_exprlist (di, 'E'));
3433 else if (peek == 'u')
3435 /* A vendor extended expression. */
3436 struct demangle_component *name, *args;
3437 d_advance (di, 1);
3438 name = d_source_name (di);
3439 args = d_template_args_1 (di);
3440 return d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_EXPR, name, args);
3442 else
3444 struct demangle_component *op;
3445 const char *code = NULL;
3446 int args;
3448 op = d_operator_name (di);
3449 if (op == NULL)
3450 return NULL;
3452 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
3454 code = op->u.s_operator.op->code;
3455 di->expansion += op->u.s_operator.op->len - 2;
3456 if (strcmp (code, "st") == 0)
3457 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3458 cplus_demangle_type (di));
3461 switch (op->type)
3463 default:
3464 return NULL;
3465 case DEMANGLE_COMPONENT_OPERATOR:
3466 args = op->u.s_operator.op->args;
3467 break;
3468 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3469 args = op->u.s_extended_operator.args;
3470 break;
3471 case DEMANGLE_COMPONENT_CAST:
3472 args = 1;
3473 break;
3476 switch (args)
3478 case 0:
3479 return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3481 case 1:
3483 struct demangle_component *operand;
3484 int suffix = 0;
3486 if (code && (code[0] == 'p' || code[0] == 'm')
3487 && code[1] == code[0])
3488 /* pp_ and mm_ are the prefix variants. */
3489 suffix = !d_check_char (di, '_');
3491 if (op->type == DEMANGLE_COMPONENT_CAST
3492 && d_check_char (di, '_'))
3493 operand = d_exprlist (di, 'E');
3494 else if (code && !strcmp (code, "sP"))
3495 operand = d_template_args_1 (di);
3496 else
3497 operand = d_expression_1 (di);
3499 if (suffix)
3500 /* Indicate the suffix variant for d_print_comp. */
3501 operand = d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS,
3502 operand, operand);
3504 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, operand);
3506 case 2:
3508 struct demangle_component *left;
3509 struct demangle_component *right;
3511 if (code == NULL)
3512 return NULL;
3513 if (op_is_new_cast (op))
3514 left = cplus_demangle_type (di);
3515 else if (code[0] == 'f')
3516 /* fold-expression. */
3517 left = d_operator_name (di);
3518 else if (!strcmp (code, "di"))
3519 left = d_unqualified_name (di);
3520 else
3521 left = d_expression_1 (di);
3522 if (!strcmp (code, "cl"))
3523 right = d_exprlist (di, 'E');
3524 else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3526 peek = d_peek_char (di);
3527 /* These codes start a qualified name. */
3528 if ((peek == 'g' && d_peek_next_char (di) == 's')
3529 || (peek == 's' && d_peek_next_char (di) == 'r'))
3530 right = d_expression_1 (di);
3531 else
3533 /* Otherwise it's an unqualified name. We use
3534 d_unqualified_name rather than d_expression_1 here for
3535 old mangled names that didn't add 'on' before operator
3536 names. */
3537 right = d_unqualified_name (di);
3538 if (d_peek_char (di) == 'I')
3539 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3540 right, d_template_args (di));
3543 else
3544 right = d_expression_1 (di);
3546 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3547 d_make_comp (di,
3548 DEMANGLE_COMPONENT_BINARY_ARGS,
3549 left, right));
3551 case 3:
3553 struct demangle_component *first;
3554 struct demangle_component *second;
3555 struct demangle_component *third;
3557 if (code == NULL)
3558 return NULL;
3559 else if (!strcmp (code, "qu")
3560 || !strcmp (code, "dX"))
3562 /* ?: expression. */
3563 first = d_expression_1 (di);
3564 second = d_expression_1 (di);
3565 third = d_expression_1 (di);
3566 if (third == NULL)
3567 return NULL;
3569 else if (code[0] == 'f')
3571 /* fold-expression. */
3572 first = d_operator_name (di);
3573 second = d_expression_1 (di);
3574 third = d_expression_1 (di);
3575 if (third == NULL)
3576 return NULL;
3578 else if (code[0] == 'n')
3580 /* new-expression. */
3581 if (code[1] != 'w' && code[1] != 'a')
3582 return NULL;
3583 first = d_exprlist (di, '_');
3584 second = cplus_demangle_type (di);
3585 if (d_peek_char (di) == 'E')
3587 d_advance (di, 1);
3588 third = NULL;
3590 else if (d_peek_char (di) == 'p'
3591 && d_peek_next_char (di) == 'i')
3593 /* Parenthesized initializer. */
3594 d_advance (di, 2);
3595 third = d_exprlist (di, 'E');
3597 else if (d_peek_char (di) == 'i'
3598 && d_peek_next_char (di) == 'l')
3599 /* initializer-list. */
3600 third = d_expression_1 (di);
3601 else
3602 return NULL;
3604 else
3605 return NULL;
3606 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3607 d_make_comp (di,
3608 DEMANGLE_COMPONENT_TRINARY_ARG1,
3609 first,
3610 d_make_comp (di,
3611 DEMANGLE_COMPONENT_TRINARY_ARG2,
3612 second, third)));
3614 default:
3615 return NULL;
3620 static struct demangle_component *
3621 d_expression (struct d_info *di)
3623 struct demangle_component *ret;
3624 int was_expression = di->is_expression;
3626 di->is_expression = 1;
3627 ret = d_expression_1 (di);
3628 di->is_expression = was_expression;
3629 return ret;
3632 /* <expr-primary> ::= L <type> <(value) number> E
3633 ::= L <type> <(value) float> E
3634 ::= L <mangled-name> E
3637 static struct demangle_component *
3638 d_expr_primary (struct d_info *di)
3640 struct demangle_component *ret;
3642 if (! d_check_char (di, 'L'))
3643 return NULL;
3644 if (d_peek_char (di) == '_'
3645 /* Workaround for G++ bug; see comment in write_template_arg. */
3646 || d_peek_char (di) == 'Z')
3647 ret = cplus_demangle_mangled_name (di, 0);
3648 else
3650 struct demangle_component *type;
3651 enum demangle_component_type t;
3652 const char *s;
3654 type = cplus_demangle_type (di);
3655 if (type == NULL)
3656 return NULL;
3658 /* If we have a type we know how to print, we aren't going to
3659 print the type name itself. */
3660 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3661 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3662 di->expansion -= type->u.s_builtin.type->len;
3664 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3665 && strcmp (type->u.s_builtin.type->name,
3666 cplus_demangle_builtin_types[33].name) == 0)
3668 if (d_peek_char (di) == 'E')
3670 d_advance (di, 1);
3671 return type;
3675 /* Rather than try to interpret the literal value, we just
3676 collect it as a string. Note that it's possible to have a
3677 floating point literal here. The ABI specifies that the
3678 format of such literals is machine independent. That's fine,
3679 but what's not fine is that versions of g++ up to 3.2 with
3680 -fabi-version=1 used upper case letters in the hex constant,
3681 and dumped out gcc's internal representation. That makes it
3682 hard to tell where the constant ends, and hard to dump the
3683 constant in any readable form anyhow. We don't attempt to
3684 handle these cases. */
3686 t = DEMANGLE_COMPONENT_LITERAL;
3687 if (d_peek_char (di) == 'n')
3689 t = DEMANGLE_COMPONENT_LITERAL_NEG;
3690 d_advance (di, 1);
3692 s = d_str (di);
3693 while (d_peek_char (di) != 'E')
3695 if (d_peek_char (di) == '\0')
3696 return NULL;
3697 d_advance (di, 1);
3699 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
3701 if (! d_check_char (di, 'E'))
3702 return NULL;
3703 return ret;
3706 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3707 ::= Z <(function) encoding> E s [<discriminator>]
3708 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3711 static struct demangle_component *
3712 d_local_name (struct d_info *di)
3714 struct demangle_component *function;
3715 struct demangle_component *name;
3717 if (! d_check_char (di, 'Z'))
3718 return NULL;
3720 function = d_encoding (di, 0);
3721 if (!function)
3722 return NULL;
3724 if (! d_check_char (di, 'E'))
3725 return NULL;
3727 if (d_peek_char (di) == 's')
3729 d_advance (di, 1);
3730 if (! d_discriminator (di))
3731 return NULL;
3732 name = d_make_name (di, "string literal", sizeof "string literal" - 1);
3734 else
3736 int num = -1;
3738 if (d_peek_char (di) == 'd')
3740 /* Default argument scope: d <number> _. */
3741 d_advance (di, 1);
3742 num = d_compact_number (di);
3743 if (num < 0)
3744 return NULL;
3747 name = d_name (di);
3749 if (name
3750 /* Lambdas and unnamed types have internal discriminators
3751 and are not functions. */
3752 && name->type != DEMANGLE_COMPONENT_LAMBDA
3753 && name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE)
3755 /* Read and ignore an optional discriminator. */
3756 if (! d_discriminator (di))
3757 return NULL;
3760 if (num >= 0)
3761 name = d_make_default_arg (di, num, name);
3764 /* Elide the return type of the containing function so as to not
3765 confuse the user thinking it is the return type of whatever local
3766 function we might be containing. */
3767 if (function->type == DEMANGLE_COMPONENT_TYPED_NAME
3768 && d_right (function)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
3769 d_left (d_right (function)) = NULL;
3771 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3774 /* <discriminator> ::= _ <number> # when number < 10
3775 ::= __ <number> _ # when number >= 10
3777 <discriminator> ::= _ <number> # when number >=10
3778 is also accepted to support gcc versions that wrongly mangled that way.
3780 We demangle the discriminator, but we don't print it out. FIXME:
3781 We should print it out in verbose mode. */
3783 static int
3784 d_discriminator (struct d_info *di)
3786 int discrim, num_underscores = 1;
3788 if (d_peek_char (di) != '_')
3789 return 1;
3790 d_advance (di, 1);
3791 if (d_peek_char (di) == '_')
3793 ++num_underscores;
3794 d_advance (di, 1);
3797 discrim = d_number (di);
3798 if (discrim < 0)
3799 return 0;
3800 if (num_underscores > 1 && discrim >= 10)
3802 if (d_peek_char (di) == '_')
3803 d_advance (di, 1);
3804 else
3805 return 0;
3808 return 1;
3811 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3813 static struct demangle_component *
3814 d_lambda (struct d_info *di)
3816 struct demangle_component *tl;
3817 struct demangle_component *ret;
3818 int num;
3820 if (! d_check_char (di, 'U'))
3821 return NULL;
3822 if (! d_check_char (di, 'l'))
3823 return NULL;
3825 tl = d_parmlist (di);
3826 if (tl == NULL)
3827 return NULL;
3829 if (! d_check_char (di, 'E'))
3830 return NULL;
3832 num = d_compact_number (di);
3833 if (num < 0)
3834 return NULL;
3836 ret = d_make_empty (di);
3837 if (ret)
3839 ret->type = DEMANGLE_COMPONENT_LAMBDA;
3840 ret->u.s_unary_num.sub = tl;
3841 ret->u.s_unary_num.num = num;
3844 return ret;
3847 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3849 static struct demangle_component *
3850 d_unnamed_type (struct d_info *di)
3852 struct demangle_component *ret;
3853 int num;
3855 if (! d_check_char (di, 'U'))
3856 return NULL;
3857 if (! d_check_char (di, 't'))
3858 return NULL;
3860 num = d_compact_number (di);
3861 if (num < 0)
3862 return NULL;
3864 ret = d_make_empty (di);
3865 if (ret)
3867 ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3868 ret->u.s_number.number = num;
3871 if (! d_add_substitution (di, ret))
3872 return NULL;
3874 return ret;
3877 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3880 static struct demangle_component *
3881 d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3883 const char *suffix = d_str (di);
3884 const char *pend = suffix;
3885 struct demangle_component *n;
3887 if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3889 pend += 2;
3890 while (IS_LOWER (*pend) || *pend == '_')
3891 ++pend;
3893 while (*pend == '.' && IS_DIGIT (pend[1]))
3895 pend += 2;
3896 while (IS_DIGIT (*pend))
3897 ++pend;
3899 d_advance (di, pend - suffix);
3900 n = d_make_name (di, suffix, pend - suffix);
3901 return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3904 /* Add a new substitution. */
3906 static int
3907 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3909 if (dc == NULL)
3910 return 0;
3911 if (di->next_sub >= di->num_subs)
3912 return 0;
3913 di->subs[di->next_sub] = dc;
3914 ++di->next_sub;
3915 return 1;
3918 /* <substitution> ::= S <seq-id> _
3919 ::= S_
3920 ::= St
3921 ::= Sa
3922 ::= Sb
3923 ::= Ss
3924 ::= Si
3925 ::= So
3926 ::= Sd
3928 If PREFIX is non-zero, then this type is being used as a prefix in
3929 a qualified name. In this case, for the standard substitutions, we
3930 need to check whether we are being used as a prefix for a
3931 constructor or destructor, and return a full template name.
3932 Otherwise we will get something like std::iostream::~iostream()
3933 which does not correspond particularly well to any function which
3934 actually appears in the source.
3937 static const struct d_standard_sub_info standard_subs[] =
3939 { 't', NL ("std"),
3940 NL ("std"),
3941 NULL, 0 },
3942 { 'a', NL ("std::allocator"),
3943 NL ("std::allocator"),
3944 NL ("allocator") },
3945 { 'b', NL ("std::basic_string"),
3946 NL ("std::basic_string"),
3947 NL ("basic_string") },
3948 { 's', NL ("std::string"),
3949 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3950 NL ("basic_string") },
3951 { 'i', NL ("std::istream"),
3952 NL ("std::basic_istream<char, std::char_traits<char> >"),
3953 NL ("basic_istream") },
3954 { 'o', NL ("std::ostream"),
3955 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3956 NL ("basic_ostream") },
3957 { 'd', NL ("std::iostream"),
3958 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3959 NL ("basic_iostream") }
3962 static struct demangle_component *
3963 d_substitution (struct d_info *di, int prefix)
3965 char c;
3967 if (! d_check_char (di, 'S'))
3968 return NULL;
3970 c = d_next_char (di);
3971 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3973 unsigned int id;
3975 id = 0;
3976 if (c != '_')
3980 unsigned int new_id;
3982 if (IS_DIGIT (c))
3983 new_id = id * 36 + c - '0';
3984 else if (IS_UPPER (c))
3985 new_id = id * 36 + c - 'A' + 10;
3986 else
3987 return NULL;
3988 if (new_id < id)
3989 return NULL;
3990 id = new_id;
3991 c = d_next_char (di);
3993 while (c != '_');
3995 ++id;
3998 if (id >= (unsigned int) di->next_sub)
3999 return NULL;
4001 return di->subs[id];
4003 else
4005 int verbose;
4006 const struct d_standard_sub_info *p;
4007 const struct d_standard_sub_info *pend;
4009 verbose = (di->options & DMGL_VERBOSE) != 0;
4010 if (! verbose && prefix)
4012 char peek;
4014 peek = d_peek_char (di);
4015 if (peek == 'C' || peek == 'D')
4016 verbose = 1;
4019 pend = (&standard_subs[0]
4020 + sizeof standard_subs / sizeof standard_subs[0]);
4021 for (p = &standard_subs[0]; p < pend; ++p)
4023 if (c == p->code)
4025 const char *s;
4026 int len;
4027 struct demangle_component *dc;
4029 if (p->set_last_name != NULL)
4030 di->last_name = d_make_sub (di, p->set_last_name,
4031 p->set_last_name_len);
4032 if (verbose)
4034 s = p->full_expansion;
4035 len = p->full_len;
4037 else
4039 s = p->simple_expansion;
4040 len = p->simple_len;
4042 di->expansion += len;
4043 dc = d_make_sub (di, s, len);
4044 if (d_peek_char (di) == 'B')
4046 /* If there are ABI tags on the abbreviation, it becomes
4047 a substitution candidate. */
4048 dc = d_abi_tags (di, dc);
4049 if (! d_add_substitution (di, dc))
4050 return NULL;
4052 return dc;
4056 return NULL;
4060 static void
4061 d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
4063 checkpoint->n = di->n;
4064 checkpoint->next_comp = di->next_comp;
4065 checkpoint->next_sub = di->next_sub;
4066 checkpoint->expansion = di->expansion;
4069 static void
4070 d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
4072 di->n = checkpoint->n;
4073 di->next_comp = checkpoint->next_comp;
4074 di->next_sub = checkpoint->next_sub;
4075 di->expansion = checkpoint->expansion;
4078 /* Initialize a growable string. */
4080 static void
4081 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
4083 dgs->buf = NULL;
4084 dgs->len = 0;
4085 dgs->alc = 0;
4086 dgs->allocation_failure = 0;
4088 if (estimate > 0)
4089 d_growable_string_resize (dgs, estimate);
4092 /* Grow a growable string to a given size. */
4094 static inline void
4095 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
4097 size_t newalc;
4098 char *newbuf;
4100 if (dgs->allocation_failure)
4101 return;
4103 /* Start allocation at two bytes to avoid any possibility of confusion
4104 with the special value of 1 used as a return in *palc to indicate
4105 allocation failures. */
4106 newalc = dgs->alc > 0 ? dgs->alc : 2;
4107 while (newalc < need)
4108 newalc <<= 1;
4110 newbuf = (char *) realloc (dgs->buf, newalc);
4111 if (newbuf == NULL)
4113 free (dgs->buf);
4114 dgs->buf = NULL;
4115 dgs->len = 0;
4116 dgs->alc = 0;
4117 dgs->allocation_failure = 1;
4118 return;
4120 dgs->buf = newbuf;
4121 dgs->alc = newalc;
4124 /* Append a buffer to a growable string. */
4126 static inline void
4127 d_growable_string_append_buffer (struct d_growable_string *dgs,
4128 const char *s, size_t l)
4130 size_t need;
4132 need = dgs->len + l + 1;
4133 if (need > dgs->alc)
4134 d_growable_string_resize (dgs, need);
4136 if (dgs->allocation_failure)
4137 return;
4139 memcpy (dgs->buf + dgs->len, s, l);
4140 dgs->buf[dgs->len + l] = '\0';
4141 dgs->len += l;
4144 /* Bridge growable strings to the callback mechanism. */
4146 static void
4147 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
4149 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
4151 d_growable_string_append_buffer (dgs, s, l);
4154 /* Walk the tree, counting the number of templates encountered, and
4155 the number of times a scope might be saved. These counts will be
4156 used to allocate data structures for d_print_comp, so the logic
4157 here must mirror the logic d_print_comp will use. It is not
4158 important that the resulting numbers are exact, so long as they
4159 are larger than the actual numbers encountered. */
4161 static void
4162 d_count_templates_scopes (struct d_print_info *dpi,
4163 struct demangle_component *dc)
4165 if (dc == NULL || dc->d_counting > 1 || dpi->recursion > MAX_RECURSION_COUNT)
4166 return;
4168 ++ dc->d_counting;
4170 switch (dc->type)
4172 case DEMANGLE_COMPONENT_NAME:
4173 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4174 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4175 case DEMANGLE_COMPONENT_SUB_STD:
4176 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4177 case DEMANGLE_COMPONENT_OPERATOR:
4178 case DEMANGLE_COMPONENT_CHARACTER:
4179 case DEMANGLE_COMPONENT_NUMBER:
4180 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4181 break;
4183 case DEMANGLE_COMPONENT_TEMPLATE:
4184 dpi->num_copy_templates++;
4185 goto recurse_left_right;
4187 case DEMANGLE_COMPONENT_REFERENCE:
4188 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4189 if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
4190 dpi->num_saved_scopes++;
4191 goto recurse_left_right;
4193 case DEMANGLE_COMPONENT_QUAL_NAME:
4194 case DEMANGLE_COMPONENT_LOCAL_NAME:
4195 case DEMANGLE_COMPONENT_TYPED_NAME:
4196 case DEMANGLE_COMPONENT_VTABLE:
4197 case DEMANGLE_COMPONENT_VTT:
4198 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4199 case DEMANGLE_COMPONENT_TYPEINFO:
4200 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4201 case DEMANGLE_COMPONENT_TYPEINFO_FN:
4202 case DEMANGLE_COMPONENT_THUNK:
4203 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4204 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4205 case DEMANGLE_COMPONENT_JAVA_CLASS:
4206 case DEMANGLE_COMPONENT_GUARD:
4207 case DEMANGLE_COMPONENT_TLS_INIT:
4208 case DEMANGLE_COMPONENT_TLS_WRAPPER:
4209 case DEMANGLE_COMPONENT_REFTEMP:
4210 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4211 case DEMANGLE_COMPONENT_RESTRICT:
4212 case DEMANGLE_COMPONENT_VOLATILE:
4213 case DEMANGLE_COMPONENT_CONST:
4214 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4215 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4216 case DEMANGLE_COMPONENT_CONST_THIS:
4217 case DEMANGLE_COMPONENT_REFERENCE_THIS:
4218 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
4219 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
4220 case DEMANGLE_COMPONENT_NOEXCEPT:
4221 case DEMANGLE_COMPONENT_THROW_SPEC:
4222 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4223 case DEMANGLE_COMPONENT_POINTER:
4224 case DEMANGLE_COMPONENT_COMPLEX:
4225 case DEMANGLE_COMPONENT_IMAGINARY:
4226 case DEMANGLE_COMPONENT_VENDOR_TYPE:
4227 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4228 case DEMANGLE_COMPONENT_ARRAY_TYPE:
4229 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4230 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4231 case DEMANGLE_COMPONENT_ARGLIST:
4232 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4233 case DEMANGLE_COMPONENT_TPARM_OBJ:
4234 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4235 case DEMANGLE_COMPONENT_CAST:
4236 case DEMANGLE_COMPONENT_CONVERSION:
4237 case DEMANGLE_COMPONENT_NULLARY:
4238 case DEMANGLE_COMPONENT_UNARY:
4239 case DEMANGLE_COMPONENT_BINARY:
4240 case DEMANGLE_COMPONENT_BINARY_ARGS:
4241 case DEMANGLE_COMPONENT_TRINARY:
4242 case DEMANGLE_COMPONENT_TRINARY_ARG1:
4243 case DEMANGLE_COMPONENT_TRINARY_ARG2:
4244 case DEMANGLE_COMPONENT_LITERAL:
4245 case DEMANGLE_COMPONENT_LITERAL_NEG:
4246 case DEMANGLE_COMPONENT_VENDOR_EXPR:
4247 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4248 case DEMANGLE_COMPONENT_COMPOUND_NAME:
4249 case DEMANGLE_COMPONENT_DECLTYPE:
4250 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4251 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4252 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4253 case DEMANGLE_COMPONENT_TAGGED_NAME:
4254 case DEMANGLE_COMPONENT_CLONE:
4255 recurse_left_right:
4256 /* PR 89394 - Check for too much recursion. */
4257 if (dpi->recursion > DEMANGLE_RECURSION_LIMIT)
4258 /* FIXME: There ought to be a way to report to the
4259 user that the recursion limit has been reached. */
4260 return;
4262 ++ dpi->recursion;
4263 d_count_templates_scopes (dpi, d_left (dc));
4264 d_count_templates_scopes (dpi, d_right (dc));
4265 -- dpi->recursion;
4266 break;
4268 case DEMANGLE_COMPONENT_CTOR:
4269 d_count_templates_scopes (dpi, dc->u.s_ctor.name);
4270 break;
4272 case DEMANGLE_COMPONENT_DTOR:
4273 d_count_templates_scopes (dpi, dc->u.s_dtor.name);
4274 break;
4276 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4277 d_count_templates_scopes (dpi, dc->u.s_extended_operator.name);
4278 break;
4280 case DEMANGLE_COMPONENT_FIXED_TYPE:
4281 d_count_templates_scopes (dpi, dc->u.s_fixed.length);
4282 break;
4284 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4285 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4286 d_count_templates_scopes (dpi, d_left (dc));
4287 break;
4289 case DEMANGLE_COMPONENT_LAMBDA:
4290 case DEMANGLE_COMPONENT_DEFAULT_ARG:
4291 d_count_templates_scopes (dpi, dc->u.s_unary_num.sub);
4292 break;
4296 /* Initialize a print information structure. */
4298 static void
4299 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
4300 void *opaque, struct demangle_component *dc)
4302 dpi->len = 0;
4303 dpi->last_char = '\0';
4304 dpi->templates = NULL;
4305 dpi->modifiers = NULL;
4306 dpi->pack_index = 0;
4307 dpi->flush_count = 0;
4309 dpi->callback = callback;
4310 dpi->opaque = opaque;
4312 dpi->demangle_failure = 0;
4313 dpi->recursion = 0;
4314 dpi->is_lambda_arg = 0;
4316 dpi->component_stack = NULL;
4318 dpi->saved_scopes = NULL;
4319 dpi->next_saved_scope = 0;
4320 dpi->num_saved_scopes = 0;
4322 dpi->copy_templates = NULL;
4323 dpi->next_copy_template = 0;
4324 dpi->num_copy_templates = 0;
4326 d_count_templates_scopes (dpi, dc);
4327 /* If we did not reach the recursion limit, then reset the
4328 current recursion value back to 0, so that we can print
4329 the templates. */
4330 if (dpi->recursion < DEMANGLE_RECURSION_LIMIT)
4331 dpi->recursion = 0;
4332 dpi->num_copy_templates *= dpi->num_saved_scopes;
4334 dpi->current_template = NULL;
4337 /* Indicate that an error occurred during printing, and test for error. */
4339 static inline void
4340 d_print_error (struct d_print_info *dpi)
4342 dpi->demangle_failure = 1;
4345 static inline int
4346 d_print_saw_error (struct d_print_info *dpi)
4348 return dpi->demangle_failure != 0;
4351 /* Flush buffered characters to the callback. */
4353 static inline void
4354 d_print_flush (struct d_print_info *dpi)
4356 dpi->buf[dpi->len] = '\0';
4357 dpi->callback (dpi->buf, dpi->len, dpi->opaque);
4358 dpi->len = 0;
4359 dpi->flush_count++;
4362 /* Append characters and buffers for printing. */
4364 static inline void
4365 d_append_char (struct d_print_info *dpi, char c)
4367 if (dpi->len == sizeof (dpi->buf) - 1)
4368 d_print_flush (dpi);
4370 dpi->buf[dpi->len++] = c;
4371 dpi->last_char = c;
4374 static inline void
4375 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4377 size_t i;
4379 for (i = 0; i < l; i++)
4380 d_append_char (dpi, s[i]);
4383 static inline void
4384 d_append_string (struct d_print_info *dpi, const char *s)
4386 d_append_buffer (dpi, s, strlen (s));
4389 static inline void
4390 d_append_num (struct d_print_info *dpi, int l)
4392 char buf[25];
4393 sprintf (buf,"%d", l);
4394 d_append_string (dpi, buf);
4397 static inline char
4398 d_last_char (struct d_print_info *dpi)
4400 return dpi->last_char;
4403 /* Turn components into a human readable string. OPTIONS is the
4404 options bits passed to the demangler. DC is the tree to print.
4405 CALLBACK is a function to call to flush demangled string segments
4406 as they fill the intermediate buffer, and OPAQUE is a generalized
4407 callback argument. On success, this returns 1. On failure,
4408 it returns 0, indicating a bad parse. It does not use heap
4409 memory to build an output string, so cannot encounter memory
4410 allocation failure. */
4412 CP_STATIC_IF_GLIBCPP_V3
4414 cplus_demangle_print_callback (int options,
4415 struct demangle_component *dc,
4416 demangle_callbackref callback, void *opaque)
4418 struct d_print_info dpi;
4420 d_print_init (&dpi, callback, opaque, dc);
4423 #ifdef CP_DYNAMIC_ARRAYS
4424 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4425 and flagged as errors by Address Sanitizer. */
4426 __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
4427 ? dpi.num_saved_scopes : 1];
4428 __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
4429 ? dpi.num_copy_templates : 1];
4431 dpi.saved_scopes = scopes;
4432 dpi.copy_templates = temps;
4433 #else
4434 dpi.saved_scopes = alloca (dpi.num_saved_scopes
4435 * sizeof (*dpi.saved_scopes));
4436 dpi.copy_templates = alloca (dpi.num_copy_templates
4437 * sizeof (*dpi.copy_templates));
4438 #endif
4440 d_print_comp (&dpi, options, dc);
4443 d_print_flush (&dpi);
4445 return ! d_print_saw_error (&dpi);
4448 /* Turn components into a human readable string. OPTIONS is the
4449 options bits passed to the demangler. DC is the tree to print.
4450 ESTIMATE is a guess at the length of the result. This returns a
4451 string allocated by malloc, or NULL on error. On success, this
4452 sets *PALC to the size of the allocated buffer. On failure, this
4453 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4454 failure. */
4456 CP_STATIC_IF_GLIBCPP_V3
4457 char *
4458 cplus_demangle_print (int options, struct demangle_component *dc,
4459 int estimate, size_t *palc)
4461 struct d_growable_string dgs;
4463 d_growable_string_init (&dgs, estimate);
4465 if (! cplus_demangle_print_callback (options, dc,
4466 d_growable_string_callback_adapter,
4467 &dgs))
4469 free (dgs.buf);
4470 *palc = 0;
4471 return NULL;
4474 *palc = dgs.allocation_failure ? 1 : dgs.alc;
4475 return dgs.buf;
4478 /* Returns the I'th element of the template arglist ARGS, or NULL on
4479 failure. If I is negative, return the entire arglist. */
4481 static struct demangle_component *
4482 d_index_template_argument (struct demangle_component *args, int i)
4484 struct demangle_component *a;
4486 if (i < 0)
4487 /* Print the whole argument pack. */
4488 return args;
4490 for (a = args;
4491 a != NULL;
4492 a = d_right (a))
4494 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4495 return NULL;
4496 if (i <= 0)
4497 break;
4498 --i;
4500 if (i != 0 || a == NULL)
4501 return NULL;
4503 return d_left (a);
4506 /* Returns the template argument from the current context indicated by DC,
4507 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4509 static struct demangle_component *
4510 d_lookup_template_argument (struct d_print_info *dpi,
4511 const struct demangle_component *dc)
4513 if (dpi->templates == NULL)
4515 d_print_error (dpi);
4516 return NULL;
4519 return d_index_template_argument
4520 (d_right (dpi->templates->template_decl),
4521 dc->u.s_number.number);
4524 /* Returns a template argument pack used in DC (any will do), or NULL. */
4526 static struct demangle_component *
4527 d_find_pack (struct d_print_info *dpi,
4528 const struct demangle_component *dc)
4530 struct demangle_component *a;
4531 if (dc == NULL)
4532 return NULL;
4534 switch (dc->type)
4536 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4537 a = d_lookup_template_argument (dpi, dc);
4538 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4539 return a;
4540 return NULL;
4542 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4543 return NULL;
4545 case DEMANGLE_COMPONENT_LAMBDA:
4546 case DEMANGLE_COMPONENT_NAME:
4547 case DEMANGLE_COMPONENT_TAGGED_NAME:
4548 case DEMANGLE_COMPONENT_OPERATOR:
4549 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4550 case DEMANGLE_COMPONENT_SUB_STD:
4551 case DEMANGLE_COMPONENT_CHARACTER:
4552 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4553 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4554 case DEMANGLE_COMPONENT_FIXED_TYPE:
4555 case DEMANGLE_COMPONENT_DEFAULT_ARG:
4556 case DEMANGLE_COMPONENT_NUMBER:
4557 return NULL;
4559 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4560 return d_find_pack (dpi, dc->u.s_extended_operator.name);
4561 case DEMANGLE_COMPONENT_CTOR:
4562 return d_find_pack (dpi, dc->u.s_ctor.name);
4563 case DEMANGLE_COMPONENT_DTOR:
4564 return d_find_pack (dpi, dc->u.s_dtor.name);
4566 default:
4567 a = d_find_pack (dpi, d_left (dc));
4568 if (a)
4569 return a;
4570 return d_find_pack (dpi, d_right (dc));
4574 /* Returns the length of the template argument pack DC. */
4576 static int
4577 d_pack_length (const struct demangle_component *dc)
4579 int count = 0;
4580 while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4581 && d_left (dc) != NULL)
4583 ++count;
4584 dc = d_right (dc);
4586 return count;
4589 /* Returns the number of template args in DC, expanding any pack expansions
4590 found there. */
4592 static int
4593 d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
4595 int count = 0;
4596 for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
4597 dc = d_right (dc))
4599 struct demangle_component *elt = d_left (dc);
4600 if (elt == NULL)
4601 break;
4602 if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
4604 struct demangle_component *a = d_find_pack (dpi, d_left (elt));
4605 count += d_pack_length (a);
4607 else
4608 ++count;
4610 return count;
4613 /* DC is a component of a mangled expression. Print it, wrapped in parens
4614 if needed. */
4616 static void
4617 d_print_subexpr (struct d_print_info *dpi, int options,
4618 struct demangle_component *dc)
4620 int simple = 0;
4621 if (dc->type == DEMANGLE_COMPONENT_NAME
4622 || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
4623 || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
4624 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
4625 simple = 1;
4626 if (!simple)
4627 d_append_char (dpi, '(');
4628 d_print_comp (dpi, options, dc);
4629 if (!simple)
4630 d_append_char (dpi, ')');
4633 /* Save the current scope. */
4635 static void
4636 d_save_scope (struct d_print_info *dpi,
4637 const struct demangle_component *container)
4639 struct d_saved_scope *scope;
4640 struct d_print_template *src, **link;
4642 if (dpi->next_saved_scope >= dpi->num_saved_scopes)
4644 d_print_error (dpi);
4645 return;
4647 scope = &dpi->saved_scopes[dpi->next_saved_scope];
4648 dpi->next_saved_scope++;
4650 scope->container = container;
4651 link = &scope->templates;
4653 for (src = dpi->templates; src != NULL; src = src->next)
4655 struct d_print_template *dst;
4657 if (dpi->next_copy_template >= dpi->num_copy_templates)
4659 d_print_error (dpi);
4660 return;
4662 dst = &dpi->copy_templates[dpi->next_copy_template];
4663 dpi->next_copy_template++;
4665 dst->template_decl = src->template_decl;
4666 *link = dst;
4667 link = &dst->next;
4670 *link = NULL;
4673 /* Attempt to locate a previously saved scope. Returns NULL if no
4674 corresponding saved scope was found. */
4676 static struct d_saved_scope *
4677 d_get_saved_scope (struct d_print_info *dpi,
4678 const struct demangle_component *container)
4680 int i;
4682 for (i = 0; i < dpi->next_saved_scope; i++)
4683 if (dpi->saved_scopes[i].container == container)
4684 return &dpi->saved_scopes[i];
4686 return NULL;
4689 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4690 return false. */
4692 static int
4693 d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
4694 struct demangle_component *dc)
4696 struct demangle_component *ops, *operator_, *op1, *op2;
4697 int save_idx;
4699 const char *fold_code = d_left (dc)->u.s_operator.op->code;
4700 if (fold_code[0] != 'f')
4701 return 0;
4703 ops = d_right (dc);
4704 operator_ = d_left (ops);
4705 op1 = d_right (ops);
4706 op2 = 0;
4707 if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
4709 op2 = d_right (op1);
4710 op1 = d_left (op1);
4713 /* Print the whole pack. */
4714 save_idx = dpi->pack_index;
4715 dpi->pack_index = -1;
4717 switch (fold_code[1])
4719 /* Unary left fold, (... + X). */
4720 case 'l':
4721 d_append_string (dpi, "(...");
4722 d_print_expr_op (dpi, options, operator_);
4723 d_print_subexpr (dpi, options, op1);
4724 d_append_char (dpi, ')');
4725 break;
4727 /* Unary right fold, (X + ...). */
4728 case 'r':
4729 d_append_char (dpi, '(');
4730 d_print_subexpr (dpi, options, op1);
4731 d_print_expr_op (dpi, options, operator_);
4732 d_append_string (dpi, "...)");
4733 break;
4735 /* Binary left fold, (42 + ... + X). */
4736 case 'L':
4737 /* Binary right fold, (X + ... + 42). */
4738 case 'R':
4739 d_append_char (dpi, '(');
4740 d_print_subexpr (dpi, options, op1);
4741 d_print_expr_op (dpi, options, operator_);
4742 d_append_string (dpi, "...");
4743 d_print_expr_op (dpi, options, operator_);
4744 d_print_subexpr (dpi, options, op2);
4745 d_append_char (dpi, ')');
4746 break;
4749 dpi->pack_index = save_idx;
4750 return 1;
4753 /* True iff DC represents a C99-style designated initializer. */
4755 static int
4756 is_designated_init (struct demangle_component *dc)
4758 if (dc->type != DEMANGLE_COMPONENT_BINARY
4759 && dc->type != DEMANGLE_COMPONENT_TRINARY)
4760 return 0;
4762 struct demangle_component *op = d_left (dc);
4763 const char *code = op->u.s_operator.op->code;
4764 return (code[0] == 'd'
4765 && (code[1] == 'i' || code[1] == 'x' || code[1] == 'X'));
4768 /* If DC represents a C99-style designated initializer, print it and return
4769 true; otherwise, return false. */
4771 static int
4772 d_maybe_print_designated_init (struct d_print_info *dpi, int options,
4773 struct demangle_component *dc)
4775 if (!is_designated_init (dc))
4776 return 0;
4778 const char *code = d_left (dc)->u.s_operator.op->code;
4780 struct demangle_component *operands = d_right (dc);
4781 struct demangle_component *op1 = d_left (operands);
4782 struct demangle_component *op2 = d_right (operands);
4784 if (code[1] == 'i')
4785 d_append_char (dpi, '.');
4786 else
4787 d_append_char (dpi, '[');
4789 d_print_comp (dpi, options, op1);
4790 if (code[1] == 'X')
4792 d_append_string (dpi, " ... ");
4793 d_print_comp (dpi, options, d_left (op2));
4794 op2 = d_right (op2);
4796 if (code[1] != 'i')
4797 d_append_char (dpi, ']');
4798 if (is_designated_init (op2))
4800 /* Don't put '=' or '(' between chained designators. */
4801 d_print_comp (dpi, options, op2);
4803 else
4805 d_append_char (dpi, '=');
4806 d_print_subexpr (dpi, options, op2);
4808 return 1;
4811 /* Subroutine to handle components. */
4813 static void
4814 d_print_comp_inner (struct d_print_info *dpi, int options,
4815 struct demangle_component *dc)
4817 /* Magic variable to let reference smashing skip over the next modifier
4818 without needing to modify *dc. */
4819 struct demangle_component *mod_inner = NULL;
4821 /* Variable used to store the current templates while a previously
4822 captured scope is used. */
4823 struct d_print_template *saved_templates;
4825 /* Nonzero if templates have been stored in the above variable. */
4826 int need_template_restore = 0;
4828 if (dc == NULL)
4830 d_print_error (dpi);
4831 return;
4833 if (d_print_saw_error (dpi))
4834 return;
4836 switch (dc->type)
4838 case DEMANGLE_COMPONENT_NAME:
4839 if ((options & DMGL_JAVA) == 0)
4840 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
4841 else
4842 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
4843 return;
4845 case DEMANGLE_COMPONENT_TAGGED_NAME:
4846 d_print_comp (dpi, options, d_left (dc));
4847 d_append_string (dpi, "[abi:");
4848 d_print_comp (dpi, options, d_right (dc));
4849 d_append_char (dpi, ']');
4850 return;
4852 case DEMANGLE_COMPONENT_QUAL_NAME:
4853 case DEMANGLE_COMPONENT_LOCAL_NAME:
4854 d_print_comp (dpi, options, d_left (dc));
4855 if ((options & DMGL_JAVA) == 0)
4856 d_append_string (dpi, "::");
4857 else
4858 d_append_char (dpi, '.');
4860 struct demangle_component *local_name = d_right (dc);
4861 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4863 d_append_string (dpi, "{default arg#");
4864 d_append_num (dpi, local_name->u.s_unary_num.num + 1);
4865 d_append_string (dpi, "}::");
4866 local_name = local_name->u.s_unary_num.sub;
4868 d_print_comp (dpi, options, local_name);
4870 return;
4872 case DEMANGLE_COMPONENT_TYPED_NAME:
4874 struct d_print_mod *hold_modifiers;
4875 struct demangle_component *typed_name;
4876 struct d_print_mod adpm[4];
4877 unsigned int i;
4878 struct d_print_template dpt;
4880 /* Pass the name down to the type so that it can be printed in
4881 the right place for the type. We also have to pass down
4882 any CV-qualifiers, which apply to the this parameter. */
4883 hold_modifiers = dpi->modifiers;
4884 dpi->modifiers = 0;
4885 i = 0;
4886 typed_name = d_left (dc);
4887 while (typed_name != NULL)
4889 if (i >= sizeof adpm / sizeof adpm[0])
4891 d_print_error (dpi);
4892 return;
4895 adpm[i].next = dpi->modifiers;
4896 dpi->modifiers = &adpm[i];
4897 adpm[i].mod = typed_name;
4898 adpm[i].printed = 0;
4899 adpm[i].templates = dpi->templates;
4900 ++i;
4902 if (!is_fnqual_component_type (typed_name->type))
4903 break;
4905 typed_name = d_left (typed_name);
4908 if (typed_name == NULL)
4910 d_print_error (dpi);
4911 return;
4914 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4915 there may be CV-qualifiers on its right argument which
4916 really apply here; this happens when parsing a class that
4917 is local to a function. */
4918 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4920 typed_name = d_right (typed_name);
4921 if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4922 typed_name = typed_name->u.s_unary_num.sub;
4923 while (typed_name != NULL
4924 && is_fnqual_component_type (typed_name->type))
4926 if (i >= sizeof adpm / sizeof adpm[0])
4928 d_print_error (dpi);
4929 return;
4932 adpm[i] = adpm[i - 1];
4933 adpm[i].next = &adpm[i - 1];
4934 dpi->modifiers = &adpm[i];
4936 adpm[i - 1].mod = typed_name;
4937 adpm[i - 1].printed = 0;
4938 adpm[i - 1].templates = dpi->templates;
4939 ++i;
4941 typed_name = d_left (typed_name);
4943 if (typed_name == NULL)
4945 d_print_error (dpi);
4946 return;
4950 /* If typed_name is a template, then it applies to the
4951 function type as well. */
4952 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4954 dpt.next = dpi->templates;
4955 dpi->templates = &dpt;
4956 dpt.template_decl = typed_name;
4959 d_print_comp (dpi, options, d_right (dc));
4961 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4962 dpi->templates = dpt.next;
4964 /* If the modifiers didn't get printed by the type, print them
4965 now. */
4966 while (i > 0)
4968 --i;
4969 if (! adpm[i].printed)
4971 d_append_char (dpi, ' ');
4972 d_print_mod (dpi, options, adpm[i].mod);
4976 dpi->modifiers = hold_modifiers;
4978 return;
4981 case DEMANGLE_COMPONENT_TEMPLATE:
4983 struct d_print_mod *hold_dpm;
4984 struct demangle_component *dcl;
4985 const struct demangle_component *hold_current;
4987 /* This template may need to be referenced by a cast operator
4988 contained in its subtree. */
4989 hold_current = dpi->current_template;
4990 dpi->current_template = dc;
4992 /* Don't push modifiers into a template definition. Doing so
4993 could give the wrong definition for a template argument.
4994 Instead, treat the template essentially as a name. */
4996 hold_dpm = dpi->modifiers;
4997 dpi->modifiers = NULL;
4999 dcl = d_left (dc);
5001 if ((options & DMGL_JAVA) != 0
5002 && dcl->type == DEMANGLE_COMPONENT_NAME
5003 && dcl->u.s_name.len == 6
5004 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
5006 /* Special-case Java arrays, so that JArray<TYPE> appears
5007 instead as TYPE[]. */
5009 d_print_comp (dpi, options, d_right (dc));
5010 d_append_string (dpi, "[]");
5012 else
5014 d_print_comp (dpi, options, dcl);
5015 if (d_last_char (dpi) == '<')
5016 d_append_char (dpi, ' ');
5017 d_append_char (dpi, '<');
5018 d_print_comp (dpi, options, d_right (dc));
5019 /* Avoid generating two consecutive '>' characters, to avoid
5020 the C++ syntactic ambiguity. */
5021 if (d_last_char (dpi) == '>')
5022 d_append_char (dpi, ' ');
5023 d_append_char (dpi, '>');
5026 dpi->modifiers = hold_dpm;
5027 dpi->current_template = hold_current;
5029 return;
5032 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5033 if (dpi->is_lambda_arg)
5035 /* Show the template parm index, as that's how g++ displays
5036 these, and future proofs us against potential
5037 '[]<typename T> (T *a, T *b) {...}'. */
5038 d_append_buffer (dpi, "auto:", 5);
5039 d_append_num (dpi, dc->u.s_number.number + 1);
5041 else
5043 struct d_print_template *hold_dpt;
5044 struct demangle_component *a = d_lookup_template_argument (dpi, dc);
5046 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5047 a = d_index_template_argument (a, dpi->pack_index);
5049 if (a == NULL)
5051 d_print_error (dpi);
5052 return;
5055 /* While processing this parameter, we need to pop the list
5056 of templates. This is because the template parameter may
5057 itself be a reference to a parameter of an outer
5058 template. */
5060 hold_dpt = dpi->templates;
5061 dpi->templates = hold_dpt->next;
5063 d_print_comp (dpi, options, a);
5065 dpi->templates = hold_dpt;
5067 return;
5069 case DEMANGLE_COMPONENT_TPARM_OBJ:
5070 d_append_string (dpi, "template parameter object for ");
5071 d_print_comp (dpi, options, d_left (dc));
5072 return;
5074 case DEMANGLE_COMPONENT_CTOR:
5075 d_print_comp (dpi, options, dc->u.s_ctor.name);
5076 return;
5078 case DEMANGLE_COMPONENT_DTOR:
5079 d_append_char (dpi, '~');
5080 d_print_comp (dpi, options, dc->u.s_dtor.name);
5081 return;
5083 case DEMANGLE_COMPONENT_VTABLE:
5084 d_append_string (dpi, "vtable for ");
5085 d_print_comp (dpi, options, d_left (dc));
5086 return;
5088 case DEMANGLE_COMPONENT_VTT:
5089 d_append_string (dpi, "VTT for ");
5090 d_print_comp (dpi, options, d_left (dc));
5091 return;
5093 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
5094 d_append_string (dpi, "construction vtable for ");
5095 d_print_comp (dpi, options, d_left (dc));
5096 d_append_string (dpi, "-in-");
5097 d_print_comp (dpi, options, d_right (dc));
5098 return;
5100 case DEMANGLE_COMPONENT_TYPEINFO:
5101 d_append_string (dpi, "typeinfo for ");
5102 d_print_comp (dpi, options, d_left (dc));
5103 return;
5105 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
5106 d_append_string (dpi, "typeinfo name for ");
5107 d_print_comp (dpi, options, d_left (dc));
5108 return;
5110 case DEMANGLE_COMPONENT_TYPEINFO_FN:
5111 d_append_string (dpi, "typeinfo fn for ");
5112 d_print_comp (dpi, options, d_left (dc));
5113 return;
5115 case DEMANGLE_COMPONENT_THUNK:
5116 d_append_string (dpi, "non-virtual thunk to ");
5117 d_print_comp (dpi, options, d_left (dc));
5118 return;
5120 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
5121 d_append_string (dpi, "virtual thunk to ");
5122 d_print_comp (dpi, options, d_left (dc));
5123 return;
5125 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
5126 d_append_string (dpi, "covariant return thunk to ");
5127 d_print_comp (dpi, options, d_left (dc));
5128 return;
5130 case DEMANGLE_COMPONENT_JAVA_CLASS:
5131 d_append_string (dpi, "java Class for ");
5132 d_print_comp (dpi, options, d_left (dc));
5133 return;
5135 case DEMANGLE_COMPONENT_GUARD:
5136 d_append_string (dpi, "guard variable for ");
5137 d_print_comp (dpi, options, d_left (dc));
5138 return;
5140 case DEMANGLE_COMPONENT_TLS_INIT:
5141 d_append_string (dpi, "TLS init function for ");
5142 d_print_comp (dpi, options, d_left (dc));
5143 return;
5145 case DEMANGLE_COMPONENT_TLS_WRAPPER:
5146 d_append_string (dpi, "TLS wrapper function for ");
5147 d_print_comp (dpi, options, d_left (dc));
5148 return;
5150 case DEMANGLE_COMPONENT_REFTEMP:
5151 d_append_string (dpi, "reference temporary #");
5152 d_print_comp (dpi, options, d_right (dc));
5153 d_append_string (dpi, " for ");
5154 d_print_comp (dpi, options, d_left (dc));
5155 return;
5157 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
5158 d_append_string (dpi, "hidden alias for ");
5159 d_print_comp (dpi, options, d_left (dc));
5160 return;
5162 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
5163 d_append_string (dpi, "transaction clone for ");
5164 d_print_comp (dpi, options, d_left (dc));
5165 return;
5167 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
5168 d_append_string (dpi, "non-transaction clone for ");
5169 d_print_comp (dpi, options, d_left (dc));
5170 return;
5172 case DEMANGLE_COMPONENT_SUB_STD:
5173 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
5174 return;
5176 case DEMANGLE_COMPONENT_RESTRICT:
5177 case DEMANGLE_COMPONENT_VOLATILE:
5178 case DEMANGLE_COMPONENT_CONST:
5180 struct d_print_mod *pdpm;
5182 /* When printing arrays, it's possible to have cases where the
5183 same CV-qualifier gets pushed on the stack multiple times.
5184 We only need to print it once. */
5186 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
5188 if (! pdpm->printed)
5190 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
5191 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
5192 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
5193 break;
5194 if (pdpm->mod->type == dc->type)
5196 d_print_comp (dpi, options, d_left (dc));
5197 return;
5202 goto modifier;
5204 case DEMANGLE_COMPONENT_REFERENCE:
5205 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5207 /* Handle reference smashing: & + && = &. */
5208 struct demangle_component *sub = d_left (dc);
5209 if (!dpi->is_lambda_arg
5210 && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
5212 struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
5213 struct demangle_component *a;
5215 if (scope == NULL)
5217 /* This is the first time SUB has been traversed.
5218 We need to capture the current templates so
5219 they can be restored if SUB is reentered as a
5220 substitution. */
5221 d_save_scope (dpi, sub);
5222 if (d_print_saw_error (dpi))
5223 return;
5225 else
5227 const struct d_component_stack *dcse;
5228 int found_self_or_parent = 0;
5230 /* This traversal is reentering SUB as a substition.
5231 If we are not beneath SUB or DC in the tree then we
5232 need to restore SUB's template stack temporarily. */
5233 for (dcse = dpi->component_stack; dcse != NULL;
5234 dcse = dcse->parent)
5236 if (dcse->dc == sub
5237 || (dcse->dc == dc
5238 && dcse != dpi->component_stack))
5240 found_self_or_parent = 1;
5241 break;
5245 if (!found_self_or_parent)
5247 saved_templates = dpi->templates;
5248 dpi->templates = scope->templates;
5249 need_template_restore = 1;
5253 a = d_lookup_template_argument (dpi, sub);
5254 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5255 a = d_index_template_argument (a, dpi->pack_index);
5257 if (a == NULL)
5259 if (need_template_restore)
5260 dpi->templates = saved_templates;
5262 d_print_error (dpi);
5263 return;
5266 sub = a;
5269 if (sub->type == DEMANGLE_COMPONENT_REFERENCE
5270 || sub->type == dc->type)
5271 dc = sub;
5272 else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
5273 mod_inner = d_left (sub);
5275 /* Fall through. */
5277 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5278 case DEMANGLE_COMPONENT_POINTER:
5279 case DEMANGLE_COMPONENT_COMPLEX:
5280 case DEMANGLE_COMPONENT_IMAGINARY:
5281 FNQUAL_COMPONENT_CASE:
5282 modifier:
5284 /* We keep a list of modifiers on the stack. */
5285 struct d_print_mod dpm;
5287 dpm.next = dpi->modifiers;
5288 dpi->modifiers = &dpm;
5289 dpm.mod = dc;
5290 dpm.printed = 0;
5291 dpm.templates = dpi->templates;
5293 if (!mod_inner)
5294 mod_inner = d_left (dc);
5296 d_print_comp (dpi, options, mod_inner);
5298 /* If the modifier didn't get printed by the type, print it
5299 now. */
5300 if (! dpm.printed)
5301 d_print_mod (dpi, options, dc);
5303 dpi->modifiers = dpm.next;
5305 if (need_template_restore)
5306 dpi->templates = saved_templates;
5308 return;
5311 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5312 if ((options & DMGL_JAVA) == 0)
5313 d_append_buffer (dpi, dc->u.s_builtin.type->name,
5314 dc->u.s_builtin.type->len);
5315 else
5316 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
5317 dc->u.s_builtin.type->java_len);
5318 return;
5320 case DEMANGLE_COMPONENT_VENDOR_TYPE:
5321 d_print_comp (dpi, options, d_left (dc));
5322 return;
5324 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5326 if ((options & DMGL_RET_POSTFIX) != 0)
5327 d_print_function_type (dpi,
5328 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5329 dc, dpi->modifiers);
5331 /* Print return type if present */
5332 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
5333 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5334 d_left (dc));
5335 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
5337 struct d_print_mod dpm;
5339 /* We must pass this type down as a modifier in order to
5340 print it in the right location. */
5341 dpm.next = dpi->modifiers;
5342 dpi->modifiers = &dpm;
5343 dpm.mod = dc;
5344 dpm.printed = 0;
5345 dpm.templates = dpi->templates;
5347 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5348 d_left (dc));
5350 dpi->modifiers = dpm.next;
5352 if (dpm.printed)
5353 return;
5355 /* In standard prefix notation, there is a space between the
5356 return type and the function signature. */
5357 if ((options & DMGL_RET_POSTFIX) == 0)
5358 d_append_char (dpi, ' ');
5361 if ((options & DMGL_RET_POSTFIX) == 0)
5362 d_print_function_type (dpi,
5363 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5364 dc, dpi->modifiers);
5366 return;
5369 case DEMANGLE_COMPONENT_ARRAY_TYPE:
5371 struct d_print_mod *hold_modifiers;
5372 struct d_print_mod adpm[4];
5373 unsigned int i;
5374 struct d_print_mod *pdpm;
5376 /* We must pass this type down as a modifier in order to print
5377 multi-dimensional arrays correctly. If the array itself is
5378 CV-qualified, we act as though the element type were
5379 CV-qualified. We do this by copying the modifiers down
5380 rather than fiddling pointers, so that we don't wind up
5381 with a d_print_mod higher on the stack pointing into our
5382 stack frame after we return. */
5384 hold_modifiers = dpi->modifiers;
5386 adpm[0].next = hold_modifiers;
5387 dpi->modifiers = &adpm[0];
5388 adpm[0].mod = dc;
5389 adpm[0].printed = 0;
5390 adpm[0].templates = dpi->templates;
5392 i = 1;
5393 pdpm = hold_modifiers;
5394 while (pdpm != NULL
5395 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
5396 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
5397 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
5399 if (! pdpm->printed)
5401 if (i >= sizeof adpm / sizeof adpm[0])
5403 d_print_error (dpi);
5404 return;
5407 adpm[i] = *pdpm;
5408 adpm[i].next = dpi->modifiers;
5409 dpi->modifiers = &adpm[i];
5410 pdpm->printed = 1;
5411 ++i;
5414 pdpm = pdpm->next;
5417 d_print_comp (dpi, options, d_right (dc));
5419 dpi->modifiers = hold_modifiers;
5421 if (adpm[0].printed)
5422 return;
5424 while (i > 1)
5426 --i;
5427 d_print_mod (dpi, options, adpm[i].mod);
5430 d_print_array_type (dpi, options, dc, dpi->modifiers);
5432 return;
5435 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5436 case DEMANGLE_COMPONENT_VECTOR_TYPE:
5438 struct d_print_mod dpm;
5440 dpm.next = dpi->modifiers;
5441 dpi->modifiers = &dpm;
5442 dpm.mod = dc;
5443 dpm.printed = 0;
5444 dpm.templates = dpi->templates;
5446 d_print_comp (dpi, options, d_right (dc));
5448 /* If the modifier didn't get printed by the type, print it
5449 now. */
5450 if (! dpm.printed)
5451 d_print_mod (dpi, options, dc);
5453 dpi->modifiers = dpm.next;
5455 return;
5458 case DEMANGLE_COMPONENT_FIXED_TYPE:
5459 if (dc->u.s_fixed.sat)
5460 d_append_string (dpi, "_Sat ");
5461 /* Don't print "int _Accum". */
5462 if (dc->u.s_fixed.length->u.s_builtin.type
5463 != &cplus_demangle_builtin_types['i'-'a'])
5465 d_print_comp (dpi, options, dc->u.s_fixed.length);
5466 d_append_char (dpi, ' ');
5468 if (dc->u.s_fixed.accum)
5469 d_append_string (dpi, "_Accum");
5470 else
5471 d_append_string (dpi, "_Fract");
5472 return;
5474 case DEMANGLE_COMPONENT_ARGLIST:
5475 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
5476 if (d_left (dc) != NULL)
5477 d_print_comp (dpi, options, d_left (dc));
5478 if (d_right (dc) != NULL)
5480 size_t len;
5481 unsigned long int flush_count;
5482 /* Make sure ", " isn't flushed by d_append_string, otherwise
5483 dpi->len -= 2 wouldn't work. */
5484 if (dpi->len >= sizeof (dpi->buf) - 2)
5485 d_print_flush (dpi);
5486 d_append_string (dpi, ", ");
5487 len = dpi->len;
5488 flush_count = dpi->flush_count;
5489 d_print_comp (dpi, options, d_right (dc));
5490 /* If that didn't print anything (which can happen with empty
5491 template argument packs), remove the comma and space. */
5492 if (dpi->flush_count == flush_count && dpi->len == len)
5493 dpi->len -= 2;
5495 return;
5497 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
5499 struct demangle_component *type = d_left (dc);
5500 struct demangle_component *list = d_right (dc);
5502 if (type)
5503 d_print_comp (dpi, options, type);
5504 d_append_char (dpi, '{');
5505 d_print_comp (dpi, options, list);
5506 d_append_char (dpi, '}');
5508 return;
5510 case DEMANGLE_COMPONENT_OPERATOR:
5512 const struct demangle_operator_info *op = dc->u.s_operator.op;
5513 int len = op->len;
5515 d_append_string (dpi, "operator");
5516 /* Add a space before new/delete. */
5517 if (IS_LOWER (op->name[0]))
5518 d_append_char (dpi, ' ');
5519 /* Omit a trailing space. */
5520 if (op->name[len-1] == ' ')
5521 --len;
5522 d_append_buffer (dpi, op->name, len);
5523 return;
5526 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
5527 d_append_string (dpi, "operator ");
5528 d_print_comp (dpi, options, dc->u.s_extended_operator.name);
5529 return;
5531 case DEMANGLE_COMPONENT_CONVERSION:
5532 d_append_string (dpi, "operator ");
5533 d_print_conversion (dpi, options, dc);
5534 return;
5536 case DEMANGLE_COMPONENT_NULLARY:
5537 d_print_expr_op (dpi, options, d_left (dc));
5538 return;
5540 case DEMANGLE_COMPONENT_UNARY:
5542 struct demangle_component *op = d_left (dc);
5543 struct demangle_component *operand = d_right (dc);
5544 const char *code = NULL;
5546 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
5548 code = op->u.s_operator.op->code;
5549 if (!strcmp (code, "ad"))
5551 /* Don't print the argument list for the address of a
5552 function. */
5553 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
5554 && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
5555 && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5556 operand = d_left (operand);
5558 if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
5560 /* This indicates a suffix operator. */
5561 operand = d_left (operand);
5562 d_print_subexpr (dpi, options, operand);
5563 d_print_expr_op (dpi, options, op);
5564 return;
5568 /* For sizeof..., just print the pack length. */
5569 if (code && !strcmp (code, "sZ"))
5571 struct demangle_component *a = d_find_pack (dpi, operand);
5572 int len = d_pack_length (a);
5573 d_append_num (dpi, len);
5574 return;
5576 else if (code && !strcmp (code, "sP"))
5578 int len = d_args_length (dpi, operand);
5579 d_append_num (dpi, len);
5580 return;
5583 if (op->type != DEMANGLE_COMPONENT_CAST)
5584 d_print_expr_op (dpi, options, op);
5585 else
5587 d_append_char (dpi, '(');
5588 d_print_cast (dpi, options, op);
5589 d_append_char (dpi, ')');
5591 if (code && !strcmp (code, "gs"))
5592 /* Avoid parens after '::'. */
5593 d_print_comp (dpi, options, operand);
5594 else if (code && !strcmp (code, "st"))
5595 /* Always print parens for sizeof (type). */
5597 d_append_char (dpi, '(');
5598 d_print_comp (dpi, options, operand);
5599 d_append_char (dpi, ')');
5601 else
5602 d_print_subexpr (dpi, options, operand);
5604 return;
5606 case DEMANGLE_COMPONENT_BINARY:
5607 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
5609 d_print_error (dpi);
5610 return;
5613 if (op_is_new_cast (d_left (dc)))
5615 d_print_expr_op (dpi, options, d_left (dc));
5616 d_append_char (dpi, '<');
5617 d_print_comp (dpi, options, d_left (d_right (dc)));
5618 d_append_string (dpi, ">(");
5619 d_print_comp (dpi, options, d_right (d_right (dc)));
5620 d_append_char (dpi, ')');
5621 return;
5624 if (d_maybe_print_fold_expression (dpi, options, dc))
5625 return;
5627 if (d_maybe_print_designated_init (dpi, options, dc))
5628 return;
5630 /* We wrap an expression which uses the greater-than operator in
5631 an extra layer of parens so that it does not get confused
5632 with the '>' which ends the template parameters. */
5633 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5634 && d_left (dc)->u.s_operator.op->len == 1
5635 && d_left (dc)->u.s_operator.op->name[0] == '>')
5636 d_append_char (dpi, '(');
5638 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
5639 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
5641 /* Function call used in an expression should not have printed types
5642 of the function arguments. Values of the function arguments still
5643 get printed below. */
5645 const struct demangle_component *func = d_left (d_right (dc));
5647 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5648 d_print_error (dpi);
5649 d_print_subexpr (dpi, options, d_left (func));
5651 else
5652 d_print_subexpr (dpi, options, d_left (d_right (dc)));
5653 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
5655 d_append_char (dpi, '[');
5656 d_print_comp (dpi, options, d_right (d_right (dc)));
5657 d_append_char (dpi, ']');
5659 else
5661 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
5662 d_print_expr_op (dpi, options, d_left (dc));
5663 d_print_subexpr (dpi, options, d_right (d_right (dc)));
5666 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5667 && d_left (dc)->u.s_operator.op->len == 1
5668 && d_left (dc)->u.s_operator.op->name[0] == '>')
5669 d_append_char (dpi, ')');
5671 return;
5673 case DEMANGLE_COMPONENT_BINARY_ARGS:
5674 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5675 d_print_error (dpi);
5676 return;
5678 case DEMANGLE_COMPONENT_TRINARY:
5679 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
5680 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
5682 d_print_error (dpi);
5683 return;
5685 if (d_maybe_print_fold_expression (dpi, options, dc))
5686 return;
5687 if (d_maybe_print_designated_init (dpi, options, dc))
5688 return;
5690 struct demangle_component *op = d_left (dc);
5691 struct demangle_component *first = d_left (d_right (dc));
5692 struct demangle_component *second = d_left (d_right (d_right (dc)));
5693 struct demangle_component *third = d_right (d_right (d_right (dc)));
5695 if (!strcmp (op->u.s_operator.op->code, "qu"))
5697 d_print_subexpr (dpi, options, first);
5698 d_print_expr_op (dpi, options, op);
5699 d_print_subexpr (dpi, options, second);
5700 d_append_string (dpi, " : ");
5701 d_print_subexpr (dpi, options, third);
5703 else
5705 d_append_string (dpi, "new ");
5706 if (d_left (first) != NULL)
5708 d_print_subexpr (dpi, options, first);
5709 d_append_char (dpi, ' ');
5711 d_print_comp (dpi, options, second);
5712 if (third)
5713 d_print_subexpr (dpi, options, third);
5716 return;
5718 case DEMANGLE_COMPONENT_TRINARY_ARG1:
5719 case DEMANGLE_COMPONENT_TRINARY_ARG2:
5720 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5721 d_print_error (dpi);
5722 return;
5724 case DEMANGLE_COMPONENT_LITERAL:
5725 case DEMANGLE_COMPONENT_LITERAL_NEG:
5727 enum d_builtin_type_print tp;
5729 /* For some builtin types, produce simpler output. */
5730 tp = D_PRINT_DEFAULT;
5731 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
5733 tp = d_left (dc)->u.s_builtin.type->print;
5734 switch (tp)
5736 case D_PRINT_INT:
5737 case D_PRINT_UNSIGNED:
5738 case D_PRINT_LONG:
5739 case D_PRINT_UNSIGNED_LONG:
5740 case D_PRINT_LONG_LONG:
5741 case D_PRINT_UNSIGNED_LONG_LONG:
5742 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
5744 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5745 d_append_char (dpi, '-');
5746 d_print_comp (dpi, options, d_right (dc));
5747 switch (tp)
5749 default:
5750 break;
5751 case D_PRINT_UNSIGNED:
5752 d_append_char (dpi, 'u');
5753 break;
5754 case D_PRINT_LONG:
5755 d_append_char (dpi, 'l');
5756 break;
5757 case D_PRINT_UNSIGNED_LONG:
5758 d_append_string (dpi, "ul");
5759 break;
5760 case D_PRINT_LONG_LONG:
5761 d_append_string (dpi, "ll");
5762 break;
5763 case D_PRINT_UNSIGNED_LONG_LONG:
5764 d_append_string (dpi, "ull");
5765 break;
5767 return;
5769 break;
5771 case D_PRINT_BOOL:
5772 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
5773 && d_right (dc)->u.s_name.len == 1
5774 && dc->type == DEMANGLE_COMPONENT_LITERAL)
5776 switch (d_right (dc)->u.s_name.s[0])
5778 case '0':
5779 d_append_string (dpi, "false");
5780 return;
5781 case '1':
5782 d_append_string (dpi, "true");
5783 return;
5784 default:
5785 break;
5788 break;
5790 default:
5791 break;
5795 d_append_char (dpi, '(');
5796 d_print_comp (dpi, options, d_left (dc));
5797 d_append_char (dpi, ')');
5798 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5799 d_append_char (dpi, '-');
5800 if (tp == D_PRINT_FLOAT)
5801 d_append_char (dpi, '[');
5802 d_print_comp (dpi, options, d_right (dc));
5803 if (tp == D_PRINT_FLOAT)
5804 d_append_char (dpi, ']');
5806 return;
5808 case DEMANGLE_COMPONENT_VENDOR_EXPR:
5809 d_print_comp (dpi, options, d_left (dc));
5810 d_append_char (dpi, '(');
5811 d_print_comp (dpi, options, d_right (dc));
5812 d_append_char (dpi, ')');
5813 return;
5815 case DEMANGLE_COMPONENT_NUMBER:
5816 d_append_num (dpi, dc->u.s_number.number);
5817 return;
5819 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
5820 d_append_string (dpi, "java resource ");
5821 d_print_comp (dpi, options, d_left (dc));
5822 return;
5824 case DEMANGLE_COMPONENT_COMPOUND_NAME:
5825 d_print_comp (dpi, options, d_left (dc));
5826 d_print_comp (dpi, options, d_right (dc));
5827 return;
5829 case DEMANGLE_COMPONENT_CHARACTER:
5830 d_append_char (dpi, dc->u.s_character.character);
5831 return;
5833 case DEMANGLE_COMPONENT_DECLTYPE:
5834 d_append_string (dpi, "decltype (");
5835 d_print_comp (dpi, options, d_left (dc));
5836 d_append_char (dpi, ')');
5837 return;
5839 case DEMANGLE_COMPONENT_PACK_EXPANSION:
5841 int len;
5842 int i;
5843 struct demangle_component *a = d_find_pack (dpi, d_left (dc));
5844 if (a == NULL)
5846 /* d_find_pack won't find anything if the only packs involved
5847 in this expansion are function parameter packs; in that
5848 case, just print the pattern and "...". */
5849 d_print_subexpr (dpi, options, d_left (dc));
5850 d_append_string (dpi, "...");
5851 return;
5854 len = d_pack_length (a);
5855 dc = d_left (dc);
5856 for (i = 0; i < len; ++i)
5858 dpi->pack_index = i;
5859 d_print_comp (dpi, options, dc);
5860 if (i < len-1)
5861 d_append_string (dpi, ", ");
5864 return;
5866 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
5868 long num = dc->u.s_number.number;
5869 if (num == 0)
5870 d_append_string (dpi, "this");
5871 else
5873 d_append_string (dpi, "{parm#");
5874 d_append_num (dpi, num);
5875 d_append_char (dpi, '}');
5878 return;
5880 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
5881 d_append_string (dpi, "global constructors keyed to ");
5882 d_print_comp (dpi, options, dc->u.s_binary.left);
5883 return;
5885 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
5886 d_append_string (dpi, "global destructors keyed to ");
5887 d_print_comp (dpi, options, dc->u.s_binary.left);
5888 return;
5890 case DEMANGLE_COMPONENT_LAMBDA:
5891 d_append_string (dpi, "{lambda(");
5892 /* Generic lambda auto parms are mangled as the template type
5893 parm they are. */
5894 dpi->is_lambda_arg++;
5895 d_print_comp (dpi, options, dc->u.s_unary_num.sub);
5896 dpi->is_lambda_arg--;
5897 d_append_string (dpi, ")#");
5898 d_append_num (dpi, dc->u.s_unary_num.num + 1);
5899 d_append_char (dpi, '}');
5900 return;
5902 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
5903 d_append_string (dpi, "{unnamed type#");
5904 d_append_num (dpi, dc->u.s_number.number + 1);
5905 d_append_char (dpi, '}');
5906 return;
5908 case DEMANGLE_COMPONENT_CLONE:
5909 d_print_comp (dpi, options, d_left (dc));
5910 d_append_string (dpi, " [clone ");
5911 d_print_comp (dpi, options, d_right (dc));
5912 d_append_char (dpi, ']');
5913 return;
5915 default:
5916 d_print_error (dpi);
5917 return;
5921 static void
5922 d_print_comp (struct d_print_info *dpi, int options,
5923 struct demangle_component *dc)
5925 struct d_component_stack self;
5926 if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
5928 d_print_error (dpi);
5929 return;
5932 dc->d_printing++;
5933 dpi->recursion++;
5935 self.dc = dc;
5936 self.parent = dpi->component_stack;
5937 dpi->component_stack = &self;
5939 d_print_comp_inner (dpi, options, dc);
5941 dpi->component_stack = self.parent;
5942 dc->d_printing--;
5943 dpi->recursion--;
5946 /* Print a Java dentifier. For Java we try to handle encoded extended
5947 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5948 so we don't it for C++. Characters are encoded as
5949 __U<hex-char>+_. */
5951 static void
5952 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
5954 const char *p;
5955 const char *end;
5957 end = name + len;
5958 for (p = name; p < end; ++p)
5960 if (end - p > 3
5961 && p[0] == '_'
5962 && p[1] == '_'
5963 && p[2] == 'U')
5965 unsigned long c;
5966 const char *q;
5968 c = 0;
5969 for (q = p + 3; q < end; ++q)
5971 int dig;
5973 if (IS_DIGIT (*q))
5974 dig = *q - '0';
5975 else if (*q >= 'A' && *q <= 'F')
5976 dig = *q - 'A' + 10;
5977 else if (*q >= 'a' && *q <= 'f')
5978 dig = *q - 'a' + 10;
5979 else
5980 break;
5982 c = c * 16 + dig;
5984 /* If the Unicode character is larger than 256, we don't try
5985 to deal with it here. FIXME. */
5986 if (q < end && *q == '_' && c < 256)
5988 d_append_char (dpi, c);
5989 p = q;
5990 continue;
5994 d_append_char (dpi, *p);
5998 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5999 qualifiers on this after printing a function. */
6001 static void
6002 d_print_mod_list (struct d_print_info *dpi, int options,
6003 struct d_print_mod *mods, int suffix)
6005 struct d_print_template *hold_dpt;
6007 if (mods == NULL || d_print_saw_error (dpi))
6008 return;
6010 if (mods->printed
6011 || (! suffix
6012 && (is_fnqual_component_type (mods->mod->type))))
6014 d_print_mod_list (dpi, options, mods->next, suffix);
6015 return;
6018 mods->printed = 1;
6020 hold_dpt = dpi->templates;
6021 dpi->templates = mods->templates;
6023 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
6025 d_print_function_type (dpi, options, mods->mod, mods->next);
6026 dpi->templates = hold_dpt;
6027 return;
6029 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
6031 d_print_array_type (dpi, options, mods->mod, mods->next);
6032 dpi->templates = hold_dpt;
6033 return;
6035 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
6037 struct d_print_mod *hold_modifiers;
6038 struct demangle_component *dc;
6040 /* When this is on the modifier stack, we have pulled any
6041 qualifiers off the right argument already. Otherwise, we
6042 print it as usual, but don't let the left argument see any
6043 modifiers. */
6045 hold_modifiers = dpi->modifiers;
6046 dpi->modifiers = NULL;
6047 d_print_comp (dpi, options, d_left (mods->mod));
6048 dpi->modifiers = hold_modifiers;
6050 if ((options & DMGL_JAVA) == 0)
6051 d_append_string (dpi, "::");
6052 else
6053 d_append_char (dpi, '.');
6055 dc = d_right (mods->mod);
6057 if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
6059 d_append_string (dpi, "{default arg#");
6060 d_append_num (dpi, dc->u.s_unary_num.num + 1);
6061 d_append_string (dpi, "}::");
6062 dc = dc->u.s_unary_num.sub;
6065 while (is_fnqual_component_type (dc->type))
6066 dc = d_left (dc);
6068 d_print_comp (dpi, options, dc);
6070 dpi->templates = hold_dpt;
6071 return;
6074 d_print_mod (dpi, options, mods->mod);
6076 dpi->templates = hold_dpt;
6078 d_print_mod_list (dpi, options, mods->next, suffix);
6081 /* Print a modifier. */
6083 static void
6084 d_print_mod (struct d_print_info *dpi, int options,
6085 struct demangle_component *mod)
6087 switch (mod->type)
6089 case DEMANGLE_COMPONENT_RESTRICT:
6090 case DEMANGLE_COMPONENT_RESTRICT_THIS:
6091 d_append_string (dpi, " restrict");
6092 return;
6093 case DEMANGLE_COMPONENT_VOLATILE:
6094 case DEMANGLE_COMPONENT_VOLATILE_THIS:
6095 d_append_string (dpi, " volatile");
6096 return;
6097 case DEMANGLE_COMPONENT_CONST:
6098 case DEMANGLE_COMPONENT_CONST_THIS:
6099 d_append_string (dpi, " const");
6100 return;
6101 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
6102 d_append_string (dpi, " transaction_safe");
6103 return;
6104 case DEMANGLE_COMPONENT_NOEXCEPT:
6105 d_append_string (dpi, " noexcept");
6106 if (d_right (mod))
6108 d_append_char (dpi, '(');
6109 d_print_comp (dpi, options, d_right (mod));
6110 d_append_char (dpi, ')');
6112 return;
6113 case DEMANGLE_COMPONENT_THROW_SPEC:
6114 d_append_string (dpi, " throw");
6115 if (d_right (mod))
6117 d_append_char (dpi, '(');
6118 d_print_comp (dpi, options, d_right (mod));
6119 d_append_char (dpi, ')');
6121 return;
6122 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
6123 d_append_char (dpi, ' ');
6124 d_print_comp (dpi, options, d_right (mod));
6125 return;
6126 case DEMANGLE_COMPONENT_POINTER:
6127 /* There is no pointer symbol in Java. */
6128 if ((options & DMGL_JAVA) == 0)
6129 d_append_char (dpi, '*');
6130 return;
6131 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6132 /* For the ref-qualifier, put a space before the &. */
6133 d_append_char (dpi, ' ');
6134 /* FALLTHRU */
6135 case DEMANGLE_COMPONENT_REFERENCE:
6136 d_append_char (dpi, '&');
6137 return;
6138 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6139 d_append_char (dpi, ' ');
6140 /* FALLTHRU */
6141 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
6142 d_append_string (dpi, "&&");
6143 return;
6144 case DEMANGLE_COMPONENT_COMPLEX:
6145 d_append_string (dpi, " _Complex");
6146 return;
6147 case DEMANGLE_COMPONENT_IMAGINARY:
6148 d_append_string (dpi, " _Imaginary");
6149 return;
6150 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
6151 if (d_last_char (dpi) != '(')
6152 d_append_char (dpi, ' ');
6153 d_print_comp (dpi, options, d_left (mod));
6154 d_append_string (dpi, "::*");
6155 return;
6156 case DEMANGLE_COMPONENT_TYPED_NAME:
6157 d_print_comp (dpi, options, d_left (mod));
6158 return;
6159 case DEMANGLE_COMPONENT_VECTOR_TYPE:
6160 d_append_string (dpi, " __vector(");
6161 d_print_comp (dpi, options, d_left (mod));
6162 d_append_char (dpi, ')');
6163 return;
6165 default:
6166 /* Otherwise, we have something that won't go back on the
6167 modifier stack, so we can just print it. */
6168 d_print_comp (dpi, options, mod);
6169 return;
6173 /* Print a function type, except for the return type. */
6175 static void
6176 d_print_function_type (struct d_print_info *dpi, int options,
6177 struct demangle_component *dc,
6178 struct d_print_mod *mods)
6180 int need_paren;
6181 int need_space;
6182 struct d_print_mod *p;
6183 struct d_print_mod *hold_modifiers;
6185 need_paren = 0;
6186 need_space = 0;
6187 for (p = mods; p != NULL; p = p->next)
6189 if (p->printed)
6190 break;
6192 switch (p->mod->type)
6194 case DEMANGLE_COMPONENT_POINTER:
6195 case DEMANGLE_COMPONENT_REFERENCE:
6196 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
6197 need_paren = 1;
6198 break;
6199 case DEMANGLE_COMPONENT_RESTRICT:
6200 case DEMANGLE_COMPONENT_VOLATILE:
6201 case DEMANGLE_COMPONENT_CONST:
6202 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
6203 case DEMANGLE_COMPONENT_COMPLEX:
6204 case DEMANGLE_COMPONENT_IMAGINARY:
6205 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
6206 need_space = 1;
6207 need_paren = 1;
6208 break;
6209 FNQUAL_COMPONENT_CASE:
6210 break;
6211 default:
6212 break;
6214 if (need_paren)
6215 break;
6218 if (need_paren)
6220 if (! need_space)
6222 if (d_last_char (dpi) != '('
6223 && d_last_char (dpi) != '*')
6224 need_space = 1;
6226 if (need_space && d_last_char (dpi) != ' ')
6227 d_append_char (dpi, ' ');
6228 d_append_char (dpi, '(');
6231 hold_modifiers = dpi->modifiers;
6232 dpi->modifiers = NULL;
6234 d_print_mod_list (dpi, options, mods, 0);
6236 if (need_paren)
6237 d_append_char (dpi, ')');
6239 d_append_char (dpi, '(');
6241 if (d_right (dc) != NULL)
6242 d_print_comp (dpi, options, d_right (dc));
6244 d_append_char (dpi, ')');
6246 d_print_mod_list (dpi, options, mods, 1);
6248 dpi->modifiers = hold_modifiers;
6251 /* Print an array type, except for the element type. */
6253 static void
6254 d_print_array_type (struct d_print_info *dpi, int options,
6255 struct demangle_component *dc,
6256 struct d_print_mod *mods)
6258 int need_space;
6260 need_space = 1;
6261 if (mods != NULL)
6263 int need_paren;
6264 struct d_print_mod *p;
6266 need_paren = 0;
6267 for (p = mods; p != NULL; p = p->next)
6269 if (! p->printed)
6271 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
6273 need_space = 0;
6274 break;
6276 else
6278 need_paren = 1;
6279 need_space = 1;
6280 break;
6285 if (need_paren)
6286 d_append_string (dpi, " (");
6288 d_print_mod_list (dpi, options, mods, 0);
6290 if (need_paren)
6291 d_append_char (dpi, ')');
6294 if (need_space)
6295 d_append_char (dpi, ' ');
6297 d_append_char (dpi, '[');
6299 if (d_left (dc) != NULL)
6300 d_print_comp (dpi, options, d_left (dc));
6302 d_append_char (dpi, ']');
6305 /* Print an operator in an expression. */
6307 static void
6308 d_print_expr_op (struct d_print_info *dpi, int options,
6309 struct demangle_component *dc)
6311 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
6312 d_append_buffer (dpi, dc->u.s_operator.op->name,
6313 dc->u.s_operator.op->len);
6314 else
6315 d_print_comp (dpi, options, dc);
6318 /* Print a cast. */
6320 static void
6321 d_print_cast (struct d_print_info *dpi, int options,
6322 struct demangle_component *dc)
6324 d_print_comp (dpi, options, d_left (dc));
6327 /* Print a conversion operator. */
6329 static void
6330 d_print_conversion (struct d_print_info *dpi, int options,
6331 struct demangle_component *dc)
6333 struct d_print_template dpt;
6335 /* For a conversion operator, we need the template parameters from
6336 the enclosing template in scope for processing the type. */
6337 if (dpi->current_template != NULL)
6339 dpt.next = dpi->templates;
6340 dpi->templates = &dpt;
6341 dpt.template_decl = dpi->current_template;
6344 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
6346 d_print_comp (dpi, options, d_left (dc));
6347 if (dpi->current_template != NULL)
6348 dpi->templates = dpt.next;
6350 else
6352 d_print_comp (dpi, options, d_left (d_left (dc)));
6354 /* For a templated cast operator, we need to remove the template
6355 parameters from scope after printing the operator name,
6356 so we need to handle the template printing here. */
6357 if (dpi->current_template != NULL)
6358 dpi->templates = dpt.next;
6360 if (d_last_char (dpi) == '<')
6361 d_append_char (dpi, ' ');
6362 d_append_char (dpi, '<');
6363 d_print_comp (dpi, options, d_right (d_left (dc)));
6364 /* Avoid generating two consecutive '>' characters, to avoid
6365 the C++ syntactic ambiguity. */
6366 if (d_last_char (dpi) == '>')
6367 d_append_char (dpi, ' ');
6368 d_append_char (dpi, '>');
6372 /* Initialize the information structure we use to pass around
6373 information. */
6375 CP_STATIC_IF_GLIBCPP_V3
6376 void
6377 cplus_demangle_init_info (const char *mangled, int options, size_t len,
6378 struct d_info *di)
6380 di->s = mangled;
6381 di->send = mangled + len;
6382 di->options = options;
6384 di->n = mangled;
6386 /* We cannot need more components than twice the number of chars in
6387 the mangled string. Most components correspond directly to
6388 chars, but the ARGLIST types are exceptions. */
6389 di->num_comps = 2 * len;
6390 di->next_comp = 0;
6392 /* Similarly, we cannot need more substitutions than there are
6393 chars in the mangled string. */
6394 di->num_subs = len;
6395 di->next_sub = 0;
6397 di->last_name = NULL;
6399 di->expansion = 0;
6400 di->is_expression = 0;
6401 di->is_conversion = 0;
6402 di->recursion_level = 0;
6405 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6406 mangled name, return strings in repeated callback giving the demangled
6407 name. OPTIONS is the usual libiberty demangler options. On success,
6408 this returns 1. On failure, returns 0. */
6410 static int
6411 d_demangle_callback (const char *mangled, int options,
6412 demangle_callbackref callback, void *opaque)
6414 enum
6416 DCT_TYPE,
6417 DCT_MANGLED,
6418 DCT_GLOBAL_CTORS,
6419 DCT_GLOBAL_DTORS
6421 type;
6422 struct d_info di;
6423 struct demangle_component *dc;
6424 int status;
6426 if (mangled[0] == '_' && mangled[1] == 'Z')
6427 type = DCT_MANGLED;
6428 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
6429 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
6430 && (mangled[9] == 'D' || mangled[9] == 'I')
6431 && mangled[10] == '_')
6432 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
6433 else
6435 if ((options & DMGL_TYPES) == 0)
6436 return 0;
6437 type = DCT_TYPE;
6440 di.unresolved_name_state = 1;
6442 again:
6443 cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
6445 /* PR 87675 - Check for a mangled string that is so long
6446 that we do not have enough stack space to demangle it. */
6447 if (((options & DMGL_NO_RECURSE_LIMIT) == 0)
6448 /* This check is a bit arbitrary, since what we really want to do is to
6449 compare the sizes of the di.comps and di.subs arrays against the
6450 amount of stack space remaining. But there is no portable way to do
6451 this, so instead we use the recursion limit as a guide to the maximum
6452 size of the arrays. */
6453 && (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT)
6455 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6456 return 0;
6460 #ifdef CP_DYNAMIC_ARRAYS
6461 __extension__ struct demangle_component comps[di.num_comps];
6462 __extension__ struct demangle_component *subs[di.num_subs];
6464 di.comps = comps;
6465 di.subs = subs;
6466 #else
6467 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6468 di.subs = alloca (di.num_subs * sizeof (*di.subs));
6469 #endif
6471 switch (type)
6473 case DCT_TYPE:
6474 dc = cplus_demangle_type (&di);
6475 break;
6476 case DCT_MANGLED:
6477 dc = cplus_demangle_mangled_name (&di, 1);
6478 break;
6479 case DCT_GLOBAL_CTORS:
6480 case DCT_GLOBAL_DTORS:
6481 d_advance (&di, 11);
6482 dc = d_make_comp (&di,
6483 (type == DCT_GLOBAL_CTORS
6484 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6485 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
6486 d_make_demangle_mangled_name (&di, d_str (&di)),
6487 NULL);
6488 d_advance (&di, strlen (d_str (&di)));
6489 break;
6490 default:
6491 abort (); /* We have listed all the cases. */
6494 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6495 mangled string, then we didn't successfully demangle it. If
6496 DMGL_PARAMS is not set, we didn't look at the trailing
6497 parameters. */
6498 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
6499 dc = NULL;
6501 /* See discussion in d_unresolved_name. */
6502 if (dc == NULL && di.unresolved_name_state == -1)
6504 di.unresolved_name_state = 0;
6505 goto again;
6508 #ifdef CP_DEMANGLE_DEBUG
6509 d_dump (dc, 0);
6510 #endif
6512 status = (dc != NULL)
6513 ? cplus_demangle_print_callback (options, dc, callback, opaque)
6514 : 0;
6517 return status;
6520 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6521 name, return a buffer allocated with malloc holding the demangled
6522 name. OPTIONS is the usual libiberty demangler options. On
6523 success, this sets *PALC to the allocated size of the returned
6524 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6525 a memory allocation failure, and returns NULL. */
6527 static char *
6528 d_demangle (const char *mangled, int options, size_t *palc)
6530 struct d_growable_string dgs;
6531 int status;
6533 d_growable_string_init (&dgs, 0);
6535 status = d_demangle_callback (mangled, options,
6536 d_growable_string_callback_adapter, &dgs);
6537 if (status == 0)
6539 free (dgs.buf);
6540 *palc = 0;
6541 return NULL;
6544 *palc = dgs.allocation_failure ? 1 : dgs.alc;
6545 return dgs.buf;
6548 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6550 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6552 /* ia64 ABI-mandated entry point in the C++ runtime library for
6553 performing demangling. MANGLED_NAME is a NUL-terminated character
6554 string containing the name to be demangled.
6556 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6557 *LENGTH bytes, into which the demangled name is stored. If
6558 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6559 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6560 is placed in a region of memory allocated with malloc.
6562 If LENGTH is non-NULL, the length of the buffer containing the
6563 demangled name, is placed in *LENGTH.
6565 The return value is a pointer to the start of the NUL-terminated
6566 demangled name, or NULL if the demangling fails. The caller is
6567 responsible for deallocating this memory using free.
6569 *STATUS is set to one of the following values:
6570 0: The demangling operation succeeded.
6571 -1: A memory allocation failure occurred.
6572 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6573 -3: One of the arguments is invalid.
6575 The demangling is performed using the C++ ABI mangling rules, with
6576 GNU extensions. */
6578 char *
6579 __cxa_demangle (const char *mangled_name, char *output_buffer,
6580 size_t *length, int *status)
6582 char *demangled;
6583 size_t alc;
6585 if (mangled_name == NULL)
6587 if (status != NULL)
6588 *status = -3;
6589 return NULL;
6592 if (output_buffer != NULL && length == NULL)
6594 if (status != NULL)
6595 *status = -3;
6596 return NULL;
6599 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
6601 if (demangled == NULL)
6603 if (status != NULL)
6605 if (alc == 1)
6606 *status = -1;
6607 else
6608 *status = -2;
6610 return NULL;
6613 if (output_buffer == NULL)
6615 if (length != NULL)
6616 *length = alc;
6618 else
6620 if (strlen (demangled) < *length)
6622 strcpy (output_buffer, demangled);
6623 free (demangled);
6624 demangled = output_buffer;
6626 else
6628 free (output_buffer);
6629 *length = alc;
6633 if (status != NULL)
6634 *status = 0;
6636 return demangled;
6639 extern int __gcclibcxx_demangle_callback (const char *,
6640 void (*)
6641 (const char *, size_t, void *),
6642 void *);
6644 /* Alternative, allocationless entry point in the C++ runtime library
6645 for performing demangling. MANGLED_NAME is a NUL-terminated character
6646 string containing the name to be demangled.
6648 CALLBACK is a callback function, called with demangled string
6649 segments as demangling progresses; it is called at least once,
6650 but may be called more than once. OPAQUE is a generalized pointer
6651 used as a callback argument.
6653 The return code is one of the following values, equivalent to
6654 the STATUS values of __cxa_demangle() (excluding -1, since this
6655 function performs no memory allocations):
6656 0: The demangling operation succeeded.
6657 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6658 -3: One of the arguments is invalid.
6660 The demangling is performed using the C++ ABI mangling rules, with
6661 GNU extensions. */
6664 __gcclibcxx_demangle_callback (const char *mangled_name,
6665 void (*callback) (const char *, size_t, void *),
6666 void *opaque)
6668 int status;
6670 if (mangled_name == NULL || callback == NULL)
6671 return -3;
6673 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
6674 callback, opaque);
6675 if (status == 0)
6676 return -2;
6678 return 0;
6681 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6683 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6684 mangled name, return a buffer allocated with malloc holding the
6685 demangled name. Otherwise, return NULL. */
6687 char *
6688 cplus_demangle_v3 (const char *mangled, int options)
6690 size_t alc;
6692 return d_demangle (mangled, options, &alc);
6696 cplus_demangle_v3_callback (const char *mangled, int options,
6697 demangle_callbackref callback, void *opaque)
6699 return d_demangle_callback (mangled, options, callback, opaque);
6702 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6703 conventions, but the output formatting is a little different.
6704 This instructs the C++ demangler not to emit pointer characters ("*"), to
6705 use Java's namespace separator symbol ("." instead of "::"), and to output
6706 JArray<TYPE> as TYPE[]. */
6708 char *
6709 java_demangle_v3 (const char *mangled)
6711 size_t alc;
6713 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
6717 java_demangle_v3_callback (const char *mangled,
6718 demangle_callbackref callback, void *opaque)
6720 return d_demangle_callback (mangled,
6721 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
6722 callback, opaque);
6725 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6727 #ifndef IN_GLIBCPP_V3
6729 /* Demangle a string in order to find out whether it is a constructor
6730 or destructor. Return non-zero on success. Set *CTOR_KIND and
6731 *DTOR_KIND appropriately. */
6733 static int
6734 is_ctor_or_dtor (const char *mangled,
6735 enum gnu_v3_ctor_kinds *ctor_kind,
6736 enum gnu_v3_dtor_kinds *dtor_kind)
6738 struct d_info di;
6739 struct demangle_component *dc;
6740 int ret;
6742 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
6743 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
6745 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
6748 #ifdef CP_DYNAMIC_ARRAYS
6749 __extension__ struct demangle_component comps[di.num_comps];
6750 __extension__ struct demangle_component *subs[di.num_subs];
6752 di.comps = comps;
6753 di.subs = subs;
6754 #else
6755 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6756 di.subs = alloca (di.num_subs * sizeof (*di.subs));
6757 #endif
6759 dc = cplus_demangle_mangled_name (&di, 1);
6761 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6762 to demangle the entire string. */
6764 ret = 0;
6765 while (dc != NULL)
6767 switch (dc->type)
6769 /* These cannot appear on a constructor or destructor. */
6770 case DEMANGLE_COMPONENT_RESTRICT_THIS:
6771 case DEMANGLE_COMPONENT_VOLATILE_THIS:
6772 case DEMANGLE_COMPONENT_CONST_THIS:
6773 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6774 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6775 default:
6776 dc = NULL;
6777 break;
6778 case DEMANGLE_COMPONENT_TYPED_NAME:
6779 case DEMANGLE_COMPONENT_TEMPLATE:
6780 dc = d_left (dc);
6781 break;
6782 case DEMANGLE_COMPONENT_QUAL_NAME:
6783 case DEMANGLE_COMPONENT_LOCAL_NAME:
6784 dc = d_right (dc);
6785 break;
6786 case DEMANGLE_COMPONENT_CTOR:
6787 *ctor_kind = dc->u.s_ctor.kind;
6788 ret = 1;
6789 dc = NULL;
6790 break;
6791 case DEMANGLE_COMPONENT_DTOR:
6792 *dtor_kind = dc->u.s_dtor.kind;
6793 ret = 1;
6794 dc = NULL;
6795 break;
6800 return ret;
6803 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6804 name. A non-zero return indicates the type of constructor. */
6806 enum gnu_v3_ctor_kinds
6807 is_gnu_v3_mangled_ctor (const char *name)
6809 enum gnu_v3_ctor_kinds ctor_kind;
6810 enum gnu_v3_dtor_kinds dtor_kind;
6812 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6813 return (enum gnu_v3_ctor_kinds) 0;
6814 return ctor_kind;
6818 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6819 name. A non-zero return indicates the type of destructor. */
6821 enum gnu_v3_dtor_kinds
6822 is_gnu_v3_mangled_dtor (const char *name)
6824 enum gnu_v3_ctor_kinds ctor_kind;
6825 enum gnu_v3_dtor_kinds dtor_kind;
6827 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6828 return (enum gnu_v3_dtor_kinds) 0;
6829 return dtor_kind;
6832 #endif /* IN_GLIBCPP_V3 */
6834 #ifdef STANDALONE_DEMANGLER
6836 #include "getopt.h"
6837 #include "dyn-string.h"
6839 static void print_usage (FILE* fp, int exit_value);
6841 #define IS_ALPHA(CHAR) \
6842 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6843 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6845 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6846 #define is_mangled_char(CHAR) \
6847 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6848 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6850 /* The name of this program, as invoked. */
6851 const char* program_name;
6853 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6855 static void
6856 print_usage (FILE* fp, int exit_value)
6858 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
6859 fprintf (fp, "Options:\n");
6860 fprintf (fp, " -h,--help Display this message.\n");
6861 fprintf (fp, " -p,--no-params Don't display function parameters\n");
6862 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
6863 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6865 exit (exit_value);
6868 /* Option specification for getopt_long. */
6869 static const struct option long_options[] =
6871 { "help", no_argument, NULL, 'h' },
6872 { "no-params", no_argument, NULL, 'p' },
6873 { "verbose", no_argument, NULL, 'v' },
6874 { NULL, no_argument, NULL, 0 },
6877 /* Main entry for a demangling filter executable. It will demangle
6878 its command line arguments, if any. If none are provided, it will
6879 filter stdin to stdout, replacing any recognized mangled C++ names
6880 with their demangled equivalents. */
6883 main (int argc, char *argv[])
6885 int i;
6886 int opt_char;
6887 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
6889 /* Use the program name of this program, as invoked. */
6890 program_name = argv[0];
6892 /* Parse options. */
6895 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
6896 switch (opt_char)
6898 case '?': /* Unrecognized option. */
6899 print_usage (stderr, 1);
6900 break;
6902 case 'h':
6903 print_usage (stdout, 0);
6904 break;
6906 case 'p':
6907 options &= ~ DMGL_PARAMS;
6908 break;
6910 case 'v':
6911 options |= DMGL_VERBOSE;
6912 break;
6915 while (opt_char != -1);
6917 if (optind == argc)
6918 /* No command line arguments were provided. Filter stdin. */
6920 dyn_string_t mangled = dyn_string_new (3);
6921 char *s;
6923 /* Read all of input. */
6924 while (!feof (stdin))
6926 char c;
6928 /* Pile characters into mangled until we hit one that can't
6929 occur in a mangled name. */
6930 c = getchar ();
6931 while (!feof (stdin) && is_mangled_char (c))
6933 dyn_string_append_char (mangled, c);
6934 if (feof (stdin))
6935 break;
6936 c = getchar ();
6939 if (dyn_string_length (mangled) > 0)
6941 #ifdef IN_GLIBCPP_V3
6942 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
6943 #else
6944 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
6945 #endif
6947 if (s != NULL)
6949 fputs (s, stdout);
6950 free (s);
6952 else
6954 /* It might not have been a mangled name. Print the
6955 original text. */
6956 fputs (dyn_string_buf (mangled), stdout);
6959 dyn_string_clear (mangled);
6962 /* If we haven't hit EOF yet, we've read one character that
6963 can't occur in a mangled name, so print it out. */
6964 if (!feof (stdin))
6965 putchar (c);
6968 dyn_string_delete (mangled);
6970 else
6971 /* Demangle command line arguments. */
6973 /* Loop over command line arguments. */
6974 for (i = optind; i < argc; ++i)
6976 char *s;
6977 #ifdef IN_GLIBCPP_V3
6978 int status;
6979 #endif
6981 /* Attempt to demangle. */
6982 #ifdef IN_GLIBCPP_V3
6983 s = __cxa_demangle (argv[i], NULL, NULL, &status);
6984 #else
6985 s = cplus_demangle_v3 (argv[i], options);
6986 #endif
6988 /* If it worked, print the demangled name. */
6989 if (s != NULL)
6991 printf ("%s\n", s);
6992 free (s);
6994 else
6996 #ifdef IN_GLIBCPP_V3
6997 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
6998 #else
6999 fprintf (stderr, "Failed: %s\n", argv[i]);
7000 #endif
7005 return 0;
7008 #endif /* STANDALONE_DEMANGLER */