1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003-2020 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 { "aw", NL ("co_await "), 1 },
1806 { "az", NL ("alignof "), 1 },
1807 { "cc", NL ("const_cast"), 2 },
1808 { "cl", NL ("()"), 2 },
1809 { "cm", NL (","), 2 },
1810 { "co", NL ("~"), 1 },
1811 { "dV", NL ("/="), 2 },
1812 { "da", NL ("delete[] "), 1 },
1813 { "dc", NL ("dynamic_cast"), 2 },
1814 { "de", NL ("*"), 1 },
1815 { "dl", NL ("delete "), 1 },
1816 { "ds", NL (".*"), 2 },
1817 { "dt", NL ("."), 2 },
1818 { "dv", NL ("/"), 2 },
1819 { "eO", NL ("^="), 2 },
1820 { "eo", NL ("^"), 2 },
1821 { "eq", NL ("=="), 2 },
1822 { "fL", NL ("..."), 3 },
1823 { "fR", NL ("..."), 3 },
1824 { "fl", NL ("..."), 2 },
1825 { "fr", NL ("..."), 2 },
1826 { "ge", NL (">="), 2 },
1827 { "gs", NL ("::"), 1 },
1828 { "gt", NL (">"), 2 },
1829 { "ix", NL ("[]"), 2 },
1830 { "lS", NL ("<<="), 2 },
1831 { "le", NL ("<="), 2 },
1832 { "li", NL ("operator\"\" "), 1 },
1833 { "ls", NL ("<<"), 2 },
1834 { "lt", NL ("<"), 2 },
1835 { "mI", NL ("-="), 2 },
1836 { "mL", NL ("*="), 2 },
1837 { "mi", NL ("-"), 2 },
1838 { "ml", NL ("*"), 2 },
1839 { "mm", NL ("--"), 1 },
1840 { "na", NL ("new[]"), 3 },
1841 { "ne", NL ("!="), 2 },
1842 { "ng", NL ("-"), 1 },
1843 { "nt", NL ("!"), 1 },
1844 { "nw", NL ("new"), 3 },
1845 { "oR", NL ("|="), 2 },
1846 { "oo", NL ("||"), 2 },
1847 { "or", NL ("|"), 2 },
1848 { "pL", NL ("+="), 2 },
1849 { "pl", NL ("+"), 2 },
1850 { "pm", NL ("->*"), 2 },
1851 { "pp", NL ("++"), 1 },
1852 { "ps", NL ("+"), 1 },
1853 { "pt", NL ("->"), 2 },
1854 { "qu", NL ("?"), 3 },
1855 { "rM", NL ("%="), 2 },
1856 { "rS", NL (">>="), 2 },
1857 { "rc", NL ("reinterpret_cast"), 2 },
1858 { "rm", NL ("%"), 2 },
1859 { "rs", NL (">>"), 2 },
1860 { "sP", NL ("sizeof..."), 1 },
1861 { "sZ", NL ("sizeof..."), 1 },
1862 { "sc", NL ("static_cast"), 2 },
1863 { "ss", NL ("<=>"), 2 },
1864 { "st", NL ("sizeof "), 1 },
1865 { "sz", NL ("sizeof "), 1 },
1866 { "tr", NL ("throw"), 0 },
1867 { "tw", NL ("throw "), 1 },
1868 { NULL
, NULL
, 0, 0 }
1871 static struct demangle_component
*
1872 d_operator_name (struct d_info
*di
)
1877 c1
= d_next_char (di
);
1878 c2
= d_next_char (di
);
1879 if (c1
== 'v' && IS_DIGIT (c2
))
1880 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1881 else if (c1
== 'c' && c2
== 'v')
1883 struct demangle_component
*type
;
1884 int was_conversion
= di
->is_conversion
;
1885 struct demangle_component
*res
;
1887 di
->is_conversion
= ! di
->is_expression
;
1888 type
= cplus_demangle_type (di
);
1889 if (di
->is_conversion
)
1890 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CONVERSION
, type
, NULL
);
1892 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CAST
, type
, NULL
);
1893 di
->is_conversion
= was_conversion
;
1898 /* LOW is the inclusive lower bound. */
1900 /* HIGH is the exclusive upper bound. We subtract one to ignore
1901 the sentinel at the end of the array. */
1902 int high
= ((sizeof (cplus_demangle_operators
)
1903 / sizeof (cplus_demangle_operators
[0]))
1909 const struct demangle_operator_info
*p
;
1911 i
= low
+ (high
- low
) / 2;
1912 p
= cplus_demangle_operators
+ i
;
1914 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1915 return d_make_operator (di
, p
);
1917 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1927 static struct demangle_component
*
1928 d_make_character (struct d_info
*di
, int c
)
1930 struct demangle_component
*p
;
1931 p
= d_make_empty (di
);
1934 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1935 p
->u
.s_character
.character
= c
;
1940 static struct demangle_component
*
1941 d_java_resource (struct d_info
*di
)
1943 struct demangle_component
*p
= NULL
;
1944 struct demangle_component
*next
= NULL
;
1949 len
= d_number (di
);
1953 /* Eat the leading '_'. */
1954 if (d_next_char (di
) != '_')
1967 /* Each chunk is either a '$' escape... */
1985 next
= d_make_character (di
, c
);
1993 /* ... or a sequence of characters. */
1996 while (i
< len
&& str
[i
] && str
[i
] != '$')
1999 next
= d_make_name (di
, str
, i
);
2012 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
2018 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
2023 /* <special-name> ::= TV <type>
2027 ::= TA <template-arg>
2028 ::= GV <(object) name>
2029 ::= T <call-offset> <(base) encoding>
2030 ::= Tc <call-offset> <call-offset> <(base) encoding>
2031 Also g++ extensions:
2032 ::= TC <type> <(offset) number> _ <(base) type>
2037 ::= Gr <resource name>
2042 static struct demangle_component
*
2043 d_special_name (struct d_info
*di
)
2045 di
->expansion
+= 20;
2046 if (d_check_char (di
, 'T'))
2048 switch (d_next_char (di
))
2052 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
2053 cplus_demangle_type (di
), NULL
);
2055 di
->expansion
-= 10;
2056 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
2057 cplus_demangle_type (di
), NULL
);
2059 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
2060 cplus_demangle_type (di
), NULL
);
2062 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
2063 cplus_demangle_type (di
), NULL
);
2066 if (! d_call_offset (di
, 'h'))
2068 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
2069 d_encoding (di
, 0), NULL
);
2072 if (! d_call_offset (di
, 'v'))
2074 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
2075 d_encoding (di
, 0), NULL
);
2078 if (! d_call_offset (di
, '\0'))
2080 if (! d_call_offset (di
, '\0'))
2082 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
2083 d_encoding (di
, 0), NULL
);
2087 struct demangle_component
*derived_type
;
2089 struct demangle_component
*base_type
;
2091 derived_type
= cplus_demangle_type (di
);
2092 offset
= d_number (di
);
2095 if (! d_check_char (di
, '_'))
2097 base_type
= cplus_demangle_type (di
);
2098 /* We don't display the offset. FIXME: We should display
2099 it in verbose mode. */
2101 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
2102 base_type
, derived_type
);
2106 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
2107 cplus_demangle_type (di
), NULL
);
2109 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
2110 cplus_demangle_type (di
), NULL
);
2113 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
2117 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
2121 return d_make_comp (di
, DEMANGLE_COMPONENT_TPARM_OBJ
,
2122 d_template_arg (di
), NULL
);
2128 else if (d_check_char (di
, 'G'))
2130 switch (d_next_char (di
))
2133 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
,
2138 struct demangle_component
*name
= d_name (di
);
2139 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
2140 d_number_component (di
));
2144 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
2145 d_encoding (di
, 0), NULL
);
2148 switch (d_next_char (di
))
2151 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
2152 d_encoding (di
, 0), NULL
);
2154 /* ??? The proposal is that other letters (such as 'h') stand
2155 for different variants of transaction cloning, such as
2156 compiling directly for hardware transaction support. But
2157 they still should all be transactional clones of some sort
2158 so go ahead and call them that. */
2160 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
2161 d_encoding (di
, 0), NULL
);
2165 return d_java_resource (di
);
2175 /* <call-offset> ::= h <nv-offset> _
2178 <nv-offset> ::= <(offset) number>
2180 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2182 The C parameter, if not '\0', is a character we just read which is
2183 the start of the <call-offset>.
2185 We don't display the offset information anywhere. FIXME: We should
2186 display it in verbose mode. */
2189 d_call_offset (struct d_info
*di
, int c
)
2192 c
= d_next_char (di
);
2199 if (! d_check_char (di
, '_'))
2206 if (! d_check_char (di
, '_'))
2212 /* <ctor-dtor-name> ::= C1
2220 static struct demangle_component
*
2221 d_ctor_dtor_name (struct d_info
*di
)
2223 if (di
->last_name
!= NULL
)
2225 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2226 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2227 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2228 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2230 switch (d_peek_char (di
))
2234 enum gnu_v3_ctor_kinds kind
;
2237 if (d_peek_next_char (di
) == 'I')
2243 switch (d_peek_next_char (di
))
2246 kind
= gnu_v3_complete_object_ctor
;
2249 kind
= gnu_v3_base_object_ctor
;
2252 kind
= gnu_v3_complete_object_allocating_ctor
;
2255 kind
= gnu_v3_unified_ctor
;
2258 kind
= gnu_v3_object_ctor_group
;
2267 cplus_demangle_type (di
);
2269 return d_make_ctor (di
, kind
, di
->last_name
);
2274 enum gnu_v3_dtor_kinds kind
;
2276 switch (d_peek_next_char (di
))
2279 kind
= gnu_v3_deleting_dtor
;
2282 kind
= gnu_v3_complete_object_dtor
;
2285 kind
= gnu_v3_base_object_dtor
;
2287 /* digit '3' is not used */
2289 kind
= gnu_v3_unified_dtor
;
2292 kind
= gnu_v3_object_dtor_group
;
2298 return d_make_dtor (di
, kind
, di
->last_name
);
2306 /* True iff we're looking at an order-insensitive type-qualifier, including
2307 function-type-qualifiers. */
2310 next_is_type_qual (struct d_info
*di
)
2312 char peek
= d_peek_char (di
);
2313 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2317 peek
= d_peek_next_char (di
);
2318 if (peek
== 'x' || peek
== 'o' || peek
== 'O' || peek
== 'w')
2324 /* <type> ::= <builtin-type>
2326 ::= <class-enum-type>
2328 ::= <pointer-to-member-type>
2329 ::= <template-param>
2330 ::= <template-template-param> <template-args>
2332 ::= <CV-qualifiers> <type>
2335 ::= O <type> (C++0x)
2338 ::= U <source-name> <type>
2340 <builtin-type> ::= various one letter codes
2344 CP_STATIC_IF_GLIBCPP_V3
2345 const struct demangle_builtin_type_info
2346 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2348 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2349 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2350 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2351 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2352 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2353 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2354 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2355 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2356 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2357 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2358 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2359 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2360 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2361 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2362 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2364 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2365 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2366 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2367 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2368 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2369 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2370 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2371 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2372 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2373 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2374 D_PRINT_UNSIGNED_LONG_LONG
},
2375 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2376 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2377 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2378 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2379 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2380 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT
},
2381 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2382 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2383 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2387 CP_STATIC_IF_GLIBCPP_V3
2388 struct demangle_component
*
2389 cplus_demangle_type (struct d_info
*di
)
2392 struct demangle_component
*ret
;
2395 /* The ABI specifies that when CV-qualifiers are used, the base type
2396 is substitutable, and the fully qualified type is substitutable,
2397 but the base type with a strict subset of the CV-qualifiers is
2398 not substitutable. The natural recursive implementation of the
2399 CV-qualifiers would cause subsets to be substitutable, so instead
2400 we pull them all off now.
2402 FIXME: The ABI says that order-insensitive vendor qualifiers
2403 should be handled in the same way, but we have no way to tell
2404 which vendor qualifiers are order-insensitive and which are
2405 order-sensitive. So we just assume that they are all
2406 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2407 __vector, and it treats it as order-sensitive when mangling
2410 if (next_is_type_qual (di
))
2412 struct demangle_component
**pret
;
2414 pret
= d_cv_qualifiers (di
, &ret
, 0);
2417 if (d_peek_char (di
) == 'F')
2419 /* cv-qualifiers before a function type apply to 'this',
2420 so avoid adding the unqualified function type to
2421 the substitution list. */
2422 *pret
= d_function_type (di
);
2425 *pret
= cplus_demangle_type (di
);
2428 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2429 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2431 /* Move the ref-qualifier outside the cv-qualifiers so that
2432 they are printed in the right order. */
2433 struct demangle_component
*fn
= d_left (*pret
);
2434 d_left (*pret
) = ret
;
2438 if (! d_add_substitution (di
, ret
))
2445 peek
= d_peek_char (di
);
2448 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2449 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2450 case 'o': case 's': case 't':
2451 case 'v': case 'w': case 'x': case 'y': case 'z':
2452 ret
= d_make_builtin_type (di
,
2453 &cplus_demangle_builtin_types
[peek
- 'a']);
2454 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2461 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2462 d_source_name (di
), NULL
);
2466 ret
= d_function_type (di
);
2469 case '0': case '1': case '2': case '3': case '4':
2470 case '5': case '6': case '7': case '8': case '9':
2473 ret
= d_class_enum_type (di
);
2477 ret
= d_array_type (di
);
2481 ret
= d_pointer_to_member_type (di
);
2485 ret
= d_template_param (di
);
2486 if (d_peek_char (di
) == 'I')
2488 /* This may be <template-template-param> <template-args>.
2489 If this is the type for a conversion operator, we can
2490 have a <template-template-param> here only by following
2491 a derivation like this:
2494 -> <template-prefix> <template-args>
2495 -> <prefix> <template-unqualified-name> <template-args>
2496 -> <unqualified-name> <template-unqualified-name> <template-args>
2497 -> <source-name> <template-unqualified-name> <template-args>
2498 -> <source-name> <operator-name> <template-args>
2499 -> <source-name> cv <type> <template-args>
2500 -> <source-name> cv <template-template-param> <template-args> <template-args>
2502 where the <template-args> is followed by another.
2503 Otherwise, we must have a derivation like this:
2506 -> <template-prefix> <template-args>
2507 -> <prefix> <template-unqualified-name> <template-args>
2508 -> <unqualified-name> <template-unqualified-name> <template-args>
2509 -> <source-name> <template-unqualified-name> <template-args>
2510 -> <source-name> <operator-name> <template-args>
2511 -> <source-name> cv <type> <template-args>
2512 -> <source-name> cv <template-param> <template-args>
2514 where we need to leave the <template-args> to be processed
2515 by d_prefix (following the <template-prefix>).
2517 The <template-template-param> part is a substitution
2519 if (! di
->is_conversion
)
2521 if (! d_add_substitution (di
, ret
))
2523 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2524 d_template_args (di
));
2528 struct demangle_component
*args
;
2529 struct d_info_checkpoint checkpoint
;
2531 d_checkpoint (di
, &checkpoint
);
2532 args
= d_template_args (di
);
2533 if (d_peek_char (di
) == 'I')
2535 if (! d_add_substitution (di
, ret
))
2537 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2541 d_backtrack (di
, &checkpoint
);
2547 /* If this is a special substitution, then it is the start of
2548 <class-enum-type>. */
2552 peek_next
= d_peek_next_char (di
);
2553 if (IS_DIGIT (peek_next
)
2555 || IS_UPPER (peek_next
))
2557 ret
= d_substitution (di
, 0);
2558 /* The substituted name may have been a template name and
2559 may be followed by tepmlate args. */
2560 if (d_peek_char (di
) == 'I')
2561 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2562 d_template_args (di
));
2568 ret
= d_class_enum_type (di
);
2569 /* If the substitution was a complete type, then it is not
2570 a new substitution candidate. However, if the
2571 substitution was followed by template arguments, then
2572 the whole thing is a substitution candidate. */
2573 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2581 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2582 cplus_demangle_type (di
), NULL
);
2587 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2588 cplus_demangle_type (di
), NULL
);
2593 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2594 cplus_demangle_type (di
), NULL
);
2599 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2600 cplus_demangle_type (di
), NULL
);
2605 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2606 cplus_demangle_type (di
), NULL
);
2611 ret
= d_source_name (di
);
2612 if (d_peek_char (di
) == 'I')
2613 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2614 d_template_args (di
));
2615 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2616 cplus_demangle_type (di
), ret
);
2622 peek
= d_next_char (di
);
2627 /* decltype (expression) */
2628 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2629 d_expression (di
), NULL
);
2630 if (ret
&& d_next_char (di
) != 'E')
2636 /* Pack expansion. */
2637 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2638 cplus_demangle_type (di
), NULL
);
2644 ret
= d_make_name (di
, "auto", 4);
2647 /* decltype(auto) */
2648 ret
= d_make_name (di
, "decltype(auto)", 14);
2652 /* 32-bit decimal floating point */
2653 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2654 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2658 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2659 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2663 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2664 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2667 /* 16-bit half-precision FP */
2668 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2669 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2673 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2674 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2678 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2679 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2683 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2684 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2688 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2689 ret
= d_make_empty (di
);
2690 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2691 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2692 /* For demangling we don't care about the bits. */
2694 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2695 if (ret
->u
.s_fixed
.length
== NULL
)
2698 peek
= d_next_char (di
);
2699 ret
->u
.s_fixed
.sat
= (peek
== 's');
2703 ret
= d_vector_type (di
);
2708 /* decltype(nullptr) */
2709 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[33]);
2710 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2724 if (! d_add_substitution (di
, ret
))
2731 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2733 static struct demangle_component
**
2734 d_cv_qualifiers (struct d_info
*di
,
2735 struct demangle_component
**pret
, int member_fn
)
2737 struct demangle_component
**pstart
;
2741 peek
= d_peek_char (di
);
2742 while (next_is_type_qual (di
))
2744 enum demangle_component_type t
;
2745 struct demangle_component
*right
= NULL
;
2751 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2752 : DEMANGLE_COMPONENT_RESTRICT
);
2753 di
->expansion
+= sizeof "restrict";
2755 else if (peek
== 'V')
2758 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2759 : DEMANGLE_COMPONENT_VOLATILE
);
2760 di
->expansion
+= sizeof "volatile";
2762 else if (peek
== 'K')
2765 ? DEMANGLE_COMPONENT_CONST_THIS
2766 : DEMANGLE_COMPONENT_CONST
);
2767 di
->expansion
+= sizeof "const";
2771 peek
= d_next_char (di
);
2774 t
= DEMANGLE_COMPONENT_TRANSACTION_SAFE
;
2775 di
->expansion
+= sizeof "transaction_safe";
2777 else if (peek
== 'o'
2780 t
= DEMANGLE_COMPONENT_NOEXCEPT
;
2781 di
->expansion
+= sizeof "noexcept";
2784 right
= d_expression (di
);
2787 if (! d_check_char (di
, 'E'))
2791 else if (peek
== 'w')
2793 t
= DEMANGLE_COMPONENT_THROW_SPEC
;
2794 di
->expansion
+= sizeof "throw";
2795 right
= d_parmlist (di
);
2798 if (! d_check_char (di
, 'E'))
2805 *pret
= d_make_comp (di
, t
, NULL
, right
);
2808 pret
= &d_left (*pret
);
2810 peek
= d_peek_char (di
);
2813 if (!member_fn
&& peek
== 'F')
2815 while (pstart
!= pret
)
2817 switch ((*pstart
)->type
)
2819 case DEMANGLE_COMPONENT_RESTRICT
:
2820 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2822 case DEMANGLE_COMPONENT_VOLATILE
:
2823 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2825 case DEMANGLE_COMPONENT_CONST
:
2826 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2831 pstart
= &d_left (*pstart
);
2838 /* <ref-qualifier> ::= R
2841 static struct demangle_component
*
2842 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2844 struct demangle_component
*ret
= sub
;
2847 peek
= d_peek_char (di
);
2848 if (peek
== 'R' || peek
== 'O')
2850 enum demangle_component_type t
;
2853 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2854 di
->expansion
+= sizeof "&";
2858 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2859 di
->expansion
+= sizeof "&&";
2863 ret
= d_make_comp (di
, t
, ret
, NULL
);
2869 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2871 static struct demangle_component
*
2872 d_function_type (struct d_info
*di
)
2874 struct demangle_component
*ret
= NULL
;
2876 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2878 if (di
->recursion_level
> DEMANGLE_RECURSION_LIMIT
)
2879 /* FIXME: There ought to be a way to report
2880 that the recursion limit has been reached. */
2883 di
->recursion_level
++;
2886 if (d_check_char (di
, 'F'))
2888 if (d_peek_char (di
) == 'Y')
2890 /* Function has C linkage. We don't print this information.
2891 FIXME: We should print it in verbose mode. */
2894 ret
= d_bare_function_type (di
, 1);
2895 ret
= d_ref_qualifier (di
, ret
);
2897 if (! d_check_char (di
, 'E'))
2901 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2902 di
->recursion_level
--;
2908 static struct demangle_component
*
2909 d_parmlist (struct d_info
*di
)
2911 struct demangle_component
*tl
;
2912 struct demangle_component
**ptl
;
2918 struct demangle_component
*type
;
2920 char peek
= d_peek_char (di
);
2921 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2923 if ((peek
== 'R' || peek
== 'O')
2924 && d_peek_next_char (di
) == 'E')
2925 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2927 type
= cplus_demangle_type (di
);
2930 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2933 ptl
= &d_right (*ptl
);
2936 /* There should be at least one parameter type besides the optional
2937 return type. A function which takes no arguments will have a
2938 single parameter type void. */
2942 /* If we have a single parameter type void, omit it. */
2943 if (d_right (tl
) == NULL
2944 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2945 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2947 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2954 /* <bare-function-type> ::= [J]<type>+ */
2956 static struct demangle_component
*
2957 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2959 struct demangle_component
*return_type
;
2960 struct demangle_component
*tl
;
2963 /* Detect special qualifier indicating that the first argument
2964 is the return type. */
2965 peek
= d_peek_char (di
);
2969 has_return_type
= 1;
2972 if (has_return_type
)
2974 return_type
= cplus_demangle_type (di
);
2975 if (return_type
== NULL
)
2981 tl
= d_parmlist (di
);
2985 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2989 /* <class-enum-type> ::= <name> */
2991 static struct demangle_component
*
2992 d_class_enum_type (struct d_info
*di
)
2997 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2998 ::= A [<(dimension) expression>] _ <(element) type>
3001 static struct demangle_component
*
3002 d_array_type (struct d_info
*di
)
3005 struct demangle_component
*dim
;
3007 if (! d_check_char (di
, 'A'))
3010 peek
= d_peek_char (di
);
3013 else if (IS_DIGIT (peek
))
3021 peek
= d_peek_char (di
);
3023 while (IS_DIGIT (peek
));
3024 dim
= d_make_name (di
, s
, d_str (di
) - s
);
3030 dim
= d_expression (di
);
3035 if (! d_check_char (di
, '_'))
3038 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
3039 cplus_demangle_type (di
));
3042 /* <vector-type> ::= Dv <number> _ <type>
3043 ::= Dv _ <expression> _ <type> */
3045 static struct demangle_component
*
3046 d_vector_type (struct d_info
*di
)
3049 struct demangle_component
*dim
;
3051 peek
= d_peek_char (di
);
3055 dim
= d_expression (di
);
3058 dim
= d_number_component (di
);
3063 if (! d_check_char (di
, '_'))
3066 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
3067 cplus_demangle_type (di
));
3070 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3072 static struct demangle_component
*
3073 d_pointer_to_member_type (struct d_info
*di
)
3075 struct demangle_component
*cl
;
3076 struct demangle_component
*mem
;
3078 if (! d_check_char (di
, 'M'))
3081 cl
= cplus_demangle_type (di
);
3085 /* The ABI says, "The type of a non-static member function is considered
3086 to be different, for the purposes of substitution, from the type of a
3087 namespace-scope or static member function whose type appears
3088 similar. The types of two non-static member functions are considered
3089 to be different, for the purposes of substitution, if the functions
3090 are members of different classes. In other words, for the purposes of
3091 substitution, the class of which the function is a member is
3092 considered part of the type of function."
3094 For a pointer to member function, this call to cplus_demangle_type
3095 will end up adding a (possibly qualified) non-member function type to
3096 the substitution table, which is not correct; however, the member
3097 function type will never be used in a substitution, so putting the
3098 wrong type in the substitution table is harmless. */
3100 mem
= cplus_demangle_type (di
);
3104 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
3107 /* <non-negative number> _ */
3110 d_compact_number (struct d_info
*di
)
3113 if (d_peek_char (di
) == '_')
3115 else if (d_peek_char (di
) == 'n')
3118 num
= d_number (di
) + 1;
3120 if (num
< 0 || ! d_check_char (di
, '_'))
3125 /* <template-param> ::= T_
3126 ::= T <(parameter-2 non-negative) number> _
3129 static struct demangle_component
*
3130 d_template_param (struct d_info
*di
)
3134 if (! d_check_char (di
, 'T'))
3137 param
= d_compact_number (di
);
3141 return d_make_template_param (di
, param
);
3144 /* <template-args> ::= I <template-arg>+ E */
3146 static struct demangle_component
*
3147 d_template_args (struct d_info
*di
)
3149 if (d_peek_char (di
) != 'I'
3150 && d_peek_char (di
) != 'J')
3154 return d_template_args_1 (di
);
3157 /* <template-arg>* E */
3159 static struct demangle_component
*
3160 d_template_args_1 (struct d_info
*di
)
3162 struct demangle_component
*hold_last_name
;
3163 struct demangle_component
*al
;
3164 struct demangle_component
**pal
;
3166 /* Preserve the last name we saw--don't let the template arguments
3167 clobber it, as that would give us the wrong name for a subsequent
3168 constructor or destructor. */
3169 hold_last_name
= di
->last_name
;
3171 if (d_peek_char (di
) == 'E')
3173 /* An argument pack can be empty. */
3175 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
3182 struct demangle_component
*a
;
3184 a
= d_template_arg (di
);
3188 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
3191 pal
= &d_right (*pal
);
3193 if (d_peek_char (di
) == 'E')
3200 di
->last_name
= hold_last_name
;
3205 /* <template-arg> ::= <type>
3206 ::= X <expression> E
3210 static struct demangle_component
*
3211 d_template_arg (struct d_info
*di
)
3213 struct demangle_component
*ret
;
3215 switch (d_peek_char (di
))
3219 ret
= d_expression (di
);
3220 if (! d_check_char (di
, 'E'))
3225 return d_expr_primary (di
);
3229 /* An argument pack. */
3230 return d_template_args (di
);
3233 return cplus_demangle_type (di
);
3237 /* Parse a sequence of expressions until we hit the terminator
3240 static struct demangle_component
*
3241 d_exprlist (struct d_info
*di
, char terminator
)
3243 struct demangle_component
*list
= NULL
;
3244 struct demangle_component
**p
= &list
;
3246 if (d_peek_char (di
) == terminator
)
3249 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
3254 struct demangle_component
*arg
= d_expression (di
);
3258 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
3263 if (d_peek_char (di
) == terminator
)
3273 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3274 dynamic_cast, static_cast or reinterpret_cast. */
3277 op_is_new_cast (struct demangle_component
*op
)
3279 const char *code
= op
->u
.s_operator
.op
->code
;
3280 return (code
[1] == 'c'
3281 && (code
[0] == 's' || code
[0] == 'd'
3282 || code
[0] == 'c' || code
[0] == 'r'));
3285 /* <expression> ::= <(unary) operator-name> <expression>
3286 ::= <(binary) operator-name> <expression> <expression>
3287 ::= <(trinary) operator-name> <expression> <expression> <expression>
3288 ::= cl <expression>+ E
3290 ::= <template-param>
3291 ::= sr <type> <unqualified-name>
3292 ::= sr <type> <unqualified-name> <template-args>
3296 static inline struct demangle_component
*
3297 d_expression_1 (struct d_info
*di
)
3301 peek
= d_peek_char (di
);
3303 return d_expr_primary (di
);
3304 else if (peek
== 'T')
3305 return d_template_param (di
);
3306 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
3308 struct demangle_component
*type
;
3309 struct demangle_component
*name
;
3312 type
= cplus_demangle_type (di
);
3313 name
= d_unqualified_name (di
);
3314 if (d_peek_char (di
) != 'I')
3315 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
3317 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
3318 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3319 d_template_args (di
)));
3321 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3324 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3325 d_expression_1 (di
), NULL
);
3327 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3329 /* Function parameter used in a late-specified return type. */
3332 if (d_peek_char (di
) == 'T')
3334 /* 'this' parameter. */
3340 index
= d_compact_number (di
);
3341 if (index
== INT_MAX
|| index
== -1)
3345 return d_make_function_param (di
, index
);
3347 else if (IS_DIGIT (peek
)
3348 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3350 /* We can get an unqualified name as an expression in the case of
3351 a dependent function call, i.e. decltype(f(t)). */
3352 struct demangle_component
*name
;
3355 /* operator-function-id, i.e. operator+(t). */
3358 name
= d_unqualified_name (di
);
3361 if (d_peek_char (di
) == 'I')
3362 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3363 d_template_args (di
));
3367 else if ((peek
== 'i' || peek
== 't')
3368 && d_peek_next_char (di
) == 'l')
3370 /* Brace-enclosed initializer list, untyped or typed. */
3371 struct demangle_component
*type
= NULL
;
3374 type
= cplus_demangle_type (di
);
3375 if (!d_peek_char (di
) || !d_peek_next_char (di
))
3377 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3378 type
, d_exprlist (di
, 'E'));
3382 struct demangle_component
*op
;
3383 const char *code
= NULL
;
3386 op
= d_operator_name (di
);
3390 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3392 code
= op
->u
.s_operator
.op
->code
;
3393 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3394 if (strcmp (code
, "st") == 0)
3395 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3396 cplus_demangle_type (di
));
3403 case DEMANGLE_COMPONENT_OPERATOR
:
3404 args
= op
->u
.s_operator
.op
->args
;
3406 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3407 args
= op
->u
.s_extended_operator
.args
;
3409 case DEMANGLE_COMPONENT_CAST
:
3417 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3421 struct demangle_component
*operand
;
3424 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3425 && code
[1] == code
[0])
3426 /* pp_ and mm_ are the prefix variants. */
3427 suffix
= !d_check_char (di
, '_');
3429 if (op
->type
== DEMANGLE_COMPONENT_CAST
3430 && d_check_char (di
, '_'))
3431 operand
= d_exprlist (di
, 'E');
3432 else if (code
&& !strcmp (code
, "sP"))
3433 operand
= d_template_args_1 (di
);
3435 operand
= d_expression_1 (di
);
3438 /* Indicate the suffix variant for d_print_comp. */
3439 operand
= d_make_comp (di
, DEMANGLE_COMPONENT_BINARY_ARGS
,
3442 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
, operand
);
3446 struct demangle_component
*left
;
3447 struct demangle_component
*right
;
3451 if (op_is_new_cast (op
))
3452 left
= cplus_demangle_type (di
);
3453 else if (code
[0] == 'f')
3454 /* fold-expression. */
3455 left
= d_operator_name (di
);
3457 left
= d_expression_1 (di
);
3458 if (!strcmp (code
, "cl"))
3459 right
= d_exprlist (di
, 'E');
3460 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3462 right
= d_unqualified_name (di
);
3463 if (d_peek_char (di
) == 'I')
3464 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3465 right
, d_template_args (di
));
3468 right
= d_expression_1 (di
);
3470 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3472 DEMANGLE_COMPONENT_BINARY_ARGS
,
3477 struct demangle_component
*first
;
3478 struct demangle_component
*second
;
3479 struct demangle_component
*third
;
3483 else if (!strcmp (code
, "qu"))
3485 /* ?: expression. */
3486 first
= d_expression_1 (di
);
3487 second
= d_expression_1 (di
);
3488 third
= d_expression_1 (di
);
3492 else if (code
[0] == 'f')
3494 /* fold-expression. */
3495 first
= d_operator_name (di
);
3496 second
= d_expression_1 (di
);
3497 third
= d_expression_1 (di
);
3501 else if (code
[0] == 'n')
3503 /* new-expression. */
3504 if (code
[1] != 'w' && code
[1] != 'a')
3506 first
= d_exprlist (di
, '_');
3507 second
= cplus_demangle_type (di
);
3508 if (d_peek_char (di
) == 'E')
3513 else if (d_peek_char (di
) == 'p'
3514 && d_peek_next_char (di
) == 'i')
3516 /* Parenthesized initializer. */
3518 third
= d_exprlist (di
, 'E');
3520 else if (d_peek_char (di
) == 'i'
3521 && d_peek_next_char (di
) == 'l')
3522 /* initializer-list. */
3523 third
= d_expression_1 (di
);
3529 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3531 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3534 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3543 static struct demangle_component
*
3544 d_expression (struct d_info
*di
)
3546 struct demangle_component
*ret
;
3547 int was_expression
= di
->is_expression
;
3549 di
->is_expression
= 1;
3550 ret
= d_expression_1 (di
);
3551 di
->is_expression
= was_expression
;
3555 /* <expr-primary> ::= L <type> <(value) number> E
3556 ::= L <type> <(value) float> E
3557 ::= L <mangled-name> E
3560 static struct demangle_component
*
3561 d_expr_primary (struct d_info
*di
)
3563 struct demangle_component
*ret
;
3565 if (! d_check_char (di
, 'L'))
3567 if (d_peek_char (di
) == '_'
3568 /* Workaround for G++ bug; see comment in write_template_arg. */
3569 || d_peek_char (di
) == 'Z')
3570 ret
= cplus_demangle_mangled_name (di
, 0);
3573 struct demangle_component
*type
;
3574 enum demangle_component_type t
;
3577 type
= cplus_demangle_type (di
);
3581 /* If we have a type we know how to print, we aren't going to
3582 print the type name itself. */
3583 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3584 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3585 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3587 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3588 && strcmp (type
->u
.s_builtin
.type
->name
,
3589 cplus_demangle_builtin_types
[33].name
) == 0)
3591 if (d_peek_char (di
) == 'E')
3598 /* Rather than try to interpret the literal value, we just
3599 collect it as a string. Note that it's possible to have a
3600 floating point literal here. The ABI specifies that the
3601 format of such literals is machine independent. That's fine,
3602 but what's not fine is that versions of g++ up to 3.2 with
3603 -fabi-version=1 used upper case letters in the hex constant,
3604 and dumped out gcc's internal representation. That makes it
3605 hard to tell where the constant ends, and hard to dump the
3606 constant in any readable form anyhow. We don't attempt to
3607 handle these cases. */
3609 t
= DEMANGLE_COMPONENT_LITERAL
;
3610 if (d_peek_char (di
) == 'n')
3612 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3616 while (d_peek_char (di
) != 'E')
3618 if (d_peek_char (di
) == '\0')
3622 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3624 if (! d_check_char (di
, 'E'))
3629 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3630 ::= Z <(function) encoding> E s [<discriminator>]
3631 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3634 static struct demangle_component
*
3635 d_local_name (struct d_info
*di
)
3637 struct demangle_component
*function
;
3638 struct demangle_component
*name
;
3640 if (! d_check_char (di
, 'Z'))
3643 function
= d_encoding (di
, 0);
3647 if (! d_check_char (di
, 'E'))
3650 if (d_peek_char (di
) == 's')
3653 if (! d_discriminator (di
))
3655 name
= d_make_name (di
, "string literal", sizeof "string literal" - 1);
3661 if (d_peek_char (di
) == 'd')
3663 /* Default argument scope: d <number> _. */
3665 num
= d_compact_number (di
);
3673 /* Lambdas and unnamed types have internal discriminators
3674 and are not functions. */
3675 && name
->type
!= DEMANGLE_COMPONENT_LAMBDA
3676 && name
->type
!= DEMANGLE_COMPONENT_UNNAMED_TYPE
)
3678 /* Read and ignore an optional discriminator. */
3679 if (! d_discriminator (di
))
3684 name
= d_make_default_arg (di
, num
, name
);
3687 /* Elide the return type of the containing function so as to not
3688 confuse the user thinking it is the return type of whatever local
3689 function we might be containing. */
3690 if (function
->type
== DEMANGLE_COMPONENT_TYPED_NAME
3691 && d_right (function
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3692 d_left (d_right (function
)) = NULL
;
3694 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3697 /* <discriminator> ::= _ <number> # when number < 10
3698 ::= __ <number> _ # when number >= 10
3700 <discriminator> ::= _ <number> # when number >=10
3701 is also accepted to support gcc versions that wrongly mangled that way.
3703 We demangle the discriminator, but we don't print it out. FIXME:
3704 We should print it out in verbose mode. */
3707 d_discriminator (struct d_info
*di
)
3709 int discrim
, num_underscores
= 1;
3711 if (d_peek_char (di
) != '_')
3714 if (d_peek_char (di
) == '_')
3720 discrim
= d_number (di
);
3723 if (num_underscores
> 1 && discrim
>= 10)
3725 if (d_peek_char (di
) == '_')
3734 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3736 static struct demangle_component
*
3737 d_lambda (struct d_info
*di
)
3739 struct demangle_component
*tl
;
3740 struct demangle_component
*ret
;
3743 if (! d_check_char (di
, 'U'))
3745 if (! d_check_char (di
, 'l'))
3748 tl
= d_parmlist (di
);
3752 if (! d_check_char (di
, 'E'))
3755 num
= d_compact_number (di
);
3759 ret
= d_make_empty (di
);
3762 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3763 ret
->u
.s_unary_num
.sub
= tl
;
3764 ret
->u
.s_unary_num
.num
= num
;
3767 if (! d_add_substitution (di
, ret
))
3773 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3775 static struct demangle_component
*
3776 d_unnamed_type (struct d_info
*di
)
3778 struct demangle_component
*ret
;
3781 if (! d_check_char (di
, 'U'))
3783 if (! d_check_char (di
, 't'))
3786 num
= d_compact_number (di
);
3790 ret
= d_make_empty (di
);
3793 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3794 ret
->u
.s_number
.number
= num
;
3797 if (! d_add_substitution (di
, ret
))
3803 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3806 static struct demangle_component
*
3807 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3809 const char *suffix
= d_str (di
);
3810 const char *pend
= suffix
;
3811 struct demangle_component
*n
;
3813 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3816 while (IS_LOWER (*pend
) || *pend
== '_')
3819 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3822 while (IS_DIGIT (*pend
))
3825 d_advance (di
, pend
- suffix
);
3826 n
= d_make_name (di
, suffix
, pend
- suffix
);
3827 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3830 /* Add a new substitution. */
3833 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3837 if (di
->next_sub
>= di
->num_subs
)
3839 di
->subs
[di
->next_sub
] = dc
;
3844 /* <substitution> ::= S <seq-id> _
3854 If PREFIX is non-zero, then this type is being used as a prefix in
3855 a qualified name. In this case, for the standard substitutions, we
3856 need to check whether we are being used as a prefix for a
3857 constructor or destructor, and return a full template name.
3858 Otherwise we will get something like std::iostream::~iostream()
3859 which does not correspond particularly well to any function which
3860 actually appears in the source.
3863 static const struct d_standard_sub_info standard_subs
[] =
3868 { 'a', NL ("std::allocator"),
3869 NL ("std::allocator"),
3871 { 'b', NL ("std::basic_string"),
3872 NL ("std::basic_string"),
3873 NL ("basic_string") },
3874 { 's', NL ("std::string"),
3875 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3876 NL ("basic_string") },
3877 { 'i', NL ("std::istream"),
3878 NL ("std::basic_istream<char, std::char_traits<char> >"),
3879 NL ("basic_istream") },
3880 { 'o', NL ("std::ostream"),
3881 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3882 NL ("basic_ostream") },
3883 { 'd', NL ("std::iostream"),
3884 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3885 NL ("basic_iostream") }
3888 static struct demangle_component
*
3889 d_substitution (struct d_info
*di
, int prefix
)
3893 if (! d_check_char (di
, 'S'))
3896 c
= d_next_char (di
);
3897 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3906 unsigned int new_id
;
3909 new_id
= id
* 36 + c
- '0';
3910 else if (IS_UPPER (c
))
3911 new_id
= id
* 36 + c
- 'A' + 10;
3917 c
= d_next_char (di
);
3924 if (id
>= (unsigned int) di
->next_sub
)
3927 return di
->subs
[id
];
3932 const struct d_standard_sub_info
*p
;
3933 const struct d_standard_sub_info
*pend
;
3935 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3936 if (! verbose
&& prefix
)
3940 peek
= d_peek_char (di
);
3941 if (peek
== 'C' || peek
== 'D')
3945 pend
= (&standard_subs
[0]
3946 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3947 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3953 struct demangle_component
*dc
;
3955 if (p
->set_last_name
!= NULL
)
3956 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3957 p
->set_last_name_len
);
3960 s
= p
->full_expansion
;
3965 s
= p
->simple_expansion
;
3966 len
= p
->simple_len
;
3968 di
->expansion
+= len
;
3969 dc
= d_make_sub (di
, s
, len
);
3970 if (d_peek_char (di
) == 'B')
3972 /* If there are ABI tags on the abbreviation, it becomes
3973 a substitution candidate. */
3974 dc
= d_abi_tags (di
, dc
);
3975 if (! d_add_substitution (di
, dc
))
3987 d_checkpoint (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3989 checkpoint
->n
= di
->n
;
3990 checkpoint
->next_comp
= di
->next_comp
;
3991 checkpoint
->next_sub
= di
->next_sub
;
3992 checkpoint
->expansion
= di
->expansion
;
3996 d_backtrack (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3998 di
->n
= checkpoint
->n
;
3999 di
->next_comp
= checkpoint
->next_comp
;
4000 di
->next_sub
= checkpoint
->next_sub
;
4001 di
->expansion
= checkpoint
->expansion
;
4004 /* Initialize a growable string. */
4007 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
4012 dgs
->allocation_failure
= 0;
4015 d_growable_string_resize (dgs
, estimate
);
4018 /* Grow a growable string to a given size. */
4021 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
4026 if (dgs
->allocation_failure
)
4029 /* Start allocation at two bytes to avoid any possibility of confusion
4030 with the special value of 1 used as a return in *palc to indicate
4031 allocation failures. */
4032 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
4033 while (newalc
< need
)
4036 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
4043 dgs
->allocation_failure
= 1;
4050 /* Append a buffer to a growable string. */
4053 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
4054 const char *s
, size_t l
)
4058 need
= dgs
->len
+ l
+ 1;
4059 if (need
> dgs
->alc
)
4060 d_growable_string_resize (dgs
, need
);
4062 if (dgs
->allocation_failure
)
4065 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
4066 dgs
->buf
[dgs
->len
+ l
] = '\0';
4070 /* Bridge growable strings to the callback mechanism. */
4073 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
4075 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
4077 d_growable_string_append_buffer (dgs
, s
, l
);
4080 /* Walk the tree, counting the number of templates encountered, and
4081 the number of times a scope might be saved. These counts will be
4082 used to allocate data structures for d_print_comp, so the logic
4083 here must mirror the logic d_print_comp will use. It is not
4084 important that the resulting numbers are exact, so long as they
4085 are larger than the actual numbers encountered. */
4088 d_count_templates_scopes (struct d_print_info
*dpi
,
4089 struct demangle_component
*dc
)
4091 if (dc
== NULL
|| dc
->d_counting
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
4098 case DEMANGLE_COMPONENT_NAME
:
4099 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4100 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4101 case DEMANGLE_COMPONENT_SUB_STD
:
4102 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4103 case DEMANGLE_COMPONENT_OPERATOR
:
4104 case DEMANGLE_COMPONENT_CHARACTER
:
4105 case DEMANGLE_COMPONENT_NUMBER
:
4106 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4109 case DEMANGLE_COMPONENT_TEMPLATE
:
4110 dpi
->num_copy_templates
++;
4111 goto recurse_left_right
;
4113 case DEMANGLE_COMPONENT_REFERENCE
:
4114 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4115 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4116 dpi
->num_saved_scopes
++;
4117 goto recurse_left_right
;
4119 case DEMANGLE_COMPONENT_QUAL_NAME
:
4120 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4121 case DEMANGLE_COMPONENT_TYPED_NAME
:
4122 case DEMANGLE_COMPONENT_VTABLE
:
4123 case DEMANGLE_COMPONENT_VTT
:
4124 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4125 case DEMANGLE_COMPONENT_TYPEINFO
:
4126 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4127 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4128 case DEMANGLE_COMPONENT_THUNK
:
4129 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4130 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4131 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4132 case DEMANGLE_COMPONENT_GUARD
:
4133 case DEMANGLE_COMPONENT_TLS_INIT
:
4134 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4135 case DEMANGLE_COMPONENT_REFTEMP
:
4136 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4137 case DEMANGLE_COMPONENT_RESTRICT
:
4138 case DEMANGLE_COMPONENT_VOLATILE
:
4139 case DEMANGLE_COMPONENT_CONST
:
4140 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4141 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4142 case DEMANGLE_COMPONENT_CONST_THIS
:
4143 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4144 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4145 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
4146 case DEMANGLE_COMPONENT_NOEXCEPT
:
4147 case DEMANGLE_COMPONENT_THROW_SPEC
:
4148 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4149 case DEMANGLE_COMPONENT_POINTER
:
4150 case DEMANGLE_COMPONENT_COMPLEX
:
4151 case DEMANGLE_COMPONENT_IMAGINARY
:
4152 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4153 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4154 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4155 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4156 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4157 case DEMANGLE_COMPONENT_ARGLIST
:
4158 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4159 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4160 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4161 case DEMANGLE_COMPONENT_CAST
:
4162 case DEMANGLE_COMPONENT_CONVERSION
:
4163 case DEMANGLE_COMPONENT_NULLARY
:
4164 case DEMANGLE_COMPONENT_UNARY
:
4165 case DEMANGLE_COMPONENT_BINARY
:
4166 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4167 case DEMANGLE_COMPONENT_TRINARY
:
4168 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4169 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4170 case DEMANGLE_COMPONENT_LITERAL
:
4171 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4172 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4173 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4174 case DEMANGLE_COMPONENT_DECLTYPE
:
4175 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4176 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4177 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4178 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4179 case DEMANGLE_COMPONENT_CLONE
:
4181 /* PR 89394 - Check for too much recursion. */
4182 if (dpi
->recursion
> DEMANGLE_RECURSION_LIMIT
)
4183 /* FIXME: There ought to be a way to report to the
4184 user that the recursion limit has been reached. */
4188 d_count_templates_scopes (dpi
, d_left (dc
));
4189 d_count_templates_scopes (dpi
, d_right (dc
));
4193 case DEMANGLE_COMPONENT_CTOR
:
4194 d_count_templates_scopes (dpi
, dc
->u
.s_ctor
.name
);
4197 case DEMANGLE_COMPONENT_DTOR
:
4198 d_count_templates_scopes (dpi
, dc
->u
.s_dtor
.name
);
4201 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4202 d_count_templates_scopes (dpi
, dc
->u
.s_extended_operator
.name
);
4205 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4206 d_count_templates_scopes (dpi
, dc
->u
.s_fixed
.length
);
4209 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4210 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4211 d_count_templates_scopes (dpi
, d_left (dc
));
4214 case DEMANGLE_COMPONENT_LAMBDA
:
4215 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4216 d_count_templates_scopes (dpi
, dc
->u
.s_unary_num
.sub
);
4221 /* Initialize a print information structure. */
4224 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
4225 void *opaque
, struct demangle_component
*dc
)
4228 dpi
->last_char
= '\0';
4229 dpi
->templates
= NULL
;
4230 dpi
->modifiers
= NULL
;
4231 dpi
->pack_index
= 0;
4232 dpi
->flush_count
= 0;
4234 dpi
->callback
= callback
;
4235 dpi
->opaque
= opaque
;
4237 dpi
->demangle_failure
= 0;
4239 dpi
->is_lambda_arg
= 0;
4241 dpi
->component_stack
= NULL
;
4243 dpi
->saved_scopes
= NULL
;
4244 dpi
->next_saved_scope
= 0;
4245 dpi
->num_saved_scopes
= 0;
4247 dpi
->copy_templates
= NULL
;
4248 dpi
->next_copy_template
= 0;
4249 dpi
->num_copy_templates
= 0;
4251 d_count_templates_scopes (dpi
, dc
);
4252 /* If we did not reach the recursion limit, then reset the
4253 current recursion value back to 0, so that we can print
4255 if (dpi
->recursion
< DEMANGLE_RECURSION_LIMIT
)
4257 dpi
->num_copy_templates
*= dpi
->num_saved_scopes
;
4259 dpi
->current_template
= NULL
;
4262 /* Indicate that an error occurred during printing, and test for error. */
4265 d_print_error (struct d_print_info
*dpi
)
4267 dpi
->demangle_failure
= 1;
4271 d_print_saw_error (struct d_print_info
*dpi
)
4273 return dpi
->demangle_failure
!= 0;
4276 /* Flush buffered characters to the callback. */
4279 d_print_flush (struct d_print_info
*dpi
)
4281 dpi
->buf
[dpi
->len
] = '\0';
4282 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
4287 /* Append characters and buffers for printing. */
4290 d_append_char (struct d_print_info
*dpi
, char c
)
4292 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
4293 d_print_flush (dpi
);
4295 dpi
->buf
[dpi
->len
++] = c
;
4300 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
4304 for (i
= 0; i
< l
; i
++)
4305 d_append_char (dpi
, s
[i
]);
4309 d_append_string (struct d_print_info
*dpi
, const char *s
)
4311 d_append_buffer (dpi
, s
, strlen (s
));
4315 d_append_num (struct d_print_info
*dpi
, int l
)
4318 sprintf (buf
,"%d", l
);
4319 d_append_string (dpi
, buf
);
4323 d_last_char (struct d_print_info
*dpi
)
4325 return dpi
->last_char
;
4328 /* Turn components into a human readable string. OPTIONS is the
4329 options bits passed to the demangler. DC is the tree to print.
4330 CALLBACK is a function to call to flush demangled string segments
4331 as they fill the intermediate buffer, and OPAQUE is a generalized
4332 callback argument. On success, this returns 1. On failure,
4333 it returns 0, indicating a bad parse. It does not use heap
4334 memory to build an output string, so cannot encounter memory
4335 allocation failure. */
4337 CP_STATIC_IF_GLIBCPP_V3
4339 cplus_demangle_print_callback (int options
,
4340 struct demangle_component
*dc
,
4341 demangle_callbackref callback
, void *opaque
)
4343 struct d_print_info dpi
;
4345 d_print_init (&dpi
, callback
, opaque
, dc
);
4348 #ifdef CP_DYNAMIC_ARRAYS
4349 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4350 and flagged as errors by Address Sanitizer. */
4351 __extension__
struct d_saved_scope scopes
[(dpi
.num_saved_scopes
> 0)
4352 ? dpi
.num_saved_scopes
: 1];
4353 __extension__
struct d_print_template temps
[(dpi
.num_copy_templates
> 0)
4354 ? dpi
.num_copy_templates
: 1];
4356 dpi
.saved_scopes
= scopes
;
4357 dpi
.copy_templates
= temps
;
4359 dpi
.saved_scopes
= alloca (dpi
.num_saved_scopes
4360 * sizeof (*dpi
.saved_scopes
));
4361 dpi
.copy_templates
= alloca (dpi
.num_copy_templates
4362 * sizeof (*dpi
.copy_templates
));
4365 d_print_comp (&dpi
, options
, dc
);
4368 d_print_flush (&dpi
);
4370 return ! d_print_saw_error (&dpi
);
4373 /* Turn components into a human readable string. OPTIONS is the
4374 options bits passed to the demangler. DC is the tree to print.
4375 ESTIMATE is a guess at the length of the result. This returns a
4376 string allocated by malloc, or NULL on error. On success, this
4377 sets *PALC to the size of the allocated buffer. On failure, this
4378 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4381 CP_STATIC_IF_GLIBCPP_V3
4383 cplus_demangle_print (int options
, struct demangle_component
*dc
,
4384 int estimate
, size_t *palc
)
4386 struct d_growable_string dgs
;
4388 d_growable_string_init (&dgs
, estimate
);
4390 if (! cplus_demangle_print_callback (options
, dc
,
4391 d_growable_string_callback_adapter
,
4399 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
4403 /* Returns the I'th element of the template arglist ARGS, or NULL on
4404 failure. If I is negative, return the entire arglist. */
4406 static struct demangle_component
*
4407 d_index_template_argument (struct demangle_component
*args
, int i
)
4409 struct demangle_component
*a
;
4412 /* Print the whole argument pack. */
4419 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4425 if (i
!= 0 || a
== NULL
)
4431 /* Returns the template argument from the current context indicated by DC,
4432 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4434 static struct demangle_component
*
4435 d_lookup_template_argument (struct d_print_info
*dpi
,
4436 const struct demangle_component
*dc
)
4438 if (dpi
->templates
== NULL
)
4440 d_print_error (dpi
);
4444 return d_index_template_argument
4445 (d_right (dpi
->templates
->template_decl
),
4446 dc
->u
.s_number
.number
);
4449 /* Returns a template argument pack used in DC (any will do), or NULL. */
4451 static struct demangle_component
*
4452 d_find_pack (struct d_print_info
*dpi
,
4453 const struct demangle_component
*dc
)
4455 struct demangle_component
*a
;
4461 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4462 a
= d_lookup_template_argument (dpi
, dc
);
4463 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4467 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4470 case DEMANGLE_COMPONENT_LAMBDA
:
4471 case DEMANGLE_COMPONENT_NAME
:
4472 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4473 case DEMANGLE_COMPONENT_OPERATOR
:
4474 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4475 case DEMANGLE_COMPONENT_SUB_STD
:
4476 case DEMANGLE_COMPONENT_CHARACTER
:
4477 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4478 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4479 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4480 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4481 case DEMANGLE_COMPONENT_NUMBER
:
4484 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4485 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
4486 case DEMANGLE_COMPONENT_CTOR
:
4487 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
4488 case DEMANGLE_COMPONENT_DTOR
:
4489 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
4492 a
= d_find_pack (dpi
, d_left (dc
));
4495 return d_find_pack (dpi
, d_right (dc
));
4499 /* Returns the length of the template argument pack DC. */
4502 d_pack_length (const struct demangle_component
*dc
)
4505 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4506 && d_left (dc
) != NULL
)
4514 /* Returns the number of template args in DC, expanding any pack expansions
4518 d_args_length (struct d_print_info
*dpi
, const struct demangle_component
*dc
)
4521 for (; dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
;
4524 struct demangle_component
*elt
= d_left (dc
);
4527 if (elt
->type
== DEMANGLE_COMPONENT_PACK_EXPANSION
)
4529 struct demangle_component
*a
= d_find_pack (dpi
, d_left (elt
));
4530 count
+= d_pack_length (a
);
4538 /* DC is a component of a mangled expression. Print it, wrapped in parens
4542 d_print_subexpr (struct d_print_info
*dpi
, int options
,
4543 struct demangle_component
*dc
)
4546 if (dc
->type
== DEMANGLE_COMPONENT_NAME
4547 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
4548 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
4549 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
4552 d_append_char (dpi
, '(');
4553 d_print_comp (dpi
, options
, dc
);
4555 d_append_char (dpi
, ')');
4558 /* Save the current scope. */
4561 d_save_scope (struct d_print_info
*dpi
,
4562 const struct demangle_component
*container
)
4564 struct d_saved_scope
*scope
;
4565 struct d_print_template
*src
, **link
;
4567 if (dpi
->next_saved_scope
>= dpi
->num_saved_scopes
)
4569 d_print_error (dpi
);
4572 scope
= &dpi
->saved_scopes
[dpi
->next_saved_scope
];
4573 dpi
->next_saved_scope
++;
4575 scope
->container
= container
;
4576 link
= &scope
->templates
;
4578 for (src
= dpi
->templates
; src
!= NULL
; src
= src
->next
)
4580 struct d_print_template
*dst
;
4582 if (dpi
->next_copy_template
>= dpi
->num_copy_templates
)
4584 d_print_error (dpi
);
4587 dst
= &dpi
->copy_templates
[dpi
->next_copy_template
];
4588 dpi
->next_copy_template
++;
4590 dst
->template_decl
= src
->template_decl
;
4598 /* Attempt to locate a previously saved scope. Returns NULL if no
4599 corresponding saved scope was found. */
4601 static struct d_saved_scope
*
4602 d_get_saved_scope (struct d_print_info
*dpi
,
4603 const struct demangle_component
*container
)
4607 for (i
= 0; i
< dpi
->next_saved_scope
; i
++)
4608 if (dpi
->saved_scopes
[i
].container
== container
)
4609 return &dpi
->saved_scopes
[i
];
4614 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4618 d_maybe_print_fold_expression (struct d_print_info
*dpi
, int options
,
4619 struct demangle_component
*dc
)
4621 struct demangle_component
*ops
, *operator_
, *op1
, *op2
;
4624 const char *fold_code
= d_left (dc
)->u
.s_operator
.op
->code
;
4625 if (fold_code
[0] != 'f')
4629 operator_
= d_left (ops
);
4630 op1
= d_right (ops
);
4632 if (op1
->type
== DEMANGLE_COMPONENT_TRINARY_ARG2
)
4634 op2
= d_right (op1
);
4638 /* Print the whole pack. */
4639 save_idx
= dpi
->pack_index
;
4640 dpi
->pack_index
= -1;
4642 switch (fold_code
[1])
4644 /* Unary left fold, (... + X). */
4646 d_append_string (dpi
, "(...");
4647 d_print_expr_op (dpi
, options
, operator_
);
4648 d_print_subexpr (dpi
, options
, op1
);
4649 d_append_char (dpi
, ')');
4652 /* Unary right fold, (X + ...). */
4654 d_append_char (dpi
, '(');
4655 d_print_subexpr (dpi
, options
, op1
);
4656 d_print_expr_op (dpi
, options
, operator_
);
4657 d_append_string (dpi
, "...)");
4660 /* Binary left fold, (42 + ... + X). */
4662 /* Binary right fold, (X + ... + 42). */
4664 d_append_char (dpi
, '(');
4665 d_print_subexpr (dpi
, options
, op1
);
4666 d_print_expr_op (dpi
, options
, operator_
);
4667 d_append_string (dpi
, "...");
4668 d_print_expr_op (dpi
, options
, operator_
);
4669 d_print_subexpr (dpi
, options
, op2
);
4670 d_append_char (dpi
, ')');
4674 dpi
->pack_index
= save_idx
;
4678 /* Subroutine to handle components. */
4681 d_print_comp_inner (struct d_print_info
*dpi
, int options
,
4682 struct demangle_component
*dc
)
4684 /* Magic variable to let reference smashing skip over the next modifier
4685 without needing to modify *dc. */
4686 struct demangle_component
*mod_inner
= NULL
;
4688 /* Variable used to store the current templates while a previously
4689 captured scope is used. */
4690 struct d_print_template
*saved_templates
;
4692 /* Nonzero if templates have been stored in the above variable. */
4693 int need_template_restore
= 0;
4697 d_print_error (dpi
);
4700 if (d_print_saw_error (dpi
))
4705 case DEMANGLE_COMPONENT_NAME
:
4706 if ((options
& DMGL_JAVA
) == 0)
4707 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4709 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4712 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4713 d_print_comp (dpi
, options
, d_left (dc
));
4714 d_append_string (dpi
, "[abi:");
4715 d_print_comp (dpi
, options
, d_right (dc
));
4716 d_append_char (dpi
, ']');
4719 case DEMANGLE_COMPONENT_QUAL_NAME
:
4720 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4721 d_print_comp (dpi
, options
, d_left (dc
));
4722 if ((options
& DMGL_JAVA
) == 0)
4723 d_append_string (dpi
, "::");
4725 d_append_char (dpi
, '.');
4727 struct demangle_component
*local_name
= d_right (dc
);
4728 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4730 d_append_string (dpi
, "{default arg#");
4731 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
4732 d_append_string (dpi
, "}::");
4733 local_name
= local_name
->u
.s_unary_num
.sub
;
4735 d_print_comp (dpi
, options
, local_name
);
4739 case DEMANGLE_COMPONENT_TYPED_NAME
:
4741 struct d_print_mod
*hold_modifiers
;
4742 struct demangle_component
*typed_name
;
4743 struct d_print_mod adpm
[4];
4745 struct d_print_template dpt
;
4747 /* Pass the name down to the type so that it can be printed in
4748 the right place for the type. We also have to pass down
4749 any CV-qualifiers, which apply to the this parameter. */
4750 hold_modifiers
= dpi
->modifiers
;
4753 typed_name
= d_left (dc
);
4754 while (typed_name
!= NULL
)
4756 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4758 d_print_error (dpi
);
4762 adpm
[i
].next
= dpi
->modifiers
;
4763 dpi
->modifiers
= &adpm
[i
];
4764 adpm
[i
].mod
= typed_name
;
4765 adpm
[i
].printed
= 0;
4766 adpm
[i
].templates
= dpi
->templates
;
4769 if (!is_fnqual_component_type (typed_name
->type
))
4772 typed_name
= d_left (typed_name
);
4775 if (typed_name
== NULL
)
4777 d_print_error (dpi
);
4781 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4782 there may be CV-qualifiers on its right argument which
4783 really apply here; this happens when parsing a class that
4784 is local to a function. */
4785 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4787 typed_name
= d_right (typed_name
);
4788 if (typed_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4789 typed_name
= typed_name
->u
.s_unary_num
.sub
;
4790 while (typed_name
!= NULL
4791 && is_fnqual_component_type (typed_name
->type
))
4793 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4795 d_print_error (dpi
);
4799 adpm
[i
] = adpm
[i
- 1];
4800 adpm
[i
].next
= &adpm
[i
- 1];
4801 dpi
->modifiers
= &adpm
[i
];
4803 adpm
[i
- 1].mod
= typed_name
;
4804 adpm
[i
- 1].printed
= 0;
4805 adpm
[i
- 1].templates
= dpi
->templates
;
4808 typed_name
= d_left (typed_name
);
4810 if (typed_name
== NULL
)
4812 d_print_error (dpi
);
4817 /* If typed_name is a template, then it applies to the
4818 function type as well. */
4819 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4821 dpt
.next
= dpi
->templates
;
4822 dpi
->templates
= &dpt
;
4823 dpt
.template_decl
= typed_name
;
4826 d_print_comp (dpi
, options
, d_right (dc
));
4828 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4829 dpi
->templates
= dpt
.next
;
4831 /* If the modifiers didn't get printed by the type, print them
4836 if (! adpm
[i
].printed
)
4838 d_append_char (dpi
, ' ');
4839 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4843 dpi
->modifiers
= hold_modifiers
;
4848 case DEMANGLE_COMPONENT_TEMPLATE
:
4850 struct d_print_mod
*hold_dpm
;
4851 struct demangle_component
*dcl
;
4852 const struct demangle_component
*hold_current
;
4854 /* This template may need to be referenced by a cast operator
4855 contained in its subtree. */
4856 hold_current
= dpi
->current_template
;
4857 dpi
->current_template
= dc
;
4859 /* Don't push modifiers into a template definition. Doing so
4860 could give the wrong definition for a template argument.
4861 Instead, treat the template essentially as a name. */
4863 hold_dpm
= dpi
->modifiers
;
4864 dpi
->modifiers
= NULL
;
4868 if ((options
& DMGL_JAVA
) != 0
4869 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4870 && dcl
->u
.s_name
.len
== 6
4871 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4873 /* Special-case Java arrays, so that JArray<TYPE> appears
4874 instead as TYPE[]. */
4876 d_print_comp (dpi
, options
, d_right (dc
));
4877 d_append_string (dpi
, "[]");
4881 d_print_comp (dpi
, options
, dcl
);
4882 if (d_last_char (dpi
) == '<')
4883 d_append_char (dpi
, ' ');
4884 d_append_char (dpi
, '<');
4885 d_print_comp (dpi
, options
, d_right (dc
));
4886 /* Avoid generating two consecutive '>' characters, to avoid
4887 the C++ syntactic ambiguity. */
4888 if (d_last_char (dpi
) == '>')
4889 d_append_char (dpi
, ' ');
4890 d_append_char (dpi
, '>');
4893 dpi
->modifiers
= hold_dpm
;
4894 dpi
->current_template
= hold_current
;
4899 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4900 if (dpi
->is_lambda_arg
)
4902 /* Show the template parm index, as that's how g++ displays
4903 these, and future proofs us against potential
4904 '[]<typename T> (T *a, T *b) {...}'. */
4905 d_append_buffer (dpi
, "auto:", 5);
4906 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4910 struct d_print_template
*hold_dpt
;
4911 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
4913 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4914 a
= d_index_template_argument (a
, dpi
->pack_index
);
4918 d_print_error (dpi
);
4922 /* While processing this parameter, we need to pop the list
4923 of templates. This is because the template parameter may
4924 itself be a reference to a parameter of an outer
4927 hold_dpt
= dpi
->templates
;
4928 dpi
->templates
= hold_dpt
->next
;
4930 d_print_comp (dpi
, options
, a
);
4932 dpi
->templates
= hold_dpt
;
4936 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4937 d_append_string (dpi
, "template parameter object for ");
4938 d_print_comp (dpi
, options
, d_left (dc
));
4941 case DEMANGLE_COMPONENT_CTOR
:
4942 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
4945 case DEMANGLE_COMPONENT_DTOR
:
4946 d_append_char (dpi
, '~');
4947 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
4950 case DEMANGLE_COMPONENT_VTABLE
:
4951 d_append_string (dpi
, "vtable for ");
4952 d_print_comp (dpi
, options
, d_left (dc
));
4955 case DEMANGLE_COMPONENT_VTT
:
4956 d_append_string (dpi
, "VTT for ");
4957 d_print_comp (dpi
, options
, d_left (dc
));
4960 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4961 d_append_string (dpi
, "construction vtable for ");
4962 d_print_comp (dpi
, options
, d_left (dc
));
4963 d_append_string (dpi
, "-in-");
4964 d_print_comp (dpi
, options
, d_right (dc
));
4967 case DEMANGLE_COMPONENT_TYPEINFO
:
4968 d_append_string (dpi
, "typeinfo for ");
4969 d_print_comp (dpi
, options
, d_left (dc
));
4972 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4973 d_append_string (dpi
, "typeinfo name for ");
4974 d_print_comp (dpi
, options
, d_left (dc
));
4977 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4978 d_append_string (dpi
, "typeinfo fn for ");
4979 d_print_comp (dpi
, options
, d_left (dc
));
4982 case DEMANGLE_COMPONENT_THUNK
:
4983 d_append_string (dpi
, "non-virtual thunk to ");
4984 d_print_comp (dpi
, options
, d_left (dc
));
4987 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4988 d_append_string (dpi
, "virtual thunk to ");
4989 d_print_comp (dpi
, options
, d_left (dc
));
4992 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4993 d_append_string (dpi
, "covariant return thunk to ");
4994 d_print_comp (dpi
, options
, d_left (dc
));
4997 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4998 d_append_string (dpi
, "java Class for ");
4999 d_print_comp (dpi
, options
, d_left (dc
));
5002 case DEMANGLE_COMPONENT_GUARD
:
5003 d_append_string (dpi
, "guard variable for ");
5004 d_print_comp (dpi
, options
, d_left (dc
));
5007 case DEMANGLE_COMPONENT_TLS_INIT
:
5008 d_append_string (dpi
, "TLS init function for ");
5009 d_print_comp (dpi
, options
, d_left (dc
));
5012 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
5013 d_append_string (dpi
, "TLS wrapper function for ");
5014 d_print_comp (dpi
, options
, d_left (dc
));
5017 case DEMANGLE_COMPONENT_REFTEMP
:
5018 d_append_string (dpi
, "reference temporary #");
5019 d_print_comp (dpi
, options
, d_right (dc
));
5020 d_append_string (dpi
, " for ");
5021 d_print_comp (dpi
, options
, d_left (dc
));
5024 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
5025 d_append_string (dpi
, "hidden alias for ");
5026 d_print_comp (dpi
, options
, d_left (dc
));
5029 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
5030 d_append_string (dpi
, "transaction clone for ");
5031 d_print_comp (dpi
, options
, d_left (dc
));
5034 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
5035 d_append_string (dpi
, "non-transaction clone for ");
5036 d_print_comp (dpi
, options
, d_left (dc
));
5039 case DEMANGLE_COMPONENT_SUB_STD
:
5040 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
5043 case DEMANGLE_COMPONENT_RESTRICT
:
5044 case DEMANGLE_COMPONENT_VOLATILE
:
5045 case DEMANGLE_COMPONENT_CONST
:
5047 struct d_print_mod
*pdpm
;
5049 /* When printing arrays, it's possible to have cases where the
5050 same CV-qualifier gets pushed on the stack multiple times.
5051 We only need to print it once. */
5053 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
5055 if (! pdpm
->printed
)
5057 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
5058 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
5059 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
5061 if (pdpm
->mod
->type
== dc
->type
)
5063 d_print_comp (dpi
, options
, d_left (dc
));
5071 case DEMANGLE_COMPONENT_REFERENCE
:
5072 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5074 /* Handle reference smashing: & + && = &. */
5075 struct demangle_component
*sub
= d_left (dc
);
5076 if (!dpi
->is_lambda_arg
5077 && sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
5079 struct d_saved_scope
*scope
= d_get_saved_scope (dpi
, sub
);
5080 struct demangle_component
*a
;
5084 /* This is the first time SUB has been traversed.
5085 We need to capture the current templates so
5086 they can be restored if SUB is reentered as a
5088 d_save_scope (dpi
, sub
);
5089 if (d_print_saw_error (dpi
))
5094 const struct d_component_stack
*dcse
;
5095 int found_self_or_parent
= 0;
5097 /* This traversal is reentering SUB as a substition.
5098 If we are not beneath SUB or DC in the tree then we
5099 need to restore SUB's template stack temporarily. */
5100 for (dcse
= dpi
->component_stack
; dcse
!= NULL
;
5101 dcse
= dcse
->parent
)
5105 && dcse
!= dpi
->component_stack
))
5107 found_self_or_parent
= 1;
5112 if (!found_self_or_parent
)
5114 saved_templates
= dpi
->templates
;
5115 dpi
->templates
= scope
->templates
;
5116 need_template_restore
= 1;
5120 a
= d_lookup_template_argument (dpi
, sub
);
5121 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
5122 a
= d_index_template_argument (a
, dpi
->pack_index
);
5126 if (need_template_restore
)
5127 dpi
->templates
= saved_templates
;
5129 d_print_error (dpi
);
5136 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
5137 || sub
->type
== dc
->type
)
5139 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
5140 mod_inner
= d_left (sub
);
5144 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5145 case DEMANGLE_COMPONENT_POINTER
:
5146 case DEMANGLE_COMPONENT_COMPLEX
:
5147 case DEMANGLE_COMPONENT_IMAGINARY
:
5148 FNQUAL_COMPONENT_CASE
:
5151 /* We keep a list of modifiers on the stack. */
5152 struct d_print_mod dpm
;
5154 dpm
.next
= dpi
->modifiers
;
5155 dpi
->modifiers
= &dpm
;
5158 dpm
.templates
= dpi
->templates
;
5161 mod_inner
= d_left (dc
);
5163 d_print_comp (dpi
, options
, mod_inner
);
5165 /* If the modifier didn't get printed by the type, print it
5168 d_print_mod (dpi
, options
, dc
);
5170 dpi
->modifiers
= dpm
.next
;
5172 if (need_template_restore
)
5173 dpi
->templates
= saved_templates
;
5178 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5179 if ((options
& DMGL_JAVA
) == 0)
5180 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
5181 dc
->u
.s_builtin
.type
->len
);
5183 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
5184 dc
->u
.s_builtin
.type
->java_len
);
5187 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5188 d_print_comp (dpi
, options
, d_left (dc
));
5191 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5193 if ((options
& DMGL_RET_POSTFIX
) != 0)
5194 d_print_function_type (dpi
,
5195 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5196 dc
, dpi
->modifiers
);
5198 /* Print return type if present */
5199 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
5200 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5202 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
5204 struct d_print_mod dpm
;
5206 /* We must pass this type down as a modifier in order to
5207 print it in the right location. */
5208 dpm
.next
= dpi
->modifiers
;
5209 dpi
->modifiers
= &dpm
;
5212 dpm
.templates
= dpi
->templates
;
5214 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5217 dpi
->modifiers
= dpm
.next
;
5222 /* In standard prefix notation, there is a space between the
5223 return type and the function signature. */
5224 if ((options
& DMGL_RET_POSTFIX
) == 0)
5225 d_append_char (dpi
, ' ');
5228 if ((options
& DMGL_RET_POSTFIX
) == 0)
5229 d_print_function_type (dpi
,
5230 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5231 dc
, dpi
->modifiers
);
5236 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5238 struct d_print_mod
*hold_modifiers
;
5239 struct d_print_mod adpm
[4];
5241 struct d_print_mod
*pdpm
;
5243 /* We must pass this type down as a modifier in order to print
5244 multi-dimensional arrays correctly. If the array itself is
5245 CV-qualified, we act as though the element type were
5246 CV-qualified. We do this by copying the modifiers down
5247 rather than fiddling pointers, so that we don't wind up
5248 with a d_print_mod higher on the stack pointing into our
5249 stack frame after we return. */
5251 hold_modifiers
= dpi
->modifiers
;
5253 adpm
[0].next
= hold_modifiers
;
5254 dpi
->modifiers
= &adpm
[0];
5256 adpm
[0].printed
= 0;
5257 adpm
[0].templates
= dpi
->templates
;
5260 pdpm
= hold_modifiers
;
5262 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
5263 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
5264 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
5266 if (! pdpm
->printed
)
5268 if (i
>= sizeof adpm
/ sizeof adpm
[0])
5270 d_print_error (dpi
);
5275 adpm
[i
].next
= dpi
->modifiers
;
5276 dpi
->modifiers
= &adpm
[i
];
5284 d_print_comp (dpi
, options
, d_right (dc
));
5286 dpi
->modifiers
= hold_modifiers
;
5288 if (adpm
[0].printed
)
5294 d_print_mod (dpi
, options
, adpm
[i
].mod
);
5297 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
5302 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5303 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5305 struct d_print_mod dpm
;
5307 dpm
.next
= dpi
->modifiers
;
5308 dpi
->modifiers
= &dpm
;
5311 dpm
.templates
= dpi
->templates
;
5313 d_print_comp (dpi
, options
, d_right (dc
));
5315 /* If the modifier didn't get printed by the type, print it
5318 d_print_mod (dpi
, options
, dc
);
5320 dpi
->modifiers
= dpm
.next
;
5325 case DEMANGLE_COMPONENT_FIXED_TYPE
:
5326 if (dc
->u
.s_fixed
.sat
)
5327 d_append_string (dpi
, "_Sat ");
5328 /* Don't print "int _Accum". */
5329 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
5330 != &cplus_demangle_builtin_types
['i'-'a'])
5332 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
5333 d_append_char (dpi
, ' ');
5335 if (dc
->u
.s_fixed
.accum
)
5336 d_append_string (dpi
, "_Accum");
5338 d_append_string (dpi
, "_Fract");
5341 case DEMANGLE_COMPONENT_ARGLIST
:
5342 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
5343 if (d_left (dc
) != NULL
)
5344 d_print_comp (dpi
, options
, d_left (dc
));
5345 if (d_right (dc
) != NULL
)
5348 unsigned long int flush_count
;
5349 /* Make sure ", " isn't flushed by d_append_string, otherwise
5350 dpi->len -= 2 wouldn't work. */
5351 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
5352 d_print_flush (dpi
);
5353 d_append_string (dpi
, ", ");
5355 flush_count
= dpi
->flush_count
;
5356 d_print_comp (dpi
, options
, d_right (dc
));
5357 /* If that didn't print anything (which can happen with empty
5358 template argument packs), remove the comma and space. */
5359 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
5364 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
5366 struct demangle_component
*type
= d_left (dc
);
5367 struct demangle_component
*list
= d_right (dc
);
5370 d_print_comp (dpi
, options
, type
);
5371 d_append_char (dpi
, '{');
5372 d_print_comp (dpi
, options
, list
);
5373 d_append_char (dpi
, '}');
5377 case DEMANGLE_COMPONENT_OPERATOR
:
5379 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
5382 d_append_string (dpi
, "operator");
5383 /* Add a space before new/delete. */
5384 if (IS_LOWER (op
->name
[0]))
5385 d_append_char (dpi
, ' ');
5386 /* Omit a trailing space. */
5387 if (op
->name
[len
-1] == ' ')
5389 d_append_buffer (dpi
, op
->name
, len
);
5393 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
5394 d_append_string (dpi
, "operator ");
5395 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5398 case DEMANGLE_COMPONENT_CONVERSION
:
5399 d_append_string (dpi
, "operator ");
5400 d_print_conversion (dpi
, options
, dc
);
5403 case DEMANGLE_COMPONENT_NULLARY
:
5404 d_print_expr_op (dpi
, options
, d_left (dc
));
5407 case DEMANGLE_COMPONENT_UNARY
:
5409 struct demangle_component
*op
= d_left (dc
);
5410 struct demangle_component
*operand
= d_right (dc
);
5411 const char *code
= NULL
;
5413 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5415 code
= op
->u
.s_operator
.op
->code
;
5416 if (!strcmp (code
, "ad"))
5418 /* Don't print the argument list for the address of a
5420 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
5421 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
5422 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5423 operand
= d_left (operand
);
5425 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
5427 /* This indicates a suffix operator. */
5428 operand
= d_left (operand
);
5429 d_print_subexpr (dpi
, options
, operand
);
5430 d_print_expr_op (dpi
, options
, op
);
5435 /* For sizeof..., just print the pack length. */
5436 if (code
&& !strcmp (code
, "sZ"))
5438 struct demangle_component
*a
= d_find_pack (dpi
, operand
);
5439 int len
= d_pack_length (a
);
5440 d_append_num (dpi
, len
);
5443 else if (code
&& !strcmp (code
, "sP"))
5445 int len
= d_args_length (dpi
, operand
);
5446 d_append_num (dpi
, len
);
5450 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
5451 d_print_expr_op (dpi
, options
, op
);
5454 d_append_char (dpi
, '(');
5455 d_print_cast (dpi
, options
, op
);
5456 d_append_char (dpi
, ')');
5458 if (code
&& !strcmp (code
, "gs"))
5459 /* Avoid parens after '::'. */
5460 d_print_comp (dpi
, options
, operand
);
5461 else if (code
&& !strcmp (code
, "st"))
5462 /* Always print parens for sizeof (type). */
5464 d_append_char (dpi
, '(');
5465 d_print_comp (dpi
, options
, operand
);
5466 d_append_char (dpi
, ')');
5469 d_print_subexpr (dpi
, options
, operand
);
5473 case DEMANGLE_COMPONENT_BINARY
:
5474 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
5476 d_print_error (dpi
);
5480 if (op_is_new_cast (d_left (dc
)))
5482 d_print_expr_op (dpi
, options
, d_left (dc
));
5483 d_append_char (dpi
, '<');
5484 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
5485 d_append_string (dpi
, ">(");
5486 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5487 d_append_char (dpi
, ')');
5491 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5494 /* We wrap an expression which uses the greater-than operator in
5495 an extra layer of parens so that it does not get confused
5496 with the '>' which ends the template parameters. */
5497 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5498 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5499 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5500 d_append_char (dpi
, '(');
5502 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
5503 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
5505 /* Function call used in an expression should not have printed types
5506 of the function arguments. Values of the function arguments still
5507 get printed below. */
5509 const struct demangle_component
*func
= d_left (d_right (dc
));
5511 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5512 d_print_error (dpi
);
5513 d_print_subexpr (dpi
, options
, d_left (func
));
5516 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
5517 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
5519 d_append_char (dpi
, '[');
5520 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5521 d_append_char (dpi
, ']');
5525 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
5526 d_print_expr_op (dpi
, options
, d_left (dc
));
5527 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
5530 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5531 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5532 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5533 d_append_char (dpi
, ')');
5537 case DEMANGLE_COMPONENT_BINARY_ARGS
:
5538 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5539 d_print_error (dpi
);
5542 case DEMANGLE_COMPONENT_TRINARY
:
5543 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
5544 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
5546 d_print_error (dpi
);
5549 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5552 struct demangle_component
*op
= d_left (dc
);
5553 struct demangle_component
*first
= d_left (d_right (dc
));
5554 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
5555 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
5557 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
5559 d_print_subexpr (dpi
, options
, first
);
5560 d_print_expr_op (dpi
, options
, op
);
5561 d_print_subexpr (dpi
, options
, second
);
5562 d_append_string (dpi
, " : ");
5563 d_print_subexpr (dpi
, options
, third
);
5567 d_append_string (dpi
, "new ");
5568 if (d_left (first
) != NULL
)
5570 d_print_subexpr (dpi
, options
, first
);
5571 d_append_char (dpi
, ' ');
5573 d_print_comp (dpi
, options
, second
);
5575 d_print_subexpr (dpi
, options
, third
);
5580 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
5581 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
5582 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5583 d_print_error (dpi
);
5586 case DEMANGLE_COMPONENT_LITERAL
:
5587 case DEMANGLE_COMPONENT_LITERAL_NEG
:
5589 enum d_builtin_type_print tp
;
5591 /* For some builtin types, produce simpler output. */
5592 tp
= D_PRINT_DEFAULT
;
5593 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
5595 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
5599 case D_PRINT_UNSIGNED
:
5601 case D_PRINT_UNSIGNED_LONG
:
5602 case D_PRINT_LONG_LONG
:
5603 case D_PRINT_UNSIGNED_LONG_LONG
:
5604 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
5606 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5607 d_append_char (dpi
, '-');
5608 d_print_comp (dpi
, options
, d_right (dc
));
5613 case D_PRINT_UNSIGNED
:
5614 d_append_char (dpi
, 'u');
5617 d_append_char (dpi
, 'l');
5619 case D_PRINT_UNSIGNED_LONG
:
5620 d_append_string (dpi
, "ul");
5622 case D_PRINT_LONG_LONG
:
5623 d_append_string (dpi
, "ll");
5625 case D_PRINT_UNSIGNED_LONG_LONG
:
5626 d_append_string (dpi
, "ull");
5634 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
5635 && d_right (dc
)->u
.s_name
.len
== 1
5636 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
5638 switch (d_right (dc
)->u
.s_name
.s
[0])
5641 d_append_string (dpi
, "false");
5644 d_append_string (dpi
, "true");
5657 d_append_char (dpi
, '(');
5658 d_print_comp (dpi
, options
, d_left (dc
));
5659 d_append_char (dpi
, ')');
5660 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5661 d_append_char (dpi
, '-');
5662 if (tp
== D_PRINT_FLOAT
)
5663 d_append_char (dpi
, '[');
5664 d_print_comp (dpi
, options
, d_right (dc
));
5665 if (tp
== D_PRINT_FLOAT
)
5666 d_append_char (dpi
, ']');
5670 case DEMANGLE_COMPONENT_NUMBER
:
5671 d_append_num (dpi
, dc
->u
.s_number
.number
);
5674 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
5675 d_append_string (dpi
, "java resource ");
5676 d_print_comp (dpi
, options
, d_left (dc
));
5679 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
5680 d_print_comp (dpi
, options
, d_left (dc
));
5681 d_print_comp (dpi
, options
, d_right (dc
));
5684 case DEMANGLE_COMPONENT_CHARACTER
:
5685 d_append_char (dpi
, dc
->u
.s_character
.character
);
5688 case DEMANGLE_COMPONENT_DECLTYPE
:
5689 d_append_string (dpi
, "decltype (");
5690 d_print_comp (dpi
, options
, d_left (dc
));
5691 d_append_char (dpi
, ')');
5694 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
5698 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
5701 /* d_find_pack won't find anything if the only packs involved
5702 in this expansion are function parameter packs; in that
5703 case, just print the pattern and "...". */
5704 d_print_subexpr (dpi
, options
, d_left (dc
));
5705 d_append_string (dpi
, "...");
5709 len
= d_pack_length (a
);
5711 for (i
= 0; i
< len
; ++i
)
5713 dpi
->pack_index
= i
;
5714 d_print_comp (dpi
, options
, dc
);
5716 d_append_string (dpi
, ", ");
5721 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
5723 long num
= dc
->u
.s_number
.number
;
5725 d_append_string (dpi
, "this");
5728 d_append_string (dpi
, "{parm#");
5729 d_append_num (dpi
, num
);
5730 d_append_char (dpi
, '}');
5735 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
5736 d_append_string (dpi
, "global constructors keyed to ");
5737 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5740 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
5741 d_append_string (dpi
, "global destructors keyed to ");
5742 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5745 case DEMANGLE_COMPONENT_LAMBDA
:
5746 d_append_string (dpi
, "{lambda(");
5747 /* Generic lambda auto parms are mangled as the template type
5749 dpi
->is_lambda_arg
++;
5750 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
5751 dpi
->is_lambda_arg
--;
5752 d_append_string (dpi
, ")#");
5753 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5754 d_append_char (dpi
, '}');
5757 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
5758 d_append_string (dpi
, "{unnamed type#");
5759 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5760 d_append_char (dpi
, '}');
5763 case DEMANGLE_COMPONENT_CLONE
:
5764 d_print_comp (dpi
, options
, d_left (dc
));
5765 d_append_string (dpi
, " [clone ");
5766 d_print_comp (dpi
, options
, d_right (dc
));
5767 d_append_char (dpi
, ']');
5771 d_print_error (dpi
);
5777 d_print_comp (struct d_print_info
*dpi
, int options
,
5778 struct demangle_component
*dc
)
5780 struct d_component_stack self
;
5781 if (dc
== NULL
|| dc
->d_printing
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
5783 d_print_error (dpi
);
5791 self
.parent
= dpi
->component_stack
;
5792 dpi
->component_stack
= &self
;
5794 d_print_comp_inner (dpi
, options
, dc
);
5796 dpi
->component_stack
= self
.parent
;
5801 /* Print a Java dentifier. For Java we try to handle encoded extended
5802 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5803 so we don't it for C++. Characters are encoded as
5807 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
5813 for (p
= name
; p
< end
; ++p
)
5824 for (q
= p
+ 3; q
< end
; ++q
)
5830 else if (*q
>= 'A' && *q
<= 'F')
5831 dig
= *q
- 'A' + 10;
5832 else if (*q
>= 'a' && *q
<= 'f')
5833 dig
= *q
- 'a' + 10;
5839 /* If the Unicode character is larger than 256, we don't try
5840 to deal with it here. FIXME. */
5841 if (q
< end
&& *q
== '_' && c
< 256)
5843 d_append_char (dpi
, c
);
5849 d_append_char (dpi
, *p
);
5853 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5854 qualifiers on this after printing a function. */
5857 d_print_mod_list (struct d_print_info
*dpi
, int options
,
5858 struct d_print_mod
*mods
, int suffix
)
5860 struct d_print_template
*hold_dpt
;
5862 if (mods
== NULL
|| d_print_saw_error (dpi
))
5867 && (is_fnqual_component_type (mods
->mod
->type
))))
5869 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5875 hold_dpt
= dpi
->templates
;
5876 dpi
->templates
= mods
->templates
;
5878 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5880 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
5881 dpi
->templates
= hold_dpt
;
5884 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5886 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
5887 dpi
->templates
= hold_dpt
;
5890 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
5892 struct d_print_mod
*hold_modifiers
;
5893 struct demangle_component
*dc
;
5895 /* When this is on the modifier stack, we have pulled any
5896 qualifiers off the right argument already. Otherwise, we
5897 print it as usual, but don't let the left argument see any
5900 hold_modifiers
= dpi
->modifiers
;
5901 dpi
->modifiers
= NULL
;
5902 d_print_comp (dpi
, options
, d_left (mods
->mod
));
5903 dpi
->modifiers
= hold_modifiers
;
5905 if ((options
& DMGL_JAVA
) == 0)
5906 d_append_string (dpi
, "::");
5908 d_append_char (dpi
, '.');
5910 dc
= d_right (mods
->mod
);
5912 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
5914 d_append_string (dpi
, "{default arg#");
5915 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5916 d_append_string (dpi
, "}::");
5917 dc
= dc
->u
.s_unary_num
.sub
;
5920 while (is_fnqual_component_type (dc
->type
))
5923 d_print_comp (dpi
, options
, dc
);
5925 dpi
->templates
= hold_dpt
;
5929 d_print_mod (dpi
, options
, mods
->mod
);
5931 dpi
->templates
= hold_dpt
;
5933 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5936 /* Print a modifier. */
5939 d_print_mod (struct d_print_info
*dpi
, int options
,
5940 struct demangle_component
*mod
)
5944 case DEMANGLE_COMPONENT_RESTRICT
:
5945 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5946 d_append_string (dpi
, " restrict");
5948 case DEMANGLE_COMPONENT_VOLATILE
:
5949 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5950 d_append_string (dpi
, " volatile");
5952 case DEMANGLE_COMPONENT_CONST
:
5953 case DEMANGLE_COMPONENT_CONST_THIS
:
5954 d_append_string (dpi
, " const");
5956 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
5957 d_append_string (dpi
, " transaction_safe");
5959 case DEMANGLE_COMPONENT_NOEXCEPT
:
5960 d_append_string (dpi
, " noexcept");
5963 d_append_char (dpi
, '(');
5964 d_print_comp (dpi
, options
, d_right (mod
));
5965 d_append_char (dpi
, ')');
5968 case DEMANGLE_COMPONENT_THROW_SPEC
:
5969 d_append_string (dpi
, " throw");
5972 d_append_char (dpi
, '(');
5973 d_print_comp (dpi
, options
, d_right (mod
));
5974 d_append_char (dpi
, ')');
5977 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5978 d_append_char (dpi
, ' ');
5979 d_print_comp (dpi
, options
, d_right (mod
));
5981 case DEMANGLE_COMPONENT_POINTER
:
5982 /* There is no pointer symbol in Java. */
5983 if ((options
& DMGL_JAVA
) == 0)
5984 d_append_char (dpi
, '*');
5986 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5987 /* For the ref-qualifier, put a space before the &. */
5988 d_append_char (dpi
, ' ');
5990 case DEMANGLE_COMPONENT_REFERENCE
:
5991 d_append_char (dpi
, '&');
5993 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5994 d_append_char (dpi
, ' ');
5996 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5997 d_append_string (dpi
, "&&");
5999 case DEMANGLE_COMPONENT_COMPLEX
:
6000 d_append_string (dpi
, " _Complex");
6002 case DEMANGLE_COMPONENT_IMAGINARY
:
6003 d_append_string (dpi
, " _Imaginary");
6005 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6006 if (d_last_char (dpi
) != '(')
6007 d_append_char (dpi
, ' ');
6008 d_print_comp (dpi
, options
, d_left (mod
));
6009 d_append_string (dpi
, "::*");
6011 case DEMANGLE_COMPONENT_TYPED_NAME
:
6012 d_print_comp (dpi
, options
, d_left (mod
));
6014 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
6015 d_append_string (dpi
, " __vector(");
6016 d_print_comp (dpi
, options
, d_left (mod
));
6017 d_append_char (dpi
, ')');
6021 /* Otherwise, we have something that won't go back on the
6022 modifier stack, so we can just print it. */
6023 d_print_comp (dpi
, options
, mod
);
6028 /* Print a function type, except for the return type. */
6031 d_print_function_type (struct d_print_info
*dpi
, int options
,
6032 struct demangle_component
*dc
,
6033 struct d_print_mod
*mods
)
6037 struct d_print_mod
*p
;
6038 struct d_print_mod
*hold_modifiers
;
6042 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6047 switch (p
->mod
->type
)
6049 case DEMANGLE_COMPONENT_POINTER
:
6050 case DEMANGLE_COMPONENT_REFERENCE
:
6051 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
6054 case DEMANGLE_COMPONENT_RESTRICT
:
6055 case DEMANGLE_COMPONENT_VOLATILE
:
6056 case DEMANGLE_COMPONENT_CONST
:
6057 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
6058 case DEMANGLE_COMPONENT_COMPLEX
:
6059 case DEMANGLE_COMPONENT_IMAGINARY
:
6060 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6064 FNQUAL_COMPONENT_CASE
:
6077 if (d_last_char (dpi
) != '('
6078 && d_last_char (dpi
) != '*')
6081 if (need_space
&& d_last_char (dpi
) != ' ')
6082 d_append_char (dpi
, ' ');
6083 d_append_char (dpi
, '(');
6086 hold_modifiers
= dpi
->modifiers
;
6087 dpi
->modifiers
= NULL
;
6089 d_print_mod_list (dpi
, options
, mods
, 0);
6092 d_append_char (dpi
, ')');
6094 d_append_char (dpi
, '(');
6096 if (d_right (dc
) != NULL
)
6097 d_print_comp (dpi
, options
, d_right (dc
));
6099 d_append_char (dpi
, ')');
6101 d_print_mod_list (dpi
, options
, mods
, 1);
6103 dpi
->modifiers
= hold_modifiers
;
6106 /* Print an array type, except for the element type. */
6109 d_print_array_type (struct d_print_info
*dpi
, int options
,
6110 struct demangle_component
*dc
,
6111 struct d_print_mod
*mods
)
6119 struct d_print_mod
*p
;
6122 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6126 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
6141 d_append_string (dpi
, " (");
6143 d_print_mod_list (dpi
, options
, mods
, 0);
6146 d_append_char (dpi
, ')');
6150 d_append_char (dpi
, ' ');
6152 d_append_char (dpi
, '[');
6154 if (d_left (dc
) != NULL
)
6155 d_print_comp (dpi
, options
, d_left (dc
));
6157 d_append_char (dpi
, ']');
6160 /* Print an operator in an expression. */
6163 d_print_expr_op (struct d_print_info
*dpi
, int options
,
6164 struct demangle_component
*dc
)
6166 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
6167 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
6168 dc
->u
.s_operator
.op
->len
);
6170 d_print_comp (dpi
, options
, dc
);
6176 d_print_cast (struct d_print_info
*dpi
, int options
,
6177 struct demangle_component
*dc
)
6179 d_print_comp (dpi
, options
, d_left (dc
));
6182 /* Print a conversion operator. */
6185 d_print_conversion (struct d_print_info
*dpi
, int options
,
6186 struct demangle_component
*dc
)
6188 struct d_print_template dpt
;
6190 /* For a conversion operator, we need the template parameters from
6191 the enclosing template in scope for processing the type. */
6192 if (dpi
->current_template
!= NULL
)
6194 dpt
.next
= dpi
->templates
;
6195 dpi
->templates
= &dpt
;
6196 dpt
.template_decl
= dpi
->current_template
;
6199 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
6201 d_print_comp (dpi
, options
, d_left (dc
));
6202 if (dpi
->current_template
!= NULL
)
6203 dpi
->templates
= dpt
.next
;
6207 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
6209 /* For a templated cast operator, we need to remove the template
6210 parameters from scope after printing the operator name,
6211 so we need to handle the template printing here. */
6212 if (dpi
->current_template
!= NULL
)
6213 dpi
->templates
= dpt
.next
;
6215 if (d_last_char (dpi
) == '<')
6216 d_append_char (dpi
, ' ');
6217 d_append_char (dpi
, '<');
6218 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
6219 /* Avoid generating two consecutive '>' characters, to avoid
6220 the C++ syntactic ambiguity. */
6221 if (d_last_char (dpi
) == '>')
6222 d_append_char (dpi
, ' ');
6223 d_append_char (dpi
, '>');
6227 /* Initialize the information structure we use to pass around
6230 CP_STATIC_IF_GLIBCPP_V3
6232 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
6236 di
->send
= mangled
+ len
;
6237 di
->options
= options
;
6241 /* We cannot need more components than twice the number of chars in
6242 the mangled string. Most components correspond directly to
6243 chars, but the ARGLIST types are exceptions. */
6244 di
->num_comps
= 2 * len
;
6247 /* Similarly, we cannot need more substitutions than there are
6248 chars in the mangled string. */
6252 di
->last_name
= NULL
;
6255 di
->is_expression
= 0;
6256 di
->is_conversion
= 0;
6257 di
->recursion_level
= 0;
6260 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6261 mangled name, return strings in repeated callback giving the demangled
6262 name. OPTIONS is the usual libiberty demangler options. On success,
6263 this returns 1. On failure, returns 0. */
6266 d_demangle_callback (const char *mangled
, int options
,
6267 demangle_callbackref callback
, void *opaque
)
6278 struct demangle_component
*dc
;
6281 if (mangled
[0] == '_' && mangled
[1] == 'Z')
6283 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
6284 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
6285 && (mangled
[9] == 'D' || mangled
[9] == 'I')
6286 && mangled
[10] == '_')
6287 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
6290 if ((options
& DMGL_TYPES
) == 0)
6295 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
6297 /* PR 87675 - Check for a mangled string that is so long
6298 that we do not have enough stack space to demangle it. */
6299 if (((options
& DMGL_NO_RECURSE_LIMIT
) == 0)
6300 /* This check is a bit arbitrary, since what we really want to do is to
6301 compare the sizes of the di.comps and di.subs arrays against the
6302 amount of stack space remaining. But there is no portable way to do
6303 this, so instead we use the recursion limit as a guide to the maximum
6304 size of the arrays. */
6305 && (unsigned long) di
.num_comps
> DEMANGLE_RECURSION_LIMIT
)
6307 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6312 #ifdef CP_DYNAMIC_ARRAYS
6313 __extension__
struct demangle_component comps
[di
.num_comps
];
6314 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6319 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6320 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6326 dc
= cplus_demangle_type (&di
);
6329 dc
= cplus_demangle_mangled_name (&di
, 1);
6331 case DCT_GLOBAL_CTORS
:
6332 case DCT_GLOBAL_DTORS
:
6333 d_advance (&di
, 11);
6334 dc
= d_make_comp (&di
,
6335 (type
== DCT_GLOBAL_CTORS
6336 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6337 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
6338 d_make_demangle_mangled_name (&di
, d_str (&di
)),
6340 d_advance (&di
, strlen (d_str (&di
)));
6343 abort (); /* We have listed all the cases. */
6346 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6347 mangled string, then we didn't successfully demangle it. If
6348 DMGL_PARAMS is not set, we didn't look at the trailing
6350 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
6353 #ifdef CP_DEMANGLE_DEBUG
6357 status
= (dc
!= NULL
)
6358 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
6365 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6366 name, return a buffer allocated with malloc holding the demangled
6367 name. OPTIONS is the usual libiberty demangler options. On
6368 success, this sets *PALC to the allocated size of the returned
6369 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6370 a memory allocation failure, and returns NULL. */
6373 d_demangle (const char *mangled
, int options
, size_t *palc
)
6375 struct d_growable_string dgs
;
6378 d_growable_string_init (&dgs
, 0);
6380 status
= d_demangle_callback (mangled
, options
,
6381 d_growable_string_callback_adapter
, &dgs
);
6389 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
6393 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6395 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6397 /* ia64 ABI-mandated entry point in the C++ runtime library for
6398 performing demangling. MANGLED_NAME is a NUL-terminated character
6399 string containing the name to be demangled.
6401 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6402 *LENGTH bytes, into which the demangled name is stored. If
6403 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6404 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6405 is placed in a region of memory allocated with malloc.
6407 If LENGTH is non-NULL, the length of the buffer containing the
6408 demangled name, is placed in *LENGTH.
6410 The return value is a pointer to the start of the NUL-terminated
6411 demangled name, or NULL if the demangling fails. The caller is
6412 responsible for deallocating this memory using free.
6414 *STATUS is set to one of the following values:
6415 0: The demangling operation succeeded.
6416 -1: A memory allocation failure occurred.
6417 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6418 -3: One of the arguments is invalid.
6420 The demangling is performed using the C++ ABI mangling rules, with
6424 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
6425 size_t *length
, int *status
)
6430 if (mangled_name
== NULL
)
6437 if (output_buffer
!= NULL
&& length
== NULL
)
6444 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
6446 if (demangled
== NULL
)
6458 if (output_buffer
== NULL
)
6465 if (strlen (demangled
) < *length
)
6467 strcpy (output_buffer
, demangled
);
6469 demangled
= output_buffer
;
6473 free (output_buffer
);
6484 extern int __gcclibcxx_demangle_callback (const char *,
6486 (const char *, size_t, void *),
6489 /* Alternative, allocationless entry point in the C++ runtime library
6490 for performing demangling. MANGLED_NAME is a NUL-terminated character
6491 string containing the name to be demangled.
6493 CALLBACK is a callback function, called with demangled string
6494 segments as demangling progresses; it is called at least once,
6495 but may be called more than once. OPAQUE is a generalized pointer
6496 used as a callback argument.
6498 The return code is one of the following values, equivalent to
6499 the STATUS values of __cxa_demangle() (excluding -1, since this
6500 function performs no memory allocations):
6501 0: The demangling operation succeeded.
6502 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6503 -3: One of the arguments is invalid.
6505 The demangling is performed using the C++ ABI mangling rules, with
6509 __gcclibcxx_demangle_callback (const char *mangled_name
,
6510 void (*callback
) (const char *, size_t, void *),
6515 if (mangled_name
== NULL
|| callback
== NULL
)
6518 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
6526 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6528 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6529 mangled name, return a buffer allocated with malloc holding the
6530 demangled name. Otherwise, return NULL. */
6533 cplus_demangle_v3 (const char *mangled
, int options
)
6537 return d_demangle (mangled
, options
, &alc
);
6541 cplus_demangle_v3_callback (const char *mangled
, int options
,
6542 demangle_callbackref callback
, void *opaque
)
6544 return d_demangle_callback (mangled
, options
, callback
, opaque
);
6547 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6548 conventions, but the output formatting is a little different.
6549 This instructs the C++ demangler not to emit pointer characters ("*"), to
6550 use Java's namespace separator symbol ("." instead of "::"), and to output
6551 JArray<TYPE> as TYPE[]. */
6554 java_demangle_v3 (const char *mangled
)
6558 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
6562 java_demangle_v3_callback (const char *mangled
,
6563 demangle_callbackref callback
, void *opaque
)
6565 return d_demangle_callback (mangled
,
6566 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
6570 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6572 #ifndef IN_GLIBCPP_V3
6574 /* Demangle a string in order to find out whether it is a constructor
6575 or destructor. Return non-zero on success. Set *CTOR_KIND and
6576 *DTOR_KIND appropriately. */
6579 is_ctor_or_dtor (const char *mangled
,
6580 enum gnu_v3_ctor_kinds
*ctor_kind
,
6581 enum gnu_v3_dtor_kinds
*dtor_kind
)
6584 struct demangle_component
*dc
;
6587 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
6588 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
6590 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
6593 #ifdef CP_DYNAMIC_ARRAYS
6594 __extension__
struct demangle_component comps
[di
.num_comps
];
6595 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6600 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6601 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6604 dc
= cplus_demangle_mangled_name (&di
, 1);
6606 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6607 to demangle the entire string. */
6614 /* These cannot appear on a constructor or destructor. */
6615 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6616 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6617 case DEMANGLE_COMPONENT_CONST_THIS
:
6618 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6619 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6623 case DEMANGLE_COMPONENT_TYPED_NAME
:
6624 case DEMANGLE_COMPONENT_TEMPLATE
:
6627 case DEMANGLE_COMPONENT_QUAL_NAME
:
6628 case DEMANGLE_COMPONENT_LOCAL_NAME
:
6631 case DEMANGLE_COMPONENT_CTOR
:
6632 *ctor_kind
= dc
->u
.s_ctor
.kind
;
6636 case DEMANGLE_COMPONENT_DTOR
:
6637 *dtor_kind
= dc
->u
.s_dtor
.kind
;
6648 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6649 name. A non-zero return indicates the type of constructor. */
6651 enum gnu_v3_ctor_kinds
6652 is_gnu_v3_mangled_ctor (const char *name
)
6654 enum gnu_v3_ctor_kinds ctor_kind
;
6655 enum gnu_v3_dtor_kinds dtor_kind
;
6657 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6658 return (enum gnu_v3_ctor_kinds
) 0;
6663 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6664 name. A non-zero return indicates the type of destructor. */
6666 enum gnu_v3_dtor_kinds
6667 is_gnu_v3_mangled_dtor (const char *name
)
6669 enum gnu_v3_ctor_kinds ctor_kind
;
6670 enum gnu_v3_dtor_kinds dtor_kind
;
6672 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6673 return (enum gnu_v3_dtor_kinds
) 0;
6677 #endif /* IN_GLIBCPP_V3 */
6679 #ifdef STANDALONE_DEMANGLER
6682 #include "dyn-string.h"
6684 static void print_usage (FILE* fp
, int exit_value
);
6686 #define IS_ALPHA(CHAR) \
6687 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6688 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6690 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6691 #define is_mangled_char(CHAR) \
6692 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6693 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6695 /* The name of this program, as invoked. */
6696 const char* program_name
;
6698 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6701 print_usage (FILE* fp
, int exit_value
)
6703 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
6704 fprintf (fp
, "Options:\n");
6705 fprintf (fp
, " -h,--help Display this message.\n");
6706 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
6707 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
6708 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6713 /* Option specification for getopt_long. */
6714 static const struct option long_options
[] =
6716 { "help", no_argument
, NULL
, 'h' },
6717 { "no-params", no_argument
, NULL
, 'p' },
6718 { "verbose", no_argument
, NULL
, 'v' },
6719 { NULL
, no_argument
, NULL
, 0 },
6722 /* Main entry for a demangling filter executable. It will demangle
6723 its command line arguments, if any. If none are provided, it will
6724 filter stdin to stdout, replacing any recognized mangled C++ names
6725 with their demangled equivalents. */
6728 main (int argc
, char *argv
[])
6732 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
6734 /* Use the program name of this program, as invoked. */
6735 program_name
= argv
[0];
6737 /* Parse options. */
6740 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
6743 case '?': /* Unrecognized option. */
6744 print_usage (stderr
, 1);
6748 print_usage (stdout
, 0);
6752 options
&= ~ DMGL_PARAMS
;
6756 options
|= DMGL_VERBOSE
;
6760 while (opt_char
!= -1);
6763 /* No command line arguments were provided. Filter stdin. */
6765 dyn_string_t mangled
= dyn_string_new (3);
6768 /* Read all of input. */
6769 while (!feof (stdin
))
6773 /* Pile characters into mangled until we hit one that can't
6774 occur in a mangled name. */
6776 while (!feof (stdin
) && is_mangled_char (c
))
6778 dyn_string_append_char (mangled
, c
);
6784 if (dyn_string_length (mangled
) > 0)
6786 #ifdef IN_GLIBCPP_V3
6787 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
6789 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
6799 /* It might not have been a mangled name. Print the
6801 fputs (dyn_string_buf (mangled
), stdout
);
6804 dyn_string_clear (mangled
);
6807 /* If we haven't hit EOF yet, we've read one character that
6808 can't occur in a mangled name, so print it out. */
6813 dyn_string_delete (mangled
);
6816 /* Demangle command line arguments. */
6818 /* Loop over command line arguments. */
6819 for (i
= optind
; i
< argc
; ++i
)
6822 #ifdef IN_GLIBCPP_V3
6826 /* Attempt to demangle. */
6827 #ifdef IN_GLIBCPP_V3
6828 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
6830 s
= cplus_demangle_v3 (argv
[i
], options
);
6833 /* If it worked, print the demangled name. */
6841 #ifdef IN_GLIBCPP_V3
6842 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
6844 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
6853 #endif /* STANDALONE_DEMANGLER */