1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003-2019 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
7 This file is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
31 /* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
33 https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
35 This code was written while looking at the demangler written by
36 Alex Samuel <samuel@codesourcery.com>.
38 This code first pulls the mangled name apart into a list of
39 components, and then walks the list generating the demangled
42 This file will normally define the following functions, q.v.:
43 char *cplus_demangle_v3(const char *mangled, int options)
44 char *java_demangle_v3(const char *mangled)
45 int cplus_demangle_v3_callback(const char *mangled, int options,
46 demangle_callbackref callback)
47 int java_demangle_v3_callback(const char *mangled,
48 demangle_callbackref callback)
49 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
50 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
52 Also, the interface to the component list is public, and defined in
53 demangle.h. The interface consists of these types, which are
54 defined in demangle.h:
55 enum demangle_component_type
56 struct demangle_component
58 and these functions defined in this file:
59 cplus_demangle_fill_name
60 cplus_demangle_fill_extended_operator
61 cplus_demangle_fill_ctor
62 cplus_demangle_fill_dtor
64 cplus_demangle_print_callback
65 and other functions defined in the file cp-demint.c.
67 This file also defines some other functions and variables which are
68 only to be used by the file cp-demint.c.
70 Preprocessor macros you can define while compiling this file:
73 If defined, this file defines the following functions, q.v.:
74 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
76 int __gcclibcxx_demangle_callback (const char *,
78 (const char *, size_t, void *),
80 instead of cplus_demangle_v3[_callback]() and
81 java_demangle_v3[_callback]().
84 If defined, this file defines only __cxa_demangle() and
85 __gcclibcxx_demangle_callback(), and no other publically visible
86 functions or variables.
89 If defined, this file defines a main() function which demangles
90 any arguments, or, if none, demangles stdin.
93 If defined, turns on debugging mode, which prints information on
94 stdout about the mangled string. This is not generally useful.
97 If defined, additional sanity checks will be performed. It will
98 cause some slowdown, but will allow to catch out-of-bound access
99 errors earlier. This macro is intended for testing and debugging. */
101 #if defined (_AIX) && !defined (__GNUC__)
123 # define alloca __builtin_alloca
125 extern char *alloca ();
126 # endif /* __GNUC__ */
128 #endif /* HAVE_ALLOCA_H */
134 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
137 #include "ansidecl.h"
138 #include "libiberty.h"
139 #include "demangle.h"
140 #include "cp-demangle.h"
142 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
143 also rename them via #define to avoid compiler errors when the
144 static definition conflicts with the extern declaration in a header
148 #define CP_STATIC_IF_GLIBCPP_V3 static
150 #define cplus_demangle_fill_name d_fill_name
151 static int d_fill_name (struct demangle_component
*, const char *, int);
153 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
155 d_fill_extended_operator (struct demangle_component
*, int,
156 struct demangle_component
*);
158 #define cplus_demangle_fill_ctor d_fill_ctor
160 d_fill_ctor (struct demangle_component
*, enum gnu_v3_ctor_kinds
,
161 struct demangle_component
*);
163 #define cplus_demangle_fill_dtor d_fill_dtor
165 d_fill_dtor (struct demangle_component
*, enum gnu_v3_dtor_kinds
,
166 struct demangle_component
*);
168 #define cplus_demangle_mangled_name d_mangled_name
169 static struct demangle_component
*d_mangled_name (struct d_info
*, int);
171 #define cplus_demangle_type d_type
172 static struct demangle_component
*d_type (struct d_info
*);
174 #define cplus_demangle_print d_print
175 static char *d_print (int, struct demangle_component
*, int, size_t *);
177 #define cplus_demangle_print_callback d_print_callback
178 static int d_print_callback (int, struct demangle_component
*,
179 demangle_callbackref
, void *);
181 #define cplus_demangle_init_info d_init_info
182 static void d_init_info (const char *, int, size_t, struct d_info
*);
184 #else /* ! defined(IN_GLIBCPP_V3) */
185 #define CP_STATIC_IF_GLIBCPP_V3
186 #endif /* ! defined(IN_GLIBCPP_V3) */
188 /* See if the compiler supports dynamic arrays. */
191 #define CP_DYNAMIC_ARRAYS
194 #ifdef __STDC_VERSION__
195 #if __STDC_VERSION__ >= 199901L
196 #define CP_DYNAMIC_ARRAYS
197 #endif /* __STDC__VERSION >= 199901L */
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 const 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)
867 p
->type
= DEMANGLE_COMPONENT_NAME
;
869 p
->u
.s_name
.len
= len
;
873 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
875 CP_STATIC_IF_GLIBCPP_V3
877 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
878 struct demangle_component
*name
)
880 if (p
== NULL
|| args
< 0 || name
== NULL
)
883 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
884 p
->u
.s_extended_operator
.args
= args
;
885 p
->u
.s_extended_operator
.name
= name
;
889 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
891 CP_STATIC_IF_GLIBCPP_V3
893 cplus_demangle_fill_ctor (struct demangle_component
*p
,
894 enum gnu_v3_ctor_kinds kind
,
895 struct demangle_component
*name
)
899 || (int) kind
< gnu_v3_complete_object_ctor
900 || (int) kind
> gnu_v3_object_ctor_group
)
903 p
->type
= DEMANGLE_COMPONENT_CTOR
;
904 p
->u
.s_ctor
.kind
= kind
;
905 p
->u
.s_ctor
.name
= name
;
909 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
911 CP_STATIC_IF_GLIBCPP_V3
913 cplus_demangle_fill_dtor (struct demangle_component
*p
,
914 enum gnu_v3_dtor_kinds kind
,
915 struct demangle_component
*name
)
919 || (int) kind
< gnu_v3_deleting_dtor
920 || (int) kind
> gnu_v3_object_dtor_group
)
923 p
->type
= DEMANGLE_COMPONENT_DTOR
;
924 p
->u
.s_dtor
.kind
= kind
;
925 p
->u
.s_dtor
.name
= name
;
929 /* Add a new component. */
931 static struct demangle_component
*
932 d_make_empty (struct d_info
*di
)
934 struct demangle_component
*p
;
936 if (di
->next_comp
>= di
->num_comps
)
938 p
= &di
->comps
[di
->next_comp
];
944 /* Add a new generic component. */
946 static struct demangle_component
*
947 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
948 struct demangle_component
*left
,
949 struct demangle_component
*right
)
951 struct demangle_component
*p
;
953 /* We check for errors here. A typical error would be a NULL return
954 from a subroutine. We catch those here, and return NULL
958 /* These types require two parameters. */
959 case DEMANGLE_COMPONENT_QUAL_NAME
:
960 case DEMANGLE_COMPONENT_LOCAL_NAME
:
961 case DEMANGLE_COMPONENT_TYPED_NAME
:
962 case DEMANGLE_COMPONENT_TAGGED_NAME
:
963 case DEMANGLE_COMPONENT_TEMPLATE
:
964 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
965 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
966 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
967 case DEMANGLE_COMPONENT_UNARY
:
968 case DEMANGLE_COMPONENT_BINARY
:
969 case DEMANGLE_COMPONENT_BINARY_ARGS
:
970 case DEMANGLE_COMPONENT_TRINARY
:
971 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
972 case DEMANGLE_COMPONENT_LITERAL
:
973 case DEMANGLE_COMPONENT_LITERAL_NEG
:
974 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
975 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
976 case DEMANGLE_COMPONENT_CLONE
:
977 if (left
== NULL
|| right
== NULL
)
981 /* These types only require one parameter. */
982 case DEMANGLE_COMPONENT_VTABLE
:
983 case DEMANGLE_COMPONENT_VTT
:
984 case DEMANGLE_COMPONENT_TYPEINFO
:
985 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
986 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
987 case DEMANGLE_COMPONENT_THUNK
:
988 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
989 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
990 case DEMANGLE_COMPONENT_JAVA_CLASS
:
991 case DEMANGLE_COMPONENT_GUARD
:
992 case DEMANGLE_COMPONENT_TLS_INIT
:
993 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
994 case DEMANGLE_COMPONENT_REFTEMP
:
995 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
996 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
997 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
998 case DEMANGLE_COMPONENT_POINTER
:
999 case DEMANGLE_COMPONENT_REFERENCE
:
1000 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
1001 case DEMANGLE_COMPONENT_COMPLEX
:
1002 case DEMANGLE_COMPONENT_IMAGINARY
:
1003 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
1004 case DEMANGLE_COMPONENT_CAST
:
1005 case DEMANGLE_COMPONENT_CONVERSION
:
1006 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
1007 case DEMANGLE_COMPONENT_DECLTYPE
:
1008 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
1009 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
1010 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
1011 case DEMANGLE_COMPONENT_NULLARY
:
1012 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
1013 case DEMANGLE_COMPONENT_TPARM_OBJ
:
1018 /* This needs a right parameter, but the left parameter can be
1020 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
1021 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
1026 /* These are allowed to have no parameters--in some cases they
1027 will be filled in later. */
1028 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
1029 case DEMANGLE_COMPONENT_RESTRICT
:
1030 case DEMANGLE_COMPONENT_VOLATILE
:
1031 case DEMANGLE_COMPONENT_CONST
:
1032 case DEMANGLE_COMPONENT_ARGLIST
:
1033 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
1034 FNQUAL_COMPONENT_CASE
:
1037 /* Other types should not be seen here. */
1042 p
= d_make_empty (di
);
1046 p
->u
.s_binary
.left
= left
;
1047 p
->u
.s_binary
.right
= right
;
1052 /* Add a new demangle mangled name component. */
1054 static struct demangle_component
*
1055 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
1057 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
1058 return d_make_name (di
, s
, strlen (s
));
1060 return d_encoding (di
, 0);
1063 /* Add a new name component. */
1065 static struct demangle_component
*
1066 d_make_name (struct d_info
*di
, const char *s
, int len
)
1068 struct demangle_component
*p
;
1070 p
= d_make_empty (di
);
1071 if (! cplus_demangle_fill_name (p
, s
, len
))
1076 /* Add a new builtin type component. */
1078 static struct demangle_component
*
1079 d_make_builtin_type (struct d_info
*di
,
1080 const struct demangle_builtin_type_info
*type
)
1082 struct demangle_component
*p
;
1086 p
= d_make_empty (di
);
1089 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
1090 p
->u
.s_builtin
.type
= type
;
1095 /* Add a new operator component. */
1097 static struct demangle_component
*
1098 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
1100 struct demangle_component
*p
;
1102 p
= d_make_empty (di
);
1105 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
1106 p
->u
.s_operator
.op
= op
;
1111 /* Add a new extended operator component. */
1113 static struct demangle_component
*
1114 d_make_extended_operator (struct d_info
*di
, int args
,
1115 struct demangle_component
*name
)
1117 struct demangle_component
*p
;
1119 p
= d_make_empty (di
);
1120 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
1125 static struct demangle_component
*
1126 d_make_default_arg (struct d_info
*di
, int num
,
1127 struct demangle_component
*sub
)
1129 struct demangle_component
*p
= d_make_empty (di
);
1132 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
1133 p
->u
.s_unary_num
.num
= num
;
1134 p
->u
.s_unary_num
.sub
= sub
;
1139 /* Add a new constructor component. */
1141 static struct demangle_component
*
1142 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
1143 struct demangle_component
*name
)
1145 struct demangle_component
*p
;
1147 p
= d_make_empty (di
);
1148 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
1153 /* Add a new destructor component. */
1155 static struct demangle_component
*
1156 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
1157 struct demangle_component
*name
)
1159 struct demangle_component
*p
;
1161 p
= d_make_empty (di
);
1162 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
1167 /* Add a new template parameter. */
1169 static struct demangle_component
*
1170 d_make_template_param (struct d_info
*di
, int i
)
1172 struct demangle_component
*p
;
1174 p
= d_make_empty (di
);
1177 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
1178 p
->u
.s_number
.number
= i
;
1183 /* Add a new function parameter. */
1185 static struct demangle_component
*
1186 d_make_function_param (struct d_info
*di
, int i
)
1188 struct demangle_component
*p
;
1190 p
= d_make_empty (di
);
1193 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1194 p
->u
.s_number
.number
= i
;
1199 /* Add a new standard substitution component. */
1201 static struct demangle_component
*
1202 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1204 struct demangle_component
*p
;
1206 p
= d_make_empty (di
);
1209 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1210 p
->u
.s_string
.string
= name
;
1211 p
->u
.s_string
.len
= len
;
1216 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1218 TOP_LEVEL is non-zero when called at the top level. */
1220 CP_STATIC_IF_GLIBCPP_V3
1221 struct demangle_component
*
1222 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1224 struct demangle_component
*p
;
1226 if (! d_check_char (di
, '_')
1227 /* Allow missing _ if not at toplevel to work around a
1228 bug in G++ abi-version=2 mangling; see the comment in
1229 write_template_arg. */
1232 if (! d_check_char (di
, 'Z'))
1234 p
= d_encoding (di
, top_level
);
1236 /* If at top level and parsing parameters, check for a clone
1238 if (top_level
&& (di
->options
& DMGL_PARAMS
) != 0)
1239 while (d_peek_char (di
) == '.'
1240 && (IS_LOWER (d_peek_next_char (di
))
1241 || d_peek_next_char (di
) == '_'
1242 || IS_DIGIT (d_peek_next_char (di
))))
1243 p
= d_clone_suffix (di
, p
);
1248 /* Return whether a function should have a return type. The argument
1249 is the function name, which may be qualified in various ways. The
1250 rules are that template functions have return types with some
1251 exceptions, function types which are not part of a function name
1252 mangling have return types with some exceptions, and non-template
1253 function names do not have return types. The exceptions are that
1254 constructors, destructors, and conversion operators do not have
1258 has_return_type (struct demangle_component
*dc
)
1266 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1267 return has_return_type (d_right (dc
));
1268 case DEMANGLE_COMPONENT_TEMPLATE
:
1269 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1270 FNQUAL_COMPONENT_CASE
:
1271 return has_return_type (d_left (dc
));
1275 /* Return whether a name is a constructor, a destructor, or a
1276 conversion operator. */
1279 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1287 case DEMANGLE_COMPONENT_QUAL_NAME
:
1288 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1289 return is_ctor_dtor_or_conversion (d_right (dc
));
1290 case DEMANGLE_COMPONENT_CTOR
:
1291 case DEMANGLE_COMPONENT_DTOR
:
1292 case DEMANGLE_COMPONENT_CONVERSION
:
1297 /* <encoding> ::= <(function) name> <bare-function-type>
1301 TOP_LEVEL is non-zero when called at the top level, in which case
1302 if DMGL_PARAMS is not set we do not demangle the function
1303 parameters. We only set this at the top level, because otherwise
1304 we would not correctly demangle names in local scopes. */
1306 static struct demangle_component
*
1307 d_encoding (struct d_info
*di
, int top_level
)
1309 char peek
= d_peek_char (di
);
1310 struct demangle_component
*dc
;
1312 if (peek
== 'G' || peek
== 'T')
1313 dc
= d_special_name (di
);
1319 /* Failed already. */;
1320 else if (top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1322 /* Strip off any initial CV-qualifiers, as they really apply
1323 to the `this' parameter, and they were not output by the
1324 v2 demangler without DMGL_PARAMS. */
1325 while (is_fnqual_component_type (dc
->type
))
1328 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1329 there may be function-qualifiers on its right argument which
1330 really apply here; this happens when parsing a class
1331 which is local to a function. */
1332 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1333 while (is_fnqual_component_type (d_right (dc
)->type
))
1334 d_right (dc
) = d_left (d_right (dc
));
1338 peek
= d_peek_char (di
);
1339 if (peek
!= '\0' && peek
!= 'E')
1341 struct demangle_component
*ftype
;
1343 ftype
= d_bare_function_type (di
, has_return_type (dc
));
1346 /* If this is a non-top-level local-name, clear the
1347 return type, so it doesn't confuse the user by
1348 being confused with the return type of whaever
1349 this is nested within. */
1350 if (!top_level
&& dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
1351 && ftype
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
1352 d_left (ftype
) = NULL
;
1354 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
,
1366 /* <tagged-name> ::= <name> B <source-name> */
1368 static struct demangle_component
*
1369 d_abi_tags (struct d_info
*di
, struct demangle_component
*dc
)
1371 struct demangle_component
*hold_last_name
;
1374 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1375 hold_last_name
= di
->last_name
;
1377 while (peek
= d_peek_char (di
),
1380 struct demangle_component
*tag
;
1382 tag
= d_source_name (di
);
1383 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TAGGED_NAME
, dc
, tag
);
1386 di
->last_name
= hold_last_name
;
1391 /* <name> ::= <nested-name>
1393 ::= <unscoped-template-name> <template-args>
1396 <unscoped-name> ::= <unqualified-name>
1397 ::= St <unqualified-name>
1399 <unscoped-template-name> ::= <unscoped-name>
1403 static struct demangle_component
*
1404 d_name (struct d_info
*di
)
1406 char peek
= d_peek_char (di
);
1407 struct demangle_component
*dc
;
1412 return d_nested_name (di
);
1415 return d_local_name (di
);
1418 return d_unqualified_name (di
);
1424 if (d_peek_next_char (di
) != 't')
1426 dc
= d_substitution (di
, 0);
1432 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1433 d_make_name (di
, "std", 3),
1434 d_unqualified_name (di
));
1439 if (d_peek_char (di
) != 'I')
1441 /* The grammar does not permit this case to occur if we
1442 called d_substitution() above (i.e., subst == 1). We
1443 don't bother to check. */
1447 /* This is <template-args>, which means that we just saw
1448 <unscoped-template-name>, which is a substitution
1449 candidate if we didn't just get it from a
1453 if (! d_add_substitution (di
, dc
))
1456 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1457 d_template_args (di
));
1465 dc
= d_unqualified_name (di
);
1466 if (d_peek_char (di
) == 'I')
1468 /* This is <template-args>, which means that we just saw
1469 <unscoped-template-name>, which is a substitution
1471 if (! d_add_substitution (di
, dc
))
1473 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1474 d_template_args (di
));
1480 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1481 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1484 static struct demangle_component
*
1485 d_nested_name (struct d_info
*di
)
1487 struct demangle_component
*ret
;
1488 struct demangle_component
**pret
;
1489 struct demangle_component
*rqual
;
1491 if (! d_check_char (di
, 'N'))
1494 pret
= d_cv_qualifiers (di
, &ret
, 1);
1498 /* Parse the ref-qualifier now and then attach it
1499 once we have something to attach it to. */
1500 rqual
= d_ref_qualifier (di
, NULL
);
1502 *pret
= d_prefix (di
);
1508 d_left (rqual
) = ret
;
1512 if (! d_check_char (di
, 'E'))
1518 /* <prefix> ::= <prefix> <unqualified-name>
1519 ::= <template-prefix> <template-args>
1520 ::= <template-param>
1525 <template-prefix> ::= <prefix> <(template) unqualified-name>
1526 ::= <template-param>
1530 static struct demangle_component
*
1531 d_prefix (struct d_info
*di
)
1533 struct demangle_component
*ret
= NULL
;
1538 enum demangle_component_type comb_type
;
1539 struct demangle_component
*dc
;
1541 peek
= d_peek_char (di
);
1545 /* The older code accepts a <local-name> here, but I don't see
1546 that in the grammar. The older code does not accept a
1547 <template-param> here. */
1549 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1552 char peek2
= d_peek_next_char (di
);
1553 if (peek2
== 'T' || peek2
== 't')
1555 dc
= cplus_demangle_type (di
);
1557 /* Destructor name. */
1558 dc
= d_unqualified_name (di
);
1560 else if (IS_DIGIT (peek
)
1565 dc
= d_unqualified_name (di
);
1566 else if (peek
== 'S')
1567 dc
= d_substitution (di
, 1);
1568 else if (peek
== 'I')
1572 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1573 dc
= d_template_args (di
);
1575 else if (peek
== 'T')
1576 dc
= d_template_param (di
);
1577 else if (peek
== 'E')
1579 else if (peek
== 'M')
1581 /* Initializer scope for a lambda. We don't need to represent
1582 this; the normal code will just treat the variable as a type
1583 scope, which gives appropriate output. */
1595 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1597 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1599 if (! d_add_substitution (di
, ret
))
1605 /* <unqualified-name> ::= <operator-name>
1606 ::= <ctor-dtor-name>
1608 ::= <local-source-name>
1610 <local-source-name> ::= L <source-name> <discriminator>
1613 static struct demangle_component
*
1614 d_unqualified_name (struct d_info
*di
)
1616 struct demangle_component
*ret
;
1619 peek
= d_peek_char (di
);
1620 if (IS_DIGIT (peek
))
1621 ret
= d_source_name (di
);
1622 else if (IS_LOWER (peek
))
1624 if (peek
== 'o' && d_peek_next_char (di
) == 'n')
1626 ret
= d_operator_name (di
);
1627 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1629 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1630 if (!strcmp (ret
->u
.s_operator
.op
->code
, "li"))
1631 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, ret
,
1632 d_source_name (di
));
1635 else if (peek
== 'C' || peek
== 'D')
1636 ret
= d_ctor_dtor_name (di
);
1637 else if (peek
== 'L')
1641 ret
= d_source_name (di
);
1644 if (! d_discriminator (di
))
1647 else if (peek
== 'U')
1649 switch (d_peek_next_char (di
))
1652 ret
= d_lambda (di
);
1655 ret
= d_unnamed_type (di
);
1664 if (d_peek_char (di
) == 'B')
1665 ret
= d_abi_tags (di
, ret
);
1669 /* <source-name> ::= <(positive length) number> <identifier> */
1671 static struct demangle_component
*
1672 d_source_name (struct d_info
*di
)
1675 struct demangle_component
*ret
;
1677 len
= d_number (di
);
1680 ret
= d_identifier (di
, len
);
1681 di
->last_name
= ret
;
1685 /* number ::= [n] <(non-negative decimal integer)> */
1688 d_number (struct d_info
*di
)
1695 peek
= d_peek_char (di
);
1700 peek
= d_peek_char (di
);
1706 if (! IS_DIGIT (peek
))
1712 if (ret
> ((INT_MAX
- (peek
- '0')) / 10))
1714 ret
= ret
* 10 + peek
- '0';
1716 peek
= d_peek_char (di
);
1720 /* Like d_number, but returns a demangle_component. */
1722 static struct demangle_component
*
1723 d_number_component (struct d_info
*di
)
1725 struct demangle_component
*ret
= d_make_empty (di
);
1728 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1729 ret
->u
.s_number
.number
= d_number (di
);
1734 /* identifier ::= <(unqualified source code identifier)> */
1736 static struct demangle_component
*
1737 d_identifier (struct d_info
*di
, int len
)
1743 if (di
->send
- name
< len
)
1746 d_advance (di
, len
);
1748 /* A Java mangled name may have a trailing '$' if it is a C++
1749 keyword. This '$' is not included in the length count. We just
1751 if ((di
->options
& DMGL_JAVA
) != 0
1752 && d_peek_char (di
) == '$')
1755 /* Look for something which looks like a gcc encoding of an
1756 anonymous namespace, and replace it with a more user friendly
1758 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1759 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1760 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1764 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1765 if ((*s
== '.' || *s
== '_' || *s
== '$')
1768 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1769 return d_make_name (di
, "(anonymous namespace)",
1770 sizeof "(anonymous namespace)" - 1);
1774 return d_make_name (di
, name
, len
);
1777 /* operator_name ::= many different two character encodings.
1779 ::= v <digit> <source-name>
1781 This list is sorted for binary search. */
1783 #define NL(s) s, (sizeof s) - 1
1785 CP_STATIC_IF_GLIBCPP_V3
1786 const struct demangle_operator_info cplus_demangle_operators
[] =
1788 { "aN", NL ("&="), 2 },
1789 { "aS", NL ("="), 2 },
1790 { "aa", NL ("&&"), 2 },
1791 { "ad", NL ("&"), 1 },
1792 { "an", NL ("&"), 2 },
1793 { "at", NL ("alignof "), 1 },
1794 { "az", NL ("alignof "), 1 },
1795 { "cc", NL ("const_cast"), 2 },
1796 { "cl", NL ("()"), 2 },
1797 { "cm", NL (","), 2 },
1798 { "co", NL ("~"), 1 },
1799 { "dV", NL ("/="), 2 },
1800 { "da", NL ("delete[] "), 1 },
1801 { "dc", NL ("dynamic_cast"), 2 },
1802 { "de", NL ("*"), 1 },
1803 { "dl", NL ("delete "), 1 },
1804 { "ds", NL (".*"), 2 },
1805 { "dt", NL ("."), 2 },
1806 { "dv", NL ("/"), 2 },
1807 { "eO", NL ("^="), 2 },
1808 { "eo", NL ("^"), 2 },
1809 { "eq", NL ("=="), 2 },
1810 { "fL", NL ("..."), 3 },
1811 { "fR", NL ("..."), 3 },
1812 { "fl", NL ("..."), 2 },
1813 { "fr", NL ("..."), 2 },
1814 { "ge", NL (">="), 2 },
1815 { "gs", NL ("::"), 1 },
1816 { "gt", NL (">"), 2 },
1817 { "ix", NL ("[]"), 2 },
1818 { "lS", NL ("<<="), 2 },
1819 { "le", NL ("<="), 2 },
1820 { "li", NL ("operator\"\" "), 1 },
1821 { "ls", NL ("<<"), 2 },
1822 { "lt", NL ("<"), 2 },
1823 { "mI", NL ("-="), 2 },
1824 { "mL", NL ("*="), 2 },
1825 { "mi", NL ("-"), 2 },
1826 { "ml", NL ("*"), 2 },
1827 { "mm", NL ("--"), 1 },
1828 { "na", NL ("new[]"), 3 },
1829 { "ne", NL ("!="), 2 },
1830 { "ng", NL ("-"), 1 },
1831 { "nt", NL ("!"), 1 },
1832 { "nw", NL ("new"), 3 },
1833 { "oR", NL ("|="), 2 },
1834 { "oo", NL ("||"), 2 },
1835 { "or", NL ("|"), 2 },
1836 { "pL", NL ("+="), 2 },
1837 { "pl", NL ("+"), 2 },
1838 { "pm", NL ("->*"), 2 },
1839 { "pp", NL ("++"), 1 },
1840 { "ps", NL ("+"), 1 },
1841 { "pt", NL ("->"), 2 },
1842 { "qu", NL ("?"), 3 },
1843 { "rM", NL ("%="), 2 },
1844 { "rS", NL (">>="), 2 },
1845 { "rc", NL ("reinterpret_cast"), 2 },
1846 { "rm", NL ("%"), 2 },
1847 { "rs", NL (">>"), 2 },
1848 { "sP", NL ("sizeof..."), 1 },
1849 { "sZ", NL ("sizeof..."), 1 },
1850 { "sc", NL ("static_cast"), 2 },
1851 { "st", NL ("sizeof "), 1 },
1852 { "sz", NL ("sizeof "), 1 },
1853 { "tr", NL ("throw"), 0 },
1854 { "tw", NL ("throw "), 1 },
1855 { NULL
, NULL
, 0, 0 }
1858 static struct demangle_component
*
1859 d_operator_name (struct d_info
*di
)
1864 c1
= d_next_char (di
);
1865 c2
= d_next_char (di
);
1866 if (c1
== 'v' && IS_DIGIT (c2
))
1867 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1868 else if (c1
== 'c' && c2
== 'v')
1870 struct demangle_component
*type
;
1871 int was_conversion
= di
->is_conversion
;
1872 struct demangle_component
*res
;
1874 di
->is_conversion
= ! di
->is_expression
;
1875 type
= cplus_demangle_type (di
);
1876 if (di
->is_conversion
)
1877 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CONVERSION
, type
, NULL
);
1879 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CAST
, type
, NULL
);
1880 di
->is_conversion
= was_conversion
;
1885 /* LOW is the inclusive lower bound. */
1887 /* HIGH is the exclusive upper bound. We subtract one to ignore
1888 the sentinel at the end of the array. */
1889 int high
= ((sizeof (cplus_demangle_operators
)
1890 / sizeof (cplus_demangle_operators
[0]))
1896 const struct demangle_operator_info
*p
;
1898 i
= low
+ (high
- low
) / 2;
1899 p
= cplus_demangle_operators
+ i
;
1901 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1902 return d_make_operator (di
, p
);
1904 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1914 static struct demangle_component
*
1915 d_make_character (struct d_info
*di
, int c
)
1917 struct demangle_component
*p
;
1918 p
= d_make_empty (di
);
1921 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1922 p
->u
.s_character
.character
= c
;
1927 static struct demangle_component
*
1928 d_java_resource (struct d_info
*di
)
1930 struct demangle_component
*p
= NULL
;
1931 struct demangle_component
*next
= NULL
;
1936 len
= d_number (di
);
1940 /* Eat the leading '_'. */
1941 if (d_next_char (di
) != '_')
1954 /* Each chunk is either a '$' escape... */
1972 next
= d_make_character (di
, c
);
1980 /* ... or a sequence of characters. */
1983 while (i
< len
&& str
[i
] && str
[i
] != '$')
1986 next
= d_make_name (di
, str
, i
);
1999 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
2005 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
2010 /* <special-name> ::= TV <type>
2014 ::= TA <template-arg>
2015 ::= GV <(object) name>
2016 ::= T <call-offset> <(base) encoding>
2017 ::= Tc <call-offset> <call-offset> <(base) encoding>
2018 Also g++ extensions:
2019 ::= TC <type> <(offset) number> _ <(base) type>
2024 ::= Gr <resource name>
2029 static struct demangle_component
*
2030 d_special_name (struct d_info
*di
)
2032 di
->expansion
+= 20;
2033 if (d_check_char (di
, 'T'))
2035 switch (d_next_char (di
))
2039 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
2040 cplus_demangle_type (di
), NULL
);
2042 di
->expansion
-= 10;
2043 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
2044 cplus_demangle_type (di
), NULL
);
2046 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
2047 cplus_demangle_type (di
), NULL
);
2049 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
2050 cplus_demangle_type (di
), NULL
);
2053 if (! d_call_offset (di
, 'h'))
2055 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
2056 d_encoding (di
, 0), NULL
);
2059 if (! d_call_offset (di
, 'v'))
2061 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
2062 d_encoding (di
, 0), NULL
);
2065 if (! d_call_offset (di
, '\0'))
2067 if (! d_call_offset (di
, '\0'))
2069 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
2070 d_encoding (di
, 0), NULL
);
2074 struct demangle_component
*derived_type
;
2076 struct demangle_component
*base_type
;
2078 derived_type
= cplus_demangle_type (di
);
2079 offset
= d_number (di
);
2082 if (! d_check_char (di
, '_'))
2084 base_type
= cplus_demangle_type (di
);
2085 /* We don't display the offset. FIXME: We should display
2086 it in verbose mode. */
2088 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
2089 base_type
, derived_type
);
2093 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
2094 cplus_demangle_type (di
), NULL
);
2096 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
2097 cplus_demangle_type (di
), NULL
);
2100 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
2104 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
2108 return d_make_comp (di
, DEMANGLE_COMPONENT_TPARM_OBJ
,
2109 d_template_arg (di
), NULL
);
2115 else if (d_check_char (di
, 'G'))
2117 switch (d_next_char (di
))
2120 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
,
2125 struct demangle_component
*name
= d_name (di
);
2126 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
2127 d_number_component (di
));
2131 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
2132 d_encoding (di
, 0), NULL
);
2135 switch (d_next_char (di
))
2138 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
2139 d_encoding (di
, 0), NULL
);
2141 /* ??? The proposal is that other letters (such as 'h') stand
2142 for different variants of transaction cloning, such as
2143 compiling directly for hardware transaction support. But
2144 they still should all be transactional clones of some sort
2145 so go ahead and call them that. */
2147 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
2148 d_encoding (di
, 0), NULL
);
2152 return d_java_resource (di
);
2162 /* <call-offset> ::= h <nv-offset> _
2165 <nv-offset> ::= <(offset) number>
2167 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2169 The C parameter, if not '\0', is a character we just read which is
2170 the start of the <call-offset>.
2172 We don't display the offset information anywhere. FIXME: We should
2173 display it in verbose mode. */
2176 d_call_offset (struct d_info
*di
, int c
)
2179 c
= d_next_char (di
);
2186 if (! d_check_char (di
, '_'))
2193 if (! d_check_char (di
, '_'))
2199 /* <ctor-dtor-name> ::= C1
2207 static struct demangle_component
*
2208 d_ctor_dtor_name (struct d_info
*di
)
2210 if (di
->last_name
!= NULL
)
2212 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2213 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2214 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2215 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2217 switch (d_peek_char (di
))
2221 enum gnu_v3_ctor_kinds kind
;
2224 if (d_peek_next_char (di
) == 'I')
2230 switch (d_peek_next_char (di
))
2233 kind
= gnu_v3_complete_object_ctor
;
2236 kind
= gnu_v3_base_object_ctor
;
2239 kind
= gnu_v3_complete_object_allocating_ctor
;
2242 kind
= gnu_v3_unified_ctor
;
2245 kind
= gnu_v3_object_ctor_group
;
2254 cplus_demangle_type (di
);
2256 return d_make_ctor (di
, kind
, di
->last_name
);
2261 enum gnu_v3_dtor_kinds kind
;
2263 switch (d_peek_next_char (di
))
2266 kind
= gnu_v3_deleting_dtor
;
2269 kind
= gnu_v3_complete_object_dtor
;
2272 kind
= gnu_v3_base_object_dtor
;
2274 /* digit '3' is not used */
2276 kind
= gnu_v3_unified_dtor
;
2279 kind
= gnu_v3_object_dtor_group
;
2285 return d_make_dtor (di
, kind
, di
->last_name
);
2293 /* True iff we're looking at an order-insensitive type-qualifier, including
2294 function-type-qualifiers. */
2297 next_is_type_qual (struct d_info
*di
)
2299 char peek
= d_peek_char (di
);
2300 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2304 peek
= d_peek_next_char (di
);
2305 if (peek
== 'x' || peek
== 'o' || peek
== 'O' || peek
== 'w')
2311 /* <type> ::= <builtin-type>
2313 ::= <class-enum-type>
2315 ::= <pointer-to-member-type>
2316 ::= <template-param>
2317 ::= <template-template-param> <template-args>
2319 ::= <CV-qualifiers> <type>
2322 ::= O <type> (C++0x)
2325 ::= U <source-name> <type>
2327 <builtin-type> ::= various one letter codes
2331 CP_STATIC_IF_GLIBCPP_V3
2332 const struct demangle_builtin_type_info
2333 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2335 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2336 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2337 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2338 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2339 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2340 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2341 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2342 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2343 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2344 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2345 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2346 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2347 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2348 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2349 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2351 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2352 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2353 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2354 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2355 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2356 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2357 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2358 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2359 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2360 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2361 D_PRINT_UNSIGNED_LONG_LONG
},
2362 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2363 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2364 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2365 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2366 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2367 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT
},
2368 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2369 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2370 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2374 CP_STATIC_IF_GLIBCPP_V3
2375 struct demangle_component
*
2376 cplus_demangle_type (struct d_info
*di
)
2379 struct demangle_component
*ret
;
2382 /* The ABI specifies that when CV-qualifiers are used, the base type
2383 is substitutable, and the fully qualified type is substitutable,
2384 but the base type with a strict subset of the CV-qualifiers is
2385 not substitutable. The natural recursive implementation of the
2386 CV-qualifiers would cause subsets to be substitutable, so instead
2387 we pull them all off now.
2389 FIXME: The ABI says that order-insensitive vendor qualifiers
2390 should be handled in the same way, but we have no way to tell
2391 which vendor qualifiers are order-insensitive and which are
2392 order-sensitive. So we just assume that they are all
2393 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2394 __vector, and it treats it as order-sensitive when mangling
2397 if (next_is_type_qual (di
))
2399 struct demangle_component
**pret
;
2401 pret
= d_cv_qualifiers (di
, &ret
, 0);
2404 if (d_peek_char (di
) == 'F')
2406 /* cv-qualifiers before a function type apply to 'this',
2407 so avoid adding the unqualified function type to
2408 the substitution list. */
2409 *pret
= d_function_type (di
);
2412 *pret
= cplus_demangle_type (di
);
2415 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2416 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2418 /* Move the ref-qualifier outside the cv-qualifiers so that
2419 they are printed in the right order. */
2420 struct demangle_component
*fn
= d_left (*pret
);
2421 d_left (*pret
) = ret
;
2425 if (! d_add_substitution (di
, ret
))
2432 peek
= d_peek_char (di
);
2435 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2436 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2437 case 'o': case 's': case 't':
2438 case 'v': case 'w': case 'x': case 'y': case 'z':
2439 ret
= d_make_builtin_type (di
,
2440 &cplus_demangle_builtin_types
[peek
- 'a']);
2441 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2448 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2449 d_source_name (di
), NULL
);
2453 ret
= d_function_type (di
);
2456 case '0': case '1': case '2': case '3': case '4':
2457 case '5': case '6': case '7': case '8': case '9':
2460 ret
= d_class_enum_type (di
);
2464 ret
= d_array_type (di
);
2468 ret
= d_pointer_to_member_type (di
);
2472 ret
= d_template_param (di
);
2473 if (d_peek_char (di
) == 'I')
2475 /* This may be <template-template-param> <template-args>.
2476 If this is the type for a conversion operator, we can
2477 have a <template-template-param> here only by following
2478 a derivation like this:
2481 -> <template-prefix> <template-args>
2482 -> <prefix> <template-unqualified-name> <template-args>
2483 -> <unqualified-name> <template-unqualified-name> <template-args>
2484 -> <source-name> <template-unqualified-name> <template-args>
2485 -> <source-name> <operator-name> <template-args>
2486 -> <source-name> cv <type> <template-args>
2487 -> <source-name> cv <template-template-param> <template-args> <template-args>
2489 where the <template-args> is followed by another.
2490 Otherwise, we must have 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-param> <template-args>
2501 where we need to leave the <template-args> to be processed
2502 by d_prefix (following the <template-prefix>).
2504 The <template-template-param> part is a substitution
2506 if (! di
->is_conversion
)
2508 if (! d_add_substitution (di
, ret
))
2510 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2511 d_template_args (di
));
2515 struct demangle_component
*args
;
2516 struct d_info_checkpoint checkpoint
;
2518 d_checkpoint (di
, &checkpoint
);
2519 args
= d_template_args (di
);
2520 if (d_peek_char (di
) == 'I')
2522 if (! d_add_substitution (di
, ret
))
2524 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2528 d_backtrack (di
, &checkpoint
);
2534 /* If this is a special substitution, then it is the start of
2535 <class-enum-type>. */
2539 peek_next
= d_peek_next_char (di
);
2540 if (IS_DIGIT (peek_next
)
2542 || IS_UPPER (peek_next
))
2544 ret
= d_substitution (di
, 0);
2545 /* The substituted name may have been a template name and
2546 may be followed by tepmlate args. */
2547 if (d_peek_char (di
) == 'I')
2548 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2549 d_template_args (di
));
2555 ret
= d_class_enum_type (di
);
2556 /* If the substitution was a complete type, then it is not
2557 a new substitution candidate. However, if the
2558 substitution was followed by template arguments, then
2559 the whole thing is a substitution candidate. */
2560 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2568 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2569 cplus_demangle_type (di
), NULL
);
2574 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2575 cplus_demangle_type (di
), NULL
);
2580 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2581 cplus_demangle_type (di
), NULL
);
2586 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2587 cplus_demangle_type (di
), NULL
);
2592 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2593 cplus_demangle_type (di
), NULL
);
2598 ret
= d_source_name (di
);
2599 if (d_peek_char (di
) == 'I')
2600 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2601 d_template_args (di
));
2602 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2603 cplus_demangle_type (di
), ret
);
2609 peek
= d_next_char (di
);
2614 /* decltype (expression) */
2615 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2616 d_expression (di
), NULL
);
2617 if (ret
&& d_next_char (di
) != 'E')
2623 /* Pack expansion. */
2624 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2625 cplus_demangle_type (di
), NULL
);
2631 ret
= d_make_name (di
, "auto", 4);
2634 /* decltype(auto) */
2635 ret
= d_make_name (di
, "decltype(auto)", 14);
2639 /* 32-bit decimal floating point */
2640 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2641 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2645 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2646 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2650 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2651 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2654 /* 16-bit half-precision FP */
2655 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2656 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2660 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2661 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2665 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2666 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2670 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2671 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2675 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2676 ret
= d_make_empty (di
);
2677 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2678 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2679 /* For demangling we don't care about the bits. */
2681 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2682 if (ret
->u
.s_fixed
.length
== NULL
)
2685 peek
= d_next_char (di
);
2686 ret
->u
.s_fixed
.sat
= (peek
== 's');
2690 ret
= d_vector_type (di
);
2695 /* decltype(nullptr) */
2696 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[33]);
2697 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2711 if (! d_add_substitution (di
, ret
))
2718 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2720 static struct demangle_component
**
2721 d_cv_qualifiers (struct d_info
*di
,
2722 struct demangle_component
**pret
, int member_fn
)
2724 struct demangle_component
**pstart
;
2728 peek
= d_peek_char (di
);
2729 while (next_is_type_qual (di
))
2731 enum demangle_component_type t
;
2732 struct demangle_component
*right
= NULL
;
2738 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2739 : DEMANGLE_COMPONENT_RESTRICT
);
2740 di
->expansion
+= sizeof "restrict";
2742 else if (peek
== 'V')
2745 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2746 : DEMANGLE_COMPONENT_VOLATILE
);
2747 di
->expansion
+= sizeof "volatile";
2749 else if (peek
== 'K')
2752 ? DEMANGLE_COMPONENT_CONST_THIS
2753 : DEMANGLE_COMPONENT_CONST
);
2754 di
->expansion
+= sizeof "const";
2758 peek
= d_next_char (di
);
2761 t
= DEMANGLE_COMPONENT_TRANSACTION_SAFE
;
2762 di
->expansion
+= sizeof "transaction_safe";
2764 else if (peek
== 'o'
2767 t
= DEMANGLE_COMPONENT_NOEXCEPT
;
2768 di
->expansion
+= sizeof "noexcept";
2771 right
= d_expression (di
);
2774 if (! d_check_char (di
, 'E'))
2778 else if (peek
== 'w')
2780 t
= DEMANGLE_COMPONENT_THROW_SPEC
;
2781 di
->expansion
+= sizeof "throw";
2782 right
= d_parmlist (di
);
2785 if (! d_check_char (di
, 'E'))
2792 *pret
= d_make_comp (di
, t
, NULL
, right
);
2795 pret
= &d_left (*pret
);
2797 peek
= d_peek_char (di
);
2800 if (!member_fn
&& peek
== 'F')
2802 while (pstart
!= pret
)
2804 switch ((*pstart
)->type
)
2806 case DEMANGLE_COMPONENT_RESTRICT
:
2807 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2809 case DEMANGLE_COMPONENT_VOLATILE
:
2810 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2812 case DEMANGLE_COMPONENT_CONST
:
2813 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2818 pstart
= &d_left (*pstart
);
2825 /* <ref-qualifier> ::= R
2828 static struct demangle_component
*
2829 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2831 struct demangle_component
*ret
= sub
;
2834 peek
= d_peek_char (di
);
2835 if (peek
== 'R' || peek
== 'O')
2837 enum demangle_component_type t
;
2840 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2841 di
->expansion
+= sizeof "&";
2845 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2846 di
->expansion
+= sizeof "&&";
2850 ret
= d_make_comp (di
, t
, ret
, NULL
);
2856 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2858 static struct demangle_component
*
2859 d_function_type (struct d_info
*di
)
2861 struct demangle_component
*ret
= NULL
;
2863 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2865 if (di
->recursion_level
> DEMANGLE_RECURSION_LIMIT
)
2866 /* FIXME: There ought to be a way to report
2867 that the recursion limit has been reached. */
2870 di
->recursion_level
++;
2873 if (d_check_char (di
, 'F'))
2875 if (d_peek_char (di
) == 'Y')
2877 /* Function has C linkage. We don't print this information.
2878 FIXME: We should print it in verbose mode. */
2881 ret
= d_bare_function_type (di
, 1);
2882 ret
= d_ref_qualifier (di
, ret
);
2884 if (! d_check_char (di
, 'E'))
2888 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2889 di
->recursion_level
--;
2895 static struct demangle_component
*
2896 d_parmlist (struct d_info
*di
)
2898 struct demangle_component
*tl
;
2899 struct demangle_component
**ptl
;
2905 struct demangle_component
*type
;
2907 char peek
= d_peek_char (di
);
2908 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2910 if ((peek
== 'R' || peek
== 'O')
2911 && d_peek_next_char (di
) == 'E')
2912 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2914 type
= cplus_demangle_type (di
);
2917 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2920 ptl
= &d_right (*ptl
);
2923 /* There should be at least one parameter type besides the optional
2924 return type. A function which takes no arguments will have a
2925 single parameter type void. */
2929 /* If we have a single parameter type void, omit it. */
2930 if (d_right (tl
) == NULL
2931 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2932 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2934 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2941 /* <bare-function-type> ::= [J]<type>+ */
2943 static struct demangle_component
*
2944 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2946 struct demangle_component
*return_type
;
2947 struct demangle_component
*tl
;
2950 /* Detect special qualifier indicating that the first argument
2951 is the return type. */
2952 peek
= d_peek_char (di
);
2956 has_return_type
= 1;
2959 if (has_return_type
)
2961 return_type
= cplus_demangle_type (di
);
2962 if (return_type
== NULL
)
2968 tl
= d_parmlist (di
);
2972 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2976 /* <class-enum-type> ::= <name> */
2978 static struct demangle_component
*
2979 d_class_enum_type (struct d_info
*di
)
2984 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2985 ::= A [<(dimension) expression>] _ <(element) type>
2988 static struct demangle_component
*
2989 d_array_type (struct d_info
*di
)
2992 struct demangle_component
*dim
;
2994 if (! d_check_char (di
, 'A'))
2997 peek
= d_peek_char (di
);
3000 else if (IS_DIGIT (peek
))
3008 peek
= d_peek_char (di
);
3010 while (IS_DIGIT (peek
));
3011 dim
= d_make_name (di
, s
, d_str (di
) - s
);
3017 dim
= d_expression (di
);
3022 if (! d_check_char (di
, '_'))
3025 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
3026 cplus_demangle_type (di
));
3029 /* <vector-type> ::= Dv <number> _ <type>
3030 ::= Dv _ <expression> _ <type> */
3032 static struct demangle_component
*
3033 d_vector_type (struct d_info
*di
)
3036 struct demangle_component
*dim
;
3038 peek
= d_peek_char (di
);
3042 dim
= d_expression (di
);
3045 dim
= d_number_component (di
);
3050 if (! d_check_char (di
, '_'))
3053 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
3054 cplus_demangle_type (di
));
3057 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3059 static struct demangle_component
*
3060 d_pointer_to_member_type (struct d_info
*di
)
3062 struct demangle_component
*cl
;
3063 struct demangle_component
*mem
;
3065 if (! d_check_char (di
, 'M'))
3068 cl
= cplus_demangle_type (di
);
3072 /* The ABI says, "The type of a non-static member function is considered
3073 to be different, for the purposes of substitution, from the type of a
3074 namespace-scope or static member function whose type appears
3075 similar. The types of two non-static member functions are considered
3076 to be different, for the purposes of substitution, if the functions
3077 are members of different classes. In other words, for the purposes of
3078 substitution, the class of which the function is a member is
3079 considered part of the type of function."
3081 For a pointer to member function, this call to cplus_demangle_type
3082 will end up adding a (possibly qualified) non-member function type to
3083 the substitution table, which is not correct; however, the member
3084 function type will never be used in a substitution, so putting the
3085 wrong type in the substitution table is harmless. */
3087 mem
= cplus_demangle_type (di
);
3091 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
3094 /* <non-negative number> _ */
3097 d_compact_number (struct d_info
*di
)
3100 if (d_peek_char (di
) == '_')
3102 else if (d_peek_char (di
) == 'n')
3105 num
= d_number (di
) + 1;
3107 if (num
< 0 || ! d_check_char (di
, '_'))
3112 /* <template-param> ::= T_
3113 ::= T <(parameter-2 non-negative) number> _
3116 static struct demangle_component
*
3117 d_template_param (struct d_info
*di
)
3121 if (! d_check_char (di
, 'T'))
3124 param
= d_compact_number (di
);
3128 return d_make_template_param (di
, param
);
3131 /* <template-args> ::= I <template-arg>+ E */
3133 static struct demangle_component
*
3134 d_template_args (struct d_info
*di
)
3136 if (d_peek_char (di
) != 'I'
3137 && d_peek_char (di
) != 'J')
3141 return d_template_args_1 (di
);
3144 /* <template-arg>* E */
3146 static struct demangle_component
*
3147 d_template_args_1 (struct d_info
*di
)
3149 struct demangle_component
*hold_last_name
;
3150 struct demangle_component
*al
;
3151 struct demangle_component
**pal
;
3153 /* Preserve the last name we saw--don't let the template arguments
3154 clobber it, as that would give us the wrong name for a subsequent
3155 constructor or destructor. */
3156 hold_last_name
= di
->last_name
;
3158 if (d_peek_char (di
) == 'E')
3160 /* An argument pack can be empty. */
3162 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
3169 struct demangle_component
*a
;
3171 a
= d_template_arg (di
);
3175 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
3178 pal
= &d_right (*pal
);
3180 if (d_peek_char (di
) == 'E')
3187 di
->last_name
= hold_last_name
;
3192 /* <template-arg> ::= <type>
3193 ::= X <expression> E
3197 static struct demangle_component
*
3198 d_template_arg (struct d_info
*di
)
3200 struct demangle_component
*ret
;
3202 switch (d_peek_char (di
))
3206 ret
= d_expression (di
);
3207 if (! d_check_char (di
, 'E'))
3212 return d_expr_primary (di
);
3216 /* An argument pack. */
3217 return d_template_args (di
);
3220 return cplus_demangle_type (di
);
3224 /* Parse a sequence of expressions until we hit the terminator
3227 static struct demangle_component
*
3228 d_exprlist (struct d_info
*di
, char terminator
)
3230 struct demangle_component
*list
= NULL
;
3231 struct demangle_component
**p
= &list
;
3233 if (d_peek_char (di
) == terminator
)
3236 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
3241 struct demangle_component
*arg
= d_expression (di
);
3245 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
3250 if (d_peek_char (di
) == terminator
)
3260 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3261 dynamic_cast, static_cast or reinterpret_cast. */
3264 op_is_new_cast (struct demangle_component
*op
)
3266 const char *code
= op
->u
.s_operator
.op
->code
;
3267 return (code
[1] == 'c'
3268 && (code
[0] == 's' || code
[0] == 'd'
3269 || code
[0] == 'c' || code
[0] == 'r'));
3272 /* <expression> ::= <(unary) operator-name> <expression>
3273 ::= <(binary) operator-name> <expression> <expression>
3274 ::= <(trinary) operator-name> <expression> <expression> <expression>
3275 ::= cl <expression>+ E
3277 ::= <template-param>
3278 ::= sr <type> <unqualified-name>
3279 ::= sr <type> <unqualified-name> <template-args>
3283 static inline struct demangle_component
*
3284 d_expression_1 (struct d_info
*di
)
3288 peek
= d_peek_char (di
);
3290 return d_expr_primary (di
);
3291 else if (peek
== 'T')
3292 return d_template_param (di
);
3293 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
3295 struct demangle_component
*type
;
3296 struct demangle_component
*name
;
3299 type
= cplus_demangle_type (di
);
3300 name
= d_unqualified_name (di
);
3301 if (d_peek_char (di
) != 'I')
3302 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
3304 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
3305 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3306 d_template_args (di
)));
3308 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3311 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3312 d_expression_1 (di
), NULL
);
3314 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3316 /* Function parameter used in a late-specified return type. */
3319 if (d_peek_char (di
) == 'T')
3321 /* 'this' parameter. */
3327 index
= d_compact_number (di
);
3328 if (index
== INT_MAX
|| index
== -1)
3332 return d_make_function_param (di
, index
);
3334 else if (IS_DIGIT (peek
)
3335 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3337 /* We can get an unqualified name as an expression in the case of
3338 a dependent function call, i.e. decltype(f(t)). */
3339 struct demangle_component
*name
;
3342 /* operator-function-id, i.e. operator+(t). */
3345 name
= d_unqualified_name (di
);
3348 if (d_peek_char (di
) == 'I')
3349 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3350 d_template_args (di
));
3354 else if ((peek
== 'i' || peek
== 't')
3355 && d_peek_next_char (di
) == 'l')
3357 /* Brace-enclosed initializer list, untyped or typed. */
3358 struct demangle_component
*type
= NULL
;
3361 type
= cplus_demangle_type (di
);
3362 if (!d_peek_next_char (di
))
3364 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3365 type
, d_exprlist (di
, 'E'));
3369 struct demangle_component
*op
;
3370 const char *code
= NULL
;
3373 op
= d_operator_name (di
);
3377 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3379 code
= op
->u
.s_operator
.op
->code
;
3380 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3381 if (strcmp (code
, "st") == 0)
3382 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3383 cplus_demangle_type (di
));
3390 case DEMANGLE_COMPONENT_OPERATOR
:
3391 args
= op
->u
.s_operator
.op
->args
;
3393 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3394 args
= op
->u
.s_extended_operator
.args
;
3396 case DEMANGLE_COMPONENT_CAST
:
3404 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3408 struct demangle_component
*operand
;
3411 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3412 && code
[1] == code
[0])
3413 /* pp_ and mm_ are the prefix variants. */
3414 suffix
= !d_check_char (di
, '_');
3416 if (op
->type
== DEMANGLE_COMPONENT_CAST
3417 && d_check_char (di
, '_'))
3418 operand
= d_exprlist (di
, 'E');
3419 else if (code
&& !strcmp (code
, "sP"))
3420 operand
= d_template_args_1 (di
);
3422 operand
= d_expression_1 (di
);
3425 /* Indicate the suffix variant for d_print_comp. */
3426 operand
= d_make_comp (di
, DEMANGLE_COMPONENT_BINARY_ARGS
,
3429 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
, operand
);
3433 struct demangle_component
*left
;
3434 struct demangle_component
*right
;
3438 if (op_is_new_cast (op
))
3439 left
= cplus_demangle_type (di
);
3440 else if (code
[0] == 'f')
3441 /* fold-expression. */
3442 left
= d_operator_name (di
);
3444 left
= d_expression_1 (di
);
3445 if (!strcmp (code
, "cl"))
3446 right
= d_exprlist (di
, 'E');
3447 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3449 right
= d_unqualified_name (di
);
3450 if (d_peek_char (di
) == 'I')
3451 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3452 right
, d_template_args (di
));
3455 right
= d_expression_1 (di
);
3457 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3459 DEMANGLE_COMPONENT_BINARY_ARGS
,
3464 struct demangle_component
*first
;
3465 struct demangle_component
*second
;
3466 struct demangle_component
*third
;
3470 else if (!strcmp (code
, "qu"))
3472 /* ?: expression. */
3473 first
= d_expression_1 (di
);
3474 second
= d_expression_1 (di
);
3475 third
= d_expression_1 (di
);
3479 else if (code
[0] == 'f')
3481 /* fold-expression. */
3482 first
= d_operator_name (di
);
3483 second
= d_expression_1 (di
);
3484 third
= d_expression_1 (di
);
3488 else if (code
[0] == 'n')
3490 /* new-expression. */
3491 if (code
[1] != 'w' && code
[1] != 'a')
3493 first
= d_exprlist (di
, '_');
3494 second
= cplus_demangle_type (di
);
3495 if (d_peek_char (di
) == 'E')
3500 else if (d_peek_char (di
) == 'p'
3501 && d_peek_next_char (di
) == 'i')
3503 /* Parenthesized initializer. */
3505 third
= d_exprlist (di
, 'E');
3507 else if (d_peek_char (di
) == 'i'
3508 && d_peek_next_char (di
) == 'l')
3509 /* initializer-list. */
3510 third
= d_expression_1 (di
);
3516 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3518 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3521 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3530 static struct demangle_component
*
3531 d_expression (struct d_info
*di
)
3533 struct demangle_component
*ret
;
3534 int was_expression
= di
->is_expression
;
3536 di
->is_expression
= 1;
3537 ret
= d_expression_1 (di
);
3538 di
->is_expression
= was_expression
;
3542 /* <expr-primary> ::= L <type> <(value) number> E
3543 ::= L <type> <(value) float> E
3544 ::= L <mangled-name> E
3547 static struct demangle_component
*
3548 d_expr_primary (struct d_info
*di
)
3550 struct demangle_component
*ret
;
3552 if (! d_check_char (di
, 'L'))
3554 if (d_peek_char (di
) == '_'
3555 /* Workaround for G++ bug; see comment in write_template_arg. */
3556 || d_peek_char (di
) == 'Z')
3557 ret
= cplus_demangle_mangled_name (di
, 0);
3560 struct demangle_component
*type
;
3561 enum demangle_component_type t
;
3564 type
= cplus_demangle_type (di
);
3568 /* If we have a type we know how to print, we aren't going to
3569 print the type name itself. */
3570 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3571 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3572 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3574 /* Rather than try to interpret the literal value, we just
3575 collect it as a string. Note that it's possible to have a
3576 floating point literal here. The ABI specifies that the
3577 format of such literals is machine independent. That's fine,
3578 but what's not fine is that versions of g++ up to 3.2 with
3579 -fabi-version=1 used upper case letters in the hex constant,
3580 and dumped out gcc's internal representation. That makes it
3581 hard to tell where the constant ends, and hard to dump the
3582 constant in any readable form anyhow. We don't attempt to
3583 handle these cases. */
3585 t
= DEMANGLE_COMPONENT_LITERAL
;
3586 if (d_peek_char (di
) == 'n')
3588 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3592 while (d_peek_char (di
) != 'E')
3594 if (d_peek_char (di
) == '\0')
3598 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3600 if (! d_check_char (di
, 'E'))
3605 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3606 ::= Z <(function) encoding> E s [<discriminator>]
3607 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3610 static struct demangle_component
*
3611 d_local_name (struct d_info
*di
)
3613 struct demangle_component
*function
;
3614 struct demangle_component
*name
;
3616 if (! d_check_char (di
, 'Z'))
3619 function
= d_encoding (di
, 0);
3623 if (! d_check_char (di
, 'E'))
3626 if (d_peek_char (di
) == 's')
3629 if (! d_discriminator (di
))
3631 name
= d_make_name (di
, "string literal", sizeof "string literal" - 1);
3637 if (d_peek_char (di
) == 'd')
3639 /* Default argument scope: d <number> _. */
3641 num
= d_compact_number (di
);
3649 /* Lambdas and unnamed types have internal discriminators
3650 and are not functions. */
3651 && name
->type
!= DEMANGLE_COMPONENT_LAMBDA
3652 && name
->type
!= DEMANGLE_COMPONENT_UNNAMED_TYPE
)
3654 /* Read and ignore an optional discriminator. */
3655 if (! d_discriminator (di
))
3660 name
= d_make_default_arg (di
, num
, name
);
3663 /* Elide the return type of the containing function so as to not
3664 confuse the user thinking it is the return type of whatever local
3665 function we might be containing. */
3666 if (function
->type
== DEMANGLE_COMPONENT_TYPED_NAME
3667 && d_right (function
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3668 d_left (d_right (function
)) = NULL
;
3670 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3673 /* <discriminator> ::= _ <number> # when number < 10
3674 ::= __ <number> _ # when number >= 10
3676 <discriminator> ::= _ <number> # when number >=10
3677 is also accepted to support gcc versions that wrongly mangled that way.
3679 We demangle the discriminator, but we don't print it out. FIXME:
3680 We should print it out in verbose mode. */
3683 d_discriminator (struct d_info
*di
)
3685 int discrim
, num_underscores
= 1;
3687 if (d_peek_char (di
) != '_')
3690 if (d_peek_char (di
) == '_')
3696 discrim
= d_number (di
);
3699 if (num_underscores
> 1 && discrim
>= 10)
3701 if (d_peek_char (di
) == '_')
3710 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3712 static struct demangle_component
*
3713 d_lambda (struct d_info
*di
)
3715 struct demangle_component
*tl
;
3716 struct demangle_component
*ret
;
3719 if (! d_check_char (di
, 'U'))
3721 if (! d_check_char (di
, 'l'))
3724 tl
= d_parmlist (di
);
3728 if (! d_check_char (di
, 'E'))
3731 num
= d_compact_number (di
);
3735 ret
= d_make_empty (di
);
3738 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3739 ret
->u
.s_unary_num
.sub
= tl
;
3740 ret
->u
.s_unary_num
.num
= num
;
3743 if (! d_add_substitution (di
, ret
))
3749 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3751 static struct demangle_component
*
3752 d_unnamed_type (struct d_info
*di
)
3754 struct demangle_component
*ret
;
3757 if (! d_check_char (di
, 'U'))
3759 if (! d_check_char (di
, 't'))
3762 num
= d_compact_number (di
);
3766 ret
= d_make_empty (di
);
3769 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3770 ret
->u
.s_number
.number
= num
;
3773 if (! d_add_substitution (di
, ret
))
3779 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3782 static struct demangle_component
*
3783 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3785 const char *suffix
= d_str (di
);
3786 const char *pend
= suffix
;
3787 struct demangle_component
*n
;
3789 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3792 while (IS_LOWER (*pend
) || *pend
== '_')
3795 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3798 while (IS_DIGIT (*pend
))
3801 d_advance (di
, pend
- suffix
);
3802 n
= d_make_name (di
, suffix
, pend
- suffix
);
3803 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3806 /* Add a new substitution. */
3809 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3813 if (di
->next_sub
>= di
->num_subs
)
3815 di
->subs
[di
->next_sub
] = dc
;
3820 /* <substitution> ::= S <seq-id> _
3830 If PREFIX is non-zero, then this type is being used as a prefix in
3831 a qualified name. In this case, for the standard substitutions, we
3832 need to check whether we are being used as a prefix for a
3833 constructor or destructor, and return a full template name.
3834 Otherwise we will get something like std::iostream::~iostream()
3835 which does not correspond particularly well to any function which
3836 actually appears in the source.
3839 static const struct d_standard_sub_info standard_subs
[] =
3844 { 'a', NL ("std::allocator"),
3845 NL ("std::allocator"),
3847 { 'b', NL ("std::basic_string"),
3848 NL ("std::basic_string"),
3849 NL ("basic_string") },
3850 { 's', NL ("std::string"),
3851 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3852 NL ("basic_string") },
3853 { 'i', NL ("std::istream"),
3854 NL ("std::basic_istream<char, std::char_traits<char> >"),
3855 NL ("basic_istream") },
3856 { 'o', NL ("std::ostream"),
3857 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3858 NL ("basic_ostream") },
3859 { 'd', NL ("std::iostream"),
3860 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3861 NL ("basic_iostream") }
3864 static struct demangle_component
*
3865 d_substitution (struct d_info
*di
, int prefix
)
3869 if (! d_check_char (di
, 'S'))
3872 c
= d_next_char (di
);
3873 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3882 unsigned int new_id
;
3885 new_id
= id
* 36 + c
- '0';
3886 else if (IS_UPPER (c
))
3887 new_id
= id
* 36 + c
- 'A' + 10;
3893 c
= d_next_char (di
);
3900 if (id
>= (unsigned int) di
->next_sub
)
3903 return di
->subs
[id
];
3908 const struct d_standard_sub_info
*p
;
3909 const struct d_standard_sub_info
*pend
;
3911 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3912 if (! verbose
&& prefix
)
3916 peek
= d_peek_char (di
);
3917 if (peek
== 'C' || peek
== 'D')
3921 pend
= (&standard_subs
[0]
3922 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3923 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3929 struct demangle_component
*dc
;
3931 if (p
->set_last_name
!= NULL
)
3932 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3933 p
->set_last_name_len
);
3936 s
= p
->full_expansion
;
3941 s
= p
->simple_expansion
;
3942 len
= p
->simple_len
;
3944 di
->expansion
+= len
;
3945 dc
= d_make_sub (di
, s
, len
);
3946 if (d_peek_char (di
) == 'B')
3948 /* If there are ABI tags on the abbreviation, it becomes
3949 a substitution candidate. */
3950 dc
= d_abi_tags (di
, dc
);
3951 if (! d_add_substitution (di
, dc
))
3963 d_checkpoint (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3965 checkpoint
->n
= di
->n
;
3966 checkpoint
->next_comp
= di
->next_comp
;
3967 checkpoint
->next_sub
= di
->next_sub
;
3968 checkpoint
->expansion
= di
->expansion
;
3972 d_backtrack (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3974 di
->n
= checkpoint
->n
;
3975 di
->next_comp
= checkpoint
->next_comp
;
3976 di
->next_sub
= checkpoint
->next_sub
;
3977 di
->expansion
= checkpoint
->expansion
;
3980 /* Initialize a growable string. */
3983 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
3988 dgs
->allocation_failure
= 0;
3991 d_growable_string_resize (dgs
, estimate
);
3994 /* Grow a growable string to a given size. */
3997 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
4002 if (dgs
->allocation_failure
)
4005 /* Start allocation at two bytes to avoid any possibility of confusion
4006 with the special value of 1 used as a return in *palc to indicate
4007 allocation failures. */
4008 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
4009 while (newalc
< need
)
4012 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
4019 dgs
->allocation_failure
= 1;
4026 /* Append a buffer to a growable string. */
4029 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
4030 const char *s
, size_t l
)
4034 need
= dgs
->len
+ l
+ 1;
4035 if (need
> dgs
->alc
)
4036 d_growable_string_resize (dgs
, need
);
4038 if (dgs
->allocation_failure
)
4041 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
4042 dgs
->buf
[dgs
->len
+ l
] = '\0';
4046 /* Bridge growable strings to the callback mechanism. */
4049 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
4051 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
4053 d_growable_string_append_buffer (dgs
, s
, l
);
4056 /* Walk the tree, counting the number of templates encountered, and
4057 the number of times a scope might be saved. These counts will be
4058 used to allocate data structures for d_print_comp, so the logic
4059 here must mirror the logic d_print_comp will use. It is not
4060 important that the resulting numbers are exact, so long as they
4061 are larger than the actual numbers encountered. */
4064 d_count_templates_scopes (int *num_templates
, int *num_scopes
,
4065 const struct demangle_component
*dc
)
4072 case DEMANGLE_COMPONENT_NAME
:
4073 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4074 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4075 case DEMANGLE_COMPONENT_SUB_STD
:
4076 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4077 case DEMANGLE_COMPONENT_OPERATOR
:
4078 case DEMANGLE_COMPONENT_CHARACTER
:
4079 case DEMANGLE_COMPONENT_NUMBER
:
4080 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4083 case DEMANGLE_COMPONENT_TEMPLATE
:
4085 goto recurse_left_right
;
4087 case DEMANGLE_COMPONENT_REFERENCE
:
4088 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4089 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4091 goto recurse_left_right
;
4093 case DEMANGLE_COMPONENT_QUAL_NAME
:
4094 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4095 case DEMANGLE_COMPONENT_TYPED_NAME
:
4096 case DEMANGLE_COMPONENT_VTABLE
:
4097 case DEMANGLE_COMPONENT_VTT
:
4098 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4099 case DEMANGLE_COMPONENT_TYPEINFO
:
4100 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4101 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4102 case DEMANGLE_COMPONENT_THUNK
:
4103 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4104 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4105 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4106 case DEMANGLE_COMPONENT_GUARD
:
4107 case DEMANGLE_COMPONENT_TLS_INIT
:
4108 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4109 case DEMANGLE_COMPONENT_REFTEMP
:
4110 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4111 case DEMANGLE_COMPONENT_RESTRICT
:
4112 case DEMANGLE_COMPONENT_VOLATILE
:
4113 case DEMANGLE_COMPONENT_CONST
:
4114 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4115 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4116 case DEMANGLE_COMPONENT_CONST_THIS
:
4117 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4118 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4119 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
4120 case DEMANGLE_COMPONENT_NOEXCEPT
:
4121 case DEMANGLE_COMPONENT_THROW_SPEC
:
4122 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4123 case DEMANGLE_COMPONENT_POINTER
:
4124 case DEMANGLE_COMPONENT_COMPLEX
:
4125 case DEMANGLE_COMPONENT_IMAGINARY
:
4126 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4127 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4128 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4129 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4130 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4131 case DEMANGLE_COMPONENT_ARGLIST
:
4132 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4133 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4134 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4135 case DEMANGLE_COMPONENT_CAST
:
4136 case DEMANGLE_COMPONENT_CONVERSION
:
4137 case DEMANGLE_COMPONENT_NULLARY
:
4138 case DEMANGLE_COMPONENT_UNARY
:
4139 case DEMANGLE_COMPONENT_BINARY
:
4140 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4141 case DEMANGLE_COMPONENT_TRINARY
:
4142 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4143 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4144 case DEMANGLE_COMPONENT_LITERAL
:
4145 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4146 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4147 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4148 case DEMANGLE_COMPONENT_DECLTYPE
:
4149 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4150 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4151 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4152 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4153 case DEMANGLE_COMPONENT_CLONE
:
4155 d_count_templates_scopes (num_templates
, num_scopes
,
4157 d_count_templates_scopes (num_templates
, num_scopes
,
4161 case DEMANGLE_COMPONENT_CTOR
:
4162 d_count_templates_scopes (num_templates
, num_scopes
,
4166 case DEMANGLE_COMPONENT_DTOR
:
4167 d_count_templates_scopes (num_templates
, num_scopes
,
4171 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4172 d_count_templates_scopes (num_templates
, num_scopes
,
4173 dc
->u
.s_extended_operator
.name
);
4176 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4177 d_count_templates_scopes (num_templates
, num_scopes
,
4178 dc
->u
.s_fixed
.length
);
4181 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4182 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4183 d_count_templates_scopes (num_templates
, num_scopes
,
4187 case DEMANGLE_COMPONENT_LAMBDA
:
4188 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4189 d_count_templates_scopes (num_templates
, num_scopes
,
4190 dc
->u
.s_unary_num
.sub
);
4195 /* Initialize a print information structure. */
4198 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
4199 void *opaque
, const struct demangle_component
*dc
)
4202 dpi
->last_char
= '\0';
4203 dpi
->templates
= NULL
;
4204 dpi
->modifiers
= NULL
;
4205 dpi
->pack_index
= 0;
4206 dpi
->flush_count
= 0;
4208 dpi
->callback
= callback
;
4209 dpi
->opaque
= opaque
;
4211 dpi
->demangle_failure
= 0;
4213 dpi
->is_lambda_arg
= 0;
4215 dpi
->component_stack
= NULL
;
4217 dpi
->saved_scopes
= NULL
;
4218 dpi
->next_saved_scope
= 0;
4219 dpi
->num_saved_scopes
= 0;
4221 dpi
->copy_templates
= NULL
;
4222 dpi
->next_copy_template
= 0;
4223 dpi
->num_copy_templates
= 0;
4225 d_count_templates_scopes (&dpi
->num_copy_templates
,
4226 &dpi
->num_saved_scopes
, dc
);
4227 dpi
->num_copy_templates
*= dpi
->num_saved_scopes
;
4229 dpi
->current_template
= NULL
;
4232 /* Indicate that an error occurred during printing, and test for error. */
4235 d_print_error (struct d_print_info
*dpi
)
4237 dpi
->demangle_failure
= 1;
4241 d_print_saw_error (struct d_print_info
*dpi
)
4243 return dpi
->demangle_failure
!= 0;
4246 /* Flush buffered characters to the callback. */
4249 d_print_flush (struct d_print_info
*dpi
)
4251 dpi
->buf
[dpi
->len
] = '\0';
4252 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
4257 /* Append characters and buffers for printing. */
4260 d_append_char (struct d_print_info
*dpi
, char c
)
4262 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
4263 d_print_flush (dpi
);
4265 dpi
->buf
[dpi
->len
++] = c
;
4270 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
4274 for (i
= 0; i
< l
; i
++)
4275 d_append_char (dpi
, s
[i
]);
4279 d_append_string (struct d_print_info
*dpi
, const char *s
)
4281 d_append_buffer (dpi
, s
, strlen (s
));
4285 d_append_num (struct d_print_info
*dpi
, int l
)
4288 sprintf (buf
,"%d", l
);
4289 d_append_string (dpi
, buf
);
4293 d_last_char (struct d_print_info
*dpi
)
4295 return dpi
->last_char
;
4298 /* Turn components into a human readable string. OPTIONS is the
4299 options bits passed to the demangler. DC is the tree to print.
4300 CALLBACK is a function to call to flush demangled string segments
4301 as they fill the intermediate buffer, and OPAQUE is a generalized
4302 callback argument. On success, this returns 1. On failure,
4303 it returns 0, indicating a bad parse. It does not use heap
4304 memory to build an output string, so cannot encounter memory
4305 allocation failure. */
4307 CP_STATIC_IF_GLIBCPP_V3
4309 cplus_demangle_print_callback (int options
,
4310 struct demangle_component
*dc
,
4311 demangle_callbackref callback
, void *opaque
)
4313 struct d_print_info dpi
;
4315 d_print_init (&dpi
, callback
, opaque
, dc
);
4318 #ifdef CP_DYNAMIC_ARRAYS
4319 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4320 and flagged as errors by Address Sanitizer. */
4321 __extension__
struct d_saved_scope scopes
[(dpi
.num_saved_scopes
> 0)
4322 ? dpi
.num_saved_scopes
: 1];
4323 __extension__
struct d_print_template temps
[(dpi
.num_copy_templates
> 0)
4324 ? dpi
.num_copy_templates
: 1];
4326 dpi
.saved_scopes
= scopes
;
4327 dpi
.copy_templates
= temps
;
4329 dpi
.saved_scopes
= alloca (dpi
.num_saved_scopes
4330 * sizeof (*dpi
.saved_scopes
));
4331 dpi
.copy_templates
= alloca (dpi
.num_copy_templates
4332 * sizeof (*dpi
.copy_templates
));
4335 d_print_comp (&dpi
, options
, dc
);
4338 d_print_flush (&dpi
);
4340 return ! d_print_saw_error (&dpi
);
4343 /* Turn components into a human readable string. OPTIONS is the
4344 options bits passed to the demangler. DC is the tree to print.
4345 ESTIMATE is a guess at the length of the result. This returns a
4346 string allocated by malloc, or NULL on error. On success, this
4347 sets *PALC to the size of the allocated buffer. On failure, this
4348 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4351 CP_STATIC_IF_GLIBCPP_V3
4353 cplus_demangle_print (int options
, struct demangle_component
*dc
,
4354 int estimate
, size_t *palc
)
4356 struct d_growable_string dgs
;
4358 d_growable_string_init (&dgs
, estimate
);
4360 if (! cplus_demangle_print_callback (options
, dc
,
4361 d_growable_string_callback_adapter
,
4369 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
4373 /* Returns the I'th element of the template arglist ARGS, or NULL on
4374 failure. If I is negative, return the entire arglist. */
4376 static struct demangle_component
*
4377 d_index_template_argument (struct demangle_component
*args
, int i
)
4379 struct demangle_component
*a
;
4382 /* Print the whole argument pack. */
4389 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4395 if (i
!= 0 || a
== NULL
)
4401 /* Returns the template argument from the current context indicated by DC,
4402 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4404 static struct demangle_component
*
4405 d_lookup_template_argument (struct d_print_info
*dpi
,
4406 const struct demangle_component
*dc
)
4408 if (dpi
->templates
== NULL
)
4410 d_print_error (dpi
);
4414 return d_index_template_argument
4415 (d_right (dpi
->templates
->template_decl
),
4416 dc
->u
.s_number
.number
);
4419 /* Returns a template argument pack used in DC (any will do), or NULL. */
4421 static struct demangle_component
*
4422 d_find_pack (struct d_print_info
*dpi
,
4423 const struct demangle_component
*dc
)
4425 struct demangle_component
*a
;
4431 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4432 a
= d_lookup_template_argument (dpi
, dc
);
4433 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4437 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4440 case DEMANGLE_COMPONENT_LAMBDA
:
4441 case DEMANGLE_COMPONENT_NAME
:
4442 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4443 case DEMANGLE_COMPONENT_OPERATOR
:
4444 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4445 case DEMANGLE_COMPONENT_SUB_STD
:
4446 case DEMANGLE_COMPONENT_CHARACTER
:
4447 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4448 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4449 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4450 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4451 case DEMANGLE_COMPONENT_NUMBER
:
4454 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4455 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
4456 case DEMANGLE_COMPONENT_CTOR
:
4457 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
4458 case DEMANGLE_COMPONENT_DTOR
:
4459 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
4462 a
= d_find_pack (dpi
, d_left (dc
));
4465 return d_find_pack (dpi
, d_right (dc
));
4469 /* Returns the length of the template argument pack DC. */
4472 d_pack_length (const struct demangle_component
*dc
)
4475 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4476 && d_left (dc
) != NULL
)
4484 /* Returns the number of template args in DC, expanding any pack expansions
4488 d_args_length (struct d_print_info
*dpi
, const struct demangle_component
*dc
)
4491 for (; dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
;
4494 struct demangle_component
*elt
= d_left (dc
);
4497 if (elt
->type
== DEMANGLE_COMPONENT_PACK_EXPANSION
)
4499 struct demangle_component
*a
= d_find_pack (dpi
, d_left (elt
));
4500 count
+= d_pack_length (a
);
4508 /* DC is a component of a mangled expression. Print it, wrapped in parens
4512 d_print_subexpr (struct d_print_info
*dpi
, int options
,
4513 struct demangle_component
*dc
)
4516 if (dc
->type
== DEMANGLE_COMPONENT_NAME
4517 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
4518 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
4519 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
4522 d_append_char (dpi
, '(');
4523 d_print_comp (dpi
, options
, dc
);
4525 d_append_char (dpi
, ')');
4528 /* Save the current scope. */
4531 d_save_scope (struct d_print_info
*dpi
,
4532 const struct demangle_component
*container
)
4534 struct d_saved_scope
*scope
;
4535 struct d_print_template
*src
, **link
;
4537 if (dpi
->next_saved_scope
>= dpi
->num_saved_scopes
)
4539 d_print_error (dpi
);
4542 scope
= &dpi
->saved_scopes
[dpi
->next_saved_scope
];
4543 dpi
->next_saved_scope
++;
4545 scope
->container
= container
;
4546 link
= &scope
->templates
;
4548 for (src
= dpi
->templates
; src
!= NULL
; src
= src
->next
)
4550 struct d_print_template
*dst
;
4552 if (dpi
->next_copy_template
>= dpi
->num_copy_templates
)
4554 d_print_error (dpi
);
4557 dst
= &dpi
->copy_templates
[dpi
->next_copy_template
];
4558 dpi
->next_copy_template
++;
4560 dst
->template_decl
= src
->template_decl
;
4568 /* Attempt to locate a previously saved scope. Returns NULL if no
4569 corresponding saved scope was found. */
4571 static struct d_saved_scope
*
4572 d_get_saved_scope (struct d_print_info
*dpi
,
4573 const struct demangle_component
*container
)
4577 for (i
= 0; i
< dpi
->next_saved_scope
; i
++)
4578 if (dpi
->saved_scopes
[i
].container
== container
)
4579 return &dpi
->saved_scopes
[i
];
4584 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4588 d_maybe_print_fold_expression (struct d_print_info
*dpi
, int options
,
4589 struct demangle_component
*dc
)
4591 struct demangle_component
*ops
, *operator_
, *op1
, *op2
;
4594 const char *fold_code
= d_left (dc
)->u
.s_operator
.op
->code
;
4595 if (fold_code
[0] != 'f')
4599 operator_
= d_left (ops
);
4600 op1
= d_right (ops
);
4602 if (op1
->type
== DEMANGLE_COMPONENT_TRINARY_ARG2
)
4604 op2
= d_right (op1
);
4608 /* Print the whole pack. */
4609 save_idx
= dpi
->pack_index
;
4610 dpi
->pack_index
= -1;
4612 switch (fold_code
[1])
4614 /* Unary left fold, (... + X). */
4616 d_append_string (dpi
, "(...");
4617 d_print_expr_op (dpi
, options
, operator_
);
4618 d_print_subexpr (dpi
, options
, op1
);
4619 d_append_char (dpi
, ')');
4622 /* Unary right fold, (X + ...). */
4624 d_append_char (dpi
, '(');
4625 d_print_subexpr (dpi
, options
, op1
);
4626 d_print_expr_op (dpi
, options
, operator_
);
4627 d_append_string (dpi
, "...)");
4630 /* Binary left fold, (42 + ... + X). */
4632 /* Binary right fold, (X + ... + 42). */
4634 d_append_char (dpi
, '(');
4635 d_print_subexpr (dpi
, options
, op1
);
4636 d_print_expr_op (dpi
, options
, operator_
);
4637 d_append_string (dpi
, "...");
4638 d_print_expr_op (dpi
, options
, operator_
);
4639 d_print_subexpr (dpi
, options
, op2
);
4640 d_append_char (dpi
, ')');
4644 dpi
->pack_index
= save_idx
;
4648 /* Subroutine to handle components. */
4651 d_print_comp_inner (struct d_print_info
*dpi
, int options
,
4652 struct demangle_component
*dc
)
4654 /* Magic variable to let reference smashing skip over the next modifier
4655 without needing to modify *dc. */
4656 struct demangle_component
*mod_inner
= NULL
;
4658 /* Variable used to store the current templates while a previously
4659 captured scope is used. */
4660 struct d_print_template
*saved_templates
;
4662 /* Nonzero if templates have been stored in the above variable. */
4663 int need_template_restore
= 0;
4667 d_print_error (dpi
);
4670 if (d_print_saw_error (dpi
))
4675 case DEMANGLE_COMPONENT_NAME
:
4676 if ((options
& DMGL_JAVA
) == 0)
4677 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4679 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4682 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4683 d_print_comp (dpi
, options
, d_left (dc
));
4684 d_append_string (dpi
, "[abi:");
4685 d_print_comp (dpi
, options
, d_right (dc
));
4686 d_append_char (dpi
, ']');
4689 case DEMANGLE_COMPONENT_QUAL_NAME
:
4690 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4691 d_print_comp (dpi
, options
, d_left (dc
));
4692 if ((options
& DMGL_JAVA
) == 0)
4693 d_append_string (dpi
, "::");
4695 d_append_char (dpi
, '.');
4697 struct demangle_component
*local_name
= d_right (dc
);
4698 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4700 d_append_string (dpi
, "{default arg#");
4701 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
4702 d_append_string (dpi
, "}::");
4703 local_name
= local_name
->u
.s_unary_num
.sub
;
4705 d_print_comp (dpi
, options
, local_name
);
4709 case DEMANGLE_COMPONENT_TYPED_NAME
:
4711 struct d_print_mod
*hold_modifiers
;
4712 struct demangle_component
*typed_name
;
4713 struct d_print_mod adpm
[4];
4715 struct d_print_template dpt
;
4717 /* Pass the name down to the type so that it can be printed in
4718 the right place for the type. We also have to pass down
4719 any CV-qualifiers, which apply to the this parameter. */
4720 hold_modifiers
= dpi
->modifiers
;
4723 typed_name
= d_left (dc
);
4724 while (typed_name
!= NULL
)
4726 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4728 d_print_error (dpi
);
4732 adpm
[i
].next
= dpi
->modifiers
;
4733 dpi
->modifiers
= &adpm
[i
];
4734 adpm
[i
].mod
= typed_name
;
4735 adpm
[i
].printed
= 0;
4736 adpm
[i
].templates
= dpi
->templates
;
4739 if (!is_fnqual_component_type (typed_name
->type
))
4742 typed_name
= d_left (typed_name
);
4745 if (typed_name
== NULL
)
4747 d_print_error (dpi
);
4751 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4752 there may be CV-qualifiers on its right argument which
4753 really apply here; this happens when parsing a class that
4754 is local to a function. */
4755 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4757 typed_name
= d_right (typed_name
);
4758 if (typed_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4759 typed_name
= typed_name
->u
.s_unary_num
.sub
;
4760 if (typed_name
== NULL
)
4762 d_print_error (dpi
);
4765 while (is_fnqual_component_type (typed_name
->type
))
4767 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4769 d_print_error (dpi
);
4773 adpm
[i
] = adpm
[i
- 1];
4774 adpm
[i
].next
= &adpm
[i
- 1];
4775 dpi
->modifiers
= &adpm
[i
];
4777 adpm
[i
- 1].mod
= typed_name
;
4778 adpm
[i
- 1].printed
= 0;
4779 adpm
[i
- 1].templates
= dpi
->templates
;
4782 typed_name
= d_left (typed_name
);
4786 /* If typed_name is a template, then it applies to the
4787 function type as well. */
4788 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4790 dpt
.next
= dpi
->templates
;
4791 dpi
->templates
= &dpt
;
4792 dpt
.template_decl
= typed_name
;
4795 d_print_comp (dpi
, options
, d_right (dc
));
4797 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4798 dpi
->templates
= dpt
.next
;
4800 /* If the modifiers didn't get printed by the type, print them
4805 if (! adpm
[i
].printed
)
4807 d_append_char (dpi
, ' ');
4808 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4812 dpi
->modifiers
= hold_modifiers
;
4817 case DEMANGLE_COMPONENT_TEMPLATE
:
4819 struct d_print_mod
*hold_dpm
;
4820 struct demangle_component
*dcl
;
4821 const struct demangle_component
*hold_current
;
4823 /* This template may need to be referenced by a cast operator
4824 contained in its subtree. */
4825 hold_current
= dpi
->current_template
;
4826 dpi
->current_template
= dc
;
4828 /* Don't push modifiers into a template definition. Doing so
4829 could give the wrong definition for a template argument.
4830 Instead, treat the template essentially as a name. */
4832 hold_dpm
= dpi
->modifiers
;
4833 dpi
->modifiers
= NULL
;
4837 if ((options
& DMGL_JAVA
) != 0
4838 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4839 && dcl
->u
.s_name
.len
== 6
4840 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4842 /* Special-case Java arrays, so that JArray<TYPE> appears
4843 instead as TYPE[]. */
4845 d_print_comp (dpi
, options
, d_right (dc
));
4846 d_append_string (dpi
, "[]");
4850 d_print_comp (dpi
, options
, dcl
);
4851 if (d_last_char (dpi
) == '<')
4852 d_append_char (dpi
, ' ');
4853 d_append_char (dpi
, '<');
4854 d_print_comp (dpi
, options
, d_right (dc
));
4855 /* Avoid generating two consecutive '>' characters, to avoid
4856 the C++ syntactic ambiguity. */
4857 if (d_last_char (dpi
) == '>')
4858 d_append_char (dpi
, ' ');
4859 d_append_char (dpi
, '>');
4862 dpi
->modifiers
= hold_dpm
;
4863 dpi
->current_template
= hold_current
;
4868 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4869 if (dpi
->is_lambda_arg
)
4871 /* Show the template parm index, as that's how g++ displays
4872 these, and future proofs us against potential
4873 '[]<typename T> (T *a, T *b) {...}'. */
4874 d_append_buffer (dpi
, "auto:", 5);
4875 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4879 struct d_print_template
*hold_dpt
;
4880 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
4882 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4883 a
= d_index_template_argument (a
, dpi
->pack_index
);
4887 d_print_error (dpi
);
4891 /* While processing this parameter, we need to pop the list
4892 of templates. This is because the template parameter may
4893 itself be a reference to a parameter of an outer
4896 hold_dpt
= dpi
->templates
;
4897 dpi
->templates
= hold_dpt
->next
;
4899 d_print_comp (dpi
, options
, a
);
4901 dpi
->templates
= hold_dpt
;
4905 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4906 d_append_string (dpi
, "template parameter object for ");
4907 d_print_comp (dpi
, options
, d_left (dc
));
4910 case DEMANGLE_COMPONENT_CTOR
:
4911 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
4914 case DEMANGLE_COMPONENT_DTOR
:
4915 d_append_char (dpi
, '~');
4916 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
4919 case DEMANGLE_COMPONENT_VTABLE
:
4920 d_append_string (dpi
, "vtable for ");
4921 d_print_comp (dpi
, options
, d_left (dc
));
4924 case DEMANGLE_COMPONENT_VTT
:
4925 d_append_string (dpi
, "VTT for ");
4926 d_print_comp (dpi
, options
, d_left (dc
));
4929 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4930 d_append_string (dpi
, "construction vtable for ");
4931 d_print_comp (dpi
, options
, d_left (dc
));
4932 d_append_string (dpi
, "-in-");
4933 d_print_comp (dpi
, options
, d_right (dc
));
4936 case DEMANGLE_COMPONENT_TYPEINFO
:
4937 d_append_string (dpi
, "typeinfo for ");
4938 d_print_comp (dpi
, options
, d_left (dc
));
4941 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4942 d_append_string (dpi
, "typeinfo name for ");
4943 d_print_comp (dpi
, options
, d_left (dc
));
4946 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4947 d_append_string (dpi
, "typeinfo fn for ");
4948 d_print_comp (dpi
, options
, d_left (dc
));
4951 case DEMANGLE_COMPONENT_THUNK
:
4952 d_append_string (dpi
, "non-virtual thunk to ");
4953 d_print_comp (dpi
, options
, d_left (dc
));
4956 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4957 d_append_string (dpi
, "virtual thunk to ");
4958 d_print_comp (dpi
, options
, d_left (dc
));
4961 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4962 d_append_string (dpi
, "covariant return thunk to ");
4963 d_print_comp (dpi
, options
, d_left (dc
));
4966 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4967 d_append_string (dpi
, "java Class for ");
4968 d_print_comp (dpi
, options
, d_left (dc
));
4971 case DEMANGLE_COMPONENT_GUARD
:
4972 d_append_string (dpi
, "guard variable for ");
4973 d_print_comp (dpi
, options
, d_left (dc
));
4976 case DEMANGLE_COMPONENT_TLS_INIT
:
4977 d_append_string (dpi
, "TLS init function for ");
4978 d_print_comp (dpi
, options
, d_left (dc
));
4981 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4982 d_append_string (dpi
, "TLS wrapper function for ");
4983 d_print_comp (dpi
, options
, d_left (dc
));
4986 case DEMANGLE_COMPONENT_REFTEMP
:
4987 d_append_string (dpi
, "reference temporary #");
4988 d_print_comp (dpi
, options
, d_right (dc
));
4989 d_append_string (dpi
, " for ");
4990 d_print_comp (dpi
, options
, d_left (dc
));
4993 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4994 d_append_string (dpi
, "hidden alias for ");
4995 d_print_comp (dpi
, options
, d_left (dc
));
4998 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4999 d_append_string (dpi
, "transaction clone for ");
5000 d_print_comp (dpi
, options
, d_left (dc
));
5003 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
5004 d_append_string (dpi
, "non-transaction clone for ");
5005 d_print_comp (dpi
, options
, d_left (dc
));
5008 case DEMANGLE_COMPONENT_SUB_STD
:
5009 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
5012 case DEMANGLE_COMPONENT_RESTRICT
:
5013 case DEMANGLE_COMPONENT_VOLATILE
:
5014 case DEMANGLE_COMPONENT_CONST
:
5016 struct d_print_mod
*pdpm
;
5018 /* When printing arrays, it's possible to have cases where the
5019 same CV-qualifier gets pushed on the stack multiple times.
5020 We only need to print it once. */
5022 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
5024 if (! pdpm
->printed
)
5026 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
5027 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
5028 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
5030 if (pdpm
->mod
->type
== dc
->type
)
5032 d_print_comp (dpi
, options
, d_left (dc
));
5040 case DEMANGLE_COMPONENT_REFERENCE
:
5041 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5043 /* Handle reference smashing: & + && = &. */
5044 struct demangle_component
*sub
= d_left (dc
);
5045 if (!dpi
->is_lambda_arg
5046 && sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
5048 struct d_saved_scope
*scope
= d_get_saved_scope (dpi
, sub
);
5049 struct demangle_component
*a
;
5053 /* This is the first time SUB has been traversed.
5054 We need to capture the current templates so
5055 they can be restored if SUB is reentered as a
5057 d_save_scope (dpi
, sub
);
5058 if (d_print_saw_error (dpi
))
5063 const struct d_component_stack
*dcse
;
5064 int found_self_or_parent
= 0;
5066 /* This traversal is reentering SUB as a substition.
5067 If we are not beneath SUB or DC in the tree then we
5068 need to restore SUB's template stack temporarily. */
5069 for (dcse
= dpi
->component_stack
; dcse
!= NULL
;
5070 dcse
= dcse
->parent
)
5074 && dcse
!= dpi
->component_stack
))
5076 found_self_or_parent
= 1;
5081 if (!found_self_or_parent
)
5083 saved_templates
= dpi
->templates
;
5084 dpi
->templates
= scope
->templates
;
5085 need_template_restore
= 1;
5089 a
= d_lookup_template_argument (dpi
, sub
);
5090 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
5091 a
= d_index_template_argument (a
, dpi
->pack_index
);
5095 if (need_template_restore
)
5096 dpi
->templates
= saved_templates
;
5098 d_print_error (dpi
);
5105 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
5106 || sub
->type
== dc
->type
)
5108 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
5109 mod_inner
= d_left (sub
);
5113 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5114 case DEMANGLE_COMPONENT_POINTER
:
5115 case DEMANGLE_COMPONENT_COMPLEX
:
5116 case DEMANGLE_COMPONENT_IMAGINARY
:
5117 FNQUAL_COMPONENT_CASE
:
5120 /* We keep a list of modifiers on the stack. */
5121 struct d_print_mod dpm
;
5123 dpm
.next
= dpi
->modifiers
;
5124 dpi
->modifiers
= &dpm
;
5127 dpm
.templates
= dpi
->templates
;
5130 mod_inner
= d_left (dc
);
5132 d_print_comp (dpi
, options
, mod_inner
);
5134 /* If the modifier didn't get printed by the type, print it
5137 d_print_mod (dpi
, options
, dc
);
5139 dpi
->modifiers
= dpm
.next
;
5141 if (need_template_restore
)
5142 dpi
->templates
= saved_templates
;
5147 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5148 if ((options
& DMGL_JAVA
) == 0)
5149 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
5150 dc
->u
.s_builtin
.type
->len
);
5152 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
5153 dc
->u
.s_builtin
.type
->java_len
);
5156 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5157 d_print_comp (dpi
, options
, d_left (dc
));
5160 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5162 if ((options
& DMGL_RET_POSTFIX
) != 0)
5163 d_print_function_type (dpi
,
5164 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5165 dc
, dpi
->modifiers
);
5167 /* Print return type if present */
5168 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
5169 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5171 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
5173 struct d_print_mod dpm
;
5175 /* We must pass this type down as a modifier in order to
5176 print it in the right location. */
5177 dpm
.next
= dpi
->modifiers
;
5178 dpi
->modifiers
= &dpm
;
5181 dpm
.templates
= dpi
->templates
;
5183 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5186 dpi
->modifiers
= dpm
.next
;
5191 /* In standard prefix notation, there is a space between the
5192 return type and the function signature. */
5193 if ((options
& DMGL_RET_POSTFIX
) == 0)
5194 d_append_char (dpi
, ' ');
5197 if ((options
& DMGL_RET_POSTFIX
) == 0)
5198 d_print_function_type (dpi
,
5199 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5200 dc
, dpi
->modifiers
);
5205 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5207 struct d_print_mod
*hold_modifiers
;
5208 struct d_print_mod adpm
[4];
5210 struct d_print_mod
*pdpm
;
5212 /* We must pass this type down as a modifier in order to print
5213 multi-dimensional arrays correctly. If the array itself is
5214 CV-qualified, we act as though the element type were
5215 CV-qualified. We do this by copying the modifiers down
5216 rather than fiddling pointers, so that we don't wind up
5217 with a d_print_mod higher on the stack pointing into our
5218 stack frame after we return. */
5220 hold_modifiers
= dpi
->modifiers
;
5222 adpm
[0].next
= hold_modifiers
;
5223 dpi
->modifiers
= &adpm
[0];
5225 adpm
[0].printed
= 0;
5226 adpm
[0].templates
= dpi
->templates
;
5229 pdpm
= hold_modifiers
;
5231 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
5232 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
5233 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
5235 if (! pdpm
->printed
)
5237 if (i
>= sizeof adpm
/ sizeof adpm
[0])
5239 d_print_error (dpi
);
5244 adpm
[i
].next
= dpi
->modifiers
;
5245 dpi
->modifiers
= &adpm
[i
];
5253 d_print_comp (dpi
, options
, d_right (dc
));
5255 dpi
->modifiers
= hold_modifiers
;
5257 if (adpm
[0].printed
)
5263 d_print_mod (dpi
, options
, adpm
[i
].mod
);
5266 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
5271 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5272 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5274 struct d_print_mod dpm
;
5276 dpm
.next
= dpi
->modifiers
;
5277 dpi
->modifiers
= &dpm
;
5280 dpm
.templates
= dpi
->templates
;
5282 d_print_comp (dpi
, options
, d_right (dc
));
5284 /* If the modifier didn't get printed by the type, print it
5287 d_print_mod (dpi
, options
, dc
);
5289 dpi
->modifiers
= dpm
.next
;
5294 case DEMANGLE_COMPONENT_FIXED_TYPE
:
5295 if (dc
->u
.s_fixed
.sat
)
5296 d_append_string (dpi
, "_Sat ");
5297 /* Don't print "int _Accum". */
5298 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
5299 != &cplus_demangle_builtin_types
['i'-'a'])
5301 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
5302 d_append_char (dpi
, ' ');
5304 if (dc
->u
.s_fixed
.accum
)
5305 d_append_string (dpi
, "_Accum");
5307 d_append_string (dpi
, "_Fract");
5310 case DEMANGLE_COMPONENT_ARGLIST
:
5311 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
5312 if (d_left (dc
) != NULL
)
5313 d_print_comp (dpi
, options
, d_left (dc
));
5314 if (d_right (dc
) != NULL
)
5317 unsigned long int flush_count
;
5318 /* Make sure ", " isn't flushed by d_append_string, otherwise
5319 dpi->len -= 2 wouldn't work. */
5320 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
5321 d_print_flush (dpi
);
5322 d_append_string (dpi
, ", ");
5324 flush_count
= dpi
->flush_count
;
5325 d_print_comp (dpi
, options
, d_right (dc
));
5326 /* If that didn't print anything (which can happen with empty
5327 template argument packs), remove the comma and space. */
5328 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
5333 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
5335 struct demangle_component
*type
= d_left (dc
);
5336 struct demangle_component
*list
= d_right (dc
);
5339 d_print_comp (dpi
, options
, type
);
5340 d_append_char (dpi
, '{');
5341 d_print_comp (dpi
, options
, list
);
5342 d_append_char (dpi
, '}');
5346 case DEMANGLE_COMPONENT_OPERATOR
:
5348 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
5351 d_append_string (dpi
, "operator");
5352 /* Add a space before new/delete. */
5353 if (IS_LOWER (op
->name
[0]))
5354 d_append_char (dpi
, ' ');
5355 /* Omit a trailing space. */
5356 if (op
->name
[len
-1] == ' ')
5358 d_append_buffer (dpi
, op
->name
, len
);
5362 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
5363 d_append_string (dpi
, "operator ");
5364 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5367 case DEMANGLE_COMPONENT_CONVERSION
:
5368 d_append_string (dpi
, "operator ");
5369 d_print_conversion (dpi
, options
, dc
);
5372 case DEMANGLE_COMPONENT_NULLARY
:
5373 d_print_expr_op (dpi
, options
, d_left (dc
));
5376 case DEMANGLE_COMPONENT_UNARY
:
5378 struct demangle_component
*op
= d_left (dc
);
5379 struct demangle_component
*operand
= d_right (dc
);
5380 const char *code
= NULL
;
5382 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5384 code
= op
->u
.s_operator
.op
->code
;
5385 if (!strcmp (code
, "ad"))
5387 /* Don't print the argument list for the address of a
5389 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
5390 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
5391 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5392 operand
= d_left (operand
);
5394 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
5396 /* This indicates a suffix operator. */
5397 operand
= d_left (operand
);
5398 d_print_subexpr (dpi
, options
, operand
);
5399 d_print_expr_op (dpi
, options
, op
);
5404 /* For sizeof..., just print the pack length. */
5405 if (code
&& !strcmp (code
, "sZ"))
5407 struct demangle_component
*a
= d_find_pack (dpi
, operand
);
5408 int len
= d_pack_length (a
);
5409 d_append_num (dpi
, len
);
5412 else if (code
&& !strcmp (code
, "sP"))
5414 int len
= d_args_length (dpi
, operand
);
5415 d_append_num (dpi
, len
);
5419 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
5420 d_print_expr_op (dpi
, options
, op
);
5423 d_append_char (dpi
, '(');
5424 d_print_cast (dpi
, options
, op
);
5425 d_append_char (dpi
, ')');
5427 if (code
&& !strcmp (code
, "gs"))
5428 /* Avoid parens after '::'. */
5429 d_print_comp (dpi
, options
, operand
);
5430 else if (code
&& !strcmp (code
, "st"))
5431 /* Always print parens for sizeof (type). */
5433 d_append_char (dpi
, '(');
5434 d_print_comp (dpi
, options
, operand
);
5435 d_append_char (dpi
, ')');
5438 d_print_subexpr (dpi
, options
, operand
);
5442 case DEMANGLE_COMPONENT_BINARY
:
5443 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
5445 d_print_error (dpi
);
5449 if (op_is_new_cast (d_left (dc
)))
5451 d_print_expr_op (dpi
, options
, d_left (dc
));
5452 d_append_char (dpi
, '<');
5453 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
5454 d_append_string (dpi
, ">(");
5455 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5456 d_append_char (dpi
, ')');
5460 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5463 /* We wrap an expression which uses the greater-than operator in
5464 an extra layer of parens so that it does not get confused
5465 with the '>' which ends the template parameters. */
5466 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5467 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5468 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5469 d_append_char (dpi
, '(');
5471 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
5472 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
5474 /* Function call used in an expression should not have printed types
5475 of the function arguments. Values of the function arguments still
5476 get printed below. */
5478 const struct demangle_component
*func
= d_left (d_right (dc
));
5480 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5481 d_print_error (dpi
);
5482 d_print_subexpr (dpi
, options
, d_left (func
));
5485 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
5486 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
5488 d_append_char (dpi
, '[');
5489 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5490 d_append_char (dpi
, ']');
5494 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
5495 d_print_expr_op (dpi
, options
, d_left (dc
));
5496 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
5499 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5500 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5501 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5502 d_append_char (dpi
, ')');
5506 case DEMANGLE_COMPONENT_BINARY_ARGS
:
5507 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5508 d_print_error (dpi
);
5511 case DEMANGLE_COMPONENT_TRINARY
:
5512 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
5513 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
5515 d_print_error (dpi
);
5518 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5521 struct demangle_component
*op
= d_left (dc
);
5522 struct demangle_component
*first
= d_left (d_right (dc
));
5523 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
5524 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
5526 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
5528 d_print_subexpr (dpi
, options
, first
);
5529 d_print_expr_op (dpi
, options
, op
);
5530 d_print_subexpr (dpi
, options
, second
);
5531 d_append_string (dpi
, " : ");
5532 d_print_subexpr (dpi
, options
, third
);
5536 d_append_string (dpi
, "new ");
5537 if (d_left (first
) != NULL
)
5539 d_print_subexpr (dpi
, options
, first
);
5540 d_append_char (dpi
, ' ');
5542 d_print_comp (dpi
, options
, second
);
5544 d_print_subexpr (dpi
, options
, third
);
5549 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
5550 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
5551 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5552 d_print_error (dpi
);
5555 case DEMANGLE_COMPONENT_LITERAL
:
5556 case DEMANGLE_COMPONENT_LITERAL_NEG
:
5558 enum d_builtin_type_print tp
;
5560 /* For some builtin types, produce simpler output. */
5561 tp
= D_PRINT_DEFAULT
;
5562 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
5564 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
5568 case D_PRINT_UNSIGNED
:
5570 case D_PRINT_UNSIGNED_LONG
:
5571 case D_PRINT_LONG_LONG
:
5572 case D_PRINT_UNSIGNED_LONG_LONG
:
5573 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
5575 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5576 d_append_char (dpi
, '-');
5577 d_print_comp (dpi
, options
, d_right (dc
));
5582 case D_PRINT_UNSIGNED
:
5583 d_append_char (dpi
, 'u');
5586 d_append_char (dpi
, 'l');
5588 case D_PRINT_UNSIGNED_LONG
:
5589 d_append_string (dpi
, "ul");
5591 case D_PRINT_LONG_LONG
:
5592 d_append_string (dpi
, "ll");
5594 case D_PRINT_UNSIGNED_LONG_LONG
:
5595 d_append_string (dpi
, "ull");
5603 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
5604 && d_right (dc
)->u
.s_name
.len
== 1
5605 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
5607 switch (d_right (dc
)->u
.s_name
.s
[0])
5610 d_append_string (dpi
, "false");
5613 d_append_string (dpi
, "true");
5626 d_append_char (dpi
, '(');
5627 d_print_comp (dpi
, options
, d_left (dc
));
5628 d_append_char (dpi
, ')');
5629 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5630 d_append_char (dpi
, '-');
5631 if (tp
== D_PRINT_FLOAT
)
5632 d_append_char (dpi
, '[');
5633 d_print_comp (dpi
, options
, d_right (dc
));
5634 if (tp
== D_PRINT_FLOAT
)
5635 d_append_char (dpi
, ']');
5639 case DEMANGLE_COMPONENT_NUMBER
:
5640 d_append_num (dpi
, dc
->u
.s_number
.number
);
5643 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
5644 d_append_string (dpi
, "java resource ");
5645 d_print_comp (dpi
, options
, d_left (dc
));
5648 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
5649 d_print_comp (dpi
, options
, d_left (dc
));
5650 d_print_comp (dpi
, options
, d_right (dc
));
5653 case DEMANGLE_COMPONENT_CHARACTER
:
5654 d_append_char (dpi
, dc
->u
.s_character
.character
);
5657 case DEMANGLE_COMPONENT_DECLTYPE
:
5658 d_append_string (dpi
, "decltype (");
5659 d_print_comp (dpi
, options
, d_left (dc
));
5660 d_append_char (dpi
, ')');
5663 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
5667 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
5670 /* d_find_pack won't find anything if the only packs involved
5671 in this expansion are function parameter packs; in that
5672 case, just print the pattern and "...". */
5673 d_print_subexpr (dpi
, options
, d_left (dc
));
5674 d_append_string (dpi
, "...");
5678 len
= d_pack_length (a
);
5680 for (i
= 0; i
< len
; ++i
)
5682 dpi
->pack_index
= i
;
5683 d_print_comp (dpi
, options
, dc
);
5685 d_append_string (dpi
, ", ");
5690 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
5692 long num
= dc
->u
.s_number
.number
;
5694 d_append_string (dpi
, "this");
5697 d_append_string (dpi
, "{parm#");
5698 d_append_num (dpi
, num
);
5699 d_append_char (dpi
, '}');
5704 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
5705 d_append_string (dpi
, "global constructors keyed to ");
5706 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5709 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
5710 d_append_string (dpi
, "global destructors keyed to ");
5711 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5714 case DEMANGLE_COMPONENT_LAMBDA
:
5715 d_append_string (dpi
, "{lambda(");
5716 /* Generic lambda auto parms are mangled as the template type
5718 dpi
->is_lambda_arg
++;
5719 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
5720 dpi
->is_lambda_arg
--;
5721 d_append_string (dpi
, ")#");
5722 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5723 d_append_char (dpi
, '}');
5726 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
5727 d_append_string (dpi
, "{unnamed type#");
5728 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5729 d_append_char (dpi
, '}');
5732 case DEMANGLE_COMPONENT_CLONE
:
5733 d_print_comp (dpi
, options
, d_left (dc
));
5734 d_append_string (dpi
, " [clone ");
5735 d_print_comp (dpi
, options
, d_right (dc
));
5736 d_append_char (dpi
, ']');
5740 d_print_error (dpi
);
5746 d_print_comp (struct d_print_info
*dpi
, int options
,
5747 struct demangle_component
*dc
)
5749 struct d_component_stack self
;
5750 if (dc
== NULL
|| dc
->d_printing
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
5752 d_print_error (dpi
);
5760 self
.parent
= dpi
->component_stack
;
5761 dpi
->component_stack
= &self
;
5763 d_print_comp_inner (dpi
, options
, dc
);
5765 dpi
->component_stack
= self
.parent
;
5770 /* Print a Java dentifier. For Java we try to handle encoded extended
5771 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5772 so we don't it for C++. Characters are encoded as
5776 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
5782 for (p
= name
; p
< end
; ++p
)
5793 for (q
= p
+ 3; q
< end
; ++q
)
5799 else if (*q
>= 'A' && *q
<= 'F')
5800 dig
= *q
- 'A' + 10;
5801 else if (*q
>= 'a' && *q
<= 'f')
5802 dig
= *q
- 'a' + 10;
5808 /* If the Unicode character is larger than 256, we don't try
5809 to deal with it here. FIXME. */
5810 if (q
< end
&& *q
== '_' && c
< 256)
5812 d_append_char (dpi
, c
);
5818 d_append_char (dpi
, *p
);
5822 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5823 qualifiers on this after printing a function. */
5826 d_print_mod_list (struct d_print_info
*dpi
, int options
,
5827 struct d_print_mod
*mods
, int suffix
)
5829 struct d_print_template
*hold_dpt
;
5831 if (mods
== NULL
|| d_print_saw_error (dpi
))
5836 && (is_fnqual_component_type (mods
->mod
->type
))))
5838 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5844 hold_dpt
= dpi
->templates
;
5845 dpi
->templates
= mods
->templates
;
5847 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5849 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
5850 dpi
->templates
= hold_dpt
;
5853 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5855 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
5856 dpi
->templates
= hold_dpt
;
5859 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
5861 struct d_print_mod
*hold_modifiers
;
5862 struct demangle_component
*dc
;
5864 /* When this is on the modifier stack, we have pulled any
5865 qualifiers off the right argument already. Otherwise, we
5866 print it as usual, but don't let the left argument see any
5869 hold_modifiers
= dpi
->modifiers
;
5870 dpi
->modifiers
= NULL
;
5871 d_print_comp (dpi
, options
, d_left (mods
->mod
));
5872 dpi
->modifiers
= hold_modifiers
;
5874 if ((options
& DMGL_JAVA
) == 0)
5875 d_append_string (dpi
, "::");
5877 d_append_char (dpi
, '.');
5879 dc
= d_right (mods
->mod
);
5881 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
5883 d_append_string (dpi
, "{default arg#");
5884 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5885 d_append_string (dpi
, "}::");
5886 dc
= dc
->u
.s_unary_num
.sub
;
5889 while (is_fnqual_component_type (dc
->type
))
5892 d_print_comp (dpi
, options
, dc
);
5894 dpi
->templates
= hold_dpt
;
5898 d_print_mod (dpi
, options
, mods
->mod
);
5900 dpi
->templates
= hold_dpt
;
5902 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5905 /* Print a modifier. */
5908 d_print_mod (struct d_print_info
*dpi
, int options
,
5909 struct demangle_component
*mod
)
5913 case DEMANGLE_COMPONENT_RESTRICT
:
5914 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5915 d_append_string (dpi
, " restrict");
5917 case DEMANGLE_COMPONENT_VOLATILE
:
5918 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5919 d_append_string (dpi
, " volatile");
5921 case DEMANGLE_COMPONENT_CONST
:
5922 case DEMANGLE_COMPONENT_CONST_THIS
:
5923 d_append_string (dpi
, " const");
5925 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
5926 d_append_string (dpi
, " transaction_safe");
5928 case DEMANGLE_COMPONENT_NOEXCEPT
:
5929 d_append_string (dpi
, " noexcept");
5932 d_append_char (dpi
, '(');
5933 d_print_comp (dpi
, options
, d_right (mod
));
5934 d_append_char (dpi
, ')');
5937 case DEMANGLE_COMPONENT_THROW_SPEC
:
5938 d_append_string (dpi
, " throw");
5941 d_append_char (dpi
, '(');
5942 d_print_comp (dpi
, options
, d_right (mod
));
5943 d_append_char (dpi
, ')');
5946 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5947 d_append_char (dpi
, ' ');
5948 d_print_comp (dpi
, options
, d_right (mod
));
5950 case DEMANGLE_COMPONENT_POINTER
:
5951 /* There is no pointer symbol in Java. */
5952 if ((options
& DMGL_JAVA
) == 0)
5953 d_append_char (dpi
, '*');
5955 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5956 /* For the ref-qualifier, put a space before the &. */
5957 d_append_char (dpi
, ' ');
5959 case DEMANGLE_COMPONENT_REFERENCE
:
5960 d_append_char (dpi
, '&');
5962 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5963 d_append_char (dpi
, ' ');
5965 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5966 d_append_string (dpi
, "&&");
5968 case DEMANGLE_COMPONENT_COMPLEX
:
5969 d_append_string (dpi
, "complex ");
5971 case DEMANGLE_COMPONENT_IMAGINARY
:
5972 d_append_string (dpi
, "imaginary ");
5974 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5975 if (d_last_char (dpi
) != '(')
5976 d_append_char (dpi
, ' ');
5977 d_print_comp (dpi
, options
, d_left (mod
));
5978 d_append_string (dpi
, "::*");
5980 case DEMANGLE_COMPONENT_TYPED_NAME
:
5981 d_print_comp (dpi
, options
, d_left (mod
));
5983 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5984 d_append_string (dpi
, " __vector(");
5985 d_print_comp (dpi
, options
, d_left (mod
));
5986 d_append_char (dpi
, ')');
5990 /* Otherwise, we have something that won't go back on the
5991 modifier stack, so we can just print it. */
5992 d_print_comp (dpi
, options
, mod
);
5997 /* Print a function type, except for the return type. */
6000 d_print_function_type (struct d_print_info
*dpi
, int options
,
6001 struct demangle_component
*dc
,
6002 struct d_print_mod
*mods
)
6006 struct d_print_mod
*p
;
6007 struct d_print_mod
*hold_modifiers
;
6011 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6016 switch (p
->mod
->type
)
6018 case DEMANGLE_COMPONENT_POINTER
:
6019 case DEMANGLE_COMPONENT_REFERENCE
:
6020 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
6023 case DEMANGLE_COMPONENT_RESTRICT
:
6024 case DEMANGLE_COMPONENT_VOLATILE
:
6025 case DEMANGLE_COMPONENT_CONST
:
6026 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
6027 case DEMANGLE_COMPONENT_COMPLEX
:
6028 case DEMANGLE_COMPONENT_IMAGINARY
:
6029 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6033 FNQUAL_COMPONENT_CASE
:
6046 if (d_last_char (dpi
) != '('
6047 && d_last_char (dpi
) != '*')
6050 if (need_space
&& d_last_char (dpi
) != ' ')
6051 d_append_char (dpi
, ' ');
6052 d_append_char (dpi
, '(');
6055 hold_modifiers
= dpi
->modifiers
;
6056 dpi
->modifiers
= NULL
;
6058 d_print_mod_list (dpi
, options
, mods
, 0);
6061 d_append_char (dpi
, ')');
6063 d_append_char (dpi
, '(');
6065 if (d_right (dc
) != NULL
)
6066 d_print_comp (dpi
, options
, d_right (dc
));
6068 d_append_char (dpi
, ')');
6070 d_print_mod_list (dpi
, options
, mods
, 1);
6072 dpi
->modifiers
= hold_modifiers
;
6075 /* Print an array type, except for the element type. */
6078 d_print_array_type (struct d_print_info
*dpi
, int options
,
6079 struct demangle_component
*dc
,
6080 struct d_print_mod
*mods
)
6088 struct d_print_mod
*p
;
6091 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6095 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
6110 d_append_string (dpi
, " (");
6112 d_print_mod_list (dpi
, options
, mods
, 0);
6115 d_append_char (dpi
, ')');
6119 d_append_char (dpi
, ' ');
6121 d_append_char (dpi
, '[');
6123 if (d_left (dc
) != NULL
)
6124 d_print_comp (dpi
, options
, d_left (dc
));
6126 d_append_char (dpi
, ']');
6129 /* Print an operator in an expression. */
6132 d_print_expr_op (struct d_print_info
*dpi
, int options
,
6133 struct demangle_component
*dc
)
6135 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
6136 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
6137 dc
->u
.s_operator
.op
->len
);
6139 d_print_comp (dpi
, options
, dc
);
6145 d_print_cast (struct d_print_info
*dpi
, int options
,
6146 struct demangle_component
*dc
)
6148 d_print_comp (dpi
, options
, d_left (dc
));
6151 /* Print a conversion operator. */
6154 d_print_conversion (struct d_print_info
*dpi
, int options
,
6155 struct demangle_component
*dc
)
6157 struct d_print_template dpt
;
6159 /* For a conversion operator, we need the template parameters from
6160 the enclosing template in scope for processing the type. */
6161 if (dpi
->current_template
!= NULL
)
6163 dpt
.next
= dpi
->templates
;
6164 dpi
->templates
= &dpt
;
6165 dpt
.template_decl
= dpi
->current_template
;
6168 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
6170 d_print_comp (dpi
, options
, d_left (dc
));
6171 if (dpi
->current_template
!= NULL
)
6172 dpi
->templates
= dpt
.next
;
6176 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
6178 /* For a templated cast operator, we need to remove the template
6179 parameters from scope after printing the operator name,
6180 so we need to handle the template printing here. */
6181 if (dpi
->current_template
!= NULL
)
6182 dpi
->templates
= dpt
.next
;
6184 if (d_last_char (dpi
) == '<')
6185 d_append_char (dpi
, ' ');
6186 d_append_char (dpi
, '<');
6187 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
6188 /* Avoid generating two consecutive '>' characters, to avoid
6189 the C++ syntactic ambiguity. */
6190 if (d_last_char (dpi
) == '>')
6191 d_append_char (dpi
, ' ');
6192 d_append_char (dpi
, '>');
6196 /* Initialize the information structure we use to pass around
6199 CP_STATIC_IF_GLIBCPP_V3
6201 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
6205 di
->send
= mangled
+ len
;
6206 di
->options
= options
;
6210 /* We cannot need more components than twice the number of chars in
6211 the mangled string. Most components correspond directly to
6212 chars, but the ARGLIST types are exceptions. */
6213 di
->num_comps
= 2 * len
;
6216 /* Similarly, we cannot need more substitutions than there are
6217 chars in the mangled string. */
6221 di
->last_name
= NULL
;
6224 di
->is_expression
= 0;
6225 di
->is_conversion
= 0;
6226 di
->recursion_level
= 0;
6229 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6230 mangled name, return strings in repeated callback giving the demangled
6231 name. OPTIONS is the usual libiberty demangler options. On success,
6232 this returns 1. On failure, returns 0. */
6235 d_demangle_callback (const char *mangled
, int options
,
6236 demangle_callbackref callback
, void *opaque
)
6247 struct demangle_component
*dc
;
6250 if (mangled
[0] == '_' && mangled
[1] == 'Z')
6252 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
6253 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
6254 && (mangled
[9] == 'D' || mangled
[9] == 'I')
6255 && mangled
[10] == '_')
6256 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
6259 if ((options
& DMGL_TYPES
) == 0)
6264 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
6266 /* PR 87675 - Check for a mangled string that is so long
6267 that we do not have enough stack space to demangle it. */
6268 if (((options
& DMGL_NO_RECURSE_LIMIT
) == 0)
6269 /* This check is a bit arbitrary, since what we really want to do is to
6270 compare the sizes of the di.comps and di.subs arrays against the
6271 amount of stack space remaining. But there is no portable way to do
6272 this, so instead we use the recursion limit as a guide to the maximum
6273 size of the arrays. */
6274 && (unsigned long) di
.num_comps
> DEMANGLE_RECURSION_LIMIT
)
6276 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6281 #ifdef CP_DYNAMIC_ARRAYS
6282 __extension__
struct demangle_component comps
[di
.num_comps
];
6283 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6288 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6289 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6295 dc
= cplus_demangle_type (&di
);
6298 dc
= cplus_demangle_mangled_name (&di
, 1);
6300 case DCT_GLOBAL_CTORS
:
6301 case DCT_GLOBAL_DTORS
:
6302 d_advance (&di
, 11);
6303 dc
= d_make_comp (&di
,
6304 (type
== DCT_GLOBAL_CTORS
6305 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6306 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
6307 d_make_demangle_mangled_name (&di
, d_str (&di
)),
6309 d_advance (&di
, strlen (d_str (&di
)));
6312 abort (); /* We have listed all the cases. */
6315 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6316 mangled string, then we didn't successfully demangle it. If
6317 DMGL_PARAMS is not set, we didn't look at the trailing
6319 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
6322 #ifdef CP_DEMANGLE_DEBUG
6326 status
= (dc
!= NULL
)
6327 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
6334 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6335 name, return a buffer allocated with malloc holding the demangled
6336 name. OPTIONS is the usual libiberty demangler options. On
6337 success, this sets *PALC to the allocated size of the returned
6338 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6339 a memory allocation failure, and returns NULL. */
6342 d_demangle (const char *mangled
, int options
, size_t *palc
)
6344 struct d_growable_string dgs
;
6347 d_growable_string_init (&dgs
, 0);
6349 status
= d_demangle_callback (mangled
, options
,
6350 d_growable_string_callback_adapter
, &dgs
);
6358 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
6362 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6364 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6366 /* ia64 ABI-mandated entry point in the C++ runtime library for
6367 performing demangling. MANGLED_NAME is a NUL-terminated character
6368 string containing the name to be demangled.
6370 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6371 *LENGTH bytes, into which the demangled name is stored. If
6372 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6373 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6374 is placed in a region of memory allocated with malloc.
6376 If LENGTH is non-NULL, the length of the buffer containing the
6377 demangled name, is placed in *LENGTH.
6379 The return value is a pointer to the start of the NUL-terminated
6380 demangled name, or NULL if the demangling fails. The caller is
6381 responsible for deallocating this memory using free.
6383 *STATUS is set to one of the following values:
6384 0: The demangling operation succeeded.
6385 -1: A memory allocation failure occurred.
6386 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6387 -3: One of the arguments is invalid.
6389 The demangling is performed using the C++ ABI mangling rules, with
6393 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
6394 size_t *length
, int *status
)
6399 if (mangled_name
== NULL
)
6406 if (output_buffer
!= NULL
&& length
== NULL
)
6413 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
6415 if (demangled
== NULL
)
6427 if (output_buffer
== NULL
)
6434 if (strlen (demangled
) < *length
)
6436 strcpy (output_buffer
, demangled
);
6438 demangled
= output_buffer
;
6442 free (output_buffer
);
6453 extern int __gcclibcxx_demangle_callback (const char *,
6455 (const char *, size_t, void *),
6458 /* Alternative, allocationless entry point in the C++ runtime library
6459 for performing demangling. MANGLED_NAME is a NUL-terminated character
6460 string containing the name to be demangled.
6462 CALLBACK is a callback function, called with demangled string
6463 segments as demangling progresses; it is called at least once,
6464 but may be called more than once. OPAQUE is a generalized pointer
6465 used as a callback argument.
6467 The return code is one of the following values, equivalent to
6468 the STATUS values of __cxa_demangle() (excluding -1, since this
6469 function performs no memory allocations):
6470 0: The demangling operation succeeded.
6471 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6472 -3: One of the arguments is invalid.
6474 The demangling is performed using the C++ ABI mangling rules, with
6478 __gcclibcxx_demangle_callback (const char *mangled_name
,
6479 void (*callback
) (const char *, size_t, void *),
6484 if (mangled_name
== NULL
|| callback
== NULL
)
6487 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
6495 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6497 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6498 mangled name, return a buffer allocated with malloc holding the
6499 demangled name. Otherwise, return NULL. */
6502 cplus_demangle_v3 (const char *mangled
, int options
)
6506 return d_demangle (mangled
, options
, &alc
);
6510 cplus_demangle_v3_callback (const char *mangled
, int options
,
6511 demangle_callbackref callback
, void *opaque
)
6513 return d_demangle_callback (mangled
, options
, callback
, opaque
);
6516 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6517 conventions, but the output formatting is a little different.
6518 This instructs the C++ demangler not to emit pointer characters ("*"), to
6519 use Java's namespace separator symbol ("." instead of "::"), and to output
6520 JArray<TYPE> as TYPE[]. */
6523 java_demangle_v3 (const char *mangled
)
6527 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
6531 java_demangle_v3_callback (const char *mangled
,
6532 demangle_callbackref callback
, void *opaque
)
6534 return d_demangle_callback (mangled
,
6535 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
6539 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6541 #ifndef IN_GLIBCPP_V3
6543 /* Demangle a string in order to find out whether it is a constructor
6544 or destructor. Return non-zero on success. Set *CTOR_KIND and
6545 *DTOR_KIND appropriately. */
6548 is_ctor_or_dtor (const char *mangled
,
6549 enum gnu_v3_ctor_kinds
*ctor_kind
,
6550 enum gnu_v3_dtor_kinds
*dtor_kind
)
6553 struct demangle_component
*dc
;
6556 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
6557 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
6559 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
6562 #ifdef CP_DYNAMIC_ARRAYS
6563 __extension__
struct demangle_component comps
[di
.num_comps
];
6564 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6569 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6570 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6573 dc
= cplus_demangle_mangled_name (&di
, 1);
6575 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6576 to demangle the entire string. */
6583 /* These cannot appear on a constructor or destructor. */
6584 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6585 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6586 case DEMANGLE_COMPONENT_CONST_THIS
:
6587 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6588 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6592 case DEMANGLE_COMPONENT_TYPED_NAME
:
6593 case DEMANGLE_COMPONENT_TEMPLATE
:
6596 case DEMANGLE_COMPONENT_QUAL_NAME
:
6597 case DEMANGLE_COMPONENT_LOCAL_NAME
:
6600 case DEMANGLE_COMPONENT_CTOR
:
6601 *ctor_kind
= dc
->u
.s_ctor
.kind
;
6605 case DEMANGLE_COMPONENT_DTOR
:
6606 *dtor_kind
= dc
->u
.s_dtor
.kind
;
6617 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6618 name. A non-zero return indicates the type of constructor. */
6620 enum gnu_v3_ctor_kinds
6621 is_gnu_v3_mangled_ctor (const char *name
)
6623 enum gnu_v3_ctor_kinds ctor_kind
;
6624 enum gnu_v3_dtor_kinds dtor_kind
;
6626 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6627 return (enum gnu_v3_ctor_kinds
) 0;
6632 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6633 name. A non-zero return indicates the type of destructor. */
6635 enum gnu_v3_dtor_kinds
6636 is_gnu_v3_mangled_dtor (const char *name
)
6638 enum gnu_v3_ctor_kinds ctor_kind
;
6639 enum gnu_v3_dtor_kinds dtor_kind
;
6641 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6642 return (enum gnu_v3_dtor_kinds
) 0;
6646 #endif /* IN_GLIBCPP_V3 */
6648 #ifdef STANDALONE_DEMANGLER
6651 #include "dyn-string.h"
6653 static void print_usage (FILE* fp
, int exit_value
);
6655 #define IS_ALPHA(CHAR) \
6656 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6657 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6659 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6660 #define is_mangled_char(CHAR) \
6661 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6662 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6664 /* The name of this program, as invoked. */
6665 const char* program_name
;
6667 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6670 print_usage (FILE* fp
, int exit_value
)
6672 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
6673 fprintf (fp
, "Options:\n");
6674 fprintf (fp
, " -h,--help Display this message.\n");
6675 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
6676 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
6677 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6682 /* Option specification for getopt_long. */
6683 static const struct option long_options
[] =
6685 { "help", no_argument
, NULL
, 'h' },
6686 { "no-params", no_argument
, NULL
, 'p' },
6687 { "verbose", no_argument
, NULL
, 'v' },
6688 { NULL
, no_argument
, NULL
, 0 },
6691 /* Main entry for a demangling filter executable. It will demangle
6692 its command line arguments, if any. If none are provided, it will
6693 filter stdin to stdout, replacing any recognized mangled C++ names
6694 with their demangled equivalents. */
6697 main (int argc
, char *argv
[])
6701 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
6703 /* Use the program name of this program, as invoked. */
6704 program_name
= argv
[0];
6706 /* Parse options. */
6709 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
6712 case '?': /* Unrecognized option. */
6713 print_usage (stderr
, 1);
6717 print_usage (stdout
, 0);
6721 options
&= ~ DMGL_PARAMS
;
6725 options
|= DMGL_VERBOSE
;
6729 while (opt_char
!= -1);
6732 /* No command line arguments were provided. Filter stdin. */
6734 dyn_string_t mangled
= dyn_string_new (3);
6737 /* Read all of input. */
6738 while (!feof (stdin
))
6742 /* Pile characters into mangled until we hit one that can't
6743 occur in a mangled name. */
6745 while (!feof (stdin
) && is_mangled_char (c
))
6747 dyn_string_append_char (mangled
, c
);
6753 if (dyn_string_length (mangled
) > 0)
6755 #ifdef IN_GLIBCPP_V3
6756 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
6758 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
6768 /* It might not have been a mangled name. Print the
6770 fputs (dyn_string_buf (mangled
), stdout
);
6773 dyn_string_clear (mangled
);
6776 /* If we haven't hit EOF yet, we've read one character that
6777 can't occur in a mangled name, so print it out. */
6782 dyn_string_delete (mangled
);
6785 /* Demangle command line arguments. */
6787 /* Loop over command line arguments. */
6788 for (i
= optind
; i
< argc
; ++i
)
6791 #ifdef IN_GLIBCPP_V3
6795 /* Attempt to demangle. */
6796 #ifdef IN_GLIBCPP_V3
6797 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
6799 s
= cplus_demangle_v3 (argv
[i
], options
);
6802 /* If it worked, print the demangled name. */
6810 #ifdef IN_GLIBCPP_V3
6811 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
6813 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
6822 #endif /* STANDALONE_DEMANGLER */