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 { "st", NL ("sizeof "), 1 },
1864 { "sz", NL ("sizeof "), 1 },
1865 { "tr", NL ("throw"), 0 },
1866 { "tw", NL ("throw "), 1 },
1867 { NULL
, NULL
, 0, 0 }
1870 static struct demangle_component
*
1871 d_operator_name (struct d_info
*di
)
1876 c1
= d_next_char (di
);
1877 c2
= d_next_char (di
);
1878 if (c1
== 'v' && IS_DIGIT (c2
))
1879 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1880 else if (c1
== 'c' && c2
== 'v')
1882 struct demangle_component
*type
;
1883 int was_conversion
= di
->is_conversion
;
1884 struct demangle_component
*res
;
1886 di
->is_conversion
= ! di
->is_expression
;
1887 type
= cplus_demangle_type (di
);
1888 if (di
->is_conversion
)
1889 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CONVERSION
, type
, NULL
);
1891 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CAST
, type
, NULL
);
1892 di
->is_conversion
= was_conversion
;
1897 /* LOW is the inclusive lower bound. */
1899 /* HIGH is the exclusive upper bound. We subtract one to ignore
1900 the sentinel at the end of the array. */
1901 int high
= ((sizeof (cplus_demangle_operators
)
1902 / sizeof (cplus_demangle_operators
[0]))
1908 const struct demangle_operator_info
*p
;
1910 i
= low
+ (high
- low
) / 2;
1911 p
= cplus_demangle_operators
+ i
;
1913 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1914 return d_make_operator (di
, p
);
1916 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1926 static struct demangle_component
*
1927 d_make_character (struct d_info
*di
, int c
)
1929 struct demangle_component
*p
;
1930 p
= d_make_empty (di
);
1933 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1934 p
->u
.s_character
.character
= c
;
1939 static struct demangle_component
*
1940 d_java_resource (struct d_info
*di
)
1942 struct demangle_component
*p
= NULL
;
1943 struct demangle_component
*next
= NULL
;
1948 len
= d_number (di
);
1952 /* Eat the leading '_'. */
1953 if (d_next_char (di
) != '_')
1966 /* Each chunk is either a '$' escape... */
1984 next
= d_make_character (di
, c
);
1992 /* ... or a sequence of characters. */
1995 while (i
< len
&& str
[i
] && str
[i
] != '$')
1998 next
= d_make_name (di
, str
, i
);
2011 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
2017 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
2022 /* <special-name> ::= TV <type>
2026 ::= TA <template-arg>
2027 ::= GV <(object) name>
2028 ::= T <call-offset> <(base) encoding>
2029 ::= Tc <call-offset> <call-offset> <(base) encoding>
2030 Also g++ extensions:
2031 ::= TC <type> <(offset) number> _ <(base) type>
2036 ::= Gr <resource name>
2041 static struct demangle_component
*
2042 d_special_name (struct d_info
*di
)
2044 di
->expansion
+= 20;
2045 if (d_check_char (di
, 'T'))
2047 switch (d_next_char (di
))
2051 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
2052 cplus_demangle_type (di
), NULL
);
2054 di
->expansion
-= 10;
2055 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
2056 cplus_demangle_type (di
), NULL
);
2058 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
2059 cplus_demangle_type (di
), NULL
);
2061 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
2062 cplus_demangle_type (di
), NULL
);
2065 if (! d_call_offset (di
, 'h'))
2067 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
2068 d_encoding (di
, 0), NULL
);
2071 if (! d_call_offset (di
, 'v'))
2073 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
2074 d_encoding (di
, 0), NULL
);
2077 if (! d_call_offset (di
, '\0'))
2079 if (! d_call_offset (di
, '\0'))
2081 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
2082 d_encoding (di
, 0), NULL
);
2086 struct demangle_component
*derived_type
;
2088 struct demangle_component
*base_type
;
2090 derived_type
= cplus_demangle_type (di
);
2091 offset
= d_number (di
);
2094 if (! d_check_char (di
, '_'))
2096 base_type
= cplus_demangle_type (di
);
2097 /* We don't display the offset. FIXME: We should display
2098 it in verbose mode. */
2100 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
2101 base_type
, derived_type
);
2105 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
2106 cplus_demangle_type (di
), NULL
);
2108 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
2109 cplus_demangle_type (di
), NULL
);
2112 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
2116 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
2120 return d_make_comp (di
, DEMANGLE_COMPONENT_TPARM_OBJ
,
2121 d_template_arg (di
), NULL
);
2127 else if (d_check_char (di
, 'G'))
2129 switch (d_next_char (di
))
2132 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
,
2137 struct demangle_component
*name
= d_name (di
);
2138 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
2139 d_number_component (di
));
2143 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
2144 d_encoding (di
, 0), NULL
);
2147 switch (d_next_char (di
))
2150 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
2151 d_encoding (di
, 0), NULL
);
2153 /* ??? The proposal is that other letters (such as 'h') stand
2154 for different variants of transaction cloning, such as
2155 compiling directly for hardware transaction support. But
2156 they still should all be transactional clones of some sort
2157 so go ahead and call them that. */
2159 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
2160 d_encoding (di
, 0), NULL
);
2164 return d_java_resource (di
);
2174 /* <call-offset> ::= h <nv-offset> _
2177 <nv-offset> ::= <(offset) number>
2179 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2181 The C parameter, if not '\0', is a character we just read which is
2182 the start of the <call-offset>.
2184 We don't display the offset information anywhere. FIXME: We should
2185 display it in verbose mode. */
2188 d_call_offset (struct d_info
*di
, int c
)
2191 c
= d_next_char (di
);
2198 if (! d_check_char (di
, '_'))
2205 if (! d_check_char (di
, '_'))
2211 /* <ctor-dtor-name> ::= C1
2219 static struct demangle_component
*
2220 d_ctor_dtor_name (struct d_info
*di
)
2222 if (di
->last_name
!= NULL
)
2224 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2225 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2226 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2227 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2229 switch (d_peek_char (di
))
2233 enum gnu_v3_ctor_kinds kind
;
2236 if (d_peek_next_char (di
) == 'I')
2242 switch (d_peek_next_char (di
))
2245 kind
= gnu_v3_complete_object_ctor
;
2248 kind
= gnu_v3_base_object_ctor
;
2251 kind
= gnu_v3_complete_object_allocating_ctor
;
2254 kind
= gnu_v3_unified_ctor
;
2257 kind
= gnu_v3_object_ctor_group
;
2266 cplus_demangle_type (di
);
2268 return d_make_ctor (di
, kind
, di
->last_name
);
2273 enum gnu_v3_dtor_kinds kind
;
2275 switch (d_peek_next_char (di
))
2278 kind
= gnu_v3_deleting_dtor
;
2281 kind
= gnu_v3_complete_object_dtor
;
2284 kind
= gnu_v3_base_object_dtor
;
2286 /* digit '3' is not used */
2288 kind
= gnu_v3_unified_dtor
;
2291 kind
= gnu_v3_object_dtor_group
;
2297 return d_make_dtor (di
, kind
, di
->last_name
);
2305 /* True iff we're looking at an order-insensitive type-qualifier, including
2306 function-type-qualifiers. */
2309 next_is_type_qual (struct d_info
*di
)
2311 char peek
= d_peek_char (di
);
2312 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2316 peek
= d_peek_next_char (di
);
2317 if (peek
== 'x' || peek
== 'o' || peek
== 'O' || peek
== 'w')
2323 /* <type> ::= <builtin-type>
2325 ::= <class-enum-type>
2327 ::= <pointer-to-member-type>
2328 ::= <template-param>
2329 ::= <template-template-param> <template-args>
2331 ::= <CV-qualifiers> <type>
2334 ::= O <type> (C++0x)
2337 ::= U <source-name> <type>
2339 <builtin-type> ::= various one letter codes
2343 CP_STATIC_IF_GLIBCPP_V3
2344 const struct demangle_builtin_type_info
2345 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2347 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2348 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2349 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2350 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2351 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2352 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2353 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2354 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2355 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2356 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2357 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2358 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2359 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2360 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2361 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2363 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2364 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2365 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2366 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2367 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2368 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2369 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2370 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2371 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2372 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2373 D_PRINT_UNSIGNED_LONG_LONG
},
2374 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2375 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2376 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2377 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2378 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2379 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT
},
2380 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2381 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2382 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2386 CP_STATIC_IF_GLIBCPP_V3
2387 struct demangle_component
*
2388 cplus_demangle_type (struct d_info
*di
)
2391 struct demangle_component
*ret
;
2394 /* The ABI specifies that when CV-qualifiers are used, the base type
2395 is substitutable, and the fully qualified type is substitutable,
2396 but the base type with a strict subset of the CV-qualifiers is
2397 not substitutable. The natural recursive implementation of the
2398 CV-qualifiers would cause subsets to be substitutable, so instead
2399 we pull them all off now.
2401 FIXME: The ABI says that order-insensitive vendor qualifiers
2402 should be handled in the same way, but we have no way to tell
2403 which vendor qualifiers are order-insensitive and which are
2404 order-sensitive. So we just assume that they are all
2405 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2406 __vector, and it treats it as order-sensitive when mangling
2409 if (next_is_type_qual (di
))
2411 struct demangle_component
**pret
;
2413 pret
= d_cv_qualifiers (di
, &ret
, 0);
2416 if (d_peek_char (di
) == 'F')
2418 /* cv-qualifiers before a function type apply to 'this',
2419 so avoid adding the unqualified function type to
2420 the substitution list. */
2421 *pret
= d_function_type (di
);
2424 *pret
= cplus_demangle_type (di
);
2427 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2428 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2430 /* Move the ref-qualifier outside the cv-qualifiers so that
2431 they are printed in the right order. */
2432 struct demangle_component
*fn
= d_left (*pret
);
2433 d_left (*pret
) = ret
;
2437 if (! d_add_substitution (di
, ret
))
2444 peek
= d_peek_char (di
);
2447 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2448 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2449 case 'o': case 's': case 't':
2450 case 'v': case 'w': case 'x': case 'y': case 'z':
2451 ret
= d_make_builtin_type (di
,
2452 &cplus_demangle_builtin_types
[peek
- 'a']);
2453 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2460 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2461 d_source_name (di
), NULL
);
2465 ret
= d_function_type (di
);
2468 case '0': case '1': case '2': case '3': case '4':
2469 case '5': case '6': case '7': case '8': case '9':
2472 ret
= d_class_enum_type (di
);
2476 ret
= d_array_type (di
);
2480 ret
= d_pointer_to_member_type (di
);
2484 ret
= d_template_param (di
);
2485 if (d_peek_char (di
) == 'I')
2487 /* This may be <template-template-param> <template-args>.
2488 If this is the type for a conversion operator, we can
2489 have a <template-template-param> here only by following
2490 a derivation like this:
2493 -> <template-prefix> <template-args>
2494 -> <prefix> <template-unqualified-name> <template-args>
2495 -> <unqualified-name> <template-unqualified-name> <template-args>
2496 -> <source-name> <template-unqualified-name> <template-args>
2497 -> <source-name> <operator-name> <template-args>
2498 -> <source-name> cv <type> <template-args>
2499 -> <source-name> cv <template-template-param> <template-args> <template-args>
2501 where the <template-args> is followed by another.
2502 Otherwise, we must have a derivation like this:
2505 -> <template-prefix> <template-args>
2506 -> <prefix> <template-unqualified-name> <template-args>
2507 -> <unqualified-name> <template-unqualified-name> <template-args>
2508 -> <source-name> <template-unqualified-name> <template-args>
2509 -> <source-name> <operator-name> <template-args>
2510 -> <source-name> cv <type> <template-args>
2511 -> <source-name> cv <template-param> <template-args>
2513 where we need to leave the <template-args> to be processed
2514 by d_prefix (following the <template-prefix>).
2516 The <template-template-param> part is a substitution
2518 if (! di
->is_conversion
)
2520 if (! d_add_substitution (di
, ret
))
2522 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2523 d_template_args (di
));
2527 struct demangle_component
*args
;
2528 struct d_info_checkpoint checkpoint
;
2530 d_checkpoint (di
, &checkpoint
);
2531 args
= d_template_args (di
);
2532 if (d_peek_char (di
) == 'I')
2534 if (! d_add_substitution (di
, ret
))
2536 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2540 d_backtrack (di
, &checkpoint
);
2546 /* If this is a special substitution, then it is the start of
2547 <class-enum-type>. */
2551 peek_next
= d_peek_next_char (di
);
2552 if (IS_DIGIT (peek_next
)
2554 || IS_UPPER (peek_next
))
2556 ret
= d_substitution (di
, 0);
2557 /* The substituted name may have been a template name and
2558 may be followed by tepmlate args. */
2559 if (d_peek_char (di
) == 'I')
2560 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2561 d_template_args (di
));
2567 ret
= d_class_enum_type (di
);
2568 /* If the substitution was a complete type, then it is not
2569 a new substitution candidate. However, if the
2570 substitution was followed by template arguments, then
2571 the whole thing is a substitution candidate. */
2572 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2580 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2581 cplus_demangle_type (di
), NULL
);
2586 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2587 cplus_demangle_type (di
), NULL
);
2592 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2593 cplus_demangle_type (di
), NULL
);
2598 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2599 cplus_demangle_type (di
), NULL
);
2604 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2605 cplus_demangle_type (di
), NULL
);
2610 ret
= d_source_name (di
);
2611 if (d_peek_char (di
) == 'I')
2612 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2613 d_template_args (di
));
2614 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2615 cplus_demangle_type (di
), ret
);
2621 peek
= d_next_char (di
);
2626 /* decltype (expression) */
2627 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2628 d_expression (di
), NULL
);
2629 if (ret
&& d_next_char (di
) != 'E')
2635 /* Pack expansion. */
2636 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2637 cplus_demangle_type (di
), NULL
);
2643 ret
= d_make_name (di
, "auto", 4);
2646 /* decltype(auto) */
2647 ret
= d_make_name (di
, "decltype(auto)", 14);
2651 /* 32-bit decimal floating point */
2652 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2653 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2657 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2658 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2662 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2663 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2666 /* 16-bit half-precision FP */
2667 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2668 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2672 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2673 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2677 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2678 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2682 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2683 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2687 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2688 ret
= d_make_empty (di
);
2689 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2690 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2691 /* For demangling we don't care about the bits. */
2693 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2694 if (ret
->u
.s_fixed
.length
== NULL
)
2697 peek
= d_next_char (di
);
2698 ret
->u
.s_fixed
.sat
= (peek
== 's');
2702 ret
= d_vector_type (di
);
2707 /* decltype(nullptr) */
2708 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[33]);
2709 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2723 if (! d_add_substitution (di
, ret
))
2730 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2732 static struct demangle_component
**
2733 d_cv_qualifiers (struct d_info
*di
,
2734 struct demangle_component
**pret
, int member_fn
)
2736 struct demangle_component
**pstart
;
2740 peek
= d_peek_char (di
);
2741 while (next_is_type_qual (di
))
2743 enum demangle_component_type t
;
2744 struct demangle_component
*right
= NULL
;
2750 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2751 : DEMANGLE_COMPONENT_RESTRICT
);
2752 di
->expansion
+= sizeof "restrict";
2754 else if (peek
== 'V')
2757 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2758 : DEMANGLE_COMPONENT_VOLATILE
);
2759 di
->expansion
+= sizeof "volatile";
2761 else if (peek
== 'K')
2764 ? DEMANGLE_COMPONENT_CONST_THIS
2765 : DEMANGLE_COMPONENT_CONST
);
2766 di
->expansion
+= sizeof "const";
2770 peek
= d_next_char (di
);
2773 t
= DEMANGLE_COMPONENT_TRANSACTION_SAFE
;
2774 di
->expansion
+= sizeof "transaction_safe";
2776 else if (peek
== 'o'
2779 t
= DEMANGLE_COMPONENT_NOEXCEPT
;
2780 di
->expansion
+= sizeof "noexcept";
2783 right
= d_expression (di
);
2786 if (! d_check_char (di
, 'E'))
2790 else if (peek
== 'w')
2792 t
= DEMANGLE_COMPONENT_THROW_SPEC
;
2793 di
->expansion
+= sizeof "throw";
2794 right
= d_parmlist (di
);
2797 if (! d_check_char (di
, 'E'))
2804 *pret
= d_make_comp (di
, t
, NULL
, right
);
2807 pret
= &d_left (*pret
);
2809 peek
= d_peek_char (di
);
2812 if (!member_fn
&& peek
== 'F')
2814 while (pstart
!= pret
)
2816 switch ((*pstart
)->type
)
2818 case DEMANGLE_COMPONENT_RESTRICT
:
2819 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2821 case DEMANGLE_COMPONENT_VOLATILE
:
2822 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2824 case DEMANGLE_COMPONENT_CONST
:
2825 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2830 pstart
= &d_left (*pstart
);
2837 /* <ref-qualifier> ::= R
2840 static struct demangle_component
*
2841 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2843 struct demangle_component
*ret
= sub
;
2846 peek
= d_peek_char (di
);
2847 if (peek
== 'R' || peek
== 'O')
2849 enum demangle_component_type t
;
2852 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2853 di
->expansion
+= sizeof "&";
2857 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2858 di
->expansion
+= sizeof "&&";
2862 ret
= d_make_comp (di
, t
, ret
, NULL
);
2868 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2870 static struct demangle_component
*
2871 d_function_type (struct d_info
*di
)
2873 struct demangle_component
*ret
= NULL
;
2875 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2877 if (di
->recursion_level
> DEMANGLE_RECURSION_LIMIT
)
2878 /* FIXME: There ought to be a way to report
2879 that the recursion limit has been reached. */
2882 di
->recursion_level
++;
2885 if (d_check_char (di
, 'F'))
2887 if (d_peek_char (di
) == 'Y')
2889 /* Function has C linkage. We don't print this information.
2890 FIXME: We should print it in verbose mode. */
2893 ret
= d_bare_function_type (di
, 1);
2894 ret
= d_ref_qualifier (di
, ret
);
2896 if (! d_check_char (di
, 'E'))
2900 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2901 di
->recursion_level
--;
2907 static struct demangle_component
*
2908 d_parmlist (struct d_info
*di
)
2910 struct demangle_component
*tl
;
2911 struct demangle_component
**ptl
;
2917 struct demangle_component
*type
;
2919 char peek
= d_peek_char (di
);
2920 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2922 if ((peek
== 'R' || peek
== 'O')
2923 && d_peek_next_char (di
) == 'E')
2924 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2926 type
= cplus_demangle_type (di
);
2929 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2932 ptl
= &d_right (*ptl
);
2935 /* There should be at least one parameter type besides the optional
2936 return type. A function which takes no arguments will have a
2937 single parameter type void. */
2941 /* If we have a single parameter type void, omit it. */
2942 if (d_right (tl
) == NULL
2943 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2944 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2946 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2953 /* <bare-function-type> ::= [J]<type>+ */
2955 static struct demangle_component
*
2956 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2958 struct demangle_component
*return_type
;
2959 struct demangle_component
*tl
;
2962 /* Detect special qualifier indicating that the first argument
2963 is the return type. */
2964 peek
= d_peek_char (di
);
2968 has_return_type
= 1;
2971 if (has_return_type
)
2973 return_type
= cplus_demangle_type (di
);
2974 if (return_type
== NULL
)
2980 tl
= d_parmlist (di
);
2984 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2988 /* <class-enum-type> ::= <name> */
2990 static struct demangle_component
*
2991 d_class_enum_type (struct d_info
*di
)
2996 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2997 ::= A [<(dimension) expression>] _ <(element) type>
3000 static struct demangle_component
*
3001 d_array_type (struct d_info
*di
)
3004 struct demangle_component
*dim
;
3006 if (! d_check_char (di
, 'A'))
3009 peek
= d_peek_char (di
);
3012 else if (IS_DIGIT (peek
))
3020 peek
= d_peek_char (di
);
3022 while (IS_DIGIT (peek
));
3023 dim
= d_make_name (di
, s
, d_str (di
) - s
);
3029 dim
= d_expression (di
);
3034 if (! d_check_char (di
, '_'))
3037 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
3038 cplus_demangle_type (di
));
3041 /* <vector-type> ::= Dv <number> _ <type>
3042 ::= Dv _ <expression> _ <type> */
3044 static struct demangle_component
*
3045 d_vector_type (struct d_info
*di
)
3048 struct demangle_component
*dim
;
3050 peek
= d_peek_char (di
);
3054 dim
= d_expression (di
);
3057 dim
= d_number_component (di
);
3062 if (! d_check_char (di
, '_'))
3065 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
3066 cplus_demangle_type (di
));
3069 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3071 static struct demangle_component
*
3072 d_pointer_to_member_type (struct d_info
*di
)
3074 struct demangle_component
*cl
;
3075 struct demangle_component
*mem
;
3077 if (! d_check_char (di
, 'M'))
3080 cl
= cplus_demangle_type (di
);
3084 /* The ABI says, "The type of a non-static member function is considered
3085 to be different, for the purposes of substitution, from the type of a
3086 namespace-scope or static member function whose type appears
3087 similar. The types of two non-static member functions are considered
3088 to be different, for the purposes of substitution, if the functions
3089 are members of different classes. In other words, for the purposes of
3090 substitution, the class of which the function is a member is
3091 considered part of the type of function."
3093 For a pointer to member function, this call to cplus_demangle_type
3094 will end up adding a (possibly qualified) non-member function type to
3095 the substitution table, which is not correct; however, the member
3096 function type will never be used in a substitution, so putting the
3097 wrong type in the substitution table is harmless. */
3099 mem
= cplus_demangle_type (di
);
3103 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
3106 /* <non-negative number> _ */
3109 d_compact_number (struct d_info
*di
)
3112 if (d_peek_char (di
) == '_')
3114 else if (d_peek_char (di
) == 'n')
3117 num
= d_number (di
) + 1;
3119 if (num
< 0 || ! d_check_char (di
, '_'))
3124 /* <template-param> ::= T_
3125 ::= T <(parameter-2 non-negative) number> _
3128 static struct demangle_component
*
3129 d_template_param (struct d_info
*di
)
3133 if (! d_check_char (di
, 'T'))
3136 param
= d_compact_number (di
);
3140 return d_make_template_param (di
, param
);
3143 /* <template-args> ::= I <template-arg>+ E */
3145 static struct demangle_component
*
3146 d_template_args (struct d_info
*di
)
3148 if (d_peek_char (di
) != 'I'
3149 && d_peek_char (di
) != 'J')
3153 return d_template_args_1 (di
);
3156 /* <template-arg>* E */
3158 static struct demangle_component
*
3159 d_template_args_1 (struct d_info
*di
)
3161 struct demangle_component
*hold_last_name
;
3162 struct demangle_component
*al
;
3163 struct demangle_component
**pal
;
3165 /* Preserve the last name we saw--don't let the template arguments
3166 clobber it, as that would give us the wrong name for a subsequent
3167 constructor or destructor. */
3168 hold_last_name
= di
->last_name
;
3170 if (d_peek_char (di
) == 'E')
3172 /* An argument pack can be empty. */
3174 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
3181 struct demangle_component
*a
;
3183 a
= d_template_arg (di
);
3187 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
3190 pal
= &d_right (*pal
);
3192 if (d_peek_char (di
) == 'E')
3199 di
->last_name
= hold_last_name
;
3204 /* <template-arg> ::= <type>
3205 ::= X <expression> E
3209 static struct demangle_component
*
3210 d_template_arg (struct d_info
*di
)
3212 struct demangle_component
*ret
;
3214 switch (d_peek_char (di
))
3218 ret
= d_expression (di
);
3219 if (! d_check_char (di
, 'E'))
3224 return d_expr_primary (di
);
3228 /* An argument pack. */
3229 return d_template_args (di
);
3232 return cplus_demangle_type (di
);
3236 /* Parse a sequence of expressions until we hit the terminator
3239 static struct demangle_component
*
3240 d_exprlist (struct d_info
*di
, char terminator
)
3242 struct demangle_component
*list
= NULL
;
3243 struct demangle_component
**p
= &list
;
3245 if (d_peek_char (di
) == terminator
)
3248 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
3253 struct demangle_component
*arg
= d_expression (di
);
3257 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
3262 if (d_peek_char (di
) == terminator
)
3272 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3273 dynamic_cast, static_cast or reinterpret_cast. */
3276 op_is_new_cast (struct demangle_component
*op
)
3278 const char *code
= op
->u
.s_operator
.op
->code
;
3279 return (code
[1] == 'c'
3280 && (code
[0] == 's' || code
[0] == 'd'
3281 || code
[0] == 'c' || code
[0] == 'r'));
3284 /* <expression> ::= <(unary) operator-name> <expression>
3285 ::= <(binary) operator-name> <expression> <expression>
3286 ::= <(trinary) operator-name> <expression> <expression> <expression>
3287 ::= cl <expression>+ E
3289 ::= <template-param>
3290 ::= sr <type> <unqualified-name>
3291 ::= sr <type> <unqualified-name> <template-args>
3295 static inline struct demangle_component
*
3296 d_expression_1 (struct d_info
*di
)
3300 peek
= d_peek_char (di
);
3302 return d_expr_primary (di
);
3303 else if (peek
== 'T')
3304 return d_template_param (di
);
3305 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
3307 struct demangle_component
*type
;
3308 struct demangle_component
*name
;
3311 type
= cplus_demangle_type (di
);
3312 name
= d_unqualified_name (di
);
3313 if (d_peek_char (di
) != 'I')
3314 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
3316 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
3317 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3318 d_template_args (di
)));
3320 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3323 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3324 d_expression_1 (di
), NULL
);
3326 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3328 /* Function parameter used in a late-specified return type. */
3331 if (d_peek_char (di
) == 'T')
3333 /* 'this' parameter. */
3339 index
= d_compact_number (di
);
3340 if (index
== INT_MAX
|| index
== -1)
3344 return d_make_function_param (di
, index
);
3346 else if (IS_DIGIT (peek
)
3347 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3349 /* We can get an unqualified name as an expression in the case of
3350 a dependent function call, i.e. decltype(f(t)). */
3351 struct demangle_component
*name
;
3354 /* operator-function-id, i.e. operator+(t). */
3357 name
= d_unqualified_name (di
);
3360 if (d_peek_char (di
) == 'I')
3361 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3362 d_template_args (di
));
3366 else if ((peek
== 'i' || peek
== 't')
3367 && d_peek_next_char (di
) == 'l')
3369 /* Brace-enclosed initializer list, untyped or typed. */
3370 struct demangle_component
*type
= NULL
;
3373 type
= cplus_demangle_type (di
);
3374 if (!d_peek_char (di
) || !d_peek_next_char (di
))
3376 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3377 type
, d_exprlist (di
, 'E'));
3381 struct demangle_component
*op
;
3382 const char *code
= NULL
;
3385 op
= d_operator_name (di
);
3389 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3391 code
= op
->u
.s_operator
.op
->code
;
3392 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3393 if (strcmp (code
, "st") == 0)
3394 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3395 cplus_demangle_type (di
));
3402 case DEMANGLE_COMPONENT_OPERATOR
:
3403 args
= op
->u
.s_operator
.op
->args
;
3405 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3406 args
= op
->u
.s_extended_operator
.args
;
3408 case DEMANGLE_COMPONENT_CAST
:
3416 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3420 struct demangle_component
*operand
;
3423 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3424 && code
[1] == code
[0])
3425 /* pp_ and mm_ are the prefix variants. */
3426 suffix
= !d_check_char (di
, '_');
3428 if (op
->type
== DEMANGLE_COMPONENT_CAST
3429 && d_check_char (di
, '_'))
3430 operand
= d_exprlist (di
, 'E');
3431 else if (code
&& !strcmp (code
, "sP"))
3432 operand
= d_template_args_1 (di
);
3434 operand
= d_expression_1 (di
);
3437 /* Indicate the suffix variant for d_print_comp. */
3438 operand
= d_make_comp (di
, DEMANGLE_COMPONENT_BINARY_ARGS
,
3441 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
, operand
);
3445 struct demangle_component
*left
;
3446 struct demangle_component
*right
;
3450 if (op_is_new_cast (op
))
3451 left
= cplus_demangle_type (di
);
3452 else if (code
[0] == 'f')
3453 /* fold-expression. */
3454 left
= d_operator_name (di
);
3456 left
= d_expression_1 (di
);
3457 if (!strcmp (code
, "cl"))
3458 right
= d_exprlist (di
, 'E');
3459 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3461 right
= d_unqualified_name (di
);
3462 if (d_peek_char (di
) == 'I')
3463 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3464 right
, d_template_args (di
));
3467 right
= d_expression_1 (di
);
3469 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3471 DEMANGLE_COMPONENT_BINARY_ARGS
,
3476 struct demangle_component
*first
;
3477 struct demangle_component
*second
;
3478 struct demangle_component
*third
;
3482 else if (!strcmp (code
, "qu"))
3484 /* ?: expression. */
3485 first
= d_expression_1 (di
);
3486 second
= d_expression_1 (di
);
3487 third
= d_expression_1 (di
);
3491 else if (code
[0] == 'f')
3493 /* fold-expression. */
3494 first
= d_operator_name (di
);
3495 second
= d_expression_1 (di
);
3496 third
= d_expression_1 (di
);
3500 else if (code
[0] == 'n')
3502 /* new-expression. */
3503 if (code
[1] != 'w' && code
[1] != 'a')
3505 first
= d_exprlist (di
, '_');
3506 second
= cplus_demangle_type (di
);
3507 if (d_peek_char (di
) == 'E')
3512 else if (d_peek_char (di
) == 'p'
3513 && d_peek_next_char (di
) == 'i')
3515 /* Parenthesized initializer. */
3517 third
= d_exprlist (di
, 'E');
3519 else if (d_peek_char (di
) == 'i'
3520 && d_peek_next_char (di
) == 'l')
3521 /* initializer-list. */
3522 third
= d_expression_1 (di
);
3528 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3530 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3533 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3542 static struct demangle_component
*
3543 d_expression (struct d_info
*di
)
3545 struct demangle_component
*ret
;
3546 int was_expression
= di
->is_expression
;
3548 di
->is_expression
= 1;
3549 ret
= d_expression_1 (di
);
3550 di
->is_expression
= was_expression
;
3554 /* <expr-primary> ::= L <type> <(value) number> E
3555 ::= L <type> <(value) float> E
3556 ::= L <mangled-name> E
3559 static struct demangle_component
*
3560 d_expr_primary (struct d_info
*di
)
3562 struct demangle_component
*ret
;
3564 if (! d_check_char (di
, 'L'))
3566 if (d_peek_char (di
) == '_'
3567 /* Workaround for G++ bug; see comment in write_template_arg. */
3568 || d_peek_char (di
) == 'Z')
3569 ret
= cplus_demangle_mangled_name (di
, 0);
3572 struct demangle_component
*type
;
3573 enum demangle_component_type t
;
3576 type
= cplus_demangle_type (di
);
3580 /* If we have a type we know how to print, we aren't going to
3581 print the type name itself. */
3582 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3583 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3584 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3586 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3587 && strcmp (type
->u
.s_builtin
.type
->name
,
3588 cplus_demangle_builtin_types
[33].name
) == 0)
3590 if (d_peek_char (di
) == 'E')
3597 /* Rather than try to interpret the literal value, we just
3598 collect it as a string. Note that it's possible to have a
3599 floating point literal here. The ABI specifies that the
3600 format of such literals is machine independent. That's fine,
3601 but what's not fine is that versions of g++ up to 3.2 with
3602 -fabi-version=1 used upper case letters in the hex constant,
3603 and dumped out gcc's internal representation. That makes it
3604 hard to tell where the constant ends, and hard to dump the
3605 constant in any readable form anyhow. We don't attempt to
3606 handle these cases. */
3608 t
= DEMANGLE_COMPONENT_LITERAL
;
3609 if (d_peek_char (di
) == 'n')
3611 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3615 while (d_peek_char (di
) != 'E')
3617 if (d_peek_char (di
) == '\0')
3621 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3623 if (! d_check_char (di
, 'E'))
3628 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3629 ::= Z <(function) encoding> E s [<discriminator>]
3630 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3633 static struct demangle_component
*
3634 d_local_name (struct d_info
*di
)
3636 struct demangle_component
*function
;
3637 struct demangle_component
*name
;
3639 if (! d_check_char (di
, 'Z'))
3642 function
= d_encoding (di
, 0);
3646 if (! d_check_char (di
, 'E'))
3649 if (d_peek_char (di
) == 's')
3652 if (! d_discriminator (di
))
3654 name
= d_make_name (di
, "string literal", sizeof "string literal" - 1);
3660 if (d_peek_char (di
) == 'd')
3662 /* Default argument scope: d <number> _. */
3664 num
= d_compact_number (di
);
3672 /* Lambdas and unnamed types have internal discriminators
3673 and are not functions. */
3674 && name
->type
!= DEMANGLE_COMPONENT_LAMBDA
3675 && name
->type
!= DEMANGLE_COMPONENT_UNNAMED_TYPE
)
3677 /* Read and ignore an optional discriminator. */
3678 if (! d_discriminator (di
))
3683 name
= d_make_default_arg (di
, num
, name
);
3686 /* Elide the return type of the containing function so as to not
3687 confuse the user thinking it is the return type of whatever local
3688 function we might be containing. */
3689 if (function
->type
== DEMANGLE_COMPONENT_TYPED_NAME
3690 && d_right (function
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3691 d_left (d_right (function
)) = NULL
;
3693 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3696 /* <discriminator> ::= _ <number> # when number < 10
3697 ::= __ <number> _ # when number >= 10
3699 <discriminator> ::= _ <number> # when number >=10
3700 is also accepted to support gcc versions that wrongly mangled that way.
3702 We demangle the discriminator, but we don't print it out. FIXME:
3703 We should print it out in verbose mode. */
3706 d_discriminator (struct d_info
*di
)
3708 int discrim
, num_underscores
= 1;
3710 if (d_peek_char (di
) != '_')
3713 if (d_peek_char (di
) == '_')
3719 discrim
= d_number (di
);
3722 if (num_underscores
> 1 && discrim
>= 10)
3724 if (d_peek_char (di
) == '_')
3733 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3735 static struct demangle_component
*
3736 d_lambda (struct d_info
*di
)
3738 struct demangle_component
*tl
;
3739 struct demangle_component
*ret
;
3742 if (! d_check_char (di
, 'U'))
3744 if (! d_check_char (di
, 'l'))
3747 tl
= d_parmlist (di
);
3751 if (! d_check_char (di
, 'E'))
3754 num
= d_compact_number (di
);
3758 ret
= d_make_empty (di
);
3761 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3762 ret
->u
.s_unary_num
.sub
= tl
;
3763 ret
->u
.s_unary_num
.num
= num
;
3766 if (! d_add_substitution (di
, ret
))
3772 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3774 static struct demangle_component
*
3775 d_unnamed_type (struct d_info
*di
)
3777 struct demangle_component
*ret
;
3780 if (! d_check_char (di
, 'U'))
3782 if (! d_check_char (di
, 't'))
3785 num
= d_compact_number (di
);
3789 ret
= d_make_empty (di
);
3792 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3793 ret
->u
.s_number
.number
= num
;
3796 if (! d_add_substitution (di
, ret
))
3802 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3805 static struct demangle_component
*
3806 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3808 const char *suffix
= d_str (di
);
3809 const char *pend
= suffix
;
3810 struct demangle_component
*n
;
3812 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3815 while (IS_LOWER (*pend
) || *pend
== '_')
3818 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3821 while (IS_DIGIT (*pend
))
3824 d_advance (di
, pend
- suffix
);
3825 n
= d_make_name (di
, suffix
, pend
- suffix
);
3826 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3829 /* Add a new substitution. */
3832 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3836 if (di
->next_sub
>= di
->num_subs
)
3838 di
->subs
[di
->next_sub
] = dc
;
3843 /* <substitution> ::= S <seq-id> _
3853 If PREFIX is non-zero, then this type is being used as a prefix in
3854 a qualified name. In this case, for the standard substitutions, we
3855 need to check whether we are being used as a prefix for a
3856 constructor or destructor, and return a full template name.
3857 Otherwise we will get something like std::iostream::~iostream()
3858 which does not correspond particularly well to any function which
3859 actually appears in the source.
3862 static const struct d_standard_sub_info standard_subs
[] =
3867 { 'a', NL ("std::allocator"),
3868 NL ("std::allocator"),
3870 { 'b', NL ("std::basic_string"),
3871 NL ("std::basic_string"),
3872 NL ("basic_string") },
3873 { 's', NL ("std::string"),
3874 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3875 NL ("basic_string") },
3876 { 'i', NL ("std::istream"),
3877 NL ("std::basic_istream<char, std::char_traits<char> >"),
3878 NL ("basic_istream") },
3879 { 'o', NL ("std::ostream"),
3880 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3881 NL ("basic_ostream") },
3882 { 'd', NL ("std::iostream"),
3883 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3884 NL ("basic_iostream") }
3887 static struct demangle_component
*
3888 d_substitution (struct d_info
*di
, int prefix
)
3892 if (! d_check_char (di
, 'S'))
3895 c
= d_next_char (di
);
3896 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3905 unsigned int new_id
;
3908 new_id
= id
* 36 + c
- '0';
3909 else if (IS_UPPER (c
))
3910 new_id
= id
* 36 + c
- 'A' + 10;
3916 c
= d_next_char (di
);
3923 if (id
>= (unsigned int) di
->next_sub
)
3926 return di
->subs
[id
];
3931 const struct d_standard_sub_info
*p
;
3932 const struct d_standard_sub_info
*pend
;
3934 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3935 if (! verbose
&& prefix
)
3939 peek
= d_peek_char (di
);
3940 if (peek
== 'C' || peek
== 'D')
3944 pend
= (&standard_subs
[0]
3945 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3946 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3952 struct demangle_component
*dc
;
3954 if (p
->set_last_name
!= NULL
)
3955 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3956 p
->set_last_name_len
);
3959 s
= p
->full_expansion
;
3964 s
= p
->simple_expansion
;
3965 len
= p
->simple_len
;
3967 di
->expansion
+= len
;
3968 dc
= d_make_sub (di
, s
, len
);
3969 if (d_peek_char (di
) == 'B')
3971 /* If there are ABI tags on the abbreviation, it becomes
3972 a substitution candidate. */
3973 dc
= d_abi_tags (di
, dc
);
3974 if (! d_add_substitution (di
, dc
))
3986 d_checkpoint (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3988 checkpoint
->n
= di
->n
;
3989 checkpoint
->next_comp
= di
->next_comp
;
3990 checkpoint
->next_sub
= di
->next_sub
;
3991 checkpoint
->expansion
= di
->expansion
;
3995 d_backtrack (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3997 di
->n
= checkpoint
->n
;
3998 di
->next_comp
= checkpoint
->next_comp
;
3999 di
->next_sub
= checkpoint
->next_sub
;
4000 di
->expansion
= checkpoint
->expansion
;
4003 /* Initialize a growable string. */
4006 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
4011 dgs
->allocation_failure
= 0;
4014 d_growable_string_resize (dgs
, estimate
);
4017 /* Grow a growable string to a given size. */
4020 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
4025 if (dgs
->allocation_failure
)
4028 /* Start allocation at two bytes to avoid any possibility of confusion
4029 with the special value of 1 used as a return in *palc to indicate
4030 allocation failures. */
4031 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
4032 while (newalc
< need
)
4035 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
4042 dgs
->allocation_failure
= 1;
4049 /* Append a buffer to a growable string. */
4052 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
4053 const char *s
, size_t l
)
4057 need
= dgs
->len
+ l
+ 1;
4058 if (need
> dgs
->alc
)
4059 d_growable_string_resize (dgs
, need
);
4061 if (dgs
->allocation_failure
)
4064 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
4065 dgs
->buf
[dgs
->len
+ l
] = '\0';
4069 /* Bridge growable strings to the callback mechanism. */
4072 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
4074 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
4076 d_growable_string_append_buffer (dgs
, s
, l
);
4079 /* Walk the tree, counting the number of templates encountered, and
4080 the number of times a scope might be saved. These counts will be
4081 used to allocate data structures for d_print_comp, so the logic
4082 here must mirror the logic d_print_comp will use. It is not
4083 important that the resulting numbers are exact, so long as they
4084 are larger than the actual numbers encountered. */
4087 d_count_templates_scopes (struct d_print_info
*dpi
,
4088 struct demangle_component
*dc
)
4090 if (dc
== NULL
|| dc
->d_counting
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
4097 case DEMANGLE_COMPONENT_NAME
:
4098 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4099 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4100 case DEMANGLE_COMPONENT_SUB_STD
:
4101 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4102 case DEMANGLE_COMPONENT_OPERATOR
:
4103 case DEMANGLE_COMPONENT_CHARACTER
:
4104 case DEMANGLE_COMPONENT_NUMBER
:
4105 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4108 case DEMANGLE_COMPONENT_TEMPLATE
:
4109 dpi
->num_copy_templates
++;
4110 goto recurse_left_right
;
4112 case DEMANGLE_COMPONENT_REFERENCE
:
4113 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4114 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4115 dpi
->num_saved_scopes
++;
4116 goto recurse_left_right
;
4118 case DEMANGLE_COMPONENT_QUAL_NAME
:
4119 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4120 case DEMANGLE_COMPONENT_TYPED_NAME
:
4121 case DEMANGLE_COMPONENT_VTABLE
:
4122 case DEMANGLE_COMPONENT_VTT
:
4123 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4124 case DEMANGLE_COMPONENT_TYPEINFO
:
4125 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4126 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4127 case DEMANGLE_COMPONENT_THUNK
:
4128 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4129 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4130 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4131 case DEMANGLE_COMPONENT_GUARD
:
4132 case DEMANGLE_COMPONENT_TLS_INIT
:
4133 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4134 case DEMANGLE_COMPONENT_REFTEMP
:
4135 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4136 case DEMANGLE_COMPONENT_RESTRICT
:
4137 case DEMANGLE_COMPONENT_VOLATILE
:
4138 case DEMANGLE_COMPONENT_CONST
:
4139 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4140 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4141 case DEMANGLE_COMPONENT_CONST_THIS
:
4142 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4143 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4144 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
4145 case DEMANGLE_COMPONENT_NOEXCEPT
:
4146 case DEMANGLE_COMPONENT_THROW_SPEC
:
4147 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4148 case DEMANGLE_COMPONENT_POINTER
:
4149 case DEMANGLE_COMPONENT_COMPLEX
:
4150 case DEMANGLE_COMPONENT_IMAGINARY
:
4151 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4152 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4153 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4154 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4155 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4156 case DEMANGLE_COMPONENT_ARGLIST
:
4157 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4158 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4159 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4160 case DEMANGLE_COMPONENT_CAST
:
4161 case DEMANGLE_COMPONENT_CONVERSION
:
4162 case DEMANGLE_COMPONENT_NULLARY
:
4163 case DEMANGLE_COMPONENT_UNARY
:
4164 case DEMANGLE_COMPONENT_BINARY
:
4165 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4166 case DEMANGLE_COMPONENT_TRINARY
:
4167 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4168 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4169 case DEMANGLE_COMPONENT_LITERAL
:
4170 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4171 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4172 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4173 case DEMANGLE_COMPONENT_DECLTYPE
:
4174 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4175 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4176 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4177 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4178 case DEMANGLE_COMPONENT_CLONE
:
4180 /* PR 89394 - Check for too much recursion. */
4181 if (dpi
->recursion
> DEMANGLE_RECURSION_LIMIT
)
4182 /* FIXME: There ought to be a way to report to the
4183 user that the recursion limit has been reached. */
4187 d_count_templates_scopes (dpi
, d_left (dc
));
4188 d_count_templates_scopes (dpi
, d_right (dc
));
4192 case DEMANGLE_COMPONENT_CTOR
:
4193 d_count_templates_scopes (dpi
, dc
->u
.s_ctor
.name
);
4196 case DEMANGLE_COMPONENT_DTOR
:
4197 d_count_templates_scopes (dpi
, dc
->u
.s_dtor
.name
);
4200 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4201 d_count_templates_scopes (dpi
, dc
->u
.s_extended_operator
.name
);
4204 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4205 d_count_templates_scopes (dpi
, dc
->u
.s_fixed
.length
);
4208 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4209 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4210 d_count_templates_scopes (dpi
, d_left (dc
));
4213 case DEMANGLE_COMPONENT_LAMBDA
:
4214 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4215 d_count_templates_scopes (dpi
, dc
->u
.s_unary_num
.sub
);
4220 /* Initialize a print information structure. */
4223 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
4224 void *opaque
, struct demangle_component
*dc
)
4227 dpi
->last_char
= '\0';
4228 dpi
->templates
= NULL
;
4229 dpi
->modifiers
= NULL
;
4230 dpi
->pack_index
= 0;
4231 dpi
->flush_count
= 0;
4233 dpi
->callback
= callback
;
4234 dpi
->opaque
= opaque
;
4236 dpi
->demangle_failure
= 0;
4238 dpi
->is_lambda_arg
= 0;
4240 dpi
->component_stack
= NULL
;
4242 dpi
->saved_scopes
= NULL
;
4243 dpi
->next_saved_scope
= 0;
4244 dpi
->num_saved_scopes
= 0;
4246 dpi
->copy_templates
= NULL
;
4247 dpi
->next_copy_template
= 0;
4248 dpi
->num_copy_templates
= 0;
4250 d_count_templates_scopes (dpi
, dc
);
4251 /* If we did not reach the recursion limit, then reset the
4252 current recursion value back to 0, so that we can print
4254 if (dpi
->recursion
< DEMANGLE_RECURSION_LIMIT
)
4256 dpi
->num_copy_templates
*= dpi
->num_saved_scopes
;
4258 dpi
->current_template
= NULL
;
4261 /* Indicate that an error occurred during printing, and test for error. */
4264 d_print_error (struct d_print_info
*dpi
)
4266 dpi
->demangle_failure
= 1;
4270 d_print_saw_error (struct d_print_info
*dpi
)
4272 return dpi
->demangle_failure
!= 0;
4275 /* Flush buffered characters to the callback. */
4278 d_print_flush (struct d_print_info
*dpi
)
4280 dpi
->buf
[dpi
->len
] = '\0';
4281 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
4286 /* Append characters and buffers for printing. */
4289 d_append_char (struct d_print_info
*dpi
, char c
)
4291 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
4292 d_print_flush (dpi
);
4294 dpi
->buf
[dpi
->len
++] = c
;
4299 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
4303 for (i
= 0; i
< l
; i
++)
4304 d_append_char (dpi
, s
[i
]);
4308 d_append_string (struct d_print_info
*dpi
, const char *s
)
4310 d_append_buffer (dpi
, s
, strlen (s
));
4314 d_append_num (struct d_print_info
*dpi
, int l
)
4317 sprintf (buf
,"%d", l
);
4318 d_append_string (dpi
, buf
);
4322 d_last_char (struct d_print_info
*dpi
)
4324 return dpi
->last_char
;
4327 /* Turn components into a human readable string. OPTIONS is the
4328 options bits passed to the demangler. DC is the tree to print.
4329 CALLBACK is a function to call to flush demangled string segments
4330 as they fill the intermediate buffer, and OPAQUE is a generalized
4331 callback argument. On success, this returns 1. On failure,
4332 it returns 0, indicating a bad parse. It does not use heap
4333 memory to build an output string, so cannot encounter memory
4334 allocation failure. */
4336 CP_STATIC_IF_GLIBCPP_V3
4338 cplus_demangle_print_callback (int options
,
4339 struct demangle_component
*dc
,
4340 demangle_callbackref callback
, void *opaque
)
4342 struct d_print_info dpi
;
4344 d_print_init (&dpi
, callback
, opaque
, dc
);
4347 #ifdef CP_DYNAMIC_ARRAYS
4348 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4349 and flagged as errors by Address Sanitizer. */
4350 __extension__
struct d_saved_scope scopes
[(dpi
.num_saved_scopes
> 0)
4351 ? dpi
.num_saved_scopes
: 1];
4352 __extension__
struct d_print_template temps
[(dpi
.num_copy_templates
> 0)
4353 ? dpi
.num_copy_templates
: 1];
4355 dpi
.saved_scopes
= scopes
;
4356 dpi
.copy_templates
= temps
;
4358 dpi
.saved_scopes
= alloca (dpi
.num_saved_scopes
4359 * sizeof (*dpi
.saved_scopes
));
4360 dpi
.copy_templates
= alloca (dpi
.num_copy_templates
4361 * sizeof (*dpi
.copy_templates
));
4364 d_print_comp (&dpi
, options
, dc
);
4367 d_print_flush (&dpi
);
4369 return ! d_print_saw_error (&dpi
);
4372 /* Turn components into a human readable string. OPTIONS is the
4373 options bits passed to the demangler. DC is the tree to print.
4374 ESTIMATE is a guess at the length of the result. This returns a
4375 string allocated by malloc, or NULL on error. On success, this
4376 sets *PALC to the size of the allocated buffer. On failure, this
4377 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4380 CP_STATIC_IF_GLIBCPP_V3
4382 cplus_demangle_print (int options
, struct demangle_component
*dc
,
4383 int estimate
, size_t *palc
)
4385 struct d_growable_string dgs
;
4387 d_growable_string_init (&dgs
, estimate
);
4389 if (! cplus_demangle_print_callback (options
, dc
,
4390 d_growable_string_callback_adapter
,
4398 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
4402 /* Returns the I'th element of the template arglist ARGS, or NULL on
4403 failure. If I is negative, return the entire arglist. */
4405 static struct demangle_component
*
4406 d_index_template_argument (struct demangle_component
*args
, int i
)
4408 struct demangle_component
*a
;
4411 /* Print the whole argument pack. */
4418 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4424 if (i
!= 0 || a
== NULL
)
4430 /* Returns the template argument from the current context indicated by DC,
4431 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4433 static struct demangle_component
*
4434 d_lookup_template_argument (struct d_print_info
*dpi
,
4435 const struct demangle_component
*dc
)
4437 if (dpi
->templates
== NULL
)
4439 d_print_error (dpi
);
4443 return d_index_template_argument
4444 (d_right (dpi
->templates
->template_decl
),
4445 dc
->u
.s_number
.number
);
4448 /* Returns a template argument pack used in DC (any will do), or NULL. */
4450 static struct demangle_component
*
4451 d_find_pack (struct d_print_info
*dpi
,
4452 const struct demangle_component
*dc
)
4454 struct demangle_component
*a
;
4460 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4461 a
= d_lookup_template_argument (dpi
, dc
);
4462 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4466 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4469 case DEMANGLE_COMPONENT_LAMBDA
:
4470 case DEMANGLE_COMPONENT_NAME
:
4471 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4472 case DEMANGLE_COMPONENT_OPERATOR
:
4473 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4474 case DEMANGLE_COMPONENT_SUB_STD
:
4475 case DEMANGLE_COMPONENT_CHARACTER
:
4476 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4477 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4478 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4479 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4480 case DEMANGLE_COMPONENT_NUMBER
:
4483 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4484 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
4485 case DEMANGLE_COMPONENT_CTOR
:
4486 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
4487 case DEMANGLE_COMPONENT_DTOR
:
4488 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
4491 a
= d_find_pack (dpi
, d_left (dc
));
4494 return d_find_pack (dpi
, d_right (dc
));
4498 /* Returns the length of the template argument pack DC. */
4501 d_pack_length (const struct demangle_component
*dc
)
4504 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4505 && d_left (dc
) != NULL
)
4513 /* Returns the number of template args in DC, expanding any pack expansions
4517 d_args_length (struct d_print_info
*dpi
, const struct demangle_component
*dc
)
4520 for (; dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
;
4523 struct demangle_component
*elt
= d_left (dc
);
4526 if (elt
->type
== DEMANGLE_COMPONENT_PACK_EXPANSION
)
4528 struct demangle_component
*a
= d_find_pack (dpi
, d_left (elt
));
4529 count
+= d_pack_length (a
);
4537 /* DC is a component of a mangled expression. Print it, wrapped in parens
4541 d_print_subexpr (struct d_print_info
*dpi
, int options
,
4542 struct demangle_component
*dc
)
4545 if (dc
->type
== DEMANGLE_COMPONENT_NAME
4546 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
4547 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
4548 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
4551 d_append_char (dpi
, '(');
4552 d_print_comp (dpi
, options
, dc
);
4554 d_append_char (dpi
, ')');
4557 /* Save the current scope. */
4560 d_save_scope (struct d_print_info
*dpi
,
4561 const struct demangle_component
*container
)
4563 struct d_saved_scope
*scope
;
4564 struct d_print_template
*src
, **link
;
4566 if (dpi
->next_saved_scope
>= dpi
->num_saved_scopes
)
4568 d_print_error (dpi
);
4571 scope
= &dpi
->saved_scopes
[dpi
->next_saved_scope
];
4572 dpi
->next_saved_scope
++;
4574 scope
->container
= container
;
4575 link
= &scope
->templates
;
4577 for (src
= dpi
->templates
; src
!= NULL
; src
= src
->next
)
4579 struct d_print_template
*dst
;
4581 if (dpi
->next_copy_template
>= dpi
->num_copy_templates
)
4583 d_print_error (dpi
);
4586 dst
= &dpi
->copy_templates
[dpi
->next_copy_template
];
4587 dpi
->next_copy_template
++;
4589 dst
->template_decl
= src
->template_decl
;
4597 /* Attempt to locate a previously saved scope. Returns NULL if no
4598 corresponding saved scope was found. */
4600 static struct d_saved_scope
*
4601 d_get_saved_scope (struct d_print_info
*dpi
,
4602 const struct demangle_component
*container
)
4606 for (i
= 0; i
< dpi
->next_saved_scope
; i
++)
4607 if (dpi
->saved_scopes
[i
].container
== container
)
4608 return &dpi
->saved_scopes
[i
];
4613 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4617 d_maybe_print_fold_expression (struct d_print_info
*dpi
, int options
,
4618 struct demangle_component
*dc
)
4620 struct demangle_component
*ops
, *operator_
, *op1
, *op2
;
4623 const char *fold_code
= d_left (dc
)->u
.s_operator
.op
->code
;
4624 if (fold_code
[0] != 'f')
4628 operator_
= d_left (ops
);
4629 op1
= d_right (ops
);
4631 if (op1
->type
== DEMANGLE_COMPONENT_TRINARY_ARG2
)
4633 op2
= d_right (op1
);
4637 /* Print the whole pack. */
4638 save_idx
= dpi
->pack_index
;
4639 dpi
->pack_index
= -1;
4641 switch (fold_code
[1])
4643 /* Unary left fold, (... + X). */
4645 d_append_string (dpi
, "(...");
4646 d_print_expr_op (dpi
, options
, operator_
);
4647 d_print_subexpr (dpi
, options
, op1
);
4648 d_append_char (dpi
, ')');
4651 /* Unary right fold, (X + ...). */
4653 d_append_char (dpi
, '(');
4654 d_print_subexpr (dpi
, options
, op1
);
4655 d_print_expr_op (dpi
, options
, operator_
);
4656 d_append_string (dpi
, "...)");
4659 /* Binary left fold, (42 + ... + X). */
4661 /* Binary right fold, (X + ... + 42). */
4663 d_append_char (dpi
, '(');
4664 d_print_subexpr (dpi
, options
, op1
);
4665 d_print_expr_op (dpi
, options
, operator_
);
4666 d_append_string (dpi
, "...");
4667 d_print_expr_op (dpi
, options
, operator_
);
4668 d_print_subexpr (dpi
, options
, op2
);
4669 d_append_char (dpi
, ')');
4673 dpi
->pack_index
= save_idx
;
4677 /* Subroutine to handle components. */
4680 d_print_comp_inner (struct d_print_info
*dpi
, int options
,
4681 struct demangle_component
*dc
)
4683 /* Magic variable to let reference smashing skip over the next modifier
4684 without needing to modify *dc. */
4685 struct demangle_component
*mod_inner
= NULL
;
4687 /* Variable used to store the current templates while a previously
4688 captured scope is used. */
4689 struct d_print_template
*saved_templates
;
4691 /* Nonzero if templates have been stored in the above variable. */
4692 int need_template_restore
= 0;
4696 d_print_error (dpi
);
4699 if (d_print_saw_error (dpi
))
4704 case DEMANGLE_COMPONENT_NAME
:
4705 if ((options
& DMGL_JAVA
) == 0)
4706 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4708 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4711 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4712 d_print_comp (dpi
, options
, d_left (dc
));
4713 d_append_string (dpi
, "[abi:");
4714 d_print_comp (dpi
, options
, d_right (dc
));
4715 d_append_char (dpi
, ']');
4718 case DEMANGLE_COMPONENT_QUAL_NAME
:
4719 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4720 d_print_comp (dpi
, options
, d_left (dc
));
4721 if ((options
& DMGL_JAVA
) == 0)
4722 d_append_string (dpi
, "::");
4724 d_append_char (dpi
, '.');
4726 struct demangle_component
*local_name
= d_right (dc
);
4727 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4729 d_append_string (dpi
, "{default arg#");
4730 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
4731 d_append_string (dpi
, "}::");
4732 local_name
= local_name
->u
.s_unary_num
.sub
;
4734 d_print_comp (dpi
, options
, local_name
);
4738 case DEMANGLE_COMPONENT_TYPED_NAME
:
4740 struct d_print_mod
*hold_modifiers
;
4741 struct demangle_component
*typed_name
;
4742 struct d_print_mod adpm
[4];
4744 struct d_print_template dpt
;
4746 /* Pass the name down to the type so that it can be printed in
4747 the right place for the type. We also have to pass down
4748 any CV-qualifiers, which apply to the this parameter. */
4749 hold_modifiers
= dpi
->modifiers
;
4752 typed_name
= d_left (dc
);
4753 while (typed_name
!= NULL
)
4755 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4757 d_print_error (dpi
);
4761 adpm
[i
].next
= dpi
->modifiers
;
4762 dpi
->modifiers
= &adpm
[i
];
4763 adpm
[i
].mod
= typed_name
;
4764 adpm
[i
].printed
= 0;
4765 adpm
[i
].templates
= dpi
->templates
;
4768 if (!is_fnqual_component_type (typed_name
->type
))
4771 typed_name
= d_left (typed_name
);
4774 if (typed_name
== NULL
)
4776 d_print_error (dpi
);
4780 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4781 there may be CV-qualifiers on its right argument which
4782 really apply here; this happens when parsing a class that
4783 is local to a function. */
4784 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4786 typed_name
= d_right (typed_name
);
4787 if (typed_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4788 typed_name
= typed_name
->u
.s_unary_num
.sub
;
4789 while (typed_name
!= NULL
4790 && is_fnqual_component_type (typed_name
->type
))
4792 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4794 d_print_error (dpi
);
4798 adpm
[i
] = adpm
[i
- 1];
4799 adpm
[i
].next
= &adpm
[i
- 1];
4800 dpi
->modifiers
= &adpm
[i
];
4802 adpm
[i
- 1].mod
= typed_name
;
4803 adpm
[i
- 1].printed
= 0;
4804 adpm
[i
- 1].templates
= dpi
->templates
;
4807 typed_name
= d_left (typed_name
);
4809 if (typed_name
== NULL
)
4811 d_print_error (dpi
);
4816 /* If typed_name is a template, then it applies to the
4817 function type as well. */
4818 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4820 dpt
.next
= dpi
->templates
;
4821 dpi
->templates
= &dpt
;
4822 dpt
.template_decl
= typed_name
;
4825 d_print_comp (dpi
, options
, d_right (dc
));
4827 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4828 dpi
->templates
= dpt
.next
;
4830 /* If the modifiers didn't get printed by the type, print them
4835 if (! adpm
[i
].printed
)
4837 d_append_char (dpi
, ' ');
4838 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4842 dpi
->modifiers
= hold_modifiers
;
4847 case DEMANGLE_COMPONENT_TEMPLATE
:
4849 struct d_print_mod
*hold_dpm
;
4850 struct demangle_component
*dcl
;
4851 const struct demangle_component
*hold_current
;
4853 /* This template may need to be referenced by a cast operator
4854 contained in its subtree. */
4855 hold_current
= dpi
->current_template
;
4856 dpi
->current_template
= dc
;
4858 /* Don't push modifiers into a template definition. Doing so
4859 could give the wrong definition for a template argument.
4860 Instead, treat the template essentially as a name. */
4862 hold_dpm
= dpi
->modifiers
;
4863 dpi
->modifiers
= NULL
;
4867 if ((options
& DMGL_JAVA
) != 0
4868 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4869 && dcl
->u
.s_name
.len
== 6
4870 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4872 /* Special-case Java arrays, so that JArray<TYPE> appears
4873 instead as TYPE[]. */
4875 d_print_comp (dpi
, options
, d_right (dc
));
4876 d_append_string (dpi
, "[]");
4880 d_print_comp (dpi
, options
, dcl
);
4881 if (d_last_char (dpi
) == '<')
4882 d_append_char (dpi
, ' ');
4883 d_append_char (dpi
, '<');
4884 d_print_comp (dpi
, options
, d_right (dc
));
4885 /* Avoid generating two consecutive '>' characters, to avoid
4886 the C++ syntactic ambiguity. */
4887 if (d_last_char (dpi
) == '>')
4888 d_append_char (dpi
, ' ');
4889 d_append_char (dpi
, '>');
4892 dpi
->modifiers
= hold_dpm
;
4893 dpi
->current_template
= hold_current
;
4898 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4899 if (dpi
->is_lambda_arg
)
4901 /* Show the template parm index, as that's how g++ displays
4902 these, and future proofs us against potential
4903 '[]<typename T> (T *a, T *b) {...}'. */
4904 d_append_buffer (dpi
, "auto:", 5);
4905 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4909 struct d_print_template
*hold_dpt
;
4910 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
4912 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4913 a
= d_index_template_argument (a
, dpi
->pack_index
);
4917 d_print_error (dpi
);
4921 /* While processing this parameter, we need to pop the list
4922 of templates. This is because the template parameter may
4923 itself be a reference to a parameter of an outer
4926 hold_dpt
= dpi
->templates
;
4927 dpi
->templates
= hold_dpt
->next
;
4929 d_print_comp (dpi
, options
, a
);
4931 dpi
->templates
= hold_dpt
;
4935 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4936 d_append_string (dpi
, "template parameter object for ");
4937 d_print_comp (dpi
, options
, d_left (dc
));
4940 case DEMANGLE_COMPONENT_CTOR
:
4941 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
4944 case DEMANGLE_COMPONENT_DTOR
:
4945 d_append_char (dpi
, '~');
4946 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
4949 case DEMANGLE_COMPONENT_VTABLE
:
4950 d_append_string (dpi
, "vtable for ");
4951 d_print_comp (dpi
, options
, d_left (dc
));
4954 case DEMANGLE_COMPONENT_VTT
:
4955 d_append_string (dpi
, "VTT for ");
4956 d_print_comp (dpi
, options
, d_left (dc
));
4959 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4960 d_append_string (dpi
, "construction vtable for ");
4961 d_print_comp (dpi
, options
, d_left (dc
));
4962 d_append_string (dpi
, "-in-");
4963 d_print_comp (dpi
, options
, d_right (dc
));
4966 case DEMANGLE_COMPONENT_TYPEINFO
:
4967 d_append_string (dpi
, "typeinfo for ");
4968 d_print_comp (dpi
, options
, d_left (dc
));
4971 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4972 d_append_string (dpi
, "typeinfo name for ");
4973 d_print_comp (dpi
, options
, d_left (dc
));
4976 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4977 d_append_string (dpi
, "typeinfo fn for ");
4978 d_print_comp (dpi
, options
, d_left (dc
));
4981 case DEMANGLE_COMPONENT_THUNK
:
4982 d_append_string (dpi
, "non-virtual thunk to ");
4983 d_print_comp (dpi
, options
, d_left (dc
));
4986 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4987 d_append_string (dpi
, "virtual thunk to ");
4988 d_print_comp (dpi
, options
, d_left (dc
));
4991 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4992 d_append_string (dpi
, "covariant return thunk to ");
4993 d_print_comp (dpi
, options
, d_left (dc
));
4996 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4997 d_append_string (dpi
, "java Class for ");
4998 d_print_comp (dpi
, options
, d_left (dc
));
5001 case DEMANGLE_COMPONENT_GUARD
:
5002 d_append_string (dpi
, "guard variable for ");
5003 d_print_comp (dpi
, options
, d_left (dc
));
5006 case DEMANGLE_COMPONENT_TLS_INIT
:
5007 d_append_string (dpi
, "TLS init function for ");
5008 d_print_comp (dpi
, options
, d_left (dc
));
5011 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
5012 d_append_string (dpi
, "TLS wrapper function for ");
5013 d_print_comp (dpi
, options
, d_left (dc
));
5016 case DEMANGLE_COMPONENT_REFTEMP
:
5017 d_append_string (dpi
, "reference temporary #");
5018 d_print_comp (dpi
, options
, d_right (dc
));
5019 d_append_string (dpi
, " for ");
5020 d_print_comp (dpi
, options
, d_left (dc
));
5023 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
5024 d_append_string (dpi
, "hidden alias for ");
5025 d_print_comp (dpi
, options
, d_left (dc
));
5028 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
5029 d_append_string (dpi
, "transaction clone for ");
5030 d_print_comp (dpi
, options
, d_left (dc
));
5033 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
5034 d_append_string (dpi
, "non-transaction clone for ");
5035 d_print_comp (dpi
, options
, d_left (dc
));
5038 case DEMANGLE_COMPONENT_SUB_STD
:
5039 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
5042 case DEMANGLE_COMPONENT_RESTRICT
:
5043 case DEMANGLE_COMPONENT_VOLATILE
:
5044 case DEMANGLE_COMPONENT_CONST
:
5046 struct d_print_mod
*pdpm
;
5048 /* When printing arrays, it's possible to have cases where the
5049 same CV-qualifier gets pushed on the stack multiple times.
5050 We only need to print it once. */
5052 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
5054 if (! pdpm
->printed
)
5056 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
5057 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
5058 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
5060 if (pdpm
->mod
->type
== dc
->type
)
5062 d_print_comp (dpi
, options
, d_left (dc
));
5070 case DEMANGLE_COMPONENT_REFERENCE
:
5071 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5073 /* Handle reference smashing: & + && = &. */
5074 struct demangle_component
*sub
= d_left (dc
);
5075 if (!dpi
->is_lambda_arg
5076 && sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
5078 struct d_saved_scope
*scope
= d_get_saved_scope (dpi
, sub
);
5079 struct demangle_component
*a
;
5083 /* This is the first time SUB has been traversed.
5084 We need to capture the current templates so
5085 they can be restored if SUB is reentered as a
5087 d_save_scope (dpi
, sub
);
5088 if (d_print_saw_error (dpi
))
5093 const struct d_component_stack
*dcse
;
5094 int found_self_or_parent
= 0;
5096 /* This traversal is reentering SUB as a substition.
5097 If we are not beneath SUB or DC in the tree then we
5098 need to restore SUB's template stack temporarily. */
5099 for (dcse
= dpi
->component_stack
; dcse
!= NULL
;
5100 dcse
= dcse
->parent
)
5104 && dcse
!= dpi
->component_stack
))
5106 found_self_or_parent
= 1;
5111 if (!found_self_or_parent
)
5113 saved_templates
= dpi
->templates
;
5114 dpi
->templates
= scope
->templates
;
5115 need_template_restore
= 1;
5119 a
= d_lookup_template_argument (dpi
, sub
);
5120 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
5121 a
= d_index_template_argument (a
, dpi
->pack_index
);
5125 if (need_template_restore
)
5126 dpi
->templates
= saved_templates
;
5128 d_print_error (dpi
);
5135 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
5136 || sub
->type
== dc
->type
)
5138 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
5139 mod_inner
= d_left (sub
);
5143 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5144 case DEMANGLE_COMPONENT_POINTER
:
5145 case DEMANGLE_COMPONENT_COMPLEX
:
5146 case DEMANGLE_COMPONENT_IMAGINARY
:
5147 FNQUAL_COMPONENT_CASE
:
5150 /* We keep a list of modifiers on the stack. */
5151 struct d_print_mod dpm
;
5153 dpm
.next
= dpi
->modifiers
;
5154 dpi
->modifiers
= &dpm
;
5157 dpm
.templates
= dpi
->templates
;
5160 mod_inner
= d_left (dc
);
5162 d_print_comp (dpi
, options
, mod_inner
);
5164 /* If the modifier didn't get printed by the type, print it
5167 d_print_mod (dpi
, options
, dc
);
5169 dpi
->modifiers
= dpm
.next
;
5171 if (need_template_restore
)
5172 dpi
->templates
= saved_templates
;
5177 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5178 if ((options
& DMGL_JAVA
) == 0)
5179 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
5180 dc
->u
.s_builtin
.type
->len
);
5182 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
5183 dc
->u
.s_builtin
.type
->java_len
);
5186 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5187 d_print_comp (dpi
, options
, d_left (dc
));
5190 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5192 if ((options
& DMGL_RET_POSTFIX
) != 0)
5193 d_print_function_type (dpi
,
5194 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5195 dc
, dpi
->modifiers
);
5197 /* Print return type if present */
5198 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
5199 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5201 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
5203 struct d_print_mod dpm
;
5205 /* We must pass this type down as a modifier in order to
5206 print it in the right location. */
5207 dpm
.next
= dpi
->modifiers
;
5208 dpi
->modifiers
= &dpm
;
5211 dpm
.templates
= dpi
->templates
;
5213 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5216 dpi
->modifiers
= dpm
.next
;
5221 /* In standard prefix notation, there is a space between the
5222 return type and the function signature. */
5223 if ((options
& DMGL_RET_POSTFIX
) == 0)
5224 d_append_char (dpi
, ' ');
5227 if ((options
& DMGL_RET_POSTFIX
) == 0)
5228 d_print_function_type (dpi
,
5229 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5230 dc
, dpi
->modifiers
);
5235 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5237 struct d_print_mod
*hold_modifiers
;
5238 struct d_print_mod adpm
[4];
5240 struct d_print_mod
*pdpm
;
5242 /* We must pass this type down as a modifier in order to print
5243 multi-dimensional arrays correctly. If the array itself is
5244 CV-qualified, we act as though the element type were
5245 CV-qualified. We do this by copying the modifiers down
5246 rather than fiddling pointers, so that we don't wind up
5247 with a d_print_mod higher on the stack pointing into our
5248 stack frame after we return. */
5250 hold_modifiers
= dpi
->modifiers
;
5252 adpm
[0].next
= hold_modifiers
;
5253 dpi
->modifiers
= &adpm
[0];
5255 adpm
[0].printed
= 0;
5256 adpm
[0].templates
= dpi
->templates
;
5259 pdpm
= hold_modifiers
;
5261 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
5262 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
5263 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
5265 if (! pdpm
->printed
)
5267 if (i
>= sizeof adpm
/ sizeof adpm
[0])
5269 d_print_error (dpi
);
5274 adpm
[i
].next
= dpi
->modifiers
;
5275 dpi
->modifiers
= &adpm
[i
];
5283 d_print_comp (dpi
, options
, d_right (dc
));
5285 dpi
->modifiers
= hold_modifiers
;
5287 if (adpm
[0].printed
)
5293 d_print_mod (dpi
, options
, adpm
[i
].mod
);
5296 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
5301 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5302 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5304 struct d_print_mod dpm
;
5306 dpm
.next
= dpi
->modifiers
;
5307 dpi
->modifiers
= &dpm
;
5310 dpm
.templates
= dpi
->templates
;
5312 d_print_comp (dpi
, options
, d_right (dc
));
5314 /* If the modifier didn't get printed by the type, print it
5317 d_print_mod (dpi
, options
, dc
);
5319 dpi
->modifiers
= dpm
.next
;
5324 case DEMANGLE_COMPONENT_FIXED_TYPE
:
5325 if (dc
->u
.s_fixed
.sat
)
5326 d_append_string (dpi
, "_Sat ");
5327 /* Don't print "int _Accum". */
5328 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
5329 != &cplus_demangle_builtin_types
['i'-'a'])
5331 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
5332 d_append_char (dpi
, ' ');
5334 if (dc
->u
.s_fixed
.accum
)
5335 d_append_string (dpi
, "_Accum");
5337 d_append_string (dpi
, "_Fract");
5340 case DEMANGLE_COMPONENT_ARGLIST
:
5341 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
5342 if (d_left (dc
) != NULL
)
5343 d_print_comp (dpi
, options
, d_left (dc
));
5344 if (d_right (dc
) != NULL
)
5347 unsigned long int flush_count
;
5348 /* Make sure ", " isn't flushed by d_append_string, otherwise
5349 dpi->len -= 2 wouldn't work. */
5350 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
5351 d_print_flush (dpi
);
5352 d_append_string (dpi
, ", ");
5354 flush_count
= dpi
->flush_count
;
5355 d_print_comp (dpi
, options
, d_right (dc
));
5356 /* If that didn't print anything (which can happen with empty
5357 template argument packs), remove the comma and space. */
5358 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
5363 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
5365 struct demangle_component
*type
= d_left (dc
);
5366 struct demangle_component
*list
= d_right (dc
);
5369 d_print_comp (dpi
, options
, type
);
5370 d_append_char (dpi
, '{');
5371 d_print_comp (dpi
, options
, list
);
5372 d_append_char (dpi
, '}');
5376 case DEMANGLE_COMPONENT_OPERATOR
:
5378 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
5381 d_append_string (dpi
, "operator");
5382 /* Add a space before new/delete. */
5383 if (IS_LOWER (op
->name
[0]))
5384 d_append_char (dpi
, ' ');
5385 /* Omit a trailing space. */
5386 if (op
->name
[len
-1] == ' ')
5388 d_append_buffer (dpi
, op
->name
, len
);
5392 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
5393 d_append_string (dpi
, "operator ");
5394 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5397 case DEMANGLE_COMPONENT_CONVERSION
:
5398 d_append_string (dpi
, "operator ");
5399 d_print_conversion (dpi
, options
, dc
);
5402 case DEMANGLE_COMPONENT_NULLARY
:
5403 d_print_expr_op (dpi
, options
, d_left (dc
));
5406 case DEMANGLE_COMPONENT_UNARY
:
5408 struct demangle_component
*op
= d_left (dc
);
5409 struct demangle_component
*operand
= d_right (dc
);
5410 const char *code
= NULL
;
5412 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5414 code
= op
->u
.s_operator
.op
->code
;
5415 if (!strcmp (code
, "ad"))
5417 /* Don't print the argument list for the address of a
5419 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
5420 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
5421 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5422 operand
= d_left (operand
);
5424 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
5426 /* This indicates a suffix operator. */
5427 operand
= d_left (operand
);
5428 d_print_subexpr (dpi
, options
, operand
);
5429 d_print_expr_op (dpi
, options
, op
);
5434 /* For sizeof..., just print the pack length. */
5435 if (code
&& !strcmp (code
, "sZ"))
5437 struct demangle_component
*a
= d_find_pack (dpi
, operand
);
5438 int len
= d_pack_length (a
);
5439 d_append_num (dpi
, len
);
5442 else if (code
&& !strcmp (code
, "sP"))
5444 int len
= d_args_length (dpi
, operand
);
5445 d_append_num (dpi
, len
);
5449 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
5450 d_print_expr_op (dpi
, options
, op
);
5453 d_append_char (dpi
, '(');
5454 d_print_cast (dpi
, options
, op
);
5455 d_append_char (dpi
, ')');
5457 if (code
&& !strcmp (code
, "gs"))
5458 /* Avoid parens after '::'. */
5459 d_print_comp (dpi
, options
, operand
);
5460 else if (code
&& !strcmp (code
, "st"))
5461 /* Always print parens for sizeof (type). */
5463 d_append_char (dpi
, '(');
5464 d_print_comp (dpi
, options
, operand
);
5465 d_append_char (dpi
, ')');
5468 d_print_subexpr (dpi
, options
, operand
);
5472 case DEMANGLE_COMPONENT_BINARY
:
5473 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
5475 d_print_error (dpi
);
5479 if (op_is_new_cast (d_left (dc
)))
5481 d_print_expr_op (dpi
, options
, d_left (dc
));
5482 d_append_char (dpi
, '<');
5483 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
5484 d_append_string (dpi
, ">(");
5485 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5486 d_append_char (dpi
, ')');
5490 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5493 /* We wrap an expression which uses the greater-than operator in
5494 an extra layer of parens so that it does not get confused
5495 with the '>' which ends the template parameters. */
5496 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5497 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5498 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5499 d_append_char (dpi
, '(');
5501 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
5502 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
5504 /* Function call used in an expression should not have printed types
5505 of the function arguments. Values of the function arguments still
5506 get printed below. */
5508 const struct demangle_component
*func
= d_left (d_right (dc
));
5510 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5511 d_print_error (dpi
);
5512 d_print_subexpr (dpi
, options
, d_left (func
));
5515 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
5516 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
5518 d_append_char (dpi
, '[');
5519 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5520 d_append_char (dpi
, ']');
5524 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
5525 d_print_expr_op (dpi
, options
, d_left (dc
));
5526 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
5529 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5530 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5531 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5532 d_append_char (dpi
, ')');
5536 case DEMANGLE_COMPONENT_BINARY_ARGS
:
5537 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5538 d_print_error (dpi
);
5541 case DEMANGLE_COMPONENT_TRINARY
:
5542 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
5543 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
5545 d_print_error (dpi
);
5548 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5551 struct demangle_component
*op
= d_left (dc
);
5552 struct demangle_component
*first
= d_left (d_right (dc
));
5553 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
5554 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
5556 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
5558 d_print_subexpr (dpi
, options
, first
);
5559 d_print_expr_op (dpi
, options
, op
);
5560 d_print_subexpr (dpi
, options
, second
);
5561 d_append_string (dpi
, " : ");
5562 d_print_subexpr (dpi
, options
, third
);
5566 d_append_string (dpi
, "new ");
5567 if (d_left (first
) != NULL
)
5569 d_print_subexpr (dpi
, options
, first
);
5570 d_append_char (dpi
, ' ');
5572 d_print_comp (dpi
, options
, second
);
5574 d_print_subexpr (dpi
, options
, third
);
5579 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
5580 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
5581 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5582 d_print_error (dpi
);
5585 case DEMANGLE_COMPONENT_LITERAL
:
5586 case DEMANGLE_COMPONENT_LITERAL_NEG
:
5588 enum d_builtin_type_print tp
;
5590 /* For some builtin types, produce simpler output. */
5591 tp
= D_PRINT_DEFAULT
;
5592 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
5594 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
5598 case D_PRINT_UNSIGNED
:
5600 case D_PRINT_UNSIGNED_LONG
:
5601 case D_PRINT_LONG_LONG
:
5602 case D_PRINT_UNSIGNED_LONG_LONG
:
5603 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
5605 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5606 d_append_char (dpi
, '-');
5607 d_print_comp (dpi
, options
, d_right (dc
));
5612 case D_PRINT_UNSIGNED
:
5613 d_append_char (dpi
, 'u');
5616 d_append_char (dpi
, 'l');
5618 case D_PRINT_UNSIGNED_LONG
:
5619 d_append_string (dpi
, "ul");
5621 case D_PRINT_LONG_LONG
:
5622 d_append_string (dpi
, "ll");
5624 case D_PRINT_UNSIGNED_LONG_LONG
:
5625 d_append_string (dpi
, "ull");
5633 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
5634 && d_right (dc
)->u
.s_name
.len
== 1
5635 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
5637 switch (d_right (dc
)->u
.s_name
.s
[0])
5640 d_append_string (dpi
, "false");
5643 d_append_string (dpi
, "true");
5656 d_append_char (dpi
, '(');
5657 d_print_comp (dpi
, options
, d_left (dc
));
5658 d_append_char (dpi
, ')');
5659 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5660 d_append_char (dpi
, '-');
5661 if (tp
== D_PRINT_FLOAT
)
5662 d_append_char (dpi
, '[');
5663 d_print_comp (dpi
, options
, d_right (dc
));
5664 if (tp
== D_PRINT_FLOAT
)
5665 d_append_char (dpi
, ']');
5669 case DEMANGLE_COMPONENT_NUMBER
:
5670 d_append_num (dpi
, dc
->u
.s_number
.number
);
5673 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
5674 d_append_string (dpi
, "java resource ");
5675 d_print_comp (dpi
, options
, d_left (dc
));
5678 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
5679 d_print_comp (dpi
, options
, d_left (dc
));
5680 d_print_comp (dpi
, options
, d_right (dc
));
5683 case DEMANGLE_COMPONENT_CHARACTER
:
5684 d_append_char (dpi
, dc
->u
.s_character
.character
);
5687 case DEMANGLE_COMPONENT_DECLTYPE
:
5688 d_append_string (dpi
, "decltype (");
5689 d_print_comp (dpi
, options
, d_left (dc
));
5690 d_append_char (dpi
, ')');
5693 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
5697 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
5700 /* d_find_pack won't find anything if the only packs involved
5701 in this expansion are function parameter packs; in that
5702 case, just print the pattern and "...". */
5703 d_print_subexpr (dpi
, options
, d_left (dc
));
5704 d_append_string (dpi
, "...");
5708 len
= d_pack_length (a
);
5710 for (i
= 0; i
< len
; ++i
)
5712 dpi
->pack_index
= i
;
5713 d_print_comp (dpi
, options
, dc
);
5715 d_append_string (dpi
, ", ");
5720 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
5722 long num
= dc
->u
.s_number
.number
;
5724 d_append_string (dpi
, "this");
5727 d_append_string (dpi
, "{parm#");
5728 d_append_num (dpi
, num
);
5729 d_append_char (dpi
, '}');
5734 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
5735 d_append_string (dpi
, "global constructors keyed to ");
5736 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5739 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
5740 d_append_string (dpi
, "global destructors keyed to ");
5741 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5744 case DEMANGLE_COMPONENT_LAMBDA
:
5745 d_append_string (dpi
, "{lambda(");
5746 /* Generic lambda auto parms are mangled as the template type
5748 dpi
->is_lambda_arg
++;
5749 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
5750 dpi
->is_lambda_arg
--;
5751 d_append_string (dpi
, ")#");
5752 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5753 d_append_char (dpi
, '}');
5756 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
5757 d_append_string (dpi
, "{unnamed type#");
5758 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5759 d_append_char (dpi
, '}');
5762 case DEMANGLE_COMPONENT_CLONE
:
5763 d_print_comp (dpi
, options
, d_left (dc
));
5764 d_append_string (dpi
, " [clone ");
5765 d_print_comp (dpi
, options
, d_right (dc
));
5766 d_append_char (dpi
, ']');
5770 d_print_error (dpi
);
5776 d_print_comp (struct d_print_info
*dpi
, int options
,
5777 struct demangle_component
*dc
)
5779 struct d_component_stack self
;
5780 if (dc
== NULL
|| dc
->d_printing
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
5782 d_print_error (dpi
);
5790 self
.parent
= dpi
->component_stack
;
5791 dpi
->component_stack
= &self
;
5793 d_print_comp_inner (dpi
, options
, dc
);
5795 dpi
->component_stack
= self
.parent
;
5800 /* Print a Java dentifier. For Java we try to handle encoded extended
5801 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5802 so we don't it for C++. Characters are encoded as
5806 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
5812 for (p
= name
; p
< end
; ++p
)
5823 for (q
= p
+ 3; q
< end
; ++q
)
5829 else if (*q
>= 'A' && *q
<= 'F')
5830 dig
= *q
- 'A' + 10;
5831 else if (*q
>= 'a' && *q
<= 'f')
5832 dig
= *q
- 'a' + 10;
5838 /* If the Unicode character is larger than 256, we don't try
5839 to deal with it here. FIXME. */
5840 if (q
< end
&& *q
== '_' && c
< 256)
5842 d_append_char (dpi
, c
);
5848 d_append_char (dpi
, *p
);
5852 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5853 qualifiers on this after printing a function. */
5856 d_print_mod_list (struct d_print_info
*dpi
, int options
,
5857 struct d_print_mod
*mods
, int suffix
)
5859 struct d_print_template
*hold_dpt
;
5861 if (mods
== NULL
|| d_print_saw_error (dpi
))
5866 && (is_fnqual_component_type (mods
->mod
->type
))))
5868 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5874 hold_dpt
= dpi
->templates
;
5875 dpi
->templates
= mods
->templates
;
5877 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5879 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
5880 dpi
->templates
= hold_dpt
;
5883 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5885 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
5886 dpi
->templates
= hold_dpt
;
5889 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
5891 struct d_print_mod
*hold_modifiers
;
5892 struct demangle_component
*dc
;
5894 /* When this is on the modifier stack, we have pulled any
5895 qualifiers off the right argument already. Otherwise, we
5896 print it as usual, but don't let the left argument see any
5899 hold_modifiers
= dpi
->modifiers
;
5900 dpi
->modifiers
= NULL
;
5901 d_print_comp (dpi
, options
, d_left (mods
->mod
));
5902 dpi
->modifiers
= hold_modifiers
;
5904 if ((options
& DMGL_JAVA
) == 0)
5905 d_append_string (dpi
, "::");
5907 d_append_char (dpi
, '.');
5909 dc
= d_right (mods
->mod
);
5911 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
5913 d_append_string (dpi
, "{default arg#");
5914 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5915 d_append_string (dpi
, "}::");
5916 dc
= dc
->u
.s_unary_num
.sub
;
5919 while (is_fnqual_component_type (dc
->type
))
5922 d_print_comp (dpi
, options
, dc
);
5924 dpi
->templates
= hold_dpt
;
5928 d_print_mod (dpi
, options
, mods
->mod
);
5930 dpi
->templates
= hold_dpt
;
5932 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5935 /* Print a modifier. */
5938 d_print_mod (struct d_print_info
*dpi
, int options
,
5939 struct demangle_component
*mod
)
5943 case DEMANGLE_COMPONENT_RESTRICT
:
5944 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5945 d_append_string (dpi
, " restrict");
5947 case DEMANGLE_COMPONENT_VOLATILE
:
5948 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5949 d_append_string (dpi
, " volatile");
5951 case DEMANGLE_COMPONENT_CONST
:
5952 case DEMANGLE_COMPONENT_CONST_THIS
:
5953 d_append_string (dpi
, " const");
5955 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
5956 d_append_string (dpi
, " transaction_safe");
5958 case DEMANGLE_COMPONENT_NOEXCEPT
:
5959 d_append_string (dpi
, " noexcept");
5962 d_append_char (dpi
, '(');
5963 d_print_comp (dpi
, options
, d_right (mod
));
5964 d_append_char (dpi
, ')');
5967 case DEMANGLE_COMPONENT_THROW_SPEC
:
5968 d_append_string (dpi
, " throw");
5971 d_append_char (dpi
, '(');
5972 d_print_comp (dpi
, options
, d_right (mod
));
5973 d_append_char (dpi
, ')');
5976 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5977 d_append_char (dpi
, ' ');
5978 d_print_comp (dpi
, options
, d_right (mod
));
5980 case DEMANGLE_COMPONENT_POINTER
:
5981 /* There is no pointer symbol in Java. */
5982 if ((options
& DMGL_JAVA
) == 0)
5983 d_append_char (dpi
, '*');
5985 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5986 /* For the ref-qualifier, put a space before the &. */
5987 d_append_char (dpi
, ' ');
5989 case DEMANGLE_COMPONENT_REFERENCE
:
5990 d_append_char (dpi
, '&');
5992 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5993 d_append_char (dpi
, ' ');
5995 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5996 d_append_string (dpi
, "&&");
5998 case DEMANGLE_COMPONENT_COMPLEX
:
5999 d_append_string (dpi
, " _Complex");
6001 case DEMANGLE_COMPONENT_IMAGINARY
:
6002 d_append_string (dpi
, " _Imaginary");
6004 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6005 if (d_last_char (dpi
) != '(')
6006 d_append_char (dpi
, ' ');
6007 d_print_comp (dpi
, options
, d_left (mod
));
6008 d_append_string (dpi
, "::*");
6010 case DEMANGLE_COMPONENT_TYPED_NAME
:
6011 d_print_comp (dpi
, options
, d_left (mod
));
6013 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
6014 d_append_string (dpi
, " __vector(");
6015 d_print_comp (dpi
, options
, d_left (mod
));
6016 d_append_char (dpi
, ')');
6020 /* Otherwise, we have something that won't go back on the
6021 modifier stack, so we can just print it. */
6022 d_print_comp (dpi
, options
, mod
);
6027 /* Print a function type, except for the return type. */
6030 d_print_function_type (struct d_print_info
*dpi
, int options
,
6031 struct demangle_component
*dc
,
6032 struct d_print_mod
*mods
)
6036 struct d_print_mod
*p
;
6037 struct d_print_mod
*hold_modifiers
;
6041 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6046 switch (p
->mod
->type
)
6048 case DEMANGLE_COMPONENT_POINTER
:
6049 case DEMANGLE_COMPONENT_REFERENCE
:
6050 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
6053 case DEMANGLE_COMPONENT_RESTRICT
:
6054 case DEMANGLE_COMPONENT_VOLATILE
:
6055 case DEMANGLE_COMPONENT_CONST
:
6056 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
6057 case DEMANGLE_COMPONENT_COMPLEX
:
6058 case DEMANGLE_COMPONENT_IMAGINARY
:
6059 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6063 FNQUAL_COMPONENT_CASE
:
6076 if (d_last_char (dpi
) != '('
6077 && d_last_char (dpi
) != '*')
6080 if (need_space
&& d_last_char (dpi
) != ' ')
6081 d_append_char (dpi
, ' ');
6082 d_append_char (dpi
, '(');
6085 hold_modifiers
= dpi
->modifiers
;
6086 dpi
->modifiers
= NULL
;
6088 d_print_mod_list (dpi
, options
, mods
, 0);
6091 d_append_char (dpi
, ')');
6093 d_append_char (dpi
, '(');
6095 if (d_right (dc
) != NULL
)
6096 d_print_comp (dpi
, options
, d_right (dc
));
6098 d_append_char (dpi
, ')');
6100 d_print_mod_list (dpi
, options
, mods
, 1);
6102 dpi
->modifiers
= hold_modifiers
;
6105 /* Print an array type, except for the element type. */
6108 d_print_array_type (struct d_print_info
*dpi
, int options
,
6109 struct demangle_component
*dc
,
6110 struct d_print_mod
*mods
)
6118 struct d_print_mod
*p
;
6121 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6125 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
6140 d_append_string (dpi
, " (");
6142 d_print_mod_list (dpi
, options
, mods
, 0);
6145 d_append_char (dpi
, ')');
6149 d_append_char (dpi
, ' ');
6151 d_append_char (dpi
, '[');
6153 if (d_left (dc
) != NULL
)
6154 d_print_comp (dpi
, options
, d_left (dc
));
6156 d_append_char (dpi
, ']');
6159 /* Print an operator in an expression. */
6162 d_print_expr_op (struct d_print_info
*dpi
, int options
,
6163 struct demangle_component
*dc
)
6165 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
6166 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
6167 dc
->u
.s_operator
.op
->len
);
6169 d_print_comp (dpi
, options
, dc
);
6175 d_print_cast (struct d_print_info
*dpi
, int options
,
6176 struct demangle_component
*dc
)
6178 d_print_comp (dpi
, options
, d_left (dc
));
6181 /* Print a conversion operator. */
6184 d_print_conversion (struct d_print_info
*dpi
, int options
,
6185 struct demangle_component
*dc
)
6187 struct d_print_template dpt
;
6189 /* For a conversion operator, we need the template parameters from
6190 the enclosing template in scope for processing the type. */
6191 if (dpi
->current_template
!= NULL
)
6193 dpt
.next
= dpi
->templates
;
6194 dpi
->templates
= &dpt
;
6195 dpt
.template_decl
= dpi
->current_template
;
6198 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
6200 d_print_comp (dpi
, options
, d_left (dc
));
6201 if (dpi
->current_template
!= NULL
)
6202 dpi
->templates
= dpt
.next
;
6206 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
6208 /* For a templated cast operator, we need to remove the template
6209 parameters from scope after printing the operator name,
6210 so we need to handle the template printing here. */
6211 if (dpi
->current_template
!= NULL
)
6212 dpi
->templates
= dpt
.next
;
6214 if (d_last_char (dpi
) == '<')
6215 d_append_char (dpi
, ' ');
6216 d_append_char (dpi
, '<');
6217 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
6218 /* Avoid generating two consecutive '>' characters, to avoid
6219 the C++ syntactic ambiguity. */
6220 if (d_last_char (dpi
) == '>')
6221 d_append_char (dpi
, ' ');
6222 d_append_char (dpi
, '>');
6226 /* Initialize the information structure we use to pass around
6229 CP_STATIC_IF_GLIBCPP_V3
6231 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
6235 di
->send
= mangled
+ len
;
6236 di
->options
= options
;
6240 /* We cannot need more components than twice the number of chars in
6241 the mangled string. Most components correspond directly to
6242 chars, but the ARGLIST types are exceptions. */
6243 di
->num_comps
= 2 * len
;
6246 /* Similarly, we cannot need more substitutions than there are
6247 chars in the mangled string. */
6251 di
->last_name
= NULL
;
6254 di
->is_expression
= 0;
6255 di
->is_conversion
= 0;
6256 di
->recursion_level
= 0;
6259 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6260 mangled name, return strings in repeated callback giving the demangled
6261 name. OPTIONS is the usual libiberty demangler options. On success,
6262 this returns 1. On failure, returns 0. */
6265 d_demangle_callback (const char *mangled
, int options
,
6266 demangle_callbackref callback
, void *opaque
)
6277 struct demangle_component
*dc
;
6280 if (mangled
[0] == '_' && mangled
[1] == 'Z')
6282 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
6283 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
6284 && (mangled
[9] == 'D' || mangled
[9] == 'I')
6285 && mangled
[10] == '_')
6286 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
6289 if ((options
& DMGL_TYPES
) == 0)
6294 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
6296 /* PR 87675 - Check for a mangled string that is so long
6297 that we do not have enough stack space to demangle it. */
6298 if (((options
& DMGL_NO_RECURSE_LIMIT
) == 0)
6299 /* This check is a bit arbitrary, since what we really want to do is to
6300 compare the sizes of the di.comps and di.subs arrays against the
6301 amount of stack space remaining. But there is no portable way to do
6302 this, so instead we use the recursion limit as a guide to the maximum
6303 size of the arrays. */
6304 && (unsigned long) di
.num_comps
> DEMANGLE_RECURSION_LIMIT
)
6306 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6311 #ifdef CP_DYNAMIC_ARRAYS
6312 __extension__
struct demangle_component comps
[di
.num_comps
];
6313 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6318 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6319 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6325 dc
= cplus_demangle_type (&di
);
6328 dc
= cplus_demangle_mangled_name (&di
, 1);
6330 case DCT_GLOBAL_CTORS
:
6331 case DCT_GLOBAL_DTORS
:
6332 d_advance (&di
, 11);
6333 dc
= d_make_comp (&di
,
6334 (type
== DCT_GLOBAL_CTORS
6335 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6336 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
6337 d_make_demangle_mangled_name (&di
, d_str (&di
)),
6339 d_advance (&di
, strlen (d_str (&di
)));
6342 abort (); /* We have listed all the cases. */
6345 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6346 mangled string, then we didn't successfully demangle it. If
6347 DMGL_PARAMS is not set, we didn't look at the trailing
6349 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
6352 #ifdef CP_DEMANGLE_DEBUG
6356 status
= (dc
!= NULL
)
6357 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
6364 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6365 name, return a buffer allocated with malloc holding the demangled
6366 name. OPTIONS is the usual libiberty demangler options. On
6367 success, this sets *PALC to the allocated size of the returned
6368 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6369 a memory allocation failure, and returns NULL. */
6372 d_demangle (const char *mangled
, int options
, size_t *palc
)
6374 struct d_growable_string dgs
;
6377 d_growable_string_init (&dgs
, 0);
6379 status
= d_demangle_callback (mangled
, options
,
6380 d_growable_string_callback_adapter
, &dgs
);
6388 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
6392 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6394 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6396 /* ia64 ABI-mandated entry point in the C++ runtime library for
6397 performing demangling. MANGLED_NAME is a NUL-terminated character
6398 string containing the name to be demangled.
6400 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6401 *LENGTH bytes, into which the demangled name is stored. If
6402 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6403 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6404 is placed in a region of memory allocated with malloc.
6406 If LENGTH is non-NULL, the length of the buffer containing the
6407 demangled name, is placed in *LENGTH.
6409 The return value is a pointer to the start of the NUL-terminated
6410 demangled name, or NULL if the demangling fails. The caller is
6411 responsible for deallocating this memory using free.
6413 *STATUS is set to one of the following values:
6414 0: The demangling operation succeeded.
6415 -1: A memory allocation failure occurred.
6416 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6417 -3: One of the arguments is invalid.
6419 The demangling is performed using the C++ ABI mangling rules, with
6423 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
6424 size_t *length
, int *status
)
6429 if (mangled_name
== NULL
)
6436 if (output_buffer
!= NULL
&& length
== NULL
)
6443 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
6445 if (demangled
== NULL
)
6457 if (output_buffer
== NULL
)
6464 if (strlen (demangled
) < *length
)
6466 strcpy (output_buffer
, demangled
);
6468 demangled
= output_buffer
;
6472 free (output_buffer
);
6483 extern int __gcclibcxx_demangle_callback (const char *,
6485 (const char *, size_t, void *),
6488 /* Alternative, allocationless entry point in the C++ runtime library
6489 for performing demangling. MANGLED_NAME is a NUL-terminated character
6490 string containing the name to be demangled.
6492 CALLBACK is a callback function, called with demangled string
6493 segments as demangling progresses; it is called at least once,
6494 but may be called more than once. OPAQUE is a generalized pointer
6495 used as a callback argument.
6497 The return code is one of the following values, equivalent to
6498 the STATUS values of __cxa_demangle() (excluding -1, since this
6499 function performs no memory allocations):
6500 0: The demangling operation succeeded.
6501 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6502 -3: One of the arguments is invalid.
6504 The demangling is performed using the C++ ABI mangling rules, with
6508 __gcclibcxx_demangle_callback (const char *mangled_name
,
6509 void (*callback
) (const char *, size_t, void *),
6514 if (mangled_name
== NULL
|| callback
== NULL
)
6517 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
6525 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6527 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6528 mangled name, return a buffer allocated with malloc holding the
6529 demangled name. Otherwise, return NULL. */
6532 cplus_demangle_v3 (const char *mangled
, int options
)
6536 return d_demangle (mangled
, options
, &alc
);
6540 cplus_demangle_v3_callback (const char *mangled
, int options
,
6541 demangle_callbackref callback
, void *opaque
)
6543 return d_demangle_callback (mangled
, options
, callback
, opaque
);
6546 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6547 conventions, but the output formatting is a little different.
6548 This instructs the C++ demangler not to emit pointer characters ("*"), to
6549 use Java's namespace separator symbol ("." instead of "::"), and to output
6550 JArray<TYPE> as TYPE[]. */
6553 java_demangle_v3 (const char *mangled
)
6557 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
6561 java_demangle_v3_callback (const char *mangled
,
6562 demangle_callbackref callback
, void *opaque
)
6564 return d_demangle_callback (mangled
,
6565 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
6569 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6571 #ifndef IN_GLIBCPP_V3
6573 /* Demangle a string in order to find out whether it is a constructor
6574 or destructor. Return non-zero on success. Set *CTOR_KIND and
6575 *DTOR_KIND appropriately. */
6578 is_ctor_or_dtor (const char *mangled
,
6579 enum gnu_v3_ctor_kinds
*ctor_kind
,
6580 enum gnu_v3_dtor_kinds
*dtor_kind
)
6583 struct demangle_component
*dc
;
6586 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
6587 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
6589 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
6592 #ifdef CP_DYNAMIC_ARRAYS
6593 __extension__
struct demangle_component comps
[di
.num_comps
];
6594 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6599 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6600 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6603 dc
= cplus_demangle_mangled_name (&di
, 1);
6605 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6606 to demangle the entire string. */
6613 /* These cannot appear on a constructor or destructor. */
6614 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6615 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6616 case DEMANGLE_COMPONENT_CONST_THIS
:
6617 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6618 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6622 case DEMANGLE_COMPONENT_TYPED_NAME
:
6623 case DEMANGLE_COMPONENT_TEMPLATE
:
6626 case DEMANGLE_COMPONENT_QUAL_NAME
:
6627 case DEMANGLE_COMPONENT_LOCAL_NAME
:
6630 case DEMANGLE_COMPONENT_CTOR
:
6631 *ctor_kind
= dc
->u
.s_ctor
.kind
;
6635 case DEMANGLE_COMPONENT_DTOR
:
6636 *dtor_kind
= dc
->u
.s_dtor
.kind
;
6647 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6648 name. A non-zero return indicates the type of constructor. */
6650 enum gnu_v3_ctor_kinds
6651 is_gnu_v3_mangled_ctor (const char *name
)
6653 enum gnu_v3_ctor_kinds ctor_kind
;
6654 enum gnu_v3_dtor_kinds dtor_kind
;
6656 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6657 return (enum gnu_v3_ctor_kinds
) 0;
6662 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6663 name. A non-zero return indicates the type of destructor. */
6665 enum gnu_v3_dtor_kinds
6666 is_gnu_v3_mangled_dtor (const char *name
)
6668 enum gnu_v3_ctor_kinds ctor_kind
;
6669 enum gnu_v3_dtor_kinds dtor_kind
;
6671 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6672 return (enum gnu_v3_dtor_kinds
) 0;
6676 #endif /* IN_GLIBCPP_V3 */
6678 #ifdef STANDALONE_DEMANGLER
6681 #include "dyn-string.h"
6683 static void print_usage (FILE* fp
, int exit_value
);
6685 #define IS_ALPHA(CHAR) \
6686 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6687 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6689 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6690 #define is_mangled_char(CHAR) \
6691 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6692 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6694 /* The name of this program, as invoked. */
6695 const char* program_name
;
6697 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6700 print_usage (FILE* fp
, int exit_value
)
6702 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
6703 fprintf (fp
, "Options:\n");
6704 fprintf (fp
, " -h,--help Display this message.\n");
6705 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
6706 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
6707 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6712 /* Option specification for getopt_long. */
6713 static const struct option long_options
[] =
6715 { "help", no_argument
, NULL
, 'h' },
6716 { "no-params", no_argument
, NULL
, 'p' },
6717 { "verbose", no_argument
, NULL
, 'v' },
6718 { NULL
, no_argument
, NULL
, 0 },
6721 /* Main entry for a demangling filter executable. It will demangle
6722 its command line arguments, if any. If none are provided, it will
6723 filter stdin to stdout, replacing any recognized mangled C++ names
6724 with their demangled equivalents. */
6727 main (int argc
, char *argv
[])
6731 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
6733 /* Use the program name of this program, as invoked. */
6734 program_name
= argv
[0];
6736 /* Parse options. */
6739 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
6742 case '?': /* Unrecognized option. */
6743 print_usage (stderr
, 1);
6747 print_usage (stdout
, 0);
6751 options
&= ~ DMGL_PARAMS
;
6755 options
|= DMGL_VERBOSE
;
6759 while (opt_char
!= -1);
6762 /* No command line arguments were provided. Filter stdin. */
6764 dyn_string_t mangled
= dyn_string_new (3);
6767 /* Read all of input. */
6768 while (!feof (stdin
))
6772 /* Pile characters into mangled until we hit one that can't
6773 occur in a mangled name. */
6775 while (!feof (stdin
) && is_mangled_char (c
))
6777 dyn_string_append_char (mangled
, c
);
6783 if (dyn_string_length (mangled
) > 0)
6785 #ifdef IN_GLIBCPP_V3
6786 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
6788 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
6798 /* It might not have been a mangled name. Print the
6800 fputs (dyn_string_buf (mangled
), stdout
);
6803 dyn_string_clear (mangled
);
6806 /* If we haven't hit EOF yet, we've read one character that
6807 can't occur in a mangled name, so print it out. */
6812 dyn_string_delete (mangled
);
6815 /* Demangle command line arguments. */
6817 /* Loop over command line arguments. */
6818 for (i
= optind
; i
< argc
; ++i
)
6821 #ifdef IN_GLIBCPP_V3
6825 /* Attempt to demangle. */
6826 #ifdef IN_GLIBCPP_V3
6827 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
6829 s
= cplus_demangle_v3 (argv
[i
], options
);
6832 /* If it worked, print the demangled name. */
6840 #ifdef IN_GLIBCPP_V3
6841 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
6843 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
6852 #endif /* STANDALONE_DEMANGLER */