1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003-2019 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
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
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
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
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:
73 If defined, this file defines the following functions, q.v.:
74 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
76 int __gcclibcxx_demangle_callback (const char *,
78 (const char *, size_t, void *),
80 instead of cplus_demangle_v3[_callback]() and
81 java_demangle_v3[_callback]().
84 If defined, this file defines only __cxa_demangle() and
85 __gcclibcxx_demangle_callback(), and no other publically visible
86 functions or variables.
89 If defined, this file defines a main() function which demangles
90 any arguments, or, if none, demangles stdin.
93 If defined, turns on debugging mode, which prints information on
94 stdout about the mangled string. This is not generally useful.
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__)
123 # define alloca __builtin_alloca
125 extern char *alloca ();
126 # endif /* __GNUC__ */
128 #endif /* HAVE_ALLOCA_H */
134 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
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
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
155 d_fill_extended_operator (struct demangle_component
*, int,
156 struct demangle_component
*);
158 #define cplus_demangle_fill_ctor d_fill_ctor
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
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. */
191 #define CP_DYNAMIC_ARRAYS
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
207 As of this writing this file has the following undefined references
208 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
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. */
227 /* The simple string it expands to. */
228 const char *simple_expansion
;
229 /* The length of the simple expansion. */
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. */
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
;
256 const struct demangle_component
*template_decl
;
259 /* A list of type modifiers. This is used while printing. */
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
;
267 struct demangle_component
*mod
;
268 /* Whether this modifier was 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. */
280 /* Current length of data in buffer. */
282 /* Allocated size of buffer. */
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
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
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 };
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. */
333 /* The last character printed, saved individually so that it survives
336 /* Callback function to handle demangled buffer flush. */
337 demangle_callbackref callback
;
338 /* Opaque callback argument. */
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.),
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. */
350 /* Non-zero if we're printing a lambda argument. A template
351 parameter reference actually means 'auto'. */
353 /* The current index into any template argument packs we are using
354 for printing, or -1 to print the whole pack. */
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);
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);
421 has_return_type (struct demangle_component
*);
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
*);
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
*);
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);
510 d_growable_string_resize (struct d_growable_string
*, size_t);
513 d_growable_string_append_buffer (struct d_growable_string
*,
514 const char *, size_t);
516 d_growable_string_callback_adapter (const char *, size_t, 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
*);
538 d_print_comp (struct d_print_info
*, int, struct demangle_component
*);
541 d_print_java_identifier (struct d_print_info
*, const char *, int);
544 d_print_mod_list (struct d_print_info
*, int, struct d_print_mod
*, int);
547 d_print_mod (struct d_print_info
*, int, struct demangle_component
*);
550 d_print_function_type (struct d_print_info
*, int,
551 struct demangle_component
*,
552 struct d_print_mod
*);
555 d_print_array_type (struct d_print_info
*, int,
556 struct demangle_component
*,
557 struct d_print_mod
*);
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. */
585 is_fnqual_component_type (enum demangle_component_type type
)
589 FNQUAL_COMPONENT_CASE
:
598 #ifdef CP_DEMANGLE_DEBUG
601 d_dump (struct demangle_component
*dc
, int indent
)
608 printf ("failed demangling\n");
612 for (i
= 0; i
< indent
; ++i
)
617 case DEMANGLE_COMPONENT_NAME
:
618 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
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);
625 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
626 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
628 case DEMANGLE_COMPONENT_TPARM_OBJ
:
629 printf ("template parameter object\n");
631 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
632 printf ("function parameter %ld\n", dc
->u
.s_number
.number
);
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);
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);
642 case DEMANGLE_COMPONENT_SUB_STD
:
643 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
645 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
646 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
648 case DEMANGLE_COMPONENT_OPERATOR
:
649 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
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);
657 case DEMANGLE_COMPONENT_QUAL_NAME
:
658 printf ("qualified name\n");
660 case DEMANGLE_COMPONENT_LOCAL_NAME
:
661 printf ("local name\n");
663 case DEMANGLE_COMPONENT_TYPED_NAME
:
664 printf ("typed name\n");
666 case DEMANGLE_COMPONENT_TEMPLATE
:
667 printf ("template\n");
669 case DEMANGLE_COMPONENT_VTABLE
:
672 case DEMANGLE_COMPONENT_VTT
:
675 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
676 printf ("construction vtable\n");
678 case DEMANGLE_COMPONENT_TYPEINFO
:
679 printf ("typeinfo\n");
681 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
682 printf ("typeinfo name\n");
684 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
685 printf ("typeinfo function\n");
687 case DEMANGLE_COMPONENT_THUNK
:
690 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
691 printf ("virtual thunk\n");
693 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
694 printf ("covariant thunk\n");
696 case DEMANGLE_COMPONENT_JAVA_CLASS
:
697 printf ("java class\n");
699 case DEMANGLE_COMPONENT_GUARD
:
702 case DEMANGLE_COMPONENT_REFTEMP
:
703 printf ("reference temporary\n");
705 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
706 printf ("hidden alias\n");
708 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
709 printf ("transaction clone\n");
711 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
712 printf ("non-transaction clone\n");
714 case DEMANGLE_COMPONENT_RESTRICT
:
715 printf ("restrict\n");
717 case DEMANGLE_COMPONENT_VOLATILE
:
718 printf ("volatile\n");
720 case DEMANGLE_COMPONENT_CONST
:
723 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
724 printf ("restrict this\n");
726 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
727 printf ("volatile this\n");
729 case DEMANGLE_COMPONENT_CONST_THIS
:
730 printf ("const this\n");
732 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
733 printf ("reference this\n");
735 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
736 printf ("rvalue reference this\n");
738 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
739 printf ("transaction_safe this\n");
741 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
742 printf ("vendor type qualifier\n");
744 case DEMANGLE_COMPONENT_POINTER
:
745 printf ("pointer\n");
747 case DEMANGLE_COMPONENT_REFERENCE
:
748 printf ("reference\n");
750 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
751 printf ("rvalue reference\n");
753 case DEMANGLE_COMPONENT_COMPLEX
:
754 printf ("complex\n");
756 case DEMANGLE_COMPONENT_IMAGINARY
:
757 printf ("imaginary\n");
759 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
760 printf ("vendor type\n");
762 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
763 printf ("function type\n");
765 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
766 printf ("array type\n");
768 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
769 printf ("pointer to member type\n");
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);
776 case DEMANGLE_COMPONENT_ARGLIST
:
777 printf ("argument list\n");
779 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
780 printf ("template argument list\n");
782 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
783 printf ("initializer list\n");
785 case DEMANGLE_COMPONENT_CAST
:
788 case DEMANGLE_COMPONENT_CONVERSION
:
789 printf ("conversion operator\n");
791 case DEMANGLE_COMPONENT_NULLARY
:
792 printf ("nullary operator\n");
794 case DEMANGLE_COMPONENT_UNARY
:
795 printf ("unary operator\n");
797 case DEMANGLE_COMPONENT_BINARY
:
798 printf ("binary operator\n");
800 case DEMANGLE_COMPONENT_BINARY_ARGS
:
801 printf ("binary operator arguments\n");
803 case DEMANGLE_COMPONENT_TRINARY
:
804 printf ("trinary operator\n");
806 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
807 printf ("trinary operator arguments 1\n");
809 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
810 printf ("trinary operator arguments 1\n");
812 case DEMANGLE_COMPONENT_LITERAL
:
813 printf ("literal\n");
815 case DEMANGLE_COMPONENT_LITERAL_NEG
:
816 printf ("negative literal\n");
818 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
819 printf ("java resource\n");
821 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
822 printf ("compound name\n");
824 case DEMANGLE_COMPONENT_CHARACTER
:
825 printf ("character '%c'\n", dc
->u
.s_character
.character
);
827 case DEMANGLE_COMPONENT_NUMBER
:
828 printf ("number %ld\n", dc
->u
.s_number
.number
);
830 case DEMANGLE_COMPONENT_DECLTYPE
:
831 printf ("decltype\n");
833 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
834 printf ("pack expansion\n");
836 case DEMANGLE_COMPONENT_TLS_INIT
:
837 printf ("tls init function\n");
839 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
840 printf ("tls wrapper function\n");
842 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
843 printf ("default argument %d\n", dc
->u
.s_unary_num
.num
);
844 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
846 case DEMANGLE_COMPONENT_LAMBDA
:
847 printf ("lambda %d\n", dc
->u
.s_unary_num
.num
);
848 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
852 d_dump (d_left (dc
), indent
+ 2);
853 d_dump (d_right (dc
), indent
+ 2);
856 #endif /* CP_DEMANGLE_DEBUG */
858 /* Fill in a DEMANGLE_COMPONENT_NAME. */
860 CP_STATIC_IF_GLIBCPP_V3
862 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
864 if (p
== NULL
|| s
== NULL
|| len
<= 0)
868 p
->type
= DEMANGLE_COMPONENT_NAME
;
870 p
->u
.s_name
.len
= len
;
874 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
876 CP_STATIC_IF_GLIBCPP_V3
878 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
879 struct demangle_component
*name
)
881 if (p
== NULL
|| args
< 0 || name
== NULL
)
885 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
886 p
->u
.s_extended_operator
.args
= args
;
887 p
->u
.s_extended_operator
.name
= name
;
891 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
893 CP_STATIC_IF_GLIBCPP_V3
895 cplus_demangle_fill_ctor (struct demangle_component
*p
,
896 enum gnu_v3_ctor_kinds kind
,
897 struct demangle_component
*name
)
901 || (int) kind
< gnu_v3_complete_object_ctor
902 || (int) kind
> gnu_v3_object_ctor_group
)
906 p
->type
= DEMANGLE_COMPONENT_CTOR
;
907 p
->u
.s_ctor
.kind
= kind
;
908 p
->u
.s_ctor
.name
= name
;
912 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
914 CP_STATIC_IF_GLIBCPP_V3
916 cplus_demangle_fill_dtor (struct demangle_component
*p
,
917 enum gnu_v3_dtor_kinds kind
,
918 struct demangle_component
*name
)
922 || (int) kind
< gnu_v3_deleting_dtor
923 || (int) kind
> gnu_v3_object_dtor_group
)
927 p
->type
= DEMANGLE_COMPONENT_DTOR
;
928 p
->u
.s_dtor
.kind
= kind
;
929 p
->u
.s_dtor
.name
= name
;
933 /* Add a new component. */
935 static struct demangle_component
*
936 d_make_empty (struct d_info
*di
)
938 struct demangle_component
*p
;
940 if (di
->next_comp
>= di
->num_comps
)
942 p
= &di
->comps
[di
->next_comp
];
949 /* Add a new generic component. */
951 static struct demangle_component
*
952 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
953 struct demangle_component
*left
,
954 struct demangle_component
*right
)
956 struct demangle_component
*p
;
958 /* We check for errors here. A typical error would be a NULL return
959 from a subroutine. We catch those here, and return NULL
963 /* These types require two parameters. */
964 case DEMANGLE_COMPONENT_QUAL_NAME
:
965 case DEMANGLE_COMPONENT_LOCAL_NAME
:
966 case DEMANGLE_COMPONENT_TYPED_NAME
:
967 case DEMANGLE_COMPONENT_TAGGED_NAME
:
968 case DEMANGLE_COMPONENT_TEMPLATE
:
969 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
970 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
971 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
972 case DEMANGLE_COMPONENT_UNARY
:
973 case DEMANGLE_COMPONENT_BINARY
:
974 case DEMANGLE_COMPONENT_BINARY_ARGS
:
975 case DEMANGLE_COMPONENT_TRINARY
:
976 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
977 case DEMANGLE_COMPONENT_LITERAL
:
978 case DEMANGLE_COMPONENT_LITERAL_NEG
:
979 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
980 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
981 case DEMANGLE_COMPONENT_CLONE
:
982 if (left
== NULL
|| right
== NULL
)
986 /* These types only require one parameter. */
987 case DEMANGLE_COMPONENT_VTABLE
:
988 case DEMANGLE_COMPONENT_VTT
:
989 case DEMANGLE_COMPONENT_TYPEINFO
:
990 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
991 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
992 case DEMANGLE_COMPONENT_THUNK
:
993 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
994 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
995 case DEMANGLE_COMPONENT_JAVA_CLASS
:
996 case DEMANGLE_COMPONENT_GUARD
:
997 case DEMANGLE_COMPONENT_TLS_INIT
:
998 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
999 case DEMANGLE_COMPONENT_REFTEMP
:
1000 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
1001 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
1002 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
1003 case DEMANGLE_COMPONENT_POINTER
:
1004 case DEMANGLE_COMPONENT_REFERENCE
:
1005 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
1006 case DEMANGLE_COMPONENT_COMPLEX
:
1007 case DEMANGLE_COMPONENT_IMAGINARY
:
1008 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
1009 case DEMANGLE_COMPONENT_CAST
:
1010 case DEMANGLE_COMPONENT_CONVERSION
:
1011 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
1012 case DEMANGLE_COMPONENT_DECLTYPE
:
1013 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
1014 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
1015 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
1016 case DEMANGLE_COMPONENT_NULLARY
:
1017 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
1018 case DEMANGLE_COMPONENT_TPARM_OBJ
:
1023 /* This needs a right parameter, but the left parameter can be
1025 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
1026 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
1031 /* These are allowed to have no parameters--in some cases they
1032 will be filled in later. */
1033 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
1034 case DEMANGLE_COMPONENT_RESTRICT
:
1035 case DEMANGLE_COMPONENT_VOLATILE
:
1036 case DEMANGLE_COMPONENT_CONST
:
1037 case DEMANGLE_COMPONENT_ARGLIST
:
1038 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
1039 FNQUAL_COMPONENT_CASE
:
1042 /* Other types should not be seen here. */
1047 p
= d_make_empty (di
);
1051 p
->u
.s_binary
.left
= left
;
1052 p
->u
.s_binary
.right
= right
;
1057 /* Add a new demangle mangled name component. */
1059 static struct demangle_component
*
1060 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
1062 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
1063 return d_make_name (di
, s
, strlen (s
));
1065 return d_encoding (di
, 0);
1068 /* Add a new name component. */
1070 static struct demangle_component
*
1071 d_make_name (struct d_info
*di
, const char *s
, int len
)
1073 struct demangle_component
*p
;
1075 p
= d_make_empty (di
);
1076 if (! cplus_demangle_fill_name (p
, s
, len
))
1081 /* Add a new builtin type component. */
1083 static struct demangle_component
*
1084 d_make_builtin_type (struct d_info
*di
,
1085 const struct demangle_builtin_type_info
*type
)
1087 struct demangle_component
*p
;
1091 p
= d_make_empty (di
);
1094 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
1095 p
->u
.s_builtin
.type
= type
;
1100 /* Add a new operator component. */
1102 static struct demangle_component
*
1103 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
1105 struct demangle_component
*p
;
1107 p
= d_make_empty (di
);
1110 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
1111 p
->u
.s_operator
.op
= op
;
1116 /* Add a new extended operator component. */
1118 static struct demangle_component
*
1119 d_make_extended_operator (struct d_info
*di
, int args
,
1120 struct demangle_component
*name
)
1122 struct demangle_component
*p
;
1124 p
= d_make_empty (di
);
1125 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
1130 static struct demangle_component
*
1131 d_make_default_arg (struct d_info
*di
, int num
,
1132 struct demangle_component
*sub
)
1134 struct demangle_component
*p
= d_make_empty (di
);
1137 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
1138 p
->u
.s_unary_num
.num
= num
;
1139 p
->u
.s_unary_num
.sub
= sub
;
1144 /* Add a new constructor component. */
1146 static struct demangle_component
*
1147 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
1148 struct demangle_component
*name
)
1150 struct demangle_component
*p
;
1152 p
= d_make_empty (di
);
1153 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
1158 /* Add a new destructor component. */
1160 static struct demangle_component
*
1161 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
1162 struct demangle_component
*name
)
1164 struct demangle_component
*p
;
1166 p
= d_make_empty (di
);
1167 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
1172 /* Add a new template parameter. */
1174 static struct demangle_component
*
1175 d_make_template_param (struct d_info
*di
, int i
)
1177 struct demangle_component
*p
;
1179 p
= d_make_empty (di
);
1182 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
1183 p
->u
.s_number
.number
= i
;
1188 /* Add a new function parameter. */
1190 static struct demangle_component
*
1191 d_make_function_param (struct d_info
*di
, int i
)
1193 struct demangle_component
*p
;
1195 p
= d_make_empty (di
);
1198 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1199 p
->u
.s_number
.number
= i
;
1204 /* Add a new standard substitution component. */
1206 static struct demangle_component
*
1207 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1209 struct demangle_component
*p
;
1211 p
= d_make_empty (di
);
1214 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1215 p
->u
.s_string
.string
= name
;
1216 p
->u
.s_string
.len
= len
;
1221 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1223 TOP_LEVEL is non-zero when called at the top level. */
1225 CP_STATIC_IF_GLIBCPP_V3
1226 struct demangle_component
*
1227 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1229 struct demangle_component
*p
;
1231 if (! d_check_char (di
, '_')
1232 /* Allow missing _ if not at toplevel to work around a
1233 bug in G++ abi-version=2 mangling; see the comment in
1234 write_template_arg. */
1237 if (! d_check_char (di
, 'Z'))
1239 p
= d_encoding (di
, top_level
);
1241 /* If at top level and parsing parameters, check for a clone
1243 if (top_level
&& (di
->options
& DMGL_PARAMS
) != 0)
1244 while (d_peek_char (di
) == '.'
1245 && (IS_LOWER (d_peek_next_char (di
))
1246 || d_peek_next_char (di
) == '_'
1247 || IS_DIGIT (d_peek_next_char (di
))))
1248 p
= d_clone_suffix (di
, p
);
1253 /* Return whether a function should have a return type. The argument
1254 is the function name, which may be qualified in various ways. The
1255 rules are that template functions have return types with some
1256 exceptions, function types which are not part of a function name
1257 mangling have return types with some exceptions, and non-template
1258 function names do not have return types. The exceptions are that
1259 constructors, destructors, and conversion operators do not have
1263 has_return_type (struct demangle_component
*dc
)
1271 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1272 return has_return_type (d_right (dc
));
1273 case DEMANGLE_COMPONENT_TEMPLATE
:
1274 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1275 FNQUAL_COMPONENT_CASE
:
1276 return has_return_type (d_left (dc
));
1280 /* Return whether a name is a constructor, a destructor, or a
1281 conversion operator. */
1284 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1292 case DEMANGLE_COMPONENT_QUAL_NAME
:
1293 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1294 return is_ctor_dtor_or_conversion (d_right (dc
));
1295 case DEMANGLE_COMPONENT_CTOR
:
1296 case DEMANGLE_COMPONENT_DTOR
:
1297 case DEMANGLE_COMPONENT_CONVERSION
:
1302 /* <encoding> ::= <(function) name> <bare-function-type>
1306 TOP_LEVEL is non-zero when called at the top level, in which case
1307 if DMGL_PARAMS is not set we do not demangle the function
1308 parameters. We only set this at the top level, because otherwise
1309 we would not correctly demangle names in local scopes. */
1311 static struct demangle_component
*
1312 d_encoding (struct d_info
*di
, int top_level
)
1314 char peek
= d_peek_char (di
);
1315 struct demangle_component
*dc
;
1317 if (peek
== 'G' || peek
== 'T')
1318 dc
= d_special_name (di
);
1324 /* Failed already. */;
1325 else if (top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1327 /* Strip off any initial CV-qualifiers, as they really apply
1328 to the `this' parameter, and they were not output by the
1329 v2 demangler without DMGL_PARAMS. */
1330 while (is_fnqual_component_type (dc
->type
))
1333 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1334 there may be function-qualifiers on its right argument which
1335 really apply here; this happens when parsing a class
1336 which is local to a function. */
1337 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1339 while (d_right (dc
) != NULL
1340 && is_fnqual_component_type (d_right (dc
)->type
))
1341 d_right (dc
) = d_left (d_right (dc
));
1343 if (d_right (dc
) == NULL
)
1349 peek
= d_peek_char (di
);
1350 if (peek
!= '\0' && peek
!= 'E')
1352 struct demangle_component
*ftype
;
1354 ftype
= d_bare_function_type (di
, has_return_type (dc
));
1357 /* If this is a non-top-level local-name, clear the
1358 return type, so it doesn't confuse the user by
1359 being confused with the return type of whaever
1360 this is nested within. */
1361 if (!top_level
&& dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
1362 && ftype
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
1363 d_left (ftype
) = NULL
;
1365 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
,
1377 /* <tagged-name> ::= <name> B <source-name> */
1379 static struct demangle_component
*
1380 d_abi_tags (struct d_info
*di
, struct demangle_component
*dc
)
1382 struct demangle_component
*hold_last_name
;
1385 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1386 hold_last_name
= di
->last_name
;
1388 while (peek
= d_peek_char (di
),
1391 struct demangle_component
*tag
;
1393 tag
= d_source_name (di
);
1394 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TAGGED_NAME
, dc
, tag
);
1397 di
->last_name
= hold_last_name
;
1402 /* <name> ::= <nested-name>
1404 ::= <unscoped-template-name> <template-args>
1407 <unscoped-name> ::= <unqualified-name>
1408 ::= St <unqualified-name>
1410 <unscoped-template-name> ::= <unscoped-name>
1414 static struct demangle_component
*
1415 d_name (struct d_info
*di
)
1417 char peek
= d_peek_char (di
);
1418 struct demangle_component
*dc
;
1423 return d_nested_name (di
);
1426 return d_local_name (di
);
1429 return d_unqualified_name (di
);
1435 if (d_peek_next_char (di
) != 't')
1437 dc
= d_substitution (di
, 0);
1443 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1444 d_make_name (di
, "std", 3),
1445 d_unqualified_name (di
));
1450 if (d_peek_char (di
) != 'I')
1452 /* The grammar does not permit this case to occur if we
1453 called d_substitution() above (i.e., subst == 1). We
1454 don't bother to check. */
1458 /* This is <template-args>, which means that we just saw
1459 <unscoped-template-name>, which is a substitution
1460 candidate if we didn't just get it from a
1464 if (! d_add_substitution (di
, dc
))
1467 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1468 d_template_args (di
));
1476 dc
= d_unqualified_name (di
);
1477 if (d_peek_char (di
) == 'I')
1479 /* This is <template-args>, which means that we just saw
1480 <unscoped-template-name>, which is a substitution
1482 if (! d_add_substitution (di
, dc
))
1484 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1485 d_template_args (di
));
1491 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1492 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1495 static struct demangle_component
*
1496 d_nested_name (struct d_info
*di
)
1498 struct demangle_component
*ret
;
1499 struct demangle_component
**pret
;
1500 struct demangle_component
*rqual
;
1502 if (! d_check_char (di
, 'N'))
1505 pret
= d_cv_qualifiers (di
, &ret
, 1);
1509 /* Parse the ref-qualifier now and then attach it
1510 once we have something to attach it to. */
1511 rqual
= d_ref_qualifier (di
, NULL
);
1513 *pret
= d_prefix (di
);
1519 d_left (rqual
) = ret
;
1523 if (! d_check_char (di
, 'E'))
1529 /* <prefix> ::= <prefix> <unqualified-name>
1530 ::= <template-prefix> <template-args>
1531 ::= <template-param>
1536 <template-prefix> ::= <prefix> <(template) unqualified-name>
1537 ::= <template-param>
1541 static struct demangle_component
*
1542 d_prefix (struct d_info
*di
)
1544 struct demangle_component
*ret
= NULL
;
1549 enum demangle_component_type comb_type
;
1550 struct demangle_component
*dc
;
1552 peek
= d_peek_char (di
);
1556 /* The older code accepts a <local-name> here, but I don't see
1557 that in the grammar. The older code does not accept a
1558 <template-param> here. */
1560 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1563 char peek2
= d_peek_next_char (di
);
1564 if (peek2
== 'T' || peek2
== 't')
1566 dc
= cplus_demangle_type (di
);
1568 /* Destructor name. */
1569 dc
= d_unqualified_name (di
);
1571 else if (IS_DIGIT (peek
)
1576 dc
= d_unqualified_name (di
);
1577 else if (peek
== 'S')
1578 dc
= d_substitution (di
, 1);
1579 else if (peek
== 'I')
1583 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1584 dc
= d_template_args (di
);
1586 else if (peek
== 'T')
1587 dc
= d_template_param (di
);
1588 else if (peek
== 'E')
1590 else if (peek
== 'M')
1592 /* Initializer scope for a lambda. We don't need to represent
1593 this; the normal code will just treat the variable as a type
1594 scope, which gives appropriate output. */
1606 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1608 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1610 if (! d_add_substitution (di
, ret
))
1616 /* <unqualified-name> ::= <operator-name>
1617 ::= <ctor-dtor-name>
1619 ::= <local-source-name>
1621 <local-source-name> ::= L <source-name> <discriminator>
1624 static struct demangle_component
*
1625 d_unqualified_name (struct d_info
*di
)
1627 struct demangle_component
*ret
;
1630 peek
= d_peek_char (di
);
1631 if (IS_DIGIT (peek
))
1632 ret
= d_source_name (di
);
1633 else if (IS_LOWER (peek
))
1635 if (peek
== 'o' && d_peek_next_char (di
) == 'n')
1637 ret
= d_operator_name (di
);
1638 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1640 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1641 if (!strcmp (ret
->u
.s_operator
.op
->code
, "li"))
1642 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, ret
,
1643 d_source_name (di
));
1646 else if (peek
== 'C' || peek
== 'D')
1647 ret
= d_ctor_dtor_name (di
);
1648 else if (peek
== 'L')
1652 ret
= d_source_name (di
);
1655 if (! d_discriminator (di
))
1658 else if (peek
== 'U')
1660 switch (d_peek_next_char (di
))
1663 ret
= d_lambda (di
);
1666 ret
= d_unnamed_type (di
);
1675 if (d_peek_char (di
) == 'B')
1676 ret
= d_abi_tags (di
, ret
);
1680 /* <source-name> ::= <(positive length) number> <identifier> */
1682 static struct demangle_component
*
1683 d_source_name (struct d_info
*di
)
1686 struct demangle_component
*ret
;
1688 len
= d_number (di
);
1691 ret
= d_identifier (di
, len
);
1692 di
->last_name
= ret
;
1696 /* number ::= [n] <(non-negative decimal integer)> */
1699 d_number (struct d_info
*di
)
1706 peek
= d_peek_char (di
);
1711 peek
= d_peek_char (di
);
1717 if (! IS_DIGIT (peek
))
1723 if (ret
> ((INT_MAX
- (peek
- '0')) / 10))
1725 ret
= ret
* 10 + (peek
- '0');
1727 peek
= d_peek_char (di
);
1731 /* Like d_number, but returns a demangle_component. */
1733 static struct demangle_component
*
1734 d_number_component (struct d_info
*di
)
1736 struct demangle_component
*ret
= d_make_empty (di
);
1739 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1740 ret
->u
.s_number
.number
= d_number (di
);
1745 /* identifier ::= <(unqualified source code identifier)> */
1747 static struct demangle_component
*
1748 d_identifier (struct d_info
*di
, int len
)
1754 if (di
->send
- name
< len
)
1757 d_advance (di
, len
);
1759 /* A Java mangled name may have a trailing '$' if it is a C++
1760 keyword. This '$' is not included in the length count. We just
1762 if ((di
->options
& DMGL_JAVA
) != 0
1763 && d_peek_char (di
) == '$')
1766 /* Look for something which looks like a gcc encoding of an
1767 anonymous namespace, and replace it with a more user friendly
1769 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1770 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1771 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1775 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1776 if ((*s
== '.' || *s
== '_' || *s
== '$')
1779 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1780 return d_make_name (di
, "(anonymous namespace)",
1781 sizeof "(anonymous namespace)" - 1);
1785 return d_make_name (di
, name
, len
);
1788 /* operator_name ::= many different two character encodings.
1790 ::= v <digit> <source-name>
1792 This list is sorted for binary search. */
1794 #define NL(s) s, (sizeof s) - 1
1796 CP_STATIC_IF_GLIBCPP_V3
1797 const struct demangle_operator_info cplus_demangle_operators
[] =
1799 { "aN", NL ("&="), 2 },
1800 { "aS", NL ("="), 2 },
1801 { "aa", NL ("&&"), 2 },
1802 { "ad", NL ("&"), 1 },
1803 { "an", NL ("&"), 2 },
1804 { "at", NL ("alignof "), 1 },
1805 { "az", NL ("alignof "), 1 },
1806 { "cc", NL ("const_cast"), 2 },
1807 { "cl", NL ("()"), 2 },
1808 { "cm", NL (","), 2 },
1809 { "co", NL ("~"), 1 },
1810 { "dV", NL ("/="), 2 },
1811 { "da", NL ("delete[] "), 1 },
1812 { "dc", NL ("dynamic_cast"), 2 },
1813 { "de", NL ("*"), 1 },
1814 { "dl", NL ("delete "), 1 },
1815 { "ds", NL (".*"), 2 },
1816 { "dt", NL ("."), 2 },
1817 { "dv", NL ("/"), 2 },
1818 { "eO", NL ("^="), 2 },
1819 { "eo", NL ("^"), 2 },
1820 { "eq", NL ("=="), 2 },
1821 { "fL", NL ("..."), 3 },
1822 { "fR", NL ("..."), 3 },
1823 { "fl", NL ("..."), 2 },
1824 { "fr", NL ("..."), 2 },
1825 { "ge", NL (">="), 2 },
1826 { "gs", NL ("::"), 1 },
1827 { "gt", NL (">"), 2 },
1828 { "ix", NL ("[]"), 2 },
1829 { "lS", NL ("<<="), 2 },
1830 { "le", NL ("<="), 2 },
1831 { "li", NL ("operator\"\" "), 1 },
1832 { "ls", NL ("<<"), 2 },
1833 { "lt", NL ("<"), 2 },
1834 { "mI", NL ("-="), 2 },
1835 { "mL", NL ("*="), 2 },
1836 { "mi", NL ("-"), 2 },
1837 { "ml", NL ("*"), 2 },
1838 { "mm", NL ("--"), 1 },
1839 { "na", NL ("new[]"), 3 },
1840 { "ne", NL ("!="), 2 },
1841 { "ng", NL ("-"), 1 },
1842 { "nt", NL ("!"), 1 },
1843 { "nw", NL ("new"), 3 },
1844 { "oR", NL ("|="), 2 },
1845 { "oo", NL ("||"), 2 },
1846 { "or", NL ("|"), 2 },
1847 { "pL", NL ("+="), 2 },
1848 { "pl", NL ("+"), 2 },
1849 { "pm", NL ("->*"), 2 },
1850 { "pp", NL ("++"), 1 },
1851 { "ps", NL ("+"), 1 },
1852 { "pt", NL ("->"), 2 },
1853 { "qu", NL ("?"), 3 },
1854 { "rM", NL ("%="), 2 },
1855 { "rS", NL (">>="), 2 },
1856 { "rc", NL ("reinterpret_cast"), 2 },
1857 { "rm", NL ("%"), 2 },
1858 { "rs", NL (">>"), 2 },
1859 { "sP", NL ("sizeof..."), 1 },
1860 { "sZ", NL ("sizeof..."), 1 },
1861 { "sc", NL ("static_cast"), 2 },
1862 { "st", NL ("sizeof "), 1 },
1863 { "sz", NL ("sizeof "), 1 },
1864 { "tr", NL ("throw"), 0 },
1865 { "tw", NL ("throw "), 1 },
1866 { NULL
, NULL
, 0, 0 }
1869 static struct demangle_component
*
1870 d_operator_name (struct d_info
*di
)
1875 c1
= d_next_char (di
);
1876 c2
= d_next_char (di
);
1877 if (c1
== 'v' && IS_DIGIT (c2
))
1878 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1879 else if (c1
== 'c' && c2
== 'v')
1881 struct demangle_component
*type
;
1882 int was_conversion
= di
->is_conversion
;
1883 struct demangle_component
*res
;
1885 di
->is_conversion
= ! di
->is_expression
;
1886 type
= cplus_demangle_type (di
);
1887 if (di
->is_conversion
)
1888 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CONVERSION
, type
, NULL
);
1890 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CAST
, type
, NULL
);
1891 di
->is_conversion
= was_conversion
;
1896 /* LOW is the inclusive lower bound. */
1898 /* HIGH is the exclusive upper bound. We subtract one to ignore
1899 the sentinel at the end of the array. */
1900 int high
= ((sizeof (cplus_demangle_operators
)
1901 / sizeof (cplus_demangle_operators
[0]))
1907 const struct demangle_operator_info
*p
;
1909 i
= low
+ (high
- low
) / 2;
1910 p
= cplus_demangle_operators
+ i
;
1912 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1913 return d_make_operator (di
, p
);
1915 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1925 static struct demangle_component
*
1926 d_make_character (struct d_info
*di
, int c
)
1928 struct demangle_component
*p
;
1929 p
= d_make_empty (di
);
1932 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1933 p
->u
.s_character
.character
= c
;
1938 static struct demangle_component
*
1939 d_java_resource (struct d_info
*di
)
1941 struct demangle_component
*p
= NULL
;
1942 struct demangle_component
*next
= NULL
;
1947 len
= d_number (di
);
1951 /* Eat the leading '_'. */
1952 if (d_next_char (di
) != '_')
1965 /* Each chunk is either a '$' escape... */
1983 next
= d_make_character (di
, c
);
1991 /* ... or a sequence of characters. */
1994 while (i
< len
&& str
[i
] && str
[i
] != '$')
1997 next
= d_make_name (di
, str
, i
);
2010 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
2016 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
2021 /* <special-name> ::= TV <type>
2025 ::= TA <template-arg>
2026 ::= GV <(object) name>
2027 ::= T <call-offset> <(base) encoding>
2028 ::= Tc <call-offset> <call-offset> <(base) encoding>
2029 Also g++ extensions:
2030 ::= TC <type> <(offset) number> _ <(base) type>
2035 ::= Gr <resource name>
2040 static struct demangle_component
*
2041 d_special_name (struct d_info
*di
)
2043 di
->expansion
+= 20;
2044 if (d_check_char (di
, 'T'))
2046 switch (d_next_char (di
))
2050 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
2051 cplus_demangle_type (di
), NULL
);
2053 di
->expansion
-= 10;
2054 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
2055 cplus_demangle_type (di
), NULL
);
2057 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
2058 cplus_demangle_type (di
), NULL
);
2060 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
2061 cplus_demangle_type (di
), NULL
);
2064 if (! d_call_offset (di
, 'h'))
2066 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
2067 d_encoding (di
, 0), NULL
);
2070 if (! d_call_offset (di
, 'v'))
2072 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
2073 d_encoding (di
, 0), NULL
);
2076 if (! d_call_offset (di
, '\0'))
2078 if (! d_call_offset (di
, '\0'))
2080 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
2081 d_encoding (di
, 0), NULL
);
2085 struct demangle_component
*derived_type
;
2087 struct demangle_component
*base_type
;
2089 derived_type
= cplus_demangle_type (di
);
2090 offset
= d_number (di
);
2093 if (! d_check_char (di
, '_'))
2095 base_type
= cplus_demangle_type (di
);
2096 /* We don't display the offset. FIXME: We should display
2097 it in verbose mode. */
2099 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
2100 base_type
, derived_type
);
2104 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
2105 cplus_demangle_type (di
), NULL
);
2107 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
2108 cplus_demangle_type (di
), NULL
);
2111 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
2115 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
2119 return d_make_comp (di
, DEMANGLE_COMPONENT_TPARM_OBJ
,
2120 d_template_arg (di
), NULL
);
2126 else if (d_check_char (di
, 'G'))
2128 switch (d_next_char (di
))
2131 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
,
2136 struct demangle_component
*name
= d_name (di
);
2137 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
2138 d_number_component (di
));
2142 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
2143 d_encoding (di
, 0), NULL
);
2146 switch (d_next_char (di
))
2149 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
2150 d_encoding (di
, 0), NULL
);
2152 /* ??? The proposal is that other letters (such as 'h') stand
2153 for different variants of transaction cloning, such as
2154 compiling directly for hardware transaction support. But
2155 they still should all be transactional clones of some sort
2156 so go ahead and call them that. */
2158 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
2159 d_encoding (di
, 0), NULL
);
2163 return d_java_resource (di
);
2173 /* <call-offset> ::= h <nv-offset> _
2176 <nv-offset> ::= <(offset) number>
2178 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2180 The C parameter, if not '\0', is a character we just read which is
2181 the start of the <call-offset>.
2183 We don't display the offset information anywhere. FIXME: We should
2184 display it in verbose mode. */
2187 d_call_offset (struct d_info
*di
, int c
)
2190 c
= d_next_char (di
);
2197 if (! d_check_char (di
, '_'))
2204 if (! d_check_char (di
, '_'))
2210 /* <ctor-dtor-name> ::= C1
2218 static struct demangle_component
*
2219 d_ctor_dtor_name (struct d_info
*di
)
2221 if (di
->last_name
!= NULL
)
2223 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2224 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2225 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2226 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2228 switch (d_peek_char (di
))
2232 enum gnu_v3_ctor_kinds kind
;
2235 if (d_peek_next_char (di
) == 'I')
2241 switch (d_peek_next_char (di
))
2244 kind
= gnu_v3_complete_object_ctor
;
2247 kind
= gnu_v3_base_object_ctor
;
2250 kind
= gnu_v3_complete_object_allocating_ctor
;
2253 kind
= gnu_v3_unified_ctor
;
2256 kind
= gnu_v3_object_ctor_group
;
2265 cplus_demangle_type (di
);
2267 return d_make_ctor (di
, kind
, di
->last_name
);
2272 enum gnu_v3_dtor_kinds kind
;
2274 switch (d_peek_next_char (di
))
2277 kind
= gnu_v3_deleting_dtor
;
2280 kind
= gnu_v3_complete_object_dtor
;
2283 kind
= gnu_v3_base_object_dtor
;
2285 /* digit '3' is not used */
2287 kind
= gnu_v3_unified_dtor
;
2290 kind
= gnu_v3_object_dtor_group
;
2296 return d_make_dtor (di
, kind
, di
->last_name
);
2304 /* True iff we're looking at an order-insensitive type-qualifier, including
2305 function-type-qualifiers. */
2308 next_is_type_qual (struct d_info
*di
)
2310 char peek
= d_peek_char (di
);
2311 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2315 peek
= d_peek_next_char (di
);
2316 if (peek
== 'x' || peek
== 'o' || peek
== 'O' || peek
== 'w')
2322 /* <type> ::= <builtin-type>
2324 ::= <class-enum-type>
2326 ::= <pointer-to-member-type>
2327 ::= <template-param>
2328 ::= <template-template-param> <template-args>
2330 ::= <CV-qualifiers> <type>
2333 ::= O <type> (C++0x)
2336 ::= U <source-name> <type>
2338 <builtin-type> ::= various one letter codes
2342 CP_STATIC_IF_GLIBCPP_V3
2343 const struct demangle_builtin_type_info
2344 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2346 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2347 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2348 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2349 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2350 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2351 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2352 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2353 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2354 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2355 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2356 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2357 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2358 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2359 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2360 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2362 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2363 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2364 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2365 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2366 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2367 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2368 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2369 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2370 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2371 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2372 D_PRINT_UNSIGNED_LONG_LONG
},
2373 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2374 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2375 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2376 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2377 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2378 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT
},
2379 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2380 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2381 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2385 CP_STATIC_IF_GLIBCPP_V3
2386 struct demangle_component
*
2387 cplus_demangle_type (struct d_info
*di
)
2390 struct demangle_component
*ret
;
2393 /* The ABI specifies that when CV-qualifiers are used, the base type
2394 is substitutable, and the fully qualified type is substitutable,
2395 but the base type with a strict subset of the CV-qualifiers is
2396 not substitutable. The natural recursive implementation of the
2397 CV-qualifiers would cause subsets to be substitutable, so instead
2398 we pull them all off now.
2400 FIXME: The ABI says that order-insensitive vendor qualifiers
2401 should be handled in the same way, but we have no way to tell
2402 which vendor qualifiers are order-insensitive and which are
2403 order-sensitive. So we just assume that they are all
2404 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2405 __vector, and it treats it as order-sensitive when mangling
2408 if (next_is_type_qual (di
))
2410 struct demangle_component
**pret
;
2412 pret
= d_cv_qualifiers (di
, &ret
, 0);
2415 if (d_peek_char (di
) == 'F')
2417 /* cv-qualifiers before a function type apply to 'this',
2418 so avoid adding the unqualified function type to
2419 the substitution list. */
2420 *pret
= d_function_type (di
);
2423 *pret
= cplus_demangle_type (di
);
2426 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2427 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2429 /* Move the ref-qualifier outside the cv-qualifiers so that
2430 they are printed in the right order. */
2431 struct demangle_component
*fn
= d_left (*pret
);
2432 d_left (*pret
) = ret
;
2436 if (! d_add_substitution (di
, ret
))
2443 peek
= d_peek_char (di
);
2446 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2447 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2448 case 'o': case 's': case 't':
2449 case 'v': case 'w': case 'x': case 'y': case 'z':
2450 ret
= d_make_builtin_type (di
,
2451 &cplus_demangle_builtin_types
[peek
- 'a']);
2452 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2459 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2460 d_source_name (di
), NULL
);
2464 ret
= d_function_type (di
);
2467 case '0': case '1': case '2': case '3': case '4':
2468 case '5': case '6': case '7': case '8': case '9':
2471 ret
= d_class_enum_type (di
);
2475 ret
= d_array_type (di
);
2479 ret
= d_pointer_to_member_type (di
);
2483 ret
= d_template_param (di
);
2484 if (d_peek_char (di
) == 'I')
2486 /* This may be <template-template-param> <template-args>.
2487 If this is the type for a conversion operator, we can
2488 have a <template-template-param> here only by following
2489 a derivation like this:
2492 -> <template-prefix> <template-args>
2493 -> <prefix> <template-unqualified-name> <template-args>
2494 -> <unqualified-name> <template-unqualified-name> <template-args>
2495 -> <source-name> <template-unqualified-name> <template-args>
2496 -> <source-name> <operator-name> <template-args>
2497 -> <source-name> cv <type> <template-args>
2498 -> <source-name> cv <template-template-param> <template-args> <template-args>
2500 where the <template-args> is followed by another.
2501 Otherwise, we must have a derivation like this:
2504 -> <template-prefix> <template-args>
2505 -> <prefix> <template-unqualified-name> <template-args>
2506 -> <unqualified-name> <template-unqualified-name> <template-args>
2507 -> <source-name> <template-unqualified-name> <template-args>
2508 -> <source-name> <operator-name> <template-args>
2509 -> <source-name> cv <type> <template-args>
2510 -> <source-name> cv <template-param> <template-args>
2512 where we need to leave the <template-args> to be processed
2513 by d_prefix (following the <template-prefix>).
2515 The <template-template-param> part is a substitution
2517 if (! di
->is_conversion
)
2519 if (! d_add_substitution (di
, ret
))
2521 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2522 d_template_args (di
));
2526 struct demangle_component
*args
;
2527 struct d_info_checkpoint checkpoint
;
2529 d_checkpoint (di
, &checkpoint
);
2530 args
= d_template_args (di
);
2531 if (d_peek_char (di
) == 'I')
2533 if (! d_add_substitution (di
, ret
))
2535 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2539 d_backtrack (di
, &checkpoint
);
2545 /* If this is a special substitution, then it is the start of
2546 <class-enum-type>. */
2550 peek_next
= d_peek_next_char (di
);
2551 if (IS_DIGIT (peek_next
)
2553 || IS_UPPER (peek_next
))
2555 ret
= d_substitution (di
, 0);
2556 /* The substituted name may have been a template name and
2557 may be followed by tepmlate args. */
2558 if (d_peek_char (di
) == 'I')
2559 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2560 d_template_args (di
));
2566 ret
= d_class_enum_type (di
);
2567 /* If the substitution was a complete type, then it is not
2568 a new substitution candidate. However, if the
2569 substitution was followed by template arguments, then
2570 the whole thing is a substitution candidate. */
2571 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2579 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2580 cplus_demangle_type (di
), NULL
);
2585 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2586 cplus_demangle_type (di
), NULL
);
2591 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2592 cplus_demangle_type (di
), NULL
);
2597 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2598 cplus_demangle_type (di
), NULL
);
2603 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2604 cplus_demangle_type (di
), NULL
);
2609 ret
= d_source_name (di
);
2610 if (d_peek_char (di
) == 'I')
2611 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2612 d_template_args (di
));
2613 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2614 cplus_demangle_type (di
), ret
);
2620 peek
= d_next_char (di
);
2625 /* decltype (expression) */
2626 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2627 d_expression (di
), NULL
);
2628 if (ret
&& d_next_char (di
) != 'E')
2634 /* Pack expansion. */
2635 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2636 cplus_demangle_type (di
), NULL
);
2642 ret
= d_make_name (di
, "auto", 4);
2645 /* decltype(auto) */
2646 ret
= d_make_name (di
, "decltype(auto)", 14);
2650 /* 32-bit decimal floating point */
2651 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2652 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2656 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2657 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2661 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2662 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2665 /* 16-bit half-precision FP */
2666 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2667 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2671 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2672 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2676 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2677 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2681 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2682 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2686 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2687 ret
= d_make_empty (di
);
2688 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2689 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2690 /* For demangling we don't care about the bits. */
2692 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2693 if (ret
->u
.s_fixed
.length
== NULL
)
2696 peek
= d_next_char (di
);
2697 ret
->u
.s_fixed
.sat
= (peek
== 's');
2701 ret
= d_vector_type (di
);
2706 /* decltype(nullptr) */
2707 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[33]);
2708 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2722 if (! d_add_substitution (di
, ret
))
2729 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2731 static struct demangle_component
**
2732 d_cv_qualifiers (struct d_info
*di
,
2733 struct demangle_component
**pret
, int member_fn
)
2735 struct demangle_component
**pstart
;
2739 peek
= d_peek_char (di
);
2740 while (next_is_type_qual (di
))
2742 enum demangle_component_type t
;
2743 struct demangle_component
*right
= NULL
;
2749 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2750 : DEMANGLE_COMPONENT_RESTRICT
);
2751 di
->expansion
+= sizeof "restrict";
2753 else if (peek
== 'V')
2756 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2757 : DEMANGLE_COMPONENT_VOLATILE
);
2758 di
->expansion
+= sizeof "volatile";
2760 else if (peek
== 'K')
2763 ? DEMANGLE_COMPONENT_CONST_THIS
2764 : DEMANGLE_COMPONENT_CONST
);
2765 di
->expansion
+= sizeof "const";
2769 peek
= d_next_char (di
);
2772 t
= DEMANGLE_COMPONENT_TRANSACTION_SAFE
;
2773 di
->expansion
+= sizeof "transaction_safe";
2775 else if (peek
== 'o'
2778 t
= DEMANGLE_COMPONENT_NOEXCEPT
;
2779 di
->expansion
+= sizeof "noexcept";
2782 right
= d_expression (di
);
2785 if (! d_check_char (di
, 'E'))
2789 else if (peek
== 'w')
2791 t
= DEMANGLE_COMPONENT_THROW_SPEC
;
2792 di
->expansion
+= sizeof "throw";
2793 right
= d_parmlist (di
);
2796 if (! d_check_char (di
, 'E'))
2803 *pret
= d_make_comp (di
, t
, NULL
, right
);
2806 pret
= &d_left (*pret
);
2808 peek
= d_peek_char (di
);
2811 if (!member_fn
&& peek
== 'F')
2813 while (pstart
!= pret
)
2815 switch ((*pstart
)->type
)
2817 case DEMANGLE_COMPONENT_RESTRICT
:
2818 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2820 case DEMANGLE_COMPONENT_VOLATILE
:
2821 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2823 case DEMANGLE_COMPONENT_CONST
:
2824 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2829 pstart
= &d_left (*pstart
);
2836 /* <ref-qualifier> ::= R
2839 static struct demangle_component
*
2840 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2842 struct demangle_component
*ret
= sub
;
2845 peek
= d_peek_char (di
);
2846 if (peek
== 'R' || peek
== 'O')
2848 enum demangle_component_type t
;
2851 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2852 di
->expansion
+= sizeof "&";
2856 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2857 di
->expansion
+= sizeof "&&";
2861 ret
= d_make_comp (di
, t
, ret
, NULL
);
2867 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2869 static struct demangle_component
*
2870 d_function_type (struct d_info
*di
)
2872 struct demangle_component
*ret
= NULL
;
2874 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2876 if (di
->recursion_level
> DEMANGLE_RECURSION_LIMIT
)
2877 /* FIXME: There ought to be a way to report
2878 that the recursion limit has been reached. */
2881 di
->recursion_level
++;
2884 if (d_check_char (di
, 'F'))
2886 if (d_peek_char (di
) == 'Y')
2888 /* Function has C linkage. We don't print this information.
2889 FIXME: We should print it in verbose mode. */
2892 ret
= d_bare_function_type (di
, 1);
2893 ret
= d_ref_qualifier (di
, ret
);
2895 if (! d_check_char (di
, 'E'))
2899 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2900 di
->recursion_level
--;
2906 static struct demangle_component
*
2907 d_parmlist (struct d_info
*di
)
2909 struct demangle_component
*tl
;
2910 struct demangle_component
**ptl
;
2916 struct demangle_component
*type
;
2918 char peek
= d_peek_char (di
);
2919 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2921 if ((peek
== 'R' || peek
== 'O')
2922 && d_peek_next_char (di
) == 'E')
2923 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2925 type
= cplus_demangle_type (di
);
2928 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2931 ptl
= &d_right (*ptl
);
2934 /* There should be at least one parameter type besides the optional
2935 return type. A function which takes no arguments will have a
2936 single parameter type void. */
2940 /* If we have a single parameter type void, omit it. */
2941 if (d_right (tl
) == NULL
2942 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2943 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2945 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2952 /* <bare-function-type> ::= [J]<type>+ */
2954 static struct demangle_component
*
2955 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2957 struct demangle_component
*return_type
;
2958 struct demangle_component
*tl
;
2961 /* Detect special qualifier indicating that the first argument
2962 is the return type. */
2963 peek
= d_peek_char (di
);
2967 has_return_type
= 1;
2970 if (has_return_type
)
2972 return_type
= cplus_demangle_type (di
);
2973 if (return_type
== NULL
)
2979 tl
= d_parmlist (di
);
2983 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2987 /* <class-enum-type> ::= <name> */
2989 static struct demangle_component
*
2990 d_class_enum_type (struct d_info
*di
)
2995 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2996 ::= A [<(dimension) expression>] _ <(element) type>
2999 static struct demangle_component
*
3000 d_array_type (struct d_info
*di
)
3003 struct demangle_component
*dim
;
3005 if (! d_check_char (di
, 'A'))
3008 peek
= d_peek_char (di
);
3011 else if (IS_DIGIT (peek
))
3019 peek
= d_peek_char (di
);
3021 while (IS_DIGIT (peek
));
3022 dim
= d_make_name (di
, s
, d_str (di
) - s
);
3028 dim
= d_expression (di
);
3033 if (! d_check_char (di
, '_'))
3036 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
3037 cplus_demangle_type (di
));
3040 /* <vector-type> ::= Dv <number> _ <type>
3041 ::= Dv _ <expression> _ <type> */
3043 static struct demangle_component
*
3044 d_vector_type (struct d_info
*di
)
3047 struct demangle_component
*dim
;
3049 peek
= d_peek_char (di
);
3053 dim
= d_expression (di
);
3056 dim
= d_number_component (di
);
3061 if (! d_check_char (di
, '_'))
3064 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
3065 cplus_demangle_type (di
));
3068 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3070 static struct demangle_component
*
3071 d_pointer_to_member_type (struct d_info
*di
)
3073 struct demangle_component
*cl
;
3074 struct demangle_component
*mem
;
3076 if (! d_check_char (di
, 'M'))
3079 cl
= cplus_demangle_type (di
);
3083 /* The ABI says, "The type of a non-static member function is considered
3084 to be different, for the purposes of substitution, from the type of a
3085 namespace-scope or static member function whose type appears
3086 similar. The types of two non-static member functions are considered
3087 to be different, for the purposes of substitution, if the functions
3088 are members of different classes. In other words, for the purposes of
3089 substitution, the class of which the function is a member is
3090 considered part of the type of function."
3092 For a pointer to member function, this call to cplus_demangle_type
3093 will end up adding a (possibly qualified) non-member function type to
3094 the substitution table, which is not correct; however, the member
3095 function type will never be used in a substitution, so putting the
3096 wrong type in the substitution table is harmless. */
3098 mem
= cplus_demangle_type (di
);
3102 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
3105 /* <non-negative number> _ */
3108 d_compact_number (struct d_info
*di
)
3111 if (d_peek_char (di
) == '_')
3113 else if (d_peek_char (di
) == 'n')
3116 num
= d_number (di
) + 1;
3118 if (num
< 0 || ! d_check_char (di
, '_'))
3123 /* <template-param> ::= T_
3124 ::= T <(parameter-2 non-negative) number> _
3127 static struct demangle_component
*
3128 d_template_param (struct d_info
*di
)
3132 if (! d_check_char (di
, 'T'))
3135 param
= d_compact_number (di
);
3139 return d_make_template_param (di
, param
);
3142 /* <template-args> ::= I <template-arg>+ E */
3144 static struct demangle_component
*
3145 d_template_args (struct d_info
*di
)
3147 if (d_peek_char (di
) != 'I'
3148 && d_peek_char (di
) != 'J')
3152 return d_template_args_1 (di
);
3155 /* <template-arg>* E */
3157 static struct demangle_component
*
3158 d_template_args_1 (struct d_info
*di
)
3160 struct demangle_component
*hold_last_name
;
3161 struct demangle_component
*al
;
3162 struct demangle_component
**pal
;
3164 /* Preserve the last name we saw--don't let the template arguments
3165 clobber it, as that would give us the wrong name for a subsequent
3166 constructor or destructor. */
3167 hold_last_name
= di
->last_name
;
3169 if (d_peek_char (di
) == 'E')
3171 /* An argument pack can be empty. */
3173 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
3180 struct demangle_component
*a
;
3182 a
= d_template_arg (di
);
3186 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
3189 pal
= &d_right (*pal
);
3191 if (d_peek_char (di
) == 'E')
3198 di
->last_name
= hold_last_name
;
3203 /* <template-arg> ::= <type>
3204 ::= X <expression> E
3208 static struct demangle_component
*
3209 d_template_arg (struct d_info
*di
)
3211 struct demangle_component
*ret
;
3213 switch (d_peek_char (di
))
3217 ret
= d_expression (di
);
3218 if (! d_check_char (di
, 'E'))
3223 return d_expr_primary (di
);
3227 /* An argument pack. */
3228 return d_template_args (di
);
3231 return cplus_demangle_type (di
);
3235 /* Parse a sequence of expressions until we hit the terminator
3238 static struct demangle_component
*
3239 d_exprlist (struct d_info
*di
, char terminator
)
3241 struct demangle_component
*list
= NULL
;
3242 struct demangle_component
**p
= &list
;
3244 if (d_peek_char (di
) == terminator
)
3247 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
3252 struct demangle_component
*arg
= d_expression (di
);
3256 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
3261 if (d_peek_char (di
) == terminator
)
3271 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3272 dynamic_cast, static_cast or reinterpret_cast. */
3275 op_is_new_cast (struct demangle_component
*op
)
3277 const char *code
= op
->u
.s_operator
.op
->code
;
3278 return (code
[1] == 'c'
3279 && (code
[0] == 's' || code
[0] == 'd'
3280 || code
[0] == 'c' || code
[0] == 'r'));
3283 /* <expression> ::= <(unary) operator-name> <expression>
3284 ::= <(binary) operator-name> <expression> <expression>
3285 ::= <(trinary) operator-name> <expression> <expression> <expression>
3286 ::= cl <expression>+ E
3288 ::= <template-param>
3289 ::= sr <type> <unqualified-name>
3290 ::= sr <type> <unqualified-name> <template-args>
3294 static inline struct demangle_component
*
3295 d_expression_1 (struct d_info
*di
)
3299 peek
= d_peek_char (di
);
3301 return d_expr_primary (di
);
3302 else if (peek
== 'T')
3303 return d_template_param (di
);
3304 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
3306 struct demangle_component
*type
;
3307 struct demangle_component
*name
;
3310 type
= cplus_demangle_type (di
);
3311 name
= d_unqualified_name (di
);
3312 if (d_peek_char (di
) != 'I')
3313 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
3315 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
3316 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3317 d_template_args (di
)));
3319 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3322 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3323 d_expression_1 (di
), NULL
);
3325 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3327 /* Function parameter used in a late-specified return type. */
3330 if (d_peek_char (di
) == 'T')
3332 /* 'this' parameter. */
3338 index
= d_compact_number (di
);
3339 if (index
== INT_MAX
|| index
== -1)
3343 return d_make_function_param (di
, index
);
3345 else if (IS_DIGIT (peek
)
3346 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3348 /* We can get an unqualified name as an expression in the case of
3349 a dependent function call, i.e. decltype(f(t)). */
3350 struct demangle_component
*name
;
3353 /* operator-function-id, i.e. operator+(t). */
3356 name
= d_unqualified_name (di
);
3359 if (d_peek_char (di
) == 'I')
3360 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3361 d_template_args (di
));
3365 else if ((peek
== 'i' || peek
== 't')
3366 && d_peek_next_char (di
) == 'l')
3368 /* Brace-enclosed initializer list, untyped or typed. */
3369 struct demangle_component
*type
= NULL
;
3372 type
= cplus_demangle_type (di
);
3373 if (!d_peek_char (di
) || !d_peek_next_char (di
))
3375 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3376 type
, d_exprlist (di
, 'E'));
3380 struct demangle_component
*op
;
3381 const char *code
= NULL
;
3384 op
= d_operator_name (di
);
3388 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3390 code
= op
->u
.s_operator
.op
->code
;
3391 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3392 if (strcmp (code
, "st") == 0)
3393 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3394 cplus_demangle_type (di
));
3401 case DEMANGLE_COMPONENT_OPERATOR
:
3402 args
= op
->u
.s_operator
.op
->args
;
3404 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3405 args
= op
->u
.s_extended_operator
.args
;
3407 case DEMANGLE_COMPONENT_CAST
:
3415 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3419 struct demangle_component
*operand
;
3422 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3423 && code
[1] == code
[0])
3424 /* pp_ and mm_ are the prefix variants. */
3425 suffix
= !d_check_char (di
, '_');
3427 if (op
->type
== DEMANGLE_COMPONENT_CAST
3428 && d_check_char (di
, '_'))
3429 operand
= d_exprlist (di
, 'E');
3430 else if (code
&& !strcmp (code
, "sP"))
3431 operand
= d_template_args_1 (di
);
3433 operand
= d_expression_1 (di
);
3436 /* Indicate the suffix variant for d_print_comp. */
3437 operand
= d_make_comp (di
, DEMANGLE_COMPONENT_BINARY_ARGS
,
3440 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
, operand
);
3444 struct demangle_component
*left
;
3445 struct demangle_component
*right
;
3449 if (op_is_new_cast (op
))
3450 left
= cplus_demangle_type (di
);
3451 else if (code
[0] == 'f')
3452 /* fold-expression. */
3453 left
= d_operator_name (di
);
3455 left
= d_expression_1 (di
);
3456 if (!strcmp (code
, "cl"))
3457 right
= d_exprlist (di
, 'E');
3458 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3460 right
= d_unqualified_name (di
);
3461 if (d_peek_char (di
) == 'I')
3462 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3463 right
, d_template_args (di
));
3466 right
= d_expression_1 (di
);
3468 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3470 DEMANGLE_COMPONENT_BINARY_ARGS
,
3475 struct demangle_component
*first
;
3476 struct demangle_component
*second
;
3477 struct demangle_component
*third
;
3481 else if (!strcmp (code
, "qu"))
3483 /* ?: expression. */
3484 first
= d_expression_1 (di
);
3485 second
= d_expression_1 (di
);
3486 third
= d_expression_1 (di
);
3490 else if (code
[0] == 'f')
3492 /* fold-expression. */
3493 first
= d_operator_name (di
);
3494 second
= d_expression_1 (di
);
3495 third
= d_expression_1 (di
);
3499 else if (code
[0] == 'n')
3501 /* new-expression. */
3502 if (code
[1] != 'w' && code
[1] != 'a')
3504 first
= d_exprlist (di
, '_');
3505 second
= cplus_demangle_type (di
);
3506 if (d_peek_char (di
) == 'E')
3511 else if (d_peek_char (di
) == 'p'
3512 && d_peek_next_char (di
) == 'i')
3514 /* Parenthesized initializer. */
3516 third
= d_exprlist (di
, 'E');
3518 else if (d_peek_char (di
) == 'i'
3519 && d_peek_next_char (di
) == 'l')
3520 /* initializer-list. */
3521 third
= d_expression_1 (di
);
3527 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3529 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3532 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3541 static struct demangle_component
*
3542 d_expression (struct d_info
*di
)
3544 struct demangle_component
*ret
;
3545 int was_expression
= di
->is_expression
;
3547 di
->is_expression
= 1;
3548 ret
= d_expression_1 (di
);
3549 di
->is_expression
= was_expression
;
3553 /* <expr-primary> ::= L <type> <(value) number> E
3554 ::= L <type> <(value) float> E
3555 ::= L <mangled-name> E
3558 static struct demangle_component
*
3559 d_expr_primary (struct d_info
*di
)
3561 struct demangle_component
*ret
;
3563 if (! d_check_char (di
, 'L'))
3565 if (d_peek_char (di
) == '_'
3566 /* Workaround for G++ bug; see comment in write_template_arg. */
3567 || d_peek_char (di
) == 'Z')
3568 ret
= cplus_demangle_mangled_name (di
, 0);
3571 struct demangle_component
*type
;
3572 enum demangle_component_type t
;
3575 type
= cplus_demangle_type (di
);
3579 /* If we have a type we know how to print, we aren't going to
3580 print the type name itself. */
3581 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3582 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3583 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3585 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3586 && strcmp (type
->u
.s_builtin
.type
->name
,
3587 cplus_demangle_builtin_types
[33].name
) == 0)
3589 if (d_peek_char (di
) == 'E')
3596 /* Rather than try to interpret the literal value, we just
3597 collect it as a string. Note that it's possible to have a
3598 floating point literal here. The ABI specifies that the
3599 format of such literals is machine independent. That's fine,
3600 but what's not fine is that versions of g++ up to 3.2 with
3601 -fabi-version=1 used upper case letters in the hex constant,
3602 and dumped out gcc's internal representation. That makes it
3603 hard to tell where the constant ends, and hard to dump the
3604 constant in any readable form anyhow. We don't attempt to
3605 handle these cases. */
3607 t
= DEMANGLE_COMPONENT_LITERAL
;
3608 if (d_peek_char (di
) == 'n')
3610 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3614 while (d_peek_char (di
) != 'E')
3616 if (d_peek_char (di
) == '\0')
3620 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3622 if (! d_check_char (di
, 'E'))
3627 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3628 ::= Z <(function) encoding> E s [<discriminator>]
3629 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3632 static struct demangle_component
*
3633 d_local_name (struct d_info
*di
)
3635 struct demangle_component
*function
;
3636 struct demangle_component
*name
;
3638 if (! d_check_char (di
, 'Z'))
3641 function
= d_encoding (di
, 0);
3645 if (! d_check_char (di
, 'E'))
3648 if (d_peek_char (di
) == 's')
3651 if (! d_discriminator (di
))
3653 name
= d_make_name (di
, "string literal", sizeof "string literal" - 1);
3659 if (d_peek_char (di
) == 'd')
3661 /* Default argument scope: d <number> _. */
3663 num
= d_compact_number (di
);
3671 /* Lambdas and unnamed types have internal discriminators
3672 and are not functions. */
3673 && name
->type
!= DEMANGLE_COMPONENT_LAMBDA
3674 && name
->type
!= DEMANGLE_COMPONENT_UNNAMED_TYPE
)
3676 /* Read and ignore an optional discriminator. */
3677 if (! d_discriminator (di
))
3682 name
= d_make_default_arg (di
, num
, name
);
3685 /* Elide the return type of the containing function so as to not
3686 confuse the user thinking it is the return type of whatever local
3687 function we might be containing. */
3688 if (function
->type
== DEMANGLE_COMPONENT_TYPED_NAME
3689 && d_right (function
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3690 d_left (d_right (function
)) = NULL
;
3692 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3695 /* <discriminator> ::= _ <number> # when number < 10
3696 ::= __ <number> _ # when number >= 10
3698 <discriminator> ::= _ <number> # when number >=10
3699 is also accepted to support gcc versions that wrongly mangled that way.
3701 We demangle the discriminator, but we don't print it out. FIXME:
3702 We should print it out in verbose mode. */
3705 d_discriminator (struct d_info
*di
)
3707 int discrim
, num_underscores
= 1;
3709 if (d_peek_char (di
) != '_')
3712 if (d_peek_char (di
) == '_')
3718 discrim
= d_number (di
);
3721 if (num_underscores
> 1 && discrim
>= 10)
3723 if (d_peek_char (di
) == '_')
3732 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3734 static struct demangle_component
*
3735 d_lambda (struct d_info
*di
)
3737 struct demangle_component
*tl
;
3738 struct demangle_component
*ret
;
3741 if (! d_check_char (di
, 'U'))
3743 if (! d_check_char (di
, 'l'))
3746 tl
= d_parmlist (di
);
3750 if (! d_check_char (di
, 'E'))
3753 num
= d_compact_number (di
);
3757 ret
= d_make_empty (di
);
3760 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3761 ret
->u
.s_unary_num
.sub
= tl
;
3762 ret
->u
.s_unary_num
.num
= num
;
3765 if (! d_add_substitution (di
, ret
))
3771 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3773 static struct demangle_component
*
3774 d_unnamed_type (struct d_info
*di
)
3776 struct demangle_component
*ret
;
3779 if (! d_check_char (di
, 'U'))
3781 if (! d_check_char (di
, 't'))
3784 num
= d_compact_number (di
);
3788 ret
= d_make_empty (di
);
3791 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3792 ret
->u
.s_number
.number
= num
;
3795 if (! d_add_substitution (di
, ret
))
3801 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3804 static struct demangle_component
*
3805 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3807 const char *suffix
= d_str (di
);
3808 const char *pend
= suffix
;
3809 struct demangle_component
*n
;
3811 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3814 while (IS_LOWER (*pend
) || *pend
== '_')
3817 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3820 while (IS_DIGIT (*pend
))
3823 d_advance (di
, pend
- suffix
);
3824 n
= d_make_name (di
, suffix
, pend
- suffix
);
3825 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3828 /* Add a new substitution. */
3831 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3835 if (di
->next_sub
>= di
->num_subs
)
3837 di
->subs
[di
->next_sub
] = dc
;
3842 /* <substitution> ::= S <seq-id> _
3852 If PREFIX is non-zero, then this type is being used as a prefix in
3853 a qualified name. In this case, for the standard substitutions, we
3854 need to check whether we are being used as a prefix for a
3855 constructor or destructor, and return a full template name.
3856 Otherwise we will get something like std::iostream::~iostream()
3857 which does not correspond particularly well to any function which
3858 actually appears in the source.
3861 static const struct d_standard_sub_info standard_subs
[] =
3866 { 'a', NL ("std::allocator"),
3867 NL ("std::allocator"),
3869 { 'b', NL ("std::basic_string"),
3870 NL ("std::basic_string"),
3871 NL ("basic_string") },
3872 { 's', NL ("std::string"),
3873 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3874 NL ("basic_string") },
3875 { 'i', NL ("std::istream"),
3876 NL ("std::basic_istream<char, std::char_traits<char> >"),
3877 NL ("basic_istream") },
3878 { 'o', NL ("std::ostream"),
3879 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3880 NL ("basic_ostream") },
3881 { 'd', NL ("std::iostream"),
3882 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3883 NL ("basic_iostream") }
3886 static struct demangle_component
*
3887 d_substitution (struct d_info
*di
, int prefix
)
3891 if (! d_check_char (di
, 'S'))
3894 c
= d_next_char (di
);
3895 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3904 unsigned int new_id
;
3907 new_id
= id
* 36 + c
- '0';
3908 else if (IS_UPPER (c
))
3909 new_id
= id
* 36 + c
- 'A' + 10;
3915 c
= d_next_char (di
);
3922 if (id
>= (unsigned int) di
->next_sub
)
3925 return di
->subs
[id
];
3930 const struct d_standard_sub_info
*p
;
3931 const struct d_standard_sub_info
*pend
;
3933 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3934 if (! verbose
&& prefix
)
3938 peek
= d_peek_char (di
);
3939 if (peek
== 'C' || peek
== 'D')
3943 pend
= (&standard_subs
[0]
3944 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3945 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3951 struct demangle_component
*dc
;
3953 if (p
->set_last_name
!= NULL
)
3954 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3955 p
->set_last_name_len
);
3958 s
= p
->full_expansion
;
3963 s
= p
->simple_expansion
;
3964 len
= p
->simple_len
;
3966 di
->expansion
+= len
;
3967 dc
= d_make_sub (di
, s
, len
);
3968 if (d_peek_char (di
) == 'B')
3970 /* If there are ABI tags on the abbreviation, it becomes
3971 a substitution candidate. */
3972 dc
= d_abi_tags (di
, dc
);
3973 if (! d_add_substitution (di
, dc
))
3985 d_checkpoint (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3987 checkpoint
->n
= di
->n
;
3988 checkpoint
->next_comp
= di
->next_comp
;
3989 checkpoint
->next_sub
= di
->next_sub
;
3990 checkpoint
->expansion
= di
->expansion
;
3994 d_backtrack (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3996 di
->n
= checkpoint
->n
;
3997 di
->next_comp
= checkpoint
->next_comp
;
3998 di
->next_sub
= checkpoint
->next_sub
;
3999 di
->expansion
= checkpoint
->expansion
;
4002 /* Initialize a growable string. */
4005 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
4010 dgs
->allocation_failure
= 0;
4013 d_growable_string_resize (dgs
, estimate
);
4016 /* Grow a growable string to a given size. */
4019 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
4024 if (dgs
->allocation_failure
)
4027 /* Start allocation at two bytes to avoid any possibility of confusion
4028 with the special value of 1 used as a return in *palc to indicate
4029 allocation failures. */
4030 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
4031 while (newalc
< need
)
4034 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
4041 dgs
->allocation_failure
= 1;
4048 /* Append a buffer to a growable string. */
4051 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
4052 const char *s
, size_t l
)
4056 need
= dgs
->len
+ l
+ 1;
4057 if (need
> dgs
->alc
)
4058 d_growable_string_resize (dgs
, need
);
4060 if (dgs
->allocation_failure
)
4063 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
4064 dgs
->buf
[dgs
->len
+ l
] = '\0';
4068 /* Bridge growable strings to the callback mechanism. */
4071 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
4073 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
4075 d_growable_string_append_buffer (dgs
, s
, l
);
4078 /* Walk the tree, counting the number of templates encountered, and
4079 the number of times a scope might be saved. These counts will be
4080 used to allocate data structures for d_print_comp, so the logic
4081 here must mirror the logic d_print_comp will use. It is not
4082 important that the resulting numbers are exact, so long as they
4083 are larger than the actual numbers encountered. */
4086 d_count_templates_scopes (struct d_print_info
*dpi
,
4087 struct demangle_component
*dc
)
4089 if (dc
== NULL
|| dc
->d_counting
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
4096 case DEMANGLE_COMPONENT_NAME
:
4097 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4098 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4099 case DEMANGLE_COMPONENT_SUB_STD
:
4100 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4101 case DEMANGLE_COMPONENT_OPERATOR
:
4102 case DEMANGLE_COMPONENT_CHARACTER
:
4103 case DEMANGLE_COMPONENT_NUMBER
:
4104 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4107 case DEMANGLE_COMPONENT_TEMPLATE
:
4108 dpi
->num_copy_templates
++;
4109 goto recurse_left_right
;
4111 case DEMANGLE_COMPONENT_REFERENCE
:
4112 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4113 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4114 dpi
->num_saved_scopes
++;
4115 goto recurse_left_right
;
4117 case DEMANGLE_COMPONENT_QUAL_NAME
:
4118 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4119 case DEMANGLE_COMPONENT_TYPED_NAME
:
4120 case DEMANGLE_COMPONENT_VTABLE
:
4121 case DEMANGLE_COMPONENT_VTT
:
4122 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4123 case DEMANGLE_COMPONENT_TYPEINFO
:
4124 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4125 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4126 case DEMANGLE_COMPONENT_THUNK
:
4127 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4128 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4129 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4130 case DEMANGLE_COMPONENT_GUARD
:
4131 case DEMANGLE_COMPONENT_TLS_INIT
:
4132 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4133 case DEMANGLE_COMPONENT_REFTEMP
:
4134 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4135 case DEMANGLE_COMPONENT_RESTRICT
:
4136 case DEMANGLE_COMPONENT_VOLATILE
:
4137 case DEMANGLE_COMPONENT_CONST
:
4138 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4139 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4140 case DEMANGLE_COMPONENT_CONST_THIS
:
4141 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4142 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4143 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
4144 case DEMANGLE_COMPONENT_NOEXCEPT
:
4145 case DEMANGLE_COMPONENT_THROW_SPEC
:
4146 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4147 case DEMANGLE_COMPONENT_POINTER
:
4148 case DEMANGLE_COMPONENT_COMPLEX
:
4149 case DEMANGLE_COMPONENT_IMAGINARY
:
4150 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4151 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4152 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4153 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4154 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4155 case DEMANGLE_COMPONENT_ARGLIST
:
4156 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4157 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4158 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4159 case DEMANGLE_COMPONENT_CAST
:
4160 case DEMANGLE_COMPONENT_CONVERSION
:
4161 case DEMANGLE_COMPONENT_NULLARY
:
4162 case DEMANGLE_COMPONENT_UNARY
:
4163 case DEMANGLE_COMPONENT_BINARY
:
4164 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4165 case DEMANGLE_COMPONENT_TRINARY
:
4166 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4167 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4168 case DEMANGLE_COMPONENT_LITERAL
:
4169 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4170 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4171 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4172 case DEMANGLE_COMPONENT_DECLTYPE
:
4173 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4174 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4175 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4176 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4177 case DEMANGLE_COMPONENT_CLONE
:
4179 /* PR 89394 - Check for too much recursion. */
4180 if (dpi
->recursion
> DEMANGLE_RECURSION_LIMIT
)
4181 /* FIXME: There ought to be a way to report to the
4182 user that the recursion limit has been reached. */
4186 d_count_templates_scopes (dpi
, d_left (dc
));
4187 d_count_templates_scopes (dpi
, d_right (dc
));
4191 case DEMANGLE_COMPONENT_CTOR
:
4192 d_count_templates_scopes (dpi
, dc
->u
.s_ctor
.name
);
4195 case DEMANGLE_COMPONENT_DTOR
:
4196 d_count_templates_scopes (dpi
, dc
->u
.s_dtor
.name
);
4199 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4200 d_count_templates_scopes (dpi
, dc
->u
.s_extended_operator
.name
);
4203 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4204 d_count_templates_scopes (dpi
, dc
->u
.s_fixed
.length
);
4207 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4208 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4209 d_count_templates_scopes (dpi
, d_left (dc
));
4212 case DEMANGLE_COMPONENT_LAMBDA
:
4213 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4214 d_count_templates_scopes (dpi
, dc
->u
.s_unary_num
.sub
);
4219 /* Initialize a print information structure. */
4222 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
4223 void *opaque
, struct demangle_component
*dc
)
4226 dpi
->last_char
= '\0';
4227 dpi
->templates
= NULL
;
4228 dpi
->modifiers
= NULL
;
4229 dpi
->pack_index
= 0;
4230 dpi
->flush_count
= 0;
4232 dpi
->callback
= callback
;
4233 dpi
->opaque
= opaque
;
4235 dpi
->demangle_failure
= 0;
4237 dpi
->is_lambda_arg
= 0;
4239 dpi
->component_stack
= NULL
;
4241 dpi
->saved_scopes
= NULL
;
4242 dpi
->next_saved_scope
= 0;
4243 dpi
->num_saved_scopes
= 0;
4245 dpi
->copy_templates
= NULL
;
4246 dpi
->next_copy_template
= 0;
4247 dpi
->num_copy_templates
= 0;
4249 d_count_templates_scopes (dpi
, dc
);
4250 /* If we did not reach the recursion limit, then reset the
4251 current recursion value back to 0, so that we can print
4253 if (dpi
->recursion
< DEMANGLE_RECURSION_LIMIT
)
4255 dpi
->num_copy_templates
*= dpi
->num_saved_scopes
;
4257 dpi
->current_template
= NULL
;
4260 /* Indicate that an error occurred during printing, and test for error. */
4263 d_print_error (struct d_print_info
*dpi
)
4265 dpi
->demangle_failure
= 1;
4269 d_print_saw_error (struct d_print_info
*dpi
)
4271 return dpi
->demangle_failure
!= 0;
4274 /* Flush buffered characters to the callback. */
4277 d_print_flush (struct d_print_info
*dpi
)
4279 dpi
->buf
[dpi
->len
] = '\0';
4280 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
4285 /* Append characters and buffers for printing. */
4288 d_append_char (struct d_print_info
*dpi
, char c
)
4290 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
4291 d_print_flush (dpi
);
4293 dpi
->buf
[dpi
->len
++] = c
;
4298 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
4302 for (i
= 0; i
< l
; i
++)
4303 d_append_char (dpi
, s
[i
]);
4307 d_append_string (struct d_print_info
*dpi
, const char *s
)
4309 d_append_buffer (dpi
, s
, strlen (s
));
4313 d_append_num (struct d_print_info
*dpi
, int l
)
4316 sprintf (buf
,"%d", l
);
4317 d_append_string (dpi
, buf
);
4321 d_last_char (struct d_print_info
*dpi
)
4323 return dpi
->last_char
;
4326 /* Turn components into a human readable string. OPTIONS is the
4327 options bits passed to the demangler. DC is the tree to print.
4328 CALLBACK is a function to call to flush demangled string segments
4329 as they fill the intermediate buffer, and OPAQUE is a generalized
4330 callback argument. On success, this returns 1. On failure,
4331 it returns 0, indicating a bad parse. It does not use heap
4332 memory to build an output string, so cannot encounter memory
4333 allocation failure. */
4335 CP_STATIC_IF_GLIBCPP_V3
4337 cplus_demangle_print_callback (int options
,
4338 struct demangle_component
*dc
,
4339 demangle_callbackref callback
, void *opaque
)
4341 struct d_print_info dpi
;
4343 d_print_init (&dpi
, callback
, opaque
, dc
);
4346 #ifdef CP_DYNAMIC_ARRAYS
4347 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4348 and flagged as errors by Address Sanitizer. */
4349 __extension__
struct d_saved_scope scopes
[(dpi
.num_saved_scopes
> 0)
4350 ? dpi
.num_saved_scopes
: 1];
4351 __extension__
struct d_print_template temps
[(dpi
.num_copy_templates
> 0)
4352 ? dpi
.num_copy_templates
: 1];
4354 dpi
.saved_scopes
= scopes
;
4355 dpi
.copy_templates
= temps
;
4357 dpi
.saved_scopes
= alloca (dpi
.num_saved_scopes
4358 * sizeof (*dpi
.saved_scopes
));
4359 dpi
.copy_templates
= alloca (dpi
.num_copy_templates
4360 * sizeof (*dpi
.copy_templates
));
4363 d_print_comp (&dpi
, options
, dc
);
4366 d_print_flush (&dpi
);
4368 return ! d_print_saw_error (&dpi
);
4371 /* Turn components into a human readable string. OPTIONS is the
4372 options bits passed to the demangler. DC is the tree to print.
4373 ESTIMATE is a guess at the length of the result. This returns a
4374 string allocated by malloc, or NULL on error. On success, this
4375 sets *PALC to the size of the allocated buffer. On failure, this
4376 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4379 CP_STATIC_IF_GLIBCPP_V3
4381 cplus_demangle_print (int options
, struct demangle_component
*dc
,
4382 int estimate
, size_t *palc
)
4384 struct d_growable_string dgs
;
4386 d_growable_string_init (&dgs
, estimate
);
4388 if (! cplus_demangle_print_callback (options
, dc
,
4389 d_growable_string_callback_adapter
,
4397 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
4401 /* Returns the I'th element of the template arglist ARGS, or NULL on
4402 failure. If I is negative, return the entire arglist. */
4404 static struct demangle_component
*
4405 d_index_template_argument (struct demangle_component
*args
, int i
)
4407 struct demangle_component
*a
;
4410 /* Print the whole argument pack. */
4417 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4423 if (i
!= 0 || a
== NULL
)
4429 /* Returns the template argument from the current context indicated by DC,
4430 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4432 static struct demangle_component
*
4433 d_lookup_template_argument (struct d_print_info
*dpi
,
4434 const struct demangle_component
*dc
)
4436 if (dpi
->templates
== NULL
)
4438 d_print_error (dpi
);
4442 return d_index_template_argument
4443 (d_right (dpi
->templates
->template_decl
),
4444 dc
->u
.s_number
.number
);
4447 /* Returns a template argument pack used in DC (any will do), or NULL. */
4449 static struct demangle_component
*
4450 d_find_pack (struct d_print_info
*dpi
,
4451 const struct demangle_component
*dc
)
4453 struct demangle_component
*a
;
4459 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4460 a
= d_lookup_template_argument (dpi
, dc
);
4461 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4465 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4468 case DEMANGLE_COMPONENT_LAMBDA
:
4469 case DEMANGLE_COMPONENT_NAME
:
4470 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4471 case DEMANGLE_COMPONENT_OPERATOR
:
4472 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4473 case DEMANGLE_COMPONENT_SUB_STD
:
4474 case DEMANGLE_COMPONENT_CHARACTER
:
4475 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4476 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4477 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4478 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4479 case DEMANGLE_COMPONENT_NUMBER
:
4482 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4483 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
4484 case DEMANGLE_COMPONENT_CTOR
:
4485 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
4486 case DEMANGLE_COMPONENT_DTOR
:
4487 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
4490 a
= d_find_pack (dpi
, d_left (dc
));
4493 return d_find_pack (dpi
, d_right (dc
));
4497 /* Returns the length of the template argument pack DC. */
4500 d_pack_length (const struct demangle_component
*dc
)
4503 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4504 && d_left (dc
) != NULL
)
4512 /* Returns the number of template args in DC, expanding any pack expansions
4516 d_args_length (struct d_print_info
*dpi
, const struct demangle_component
*dc
)
4519 for (; dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
;
4522 struct demangle_component
*elt
= d_left (dc
);
4525 if (elt
->type
== DEMANGLE_COMPONENT_PACK_EXPANSION
)
4527 struct demangle_component
*a
= d_find_pack (dpi
, d_left (elt
));
4528 count
+= d_pack_length (a
);
4536 /* DC is a component of a mangled expression. Print it, wrapped in parens
4540 d_print_subexpr (struct d_print_info
*dpi
, int options
,
4541 struct demangle_component
*dc
)
4544 if (dc
->type
== DEMANGLE_COMPONENT_NAME
4545 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
4546 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
4547 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
4550 d_append_char (dpi
, '(');
4551 d_print_comp (dpi
, options
, dc
);
4553 d_append_char (dpi
, ')');
4556 /* Save the current scope. */
4559 d_save_scope (struct d_print_info
*dpi
,
4560 const struct demangle_component
*container
)
4562 struct d_saved_scope
*scope
;
4563 struct d_print_template
*src
, **link
;
4565 if (dpi
->next_saved_scope
>= dpi
->num_saved_scopes
)
4567 d_print_error (dpi
);
4570 scope
= &dpi
->saved_scopes
[dpi
->next_saved_scope
];
4571 dpi
->next_saved_scope
++;
4573 scope
->container
= container
;
4574 link
= &scope
->templates
;
4576 for (src
= dpi
->templates
; src
!= NULL
; src
= src
->next
)
4578 struct d_print_template
*dst
;
4580 if (dpi
->next_copy_template
>= dpi
->num_copy_templates
)
4582 d_print_error (dpi
);
4585 dst
= &dpi
->copy_templates
[dpi
->next_copy_template
];
4586 dpi
->next_copy_template
++;
4588 dst
->template_decl
= src
->template_decl
;
4596 /* Attempt to locate a previously saved scope. Returns NULL if no
4597 corresponding saved scope was found. */
4599 static struct d_saved_scope
*
4600 d_get_saved_scope (struct d_print_info
*dpi
,
4601 const struct demangle_component
*container
)
4605 for (i
= 0; i
< dpi
->next_saved_scope
; i
++)
4606 if (dpi
->saved_scopes
[i
].container
== container
)
4607 return &dpi
->saved_scopes
[i
];
4612 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4616 d_maybe_print_fold_expression (struct d_print_info
*dpi
, int options
,
4617 struct demangle_component
*dc
)
4619 struct demangle_component
*ops
, *operator_
, *op1
, *op2
;
4622 const char *fold_code
= d_left (dc
)->u
.s_operator
.op
->code
;
4623 if (fold_code
[0] != 'f')
4627 operator_
= d_left (ops
);
4628 op1
= d_right (ops
);
4630 if (op1
->type
== DEMANGLE_COMPONENT_TRINARY_ARG2
)
4632 op2
= d_right (op1
);
4636 /* Print the whole pack. */
4637 save_idx
= dpi
->pack_index
;
4638 dpi
->pack_index
= -1;
4640 switch (fold_code
[1])
4642 /* Unary left fold, (... + X). */
4644 d_append_string (dpi
, "(...");
4645 d_print_expr_op (dpi
, options
, operator_
);
4646 d_print_subexpr (dpi
, options
, op1
);
4647 d_append_char (dpi
, ')');
4650 /* Unary right fold, (X + ...). */
4652 d_append_char (dpi
, '(');
4653 d_print_subexpr (dpi
, options
, op1
);
4654 d_print_expr_op (dpi
, options
, operator_
);
4655 d_append_string (dpi
, "...)");
4658 /* Binary left fold, (42 + ... + X). */
4660 /* Binary right fold, (X + ... + 42). */
4662 d_append_char (dpi
, '(');
4663 d_print_subexpr (dpi
, options
, op1
);
4664 d_print_expr_op (dpi
, options
, operator_
);
4665 d_append_string (dpi
, "...");
4666 d_print_expr_op (dpi
, options
, operator_
);
4667 d_print_subexpr (dpi
, options
, op2
);
4668 d_append_char (dpi
, ')');
4672 dpi
->pack_index
= save_idx
;
4676 /* Subroutine to handle components. */
4679 d_print_comp_inner (struct d_print_info
*dpi
, int options
,
4680 struct demangle_component
*dc
)
4682 /* Magic variable to let reference smashing skip over the next modifier
4683 without needing to modify *dc. */
4684 struct demangle_component
*mod_inner
= NULL
;
4686 /* Variable used to store the current templates while a previously
4687 captured scope is used. */
4688 struct d_print_template
*saved_templates
;
4690 /* Nonzero if templates have been stored in the above variable. */
4691 int need_template_restore
= 0;
4695 d_print_error (dpi
);
4698 if (d_print_saw_error (dpi
))
4703 case DEMANGLE_COMPONENT_NAME
:
4704 if ((options
& DMGL_JAVA
) == 0)
4705 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4707 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4710 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4711 d_print_comp (dpi
, options
, d_left (dc
));
4712 d_append_string (dpi
, "[abi:");
4713 d_print_comp (dpi
, options
, d_right (dc
));
4714 d_append_char (dpi
, ']');
4717 case DEMANGLE_COMPONENT_QUAL_NAME
:
4718 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4719 d_print_comp (dpi
, options
, d_left (dc
));
4720 if ((options
& DMGL_JAVA
) == 0)
4721 d_append_string (dpi
, "::");
4723 d_append_char (dpi
, '.');
4725 struct demangle_component
*local_name
= d_right (dc
);
4726 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4728 d_append_string (dpi
, "{default arg#");
4729 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
4730 d_append_string (dpi
, "}::");
4731 local_name
= local_name
->u
.s_unary_num
.sub
;
4733 d_print_comp (dpi
, options
, local_name
);
4737 case DEMANGLE_COMPONENT_TYPED_NAME
:
4739 struct d_print_mod
*hold_modifiers
;
4740 struct demangle_component
*typed_name
;
4741 struct d_print_mod adpm
[4];
4743 struct d_print_template dpt
;
4745 /* Pass the name down to the type so that it can be printed in
4746 the right place for the type. We also have to pass down
4747 any CV-qualifiers, which apply to the this parameter. */
4748 hold_modifiers
= dpi
->modifiers
;
4751 typed_name
= d_left (dc
);
4752 while (typed_name
!= NULL
)
4754 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4756 d_print_error (dpi
);
4760 adpm
[i
].next
= dpi
->modifiers
;
4761 dpi
->modifiers
= &adpm
[i
];
4762 adpm
[i
].mod
= typed_name
;
4763 adpm
[i
].printed
= 0;
4764 adpm
[i
].templates
= dpi
->templates
;
4767 if (!is_fnqual_component_type (typed_name
->type
))
4770 typed_name
= d_left (typed_name
);
4773 if (typed_name
== NULL
)
4775 d_print_error (dpi
);
4779 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4780 there may be CV-qualifiers on its right argument which
4781 really apply here; this happens when parsing a class that
4782 is local to a function. */
4783 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4785 typed_name
= d_right (typed_name
);
4786 if (typed_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4787 typed_name
= typed_name
->u
.s_unary_num
.sub
;
4788 while (typed_name
!= NULL
4789 && is_fnqual_component_type (typed_name
->type
))
4791 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4793 d_print_error (dpi
);
4797 adpm
[i
] = adpm
[i
- 1];
4798 adpm
[i
].next
= &adpm
[i
- 1];
4799 dpi
->modifiers
= &adpm
[i
];
4801 adpm
[i
- 1].mod
= typed_name
;
4802 adpm
[i
- 1].printed
= 0;
4803 adpm
[i
- 1].templates
= dpi
->templates
;
4806 typed_name
= d_left (typed_name
);
4808 if (typed_name
== NULL
)
4810 d_print_error (dpi
);
4815 /* If typed_name is a template, then it applies to the
4816 function type as well. */
4817 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4819 dpt
.next
= dpi
->templates
;
4820 dpi
->templates
= &dpt
;
4821 dpt
.template_decl
= typed_name
;
4824 d_print_comp (dpi
, options
, d_right (dc
));
4826 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4827 dpi
->templates
= dpt
.next
;
4829 /* If the modifiers didn't get printed by the type, print them
4834 if (! adpm
[i
].printed
)
4836 d_append_char (dpi
, ' ');
4837 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4841 dpi
->modifiers
= hold_modifiers
;
4846 case DEMANGLE_COMPONENT_TEMPLATE
:
4848 struct d_print_mod
*hold_dpm
;
4849 struct demangle_component
*dcl
;
4850 const struct demangle_component
*hold_current
;
4852 /* This template may need to be referenced by a cast operator
4853 contained in its subtree. */
4854 hold_current
= dpi
->current_template
;
4855 dpi
->current_template
= dc
;
4857 /* Don't push modifiers into a template definition. Doing so
4858 could give the wrong definition for a template argument.
4859 Instead, treat the template essentially as a name. */
4861 hold_dpm
= dpi
->modifiers
;
4862 dpi
->modifiers
= NULL
;
4866 if ((options
& DMGL_JAVA
) != 0
4867 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4868 && dcl
->u
.s_name
.len
== 6
4869 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4871 /* Special-case Java arrays, so that JArray<TYPE> appears
4872 instead as TYPE[]. */
4874 d_print_comp (dpi
, options
, d_right (dc
));
4875 d_append_string (dpi
, "[]");
4879 d_print_comp (dpi
, options
, dcl
);
4880 if (d_last_char (dpi
) == '<')
4881 d_append_char (dpi
, ' ');
4882 d_append_char (dpi
, '<');
4883 d_print_comp (dpi
, options
, d_right (dc
));
4884 /* Avoid generating two consecutive '>' characters, to avoid
4885 the C++ syntactic ambiguity. */
4886 if (d_last_char (dpi
) == '>')
4887 d_append_char (dpi
, ' ');
4888 d_append_char (dpi
, '>');
4891 dpi
->modifiers
= hold_dpm
;
4892 dpi
->current_template
= hold_current
;
4897 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4898 if (dpi
->is_lambda_arg
)
4900 /* Show the template parm index, as that's how g++ displays
4901 these, and future proofs us against potential
4902 '[]<typename T> (T *a, T *b) {...}'. */
4903 d_append_buffer (dpi
, "auto:", 5);
4904 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4908 struct d_print_template
*hold_dpt
;
4909 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
4911 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4912 a
= d_index_template_argument (a
, dpi
->pack_index
);
4916 d_print_error (dpi
);
4920 /* While processing this parameter, we need to pop the list
4921 of templates. This is because the template parameter may
4922 itself be a reference to a parameter of an outer
4925 hold_dpt
= dpi
->templates
;
4926 dpi
->templates
= hold_dpt
->next
;
4928 d_print_comp (dpi
, options
, a
);
4930 dpi
->templates
= hold_dpt
;
4934 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4935 d_append_string (dpi
, "template parameter object for ");
4936 d_print_comp (dpi
, options
, d_left (dc
));
4939 case DEMANGLE_COMPONENT_CTOR
:
4940 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
4943 case DEMANGLE_COMPONENT_DTOR
:
4944 d_append_char (dpi
, '~');
4945 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
4948 case DEMANGLE_COMPONENT_VTABLE
:
4949 d_append_string (dpi
, "vtable for ");
4950 d_print_comp (dpi
, options
, d_left (dc
));
4953 case DEMANGLE_COMPONENT_VTT
:
4954 d_append_string (dpi
, "VTT for ");
4955 d_print_comp (dpi
, options
, d_left (dc
));
4958 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4959 d_append_string (dpi
, "construction vtable for ");
4960 d_print_comp (dpi
, options
, d_left (dc
));
4961 d_append_string (dpi
, "-in-");
4962 d_print_comp (dpi
, options
, d_right (dc
));
4965 case DEMANGLE_COMPONENT_TYPEINFO
:
4966 d_append_string (dpi
, "typeinfo for ");
4967 d_print_comp (dpi
, options
, d_left (dc
));
4970 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4971 d_append_string (dpi
, "typeinfo name for ");
4972 d_print_comp (dpi
, options
, d_left (dc
));
4975 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4976 d_append_string (dpi
, "typeinfo fn for ");
4977 d_print_comp (dpi
, options
, d_left (dc
));
4980 case DEMANGLE_COMPONENT_THUNK
:
4981 d_append_string (dpi
, "non-virtual thunk to ");
4982 d_print_comp (dpi
, options
, d_left (dc
));
4985 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4986 d_append_string (dpi
, "virtual thunk to ");
4987 d_print_comp (dpi
, options
, d_left (dc
));
4990 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4991 d_append_string (dpi
, "covariant return thunk to ");
4992 d_print_comp (dpi
, options
, d_left (dc
));
4995 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4996 d_append_string (dpi
, "java Class for ");
4997 d_print_comp (dpi
, options
, d_left (dc
));
5000 case DEMANGLE_COMPONENT_GUARD
:
5001 d_append_string (dpi
, "guard variable for ");
5002 d_print_comp (dpi
, options
, d_left (dc
));
5005 case DEMANGLE_COMPONENT_TLS_INIT
:
5006 d_append_string (dpi
, "TLS init function for ");
5007 d_print_comp (dpi
, options
, d_left (dc
));
5010 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
5011 d_append_string (dpi
, "TLS wrapper function for ");
5012 d_print_comp (dpi
, options
, d_left (dc
));
5015 case DEMANGLE_COMPONENT_REFTEMP
:
5016 d_append_string (dpi
, "reference temporary #");
5017 d_print_comp (dpi
, options
, d_right (dc
));
5018 d_append_string (dpi
, " for ");
5019 d_print_comp (dpi
, options
, d_left (dc
));
5022 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
5023 d_append_string (dpi
, "hidden alias for ");
5024 d_print_comp (dpi
, options
, d_left (dc
));
5027 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
5028 d_append_string (dpi
, "transaction clone for ");
5029 d_print_comp (dpi
, options
, d_left (dc
));
5032 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
5033 d_append_string (dpi
, "non-transaction clone for ");
5034 d_print_comp (dpi
, options
, d_left (dc
));
5037 case DEMANGLE_COMPONENT_SUB_STD
:
5038 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
5041 case DEMANGLE_COMPONENT_RESTRICT
:
5042 case DEMANGLE_COMPONENT_VOLATILE
:
5043 case DEMANGLE_COMPONENT_CONST
:
5045 struct d_print_mod
*pdpm
;
5047 /* When printing arrays, it's possible to have cases where the
5048 same CV-qualifier gets pushed on the stack multiple times.
5049 We only need to print it once. */
5051 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
5053 if (! pdpm
->printed
)
5055 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
5056 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
5057 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
5059 if (pdpm
->mod
->type
== dc
->type
)
5061 d_print_comp (dpi
, options
, d_left (dc
));
5069 case DEMANGLE_COMPONENT_REFERENCE
:
5070 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5072 /* Handle reference smashing: & + && = &. */
5073 struct demangle_component
*sub
= d_left (dc
);
5074 if (!dpi
->is_lambda_arg
5075 && sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
5077 struct d_saved_scope
*scope
= d_get_saved_scope (dpi
, sub
);
5078 struct demangle_component
*a
;
5082 /* This is the first time SUB has been traversed.
5083 We need to capture the current templates so
5084 they can be restored if SUB is reentered as a
5086 d_save_scope (dpi
, sub
);
5087 if (d_print_saw_error (dpi
))
5092 const struct d_component_stack
*dcse
;
5093 int found_self_or_parent
= 0;
5095 /* This traversal is reentering SUB as a substition.
5096 If we are not beneath SUB or DC in the tree then we
5097 need to restore SUB's template stack temporarily. */
5098 for (dcse
= dpi
->component_stack
; dcse
!= NULL
;
5099 dcse
= dcse
->parent
)
5103 && dcse
!= dpi
->component_stack
))
5105 found_self_or_parent
= 1;
5110 if (!found_self_or_parent
)
5112 saved_templates
= dpi
->templates
;
5113 dpi
->templates
= scope
->templates
;
5114 need_template_restore
= 1;
5118 a
= d_lookup_template_argument (dpi
, sub
);
5119 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
5120 a
= d_index_template_argument (a
, dpi
->pack_index
);
5124 if (need_template_restore
)
5125 dpi
->templates
= saved_templates
;
5127 d_print_error (dpi
);
5134 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
5135 || sub
->type
== dc
->type
)
5137 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
5138 mod_inner
= d_left (sub
);
5142 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5143 case DEMANGLE_COMPONENT_POINTER
:
5144 case DEMANGLE_COMPONENT_COMPLEX
:
5145 case DEMANGLE_COMPONENT_IMAGINARY
:
5146 FNQUAL_COMPONENT_CASE
:
5149 /* We keep a list of modifiers on the stack. */
5150 struct d_print_mod dpm
;
5152 dpm
.next
= dpi
->modifiers
;
5153 dpi
->modifiers
= &dpm
;
5156 dpm
.templates
= dpi
->templates
;
5159 mod_inner
= d_left (dc
);
5161 d_print_comp (dpi
, options
, mod_inner
);
5163 /* If the modifier didn't get printed by the type, print it
5166 d_print_mod (dpi
, options
, dc
);
5168 dpi
->modifiers
= dpm
.next
;
5170 if (need_template_restore
)
5171 dpi
->templates
= saved_templates
;
5176 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5177 if ((options
& DMGL_JAVA
) == 0)
5178 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
5179 dc
->u
.s_builtin
.type
->len
);
5181 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
5182 dc
->u
.s_builtin
.type
->java_len
);
5185 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5186 d_print_comp (dpi
, options
, d_left (dc
));
5189 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5191 if ((options
& DMGL_RET_POSTFIX
) != 0)
5192 d_print_function_type (dpi
,
5193 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5194 dc
, dpi
->modifiers
);
5196 /* Print return type if present */
5197 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
5198 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5200 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
5202 struct d_print_mod dpm
;
5204 /* We must pass this type down as a modifier in order to
5205 print it in the right location. */
5206 dpm
.next
= dpi
->modifiers
;
5207 dpi
->modifiers
= &dpm
;
5210 dpm
.templates
= dpi
->templates
;
5212 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5215 dpi
->modifiers
= dpm
.next
;
5220 /* In standard prefix notation, there is a space between the
5221 return type and the function signature. */
5222 if ((options
& DMGL_RET_POSTFIX
) == 0)
5223 d_append_char (dpi
, ' ');
5226 if ((options
& DMGL_RET_POSTFIX
) == 0)
5227 d_print_function_type (dpi
,
5228 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5229 dc
, dpi
->modifiers
);
5234 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5236 struct d_print_mod
*hold_modifiers
;
5237 struct d_print_mod adpm
[4];
5239 struct d_print_mod
*pdpm
;
5241 /* We must pass this type down as a modifier in order to print
5242 multi-dimensional arrays correctly. If the array itself is
5243 CV-qualified, we act as though the element type were
5244 CV-qualified. We do this by copying the modifiers down
5245 rather than fiddling pointers, so that we don't wind up
5246 with a d_print_mod higher on the stack pointing into our
5247 stack frame after we return. */
5249 hold_modifiers
= dpi
->modifiers
;
5251 adpm
[0].next
= hold_modifiers
;
5252 dpi
->modifiers
= &adpm
[0];
5254 adpm
[0].printed
= 0;
5255 adpm
[0].templates
= dpi
->templates
;
5258 pdpm
= hold_modifiers
;
5260 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
5261 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
5262 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
5264 if (! pdpm
->printed
)
5266 if (i
>= sizeof adpm
/ sizeof adpm
[0])
5268 d_print_error (dpi
);
5273 adpm
[i
].next
= dpi
->modifiers
;
5274 dpi
->modifiers
= &adpm
[i
];
5282 d_print_comp (dpi
, options
, d_right (dc
));
5284 dpi
->modifiers
= hold_modifiers
;
5286 if (adpm
[0].printed
)
5292 d_print_mod (dpi
, options
, adpm
[i
].mod
);
5295 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
5300 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5301 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5303 struct d_print_mod dpm
;
5305 dpm
.next
= dpi
->modifiers
;
5306 dpi
->modifiers
= &dpm
;
5309 dpm
.templates
= dpi
->templates
;
5311 d_print_comp (dpi
, options
, d_right (dc
));
5313 /* If the modifier didn't get printed by the type, print it
5316 d_print_mod (dpi
, options
, dc
);
5318 dpi
->modifiers
= dpm
.next
;
5323 case DEMANGLE_COMPONENT_FIXED_TYPE
:
5324 if (dc
->u
.s_fixed
.sat
)
5325 d_append_string (dpi
, "_Sat ");
5326 /* Don't print "int _Accum". */
5327 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
5328 != &cplus_demangle_builtin_types
['i'-'a'])
5330 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
5331 d_append_char (dpi
, ' ');
5333 if (dc
->u
.s_fixed
.accum
)
5334 d_append_string (dpi
, "_Accum");
5336 d_append_string (dpi
, "_Fract");
5339 case DEMANGLE_COMPONENT_ARGLIST
:
5340 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
5341 if (d_left (dc
) != NULL
)
5342 d_print_comp (dpi
, options
, d_left (dc
));
5343 if (d_right (dc
) != NULL
)
5346 unsigned long int flush_count
;
5347 /* Make sure ", " isn't flushed by d_append_string, otherwise
5348 dpi->len -= 2 wouldn't work. */
5349 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
5350 d_print_flush (dpi
);
5351 d_append_string (dpi
, ", ");
5353 flush_count
= dpi
->flush_count
;
5354 d_print_comp (dpi
, options
, d_right (dc
));
5355 /* If that didn't print anything (which can happen with empty
5356 template argument packs), remove the comma and space. */
5357 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
5362 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
5364 struct demangle_component
*type
= d_left (dc
);
5365 struct demangle_component
*list
= d_right (dc
);
5368 d_print_comp (dpi
, options
, type
);
5369 d_append_char (dpi
, '{');
5370 d_print_comp (dpi
, options
, list
);
5371 d_append_char (dpi
, '}');
5375 case DEMANGLE_COMPONENT_OPERATOR
:
5377 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
5380 d_append_string (dpi
, "operator");
5381 /* Add a space before new/delete. */
5382 if (IS_LOWER (op
->name
[0]))
5383 d_append_char (dpi
, ' ');
5384 /* Omit a trailing space. */
5385 if (op
->name
[len
-1] == ' ')
5387 d_append_buffer (dpi
, op
->name
, len
);
5391 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
5392 d_append_string (dpi
, "operator ");
5393 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5396 case DEMANGLE_COMPONENT_CONVERSION
:
5397 d_append_string (dpi
, "operator ");
5398 d_print_conversion (dpi
, options
, dc
);
5401 case DEMANGLE_COMPONENT_NULLARY
:
5402 d_print_expr_op (dpi
, options
, d_left (dc
));
5405 case DEMANGLE_COMPONENT_UNARY
:
5407 struct demangle_component
*op
= d_left (dc
);
5408 struct demangle_component
*operand
= d_right (dc
);
5409 const char *code
= NULL
;
5411 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5413 code
= op
->u
.s_operator
.op
->code
;
5414 if (!strcmp (code
, "ad"))
5416 /* Don't print the argument list for the address of a
5418 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
5419 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
5420 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5421 operand
= d_left (operand
);
5423 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
5425 /* This indicates a suffix operator. */
5426 operand
= d_left (operand
);
5427 d_print_subexpr (dpi
, options
, operand
);
5428 d_print_expr_op (dpi
, options
, op
);
5433 /* For sizeof..., just print the pack length. */
5434 if (code
&& !strcmp (code
, "sZ"))
5436 struct demangle_component
*a
= d_find_pack (dpi
, operand
);
5437 int len
= d_pack_length (a
);
5438 d_append_num (dpi
, len
);
5441 else if (code
&& !strcmp (code
, "sP"))
5443 int len
= d_args_length (dpi
, operand
);
5444 d_append_num (dpi
, len
);
5448 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
5449 d_print_expr_op (dpi
, options
, op
);
5452 d_append_char (dpi
, '(');
5453 d_print_cast (dpi
, options
, op
);
5454 d_append_char (dpi
, ')');
5456 if (code
&& !strcmp (code
, "gs"))
5457 /* Avoid parens after '::'. */
5458 d_print_comp (dpi
, options
, operand
);
5459 else if (code
&& !strcmp (code
, "st"))
5460 /* Always print parens for sizeof (type). */
5462 d_append_char (dpi
, '(');
5463 d_print_comp (dpi
, options
, operand
);
5464 d_append_char (dpi
, ')');
5467 d_print_subexpr (dpi
, options
, operand
);
5471 case DEMANGLE_COMPONENT_BINARY
:
5472 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
5474 d_print_error (dpi
);
5478 if (op_is_new_cast (d_left (dc
)))
5480 d_print_expr_op (dpi
, options
, d_left (dc
));
5481 d_append_char (dpi
, '<');
5482 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
5483 d_append_string (dpi
, ">(");
5484 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5485 d_append_char (dpi
, ')');
5489 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5492 /* We wrap an expression which uses the greater-than operator in
5493 an extra layer of parens so that it does not get confused
5494 with the '>' which ends the template parameters. */
5495 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5496 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5497 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5498 d_append_char (dpi
, '(');
5500 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
5501 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
5503 /* Function call used in an expression should not have printed types
5504 of the function arguments. Values of the function arguments still
5505 get printed below. */
5507 const struct demangle_component
*func
= d_left (d_right (dc
));
5509 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5510 d_print_error (dpi
);
5511 d_print_subexpr (dpi
, options
, d_left (func
));
5514 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
5515 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
5517 d_append_char (dpi
, '[');
5518 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5519 d_append_char (dpi
, ']');
5523 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
5524 d_print_expr_op (dpi
, options
, d_left (dc
));
5525 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
5528 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5529 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5530 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5531 d_append_char (dpi
, ')');
5535 case DEMANGLE_COMPONENT_BINARY_ARGS
:
5536 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5537 d_print_error (dpi
);
5540 case DEMANGLE_COMPONENT_TRINARY
:
5541 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
5542 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
5544 d_print_error (dpi
);
5547 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5550 struct demangle_component
*op
= d_left (dc
);
5551 struct demangle_component
*first
= d_left (d_right (dc
));
5552 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
5553 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
5555 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
5557 d_print_subexpr (dpi
, options
, first
);
5558 d_print_expr_op (dpi
, options
, op
);
5559 d_print_subexpr (dpi
, options
, second
);
5560 d_append_string (dpi
, " : ");
5561 d_print_subexpr (dpi
, options
, third
);
5565 d_append_string (dpi
, "new ");
5566 if (d_left (first
) != NULL
)
5568 d_print_subexpr (dpi
, options
, first
);
5569 d_append_char (dpi
, ' ');
5571 d_print_comp (dpi
, options
, second
);
5573 d_print_subexpr (dpi
, options
, third
);
5578 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
5579 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
5580 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5581 d_print_error (dpi
);
5584 case DEMANGLE_COMPONENT_LITERAL
:
5585 case DEMANGLE_COMPONENT_LITERAL_NEG
:
5587 enum d_builtin_type_print tp
;
5589 /* For some builtin types, produce simpler output. */
5590 tp
= D_PRINT_DEFAULT
;
5591 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
5593 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
5597 case D_PRINT_UNSIGNED
:
5599 case D_PRINT_UNSIGNED_LONG
:
5600 case D_PRINT_LONG_LONG
:
5601 case D_PRINT_UNSIGNED_LONG_LONG
:
5602 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
5604 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5605 d_append_char (dpi
, '-');
5606 d_print_comp (dpi
, options
, d_right (dc
));
5611 case D_PRINT_UNSIGNED
:
5612 d_append_char (dpi
, 'u');
5615 d_append_char (dpi
, 'l');
5617 case D_PRINT_UNSIGNED_LONG
:
5618 d_append_string (dpi
, "ul");
5620 case D_PRINT_LONG_LONG
:
5621 d_append_string (dpi
, "ll");
5623 case D_PRINT_UNSIGNED_LONG_LONG
:
5624 d_append_string (dpi
, "ull");
5632 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
5633 && d_right (dc
)->u
.s_name
.len
== 1
5634 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
5636 switch (d_right (dc
)->u
.s_name
.s
[0])
5639 d_append_string (dpi
, "false");
5642 d_append_string (dpi
, "true");
5655 d_append_char (dpi
, '(');
5656 d_print_comp (dpi
, options
, d_left (dc
));
5657 d_append_char (dpi
, ')');
5658 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5659 d_append_char (dpi
, '-');
5660 if (tp
== D_PRINT_FLOAT
)
5661 d_append_char (dpi
, '[');
5662 d_print_comp (dpi
, options
, d_right (dc
));
5663 if (tp
== D_PRINT_FLOAT
)
5664 d_append_char (dpi
, ']');
5668 case DEMANGLE_COMPONENT_NUMBER
:
5669 d_append_num (dpi
, dc
->u
.s_number
.number
);
5672 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
5673 d_append_string (dpi
, "java resource ");
5674 d_print_comp (dpi
, options
, d_left (dc
));
5677 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
5678 d_print_comp (dpi
, options
, d_left (dc
));
5679 d_print_comp (dpi
, options
, d_right (dc
));
5682 case DEMANGLE_COMPONENT_CHARACTER
:
5683 d_append_char (dpi
, dc
->u
.s_character
.character
);
5686 case DEMANGLE_COMPONENT_DECLTYPE
:
5687 d_append_string (dpi
, "decltype (");
5688 d_print_comp (dpi
, options
, d_left (dc
));
5689 d_append_char (dpi
, ')');
5692 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
5696 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
5699 /* d_find_pack won't find anything if the only packs involved
5700 in this expansion are function parameter packs; in that
5701 case, just print the pattern and "...". */
5702 d_print_subexpr (dpi
, options
, d_left (dc
));
5703 d_append_string (dpi
, "...");
5707 len
= d_pack_length (a
);
5709 for (i
= 0; i
< len
; ++i
)
5711 dpi
->pack_index
= i
;
5712 d_print_comp (dpi
, options
, dc
);
5714 d_append_string (dpi
, ", ");
5719 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
5721 long num
= dc
->u
.s_number
.number
;
5723 d_append_string (dpi
, "this");
5726 d_append_string (dpi
, "{parm#");
5727 d_append_num (dpi
, num
);
5728 d_append_char (dpi
, '}');
5733 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
5734 d_append_string (dpi
, "global constructors keyed to ");
5735 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5738 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
5739 d_append_string (dpi
, "global destructors keyed to ");
5740 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5743 case DEMANGLE_COMPONENT_LAMBDA
:
5744 d_append_string (dpi
, "{lambda(");
5745 /* Generic lambda auto parms are mangled as the template type
5747 dpi
->is_lambda_arg
++;
5748 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
5749 dpi
->is_lambda_arg
--;
5750 d_append_string (dpi
, ")#");
5751 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5752 d_append_char (dpi
, '}');
5755 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
5756 d_append_string (dpi
, "{unnamed type#");
5757 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5758 d_append_char (dpi
, '}');
5761 case DEMANGLE_COMPONENT_CLONE
:
5762 d_print_comp (dpi
, options
, d_left (dc
));
5763 d_append_string (dpi
, " [clone ");
5764 d_print_comp (dpi
, options
, d_right (dc
));
5765 d_append_char (dpi
, ']');
5769 d_print_error (dpi
);
5775 d_print_comp (struct d_print_info
*dpi
, int options
,
5776 struct demangle_component
*dc
)
5778 struct d_component_stack self
;
5779 if (dc
== NULL
|| dc
->d_printing
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
5781 d_print_error (dpi
);
5789 self
.parent
= dpi
->component_stack
;
5790 dpi
->component_stack
= &self
;
5792 d_print_comp_inner (dpi
, options
, dc
);
5794 dpi
->component_stack
= self
.parent
;
5799 /* Print a Java dentifier. For Java we try to handle encoded extended
5800 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5801 so we don't it for C++. Characters are encoded as
5805 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
5811 for (p
= name
; p
< end
; ++p
)
5822 for (q
= p
+ 3; q
< end
; ++q
)
5828 else if (*q
>= 'A' && *q
<= 'F')
5829 dig
= *q
- 'A' + 10;
5830 else if (*q
>= 'a' && *q
<= 'f')
5831 dig
= *q
- 'a' + 10;
5837 /* If the Unicode character is larger than 256, we don't try
5838 to deal with it here. FIXME. */
5839 if (q
< end
&& *q
== '_' && c
< 256)
5841 d_append_char (dpi
, c
);
5847 d_append_char (dpi
, *p
);
5851 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5852 qualifiers on this after printing a function. */
5855 d_print_mod_list (struct d_print_info
*dpi
, int options
,
5856 struct d_print_mod
*mods
, int suffix
)
5858 struct d_print_template
*hold_dpt
;
5860 if (mods
== NULL
|| d_print_saw_error (dpi
))
5865 && (is_fnqual_component_type (mods
->mod
->type
))))
5867 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5873 hold_dpt
= dpi
->templates
;
5874 dpi
->templates
= mods
->templates
;
5876 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5878 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
5879 dpi
->templates
= hold_dpt
;
5882 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5884 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
5885 dpi
->templates
= hold_dpt
;
5888 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
5890 struct d_print_mod
*hold_modifiers
;
5891 struct demangle_component
*dc
;
5893 /* When this is on the modifier stack, we have pulled any
5894 qualifiers off the right argument already. Otherwise, we
5895 print it as usual, but don't let the left argument see any
5898 hold_modifiers
= dpi
->modifiers
;
5899 dpi
->modifiers
= NULL
;
5900 d_print_comp (dpi
, options
, d_left (mods
->mod
));
5901 dpi
->modifiers
= hold_modifiers
;
5903 if ((options
& DMGL_JAVA
) == 0)
5904 d_append_string (dpi
, "::");
5906 d_append_char (dpi
, '.');
5908 dc
= d_right (mods
->mod
);
5910 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
5912 d_append_string (dpi
, "{default arg#");
5913 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5914 d_append_string (dpi
, "}::");
5915 dc
= dc
->u
.s_unary_num
.sub
;
5918 while (is_fnqual_component_type (dc
->type
))
5921 d_print_comp (dpi
, options
, dc
);
5923 dpi
->templates
= hold_dpt
;
5927 d_print_mod (dpi
, options
, mods
->mod
);
5929 dpi
->templates
= hold_dpt
;
5931 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5934 /* Print a modifier. */
5937 d_print_mod (struct d_print_info
*dpi
, int options
,
5938 struct demangle_component
*mod
)
5942 case DEMANGLE_COMPONENT_RESTRICT
:
5943 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5944 d_append_string (dpi
, " restrict");
5946 case DEMANGLE_COMPONENT_VOLATILE
:
5947 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5948 d_append_string (dpi
, " volatile");
5950 case DEMANGLE_COMPONENT_CONST
:
5951 case DEMANGLE_COMPONENT_CONST_THIS
:
5952 d_append_string (dpi
, " const");
5954 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
5955 d_append_string (dpi
, " transaction_safe");
5957 case DEMANGLE_COMPONENT_NOEXCEPT
:
5958 d_append_string (dpi
, " noexcept");
5961 d_append_char (dpi
, '(');
5962 d_print_comp (dpi
, options
, d_right (mod
));
5963 d_append_char (dpi
, ')');
5966 case DEMANGLE_COMPONENT_THROW_SPEC
:
5967 d_append_string (dpi
, " throw");
5970 d_append_char (dpi
, '(');
5971 d_print_comp (dpi
, options
, d_right (mod
));
5972 d_append_char (dpi
, ')');
5975 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5976 d_append_char (dpi
, ' ');
5977 d_print_comp (dpi
, options
, d_right (mod
));
5979 case DEMANGLE_COMPONENT_POINTER
:
5980 /* There is no pointer symbol in Java. */
5981 if ((options
& DMGL_JAVA
) == 0)
5982 d_append_char (dpi
, '*');
5984 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5985 /* For the ref-qualifier, put a space before the &. */
5986 d_append_char (dpi
, ' ');
5988 case DEMANGLE_COMPONENT_REFERENCE
:
5989 d_append_char (dpi
, '&');
5991 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5992 d_append_char (dpi
, ' ');
5994 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5995 d_append_string (dpi
, "&&");
5997 case DEMANGLE_COMPONENT_COMPLEX
:
5998 d_append_string (dpi
, " _Complex");
6000 case DEMANGLE_COMPONENT_IMAGINARY
:
6001 d_append_string (dpi
, " _Imaginary");
6003 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6004 if (d_last_char (dpi
) != '(')
6005 d_append_char (dpi
, ' ');
6006 d_print_comp (dpi
, options
, d_left (mod
));
6007 d_append_string (dpi
, "::*");
6009 case DEMANGLE_COMPONENT_TYPED_NAME
:
6010 d_print_comp (dpi
, options
, d_left (mod
));
6012 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
6013 d_append_string (dpi
, " __vector(");
6014 d_print_comp (dpi
, options
, d_left (mod
));
6015 d_append_char (dpi
, ')');
6019 /* Otherwise, we have something that won't go back on the
6020 modifier stack, so we can just print it. */
6021 d_print_comp (dpi
, options
, mod
);
6026 /* Print a function type, except for the return type. */
6029 d_print_function_type (struct d_print_info
*dpi
, int options
,
6030 struct demangle_component
*dc
,
6031 struct d_print_mod
*mods
)
6035 struct d_print_mod
*p
;
6036 struct d_print_mod
*hold_modifiers
;
6040 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6045 switch (p
->mod
->type
)
6047 case DEMANGLE_COMPONENT_POINTER
:
6048 case DEMANGLE_COMPONENT_REFERENCE
:
6049 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
6052 case DEMANGLE_COMPONENT_RESTRICT
:
6053 case DEMANGLE_COMPONENT_VOLATILE
:
6054 case DEMANGLE_COMPONENT_CONST
:
6055 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
6056 case DEMANGLE_COMPONENT_COMPLEX
:
6057 case DEMANGLE_COMPONENT_IMAGINARY
:
6058 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6062 FNQUAL_COMPONENT_CASE
:
6075 if (d_last_char (dpi
) != '('
6076 && d_last_char (dpi
) != '*')
6079 if (need_space
&& d_last_char (dpi
) != ' ')
6080 d_append_char (dpi
, ' ');
6081 d_append_char (dpi
, '(');
6084 hold_modifiers
= dpi
->modifiers
;
6085 dpi
->modifiers
= NULL
;
6087 d_print_mod_list (dpi
, options
, mods
, 0);
6090 d_append_char (dpi
, ')');
6092 d_append_char (dpi
, '(');
6094 if (d_right (dc
) != NULL
)
6095 d_print_comp (dpi
, options
, d_right (dc
));
6097 d_append_char (dpi
, ')');
6099 d_print_mod_list (dpi
, options
, mods
, 1);
6101 dpi
->modifiers
= hold_modifiers
;
6104 /* Print an array type, except for the element type. */
6107 d_print_array_type (struct d_print_info
*dpi
, int options
,
6108 struct demangle_component
*dc
,
6109 struct d_print_mod
*mods
)
6117 struct d_print_mod
*p
;
6120 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6124 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
6139 d_append_string (dpi
, " (");
6141 d_print_mod_list (dpi
, options
, mods
, 0);
6144 d_append_char (dpi
, ')');
6148 d_append_char (dpi
, ' ');
6150 d_append_char (dpi
, '[');
6152 if (d_left (dc
) != NULL
)
6153 d_print_comp (dpi
, options
, d_left (dc
));
6155 d_append_char (dpi
, ']');
6158 /* Print an operator in an expression. */
6161 d_print_expr_op (struct d_print_info
*dpi
, int options
,
6162 struct demangle_component
*dc
)
6164 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
6165 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
6166 dc
->u
.s_operator
.op
->len
);
6168 d_print_comp (dpi
, options
, dc
);
6174 d_print_cast (struct d_print_info
*dpi
, int options
,
6175 struct demangle_component
*dc
)
6177 d_print_comp (dpi
, options
, d_left (dc
));
6180 /* Print a conversion operator. */
6183 d_print_conversion (struct d_print_info
*dpi
, int options
,
6184 struct demangle_component
*dc
)
6186 struct d_print_template dpt
;
6188 /* For a conversion operator, we need the template parameters from
6189 the enclosing template in scope for processing the type. */
6190 if (dpi
->current_template
!= NULL
)
6192 dpt
.next
= dpi
->templates
;
6193 dpi
->templates
= &dpt
;
6194 dpt
.template_decl
= dpi
->current_template
;
6197 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
6199 d_print_comp (dpi
, options
, d_left (dc
));
6200 if (dpi
->current_template
!= NULL
)
6201 dpi
->templates
= dpt
.next
;
6205 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
6207 /* For a templated cast operator, we need to remove the template
6208 parameters from scope after printing the operator name,
6209 so we need to handle the template printing here. */
6210 if (dpi
->current_template
!= NULL
)
6211 dpi
->templates
= dpt
.next
;
6213 if (d_last_char (dpi
) == '<')
6214 d_append_char (dpi
, ' ');
6215 d_append_char (dpi
, '<');
6216 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
6217 /* Avoid generating two consecutive '>' characters, to avoid
6218 the C++ syntactic ambiguity. */
6219 if (d_last_char (dpi
) == '>')
6220 d_append_char (dpi
, ' ');
6221 d_append_char (dpi
, '>');
6225 /* Initialize the information structure we use to pass around
6228 CP_STATIC_IF_GLIBCPP_V3
6230 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
6234 di
->send
= mangled
+ len
;
6235 di
->options
= options
;
6239 /* We cannot need more components than twice the number of chars in
6240 the mangled string. Most components correspond directly to
6241 chars, but the ARGLIST types are exceptions. */
6242 di
->num_comps
= 2 * len
;
6245 /* Similarly, we cannot need more substitutions than there are
6246 chars in the mangled string. */
6250 di
->last_name
= NULL
;
6253 di
->is_expression
= 0;
6254 di
->is_conversion
= 0;
6255 di
->recursion_level
= 0;
6258 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6259 mangled name, return strings in repeated callback giving the demangled
6260 name. OPTIONS is the usual libiberty demangler options. On success,
6261 this returns 1. On failure, returns 0. */
6264 d_demangle_callback (const char *mangled
, int options
,
6265 demangle_callbackref callback
, void *opaque
)
6276 struct demangle_component
*dc
;
6279 if (mangled
[0] == '_' && mangled
[1] == 'Z')
6281 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
6282 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
6283 && (mangled
[9] == 'D' || mangled
[9] == 'I')
6284 && mangled
[10] == '_')
6285 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
6288 if ((options
& DMGL_TYPES
) == 0)
6293 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
6295 /* PR 87675 - Check for a mangled string that is so long
6296 that we do not have enough stack space to demangle it. */
6297 if (((options
& DMGL_NO_RECURSE_LIMIT
) == 0)
6298 /* This check is a bit arbitrary, since what we really want to do is to
6299 compare the sizes of the di.comps and di.subs arrays against the
6300 amount of stack space remaining. But there is no portable way to do
6301 this, so instead we use the recursion limit as a guide to the maximum
6302 size of the arrays. */
6303 && (unsigned long) di
.num_comps
> DEMANGLE_RECURSION_LIMIT
)
6305 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6310 #ifdef CP_DYNAMIC_ARRAYS
6311 __extension__
struct demangle_component comps
[di
.num_comps
];
6312 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6317 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6318 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6324 dc
= cplus_demangle_type (&di
);
6327 dc
= cplus_demangle_mangled_name (&di
, 1);
6329 case DCT_GLOBAL_CTORS
:
6330 case DCT_GLOBAL_DTORS
:
6331 d_advance (&di
, 11);
6332 dc
= d_make_comp (&di
,
6333 (type
== DCT_GLOBAL_CTORS
6334 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6335 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
6336 d_make_demangle_mangled_name (&di
, d_str (&di
)),
6338 d_advance (&di
, strlen (d_str (&di
)));
6341 abort (); /* We have listed all the cases. */
6344 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6345 mangled string, then we didn't successfully demangle it. If
6346 DMGL_PARAMS is not set, we didn't look at the trailing
6348 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
6351 #ifdef CP_DEMANGLE_DEBUG
6355 status
= (dc
!= NULL
)
6356 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
6363 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6364 name, return a buffer allocated with malloc holding the demangled
6365 name. OPTIONS is the usual libiberty demangler options. On
6366 success, this sets *PALC to the allocated size of the returned
6367 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6368 a memory allocation failure, and returns NULL. */
6371 d_demangle (const char *mangled
, int options
, size_t *palc
)
6373 struct d_growable_string dgs
;
6376 d_growable_string_init (&dgs
, 0);
6378 status
= d_demangle_callback (mangled
, options
,
6379 d_growable_string_callback_adapter
, &dgs
);
6387 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
6391 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6393 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6395 /* ia64 ABI-mandated entry point in the C++ runtime library for
6396 performing demangling. MANGLED_NAME is a NUL-terminated character
6397 string containing the name to be demangled.
6399 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6400 *LENGTH bytes, into which the demangled name is stored. If
6401 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6402 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6403 is placed in a region of memory allocated with malloc.
6405 If LENGTH is non-NULL, the length of the buffer containing the
6406 demangled name, is placed in *LENGTH.
6408 The return value is a pointer to the start of the NUL-terminated
6409 demangled name, or NULL if the demangling fails. The caller is
6410 responsible for deallocating this memory using free.
6412 *STATUS is set to one of the following values:
6413 0: The demangling operation succeeded.
6414 -1: A memory allocation failure occurred.
6415 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6416 -3: One of the arguments is invalid.
6418 The demangling is performed using the C++ ABI mangling rules, with
6422 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
6423 size_t *length
, int *status
)
6428 if (mangled_name
== NULL
)
6435 if (output_buffer
!= NULL
&& length
== NULL
)
6442 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
6444 if (demangled
== NULL
)
6456 if (output_buffer
== NULL
)
6463 if (strlen (demangled
) < *length
)
6465 strcpy (output_buffer
, demangled
);
6467 demangled
= output_buffer
;
6471 free (output_buffer
);
6482 extern int __gcclibcxx_demangle_callback (const char *,
6484 (const char *, size_t, void *),
6487 /* Alternative, allocationless entry point in the C++ runtime library
6488 for performing demangling. MANGLED_NAME is a NUL-terminated character
6489 string containing the name to be demangled.
6491 CALLBACK is a callback function, called with demangled string
6492 segments as demangling progresses; it is called at least once,
6493 but may be called more than once. OPAQUE is a generalized pointer
6494 used as a callback argument.
6496 The return code is one of the following values, equivalent to
6497 the STATUS values of __cxa_demangle() (excluding -1, since this
6498 function performs no memory allocations):
6499 0: The demangling operation succeeded.
6500 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6501 -3: One of the arguments is invalid.
6503 The demangling is performed using the C++ ABI mangling rules, with
6507 __gcclibcxx_demangle_callback (const char *mangled_name
,
6508 void (*callback
) (const char *, size_t, void *),
6513 if (mangled_name
== NULL
|| callback
== NULL
)
6516 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
6524 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6526 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6527 mangled name, return a buffer allocated with malloc holding the
6528 demangled name. Otherwise, return NULL. */
6531 cplus_demangle_v3 (const char *mangled
, int options
)
6535 return d_demangle (mangled
, options
, &alc
);
6539 cplus_demangle_v3_callback (const char *mangled
, int options
,
6540 demangle_callbackref callback
, void *opaque
)
6542 return d_demangle_callback (mangled
, options
, callback
, opaque
);
6545 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6546 conventions, but the output formatting is a little different.
6547 This instructs the C++ demangler not to emit pointer characters ("*"), to
6548 use Java's namespace separator symbol ("." instead of "::"), and to output
6549 JArray<TYPE> as TYPE[]. */
6552 java_demangle_v3 (const char *mangled
)
6556 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
6560 java_demangle_v3_callback (const char *mangled
,
6561 demangle_callbackref callback
, void *opaque
)
6563 return d_demangle_callback (mangled
,
6564 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
6568 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6570 #ifndef IN_GLIBCPP_V3
6572 /* Demangle a string in order to find out whether it is a constructor
6573 or destructor. Return non-zero on success. Set *CTOR_KIND and
6574 *DTOR_KIND appropriately. */
6577 is_ctor_or_dtor (const char *mangled
,
6578 enum gnu_v3_ctor_kinds
*ctor_kind
,
6579 enum gnu_v3_dtor_kinds
*dtor_kind
)
6582 struct demangle_component
*dc
;
6585 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
6586 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
6588 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
6591 #ifdef CP_DYNAMIC_ARRAYS
6592 __extension__
struct demangle_component comps
[di
.num_comps
];
6593 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6598 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6599 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6602 dc
= cplus_demangle_mangled_name (&di
, 1);
6604 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6605 to demangle the entire string. */
6612 /* These cannot appear on a constructor or destructor. */
6613 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6614 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6615 case DEMANGLE_COMPONENT_CONST_THIS
:
6616 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6617 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6621 case DEMANGLE_COMPONENT_TYPED_NAME
:
6622 case DEMANGLE_COMPONENT_TEMPLATE
:
6625 case DEMANGLE_COMPONENT_QUAL_NAME
:
6626 case DEMANGLE_COMPONENT_LOCAL_NAME
:
6629 case DEMANGLE_COMPONENT_CTOR
:
6630 *ctor_kind
= dc
->u
.s_ctor
.kind
;
6634 case DEMANGLE_COMPONENT_DTOR
:
6635 *dtor_kind
= dc
->u
.s_dtor
.kind
;
6646 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6647 name. A non-zero return indicates the type of constructor. */
6649 enum gnu_v3_ctor_kinds
6650 is_gnu_v3_mangled_ctor (const char *name
)
6652 enum gnu_v3_ctor_kinds ctor_kind
;
6653 enum gnu_v3_dtor_kinds dtor_kind
;
6655 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6656 return (enum gnu_v3_ctor_kinds
) 0;
6661 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6662 name. A non-zero return indicates the type of destructor. */
6664 enum gnu_v3_dtor_kinds
6665 is_gnu_v3_mangled_dtor (const char *name
)
6667 enum gnu_v3_ctor_kinds ctor_kind
;
6668 enum gnu_v3_dtor_kinds dtor_kind
;
6670 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6671 return (enum gnu_v3_dtor_kinds
) 0;
6675 #endif /* IN_GLIBCPP_V3 */
6677 #ifdef STANDALONE_DEMANGLER
6680 #include "dyn-string.h"
6682 static void print_usage (FILE* fp
, int exit_value
);
6684 #define IS_ALPHA(CHAR) \
6685 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6686 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6688 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6689 #define is_mangled_char(CHAR) \
6690 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6691 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6693 /* The name of this program, as invoked. */
6694 const char* program_name
;
6696 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6699 print_usage (FILE* fp
, int exit_value
)
6701 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
6702 fprintf (fp
, "Options:\n");
6703 fprintf (fp
, " -h,--help Display this message.\n");
6704 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
6705 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
6706 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6711 /* Option specification for getopt_long. */
6712 static const struct option long_options
[] =
6714 { "help", no_argument
, NULL
, 'h' },
6715 { "no-params", no_argument
, NULL
, 'p' },
6716 { "verbose", no_argument
, NULL
, 'v' },
6717 { NULL
, no_argument
, NULL
, 0 },
6720 /* Main entry for a demangling filter executable. It will demangle
6721 its command line arguments, if any. If none are provided, it will
6722 filter stdin to stdout, replacing any recognized mangled C++ names
6723 with their demangled equivalents. */
6726 main (int argc
, char *argv
[])
6730 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
6732 /* Use the program name of this program, as invoked. */
6733 program_name
= argv
[0];
6735 /* Parse options. */
6738 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
6741 case '?': /* Unrecognized option. */
6742 print_usage (stderr
, 1);
6746 print_usage (stdout
, 0);
6750 options
&= ~ DMGL_PARAMS
;
6754 options
|= DMGL_VERBOSE
;
6758 while (opt_char
!= -1);
6761 /* No command line arguments were provided. Filter stdin. */
6763 dyn_string_t mangled
= dyn_string_new (3);
6766 /* Read all of input. */
6767 while (!feof (stdin
))
6771 /* Pile characters into mangled until we hit one that can't
6772 occur in a mangled name. */
6774 while (!feof (stdin
) && is_mangled_char (c
))
6776 dyn_string_append_char (mangled
, c
);
6782 if (dyn_string_length (mangled
) > 0)
6784 #ifdef IN_GLIBCPP_V3
6785 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
6787 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
6797 /* It might not have been a mangled name. Print the
6799 fputs (dyn_string_buf (mangled
), stdout
);
6802 dyn_string_clear (mangled
);
6805 /* If we haven't hit EOF yet, we've read one character that
6806 can't occur in a mangled name, so print it out. */
6811 dyn_string_delete (mangled
);
6814 /* Demangle command line arguments. */
6816 /* Loop over command line arguments. */
6817 for (i
= optind
; i
< argc
; ++i
)
6820 #ifdef IN_GLIBCPP_V3
6824 /* Attempt to demangle. */
6825 #ifdef IN_GLIBCPP_V3
6826 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
6828 s
= cplus_demangle_v3 (argv
[i
], options
);
6831 /* If it worked, print the demangled name. */
6839 #ifdef IN_GLIBCPP_V3
6840 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
6842 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
6851 #endif /* STANDALONE_DEMANGLER */