1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@wasabisystems.com>.
6 This file is part of the libiberty library, which is part of GCC.
8 This file is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 In addition to the permissions in the GNU General Public License, the
14 Free Software Foundation gives you unlimited permission to link the
15 compiled version of this file into combinations with other programs,
16 and to distribute those combinations without any restriction coming
17 from the use of this file. (The General Public License restrictions
18 do apply in other respects; for example, they cover modification of
19 the file, and distribution when not linked into a combined
22 This program is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
32 /* This code implements a demangler for the g++ V3 ABI. The ABI is
33 described on this web page:
34 http://www.codesourcery.com/cxx-abi/abi.html#mangling
36 This code was written while looking at the demangler written by
37 Alex Samuel <samuel@codesourcery.com>.
39 This code first pulls the mangled name apart into a list of
40 components, and then walks the list generating the demangled
43 This file will normally define the following functions, q.v.:
44 char *cplus_demangle_v3(const char *mangled, int options)
45 char *java_demangle_v3(const char *mangled)
46 int cplus_demangle_v3_callback(const char *mangled, int options,
47 demangle_callbackref callback)
48 int java_demangle_v3_callback(const char *mangled,
49 demangle_callbackref callback)
50 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
51 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
53 Also, the interface to the component list is public, and defined in
54 demangle.h. The interface consists of these types, which are
55 defined in demangle.h:
56 enum demangle_component_type
57 struct demangle_component
59 and these functions defined in this file:
60 cplus_demangle_fill_name
61 cplus_demangle_fill_extended_operator
62 cplus_demangle_fill_ctor
63 cplus_demangle_fill_dtor
65 cplus_demangle_print_callback
66 and other functions defined in the file cp-demint.c.
68 This file also defines some other functions and variables which are
69 only to be used by the file cp-demint.c.
71 Preprocessor macros you can define while compiling this file:
74 If defined, this file defines the following functions, q.v.:
75 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
77 int __gcclibcxx_demangle_callback (const char *,
79 (const char *, size_t, void *),
81 instead of cplus_demangle_v3[_callback]() and
82 java_demangle_v3[_callback]().
85 If defined, this file defines only __cxa_demangle() and
86 __gcclibcxx_demangle_callback(), and no other publically visible
87 functions or variables.
90 If defined, this file defines a main() function which demangles
91 any arguments, or, if none, demangles stdin.
94 If defined, turns on debugging mode, which prints information on
95 stdout about the mangled string. This is not generally useful.
98 #if defined (_AIX) && !defined (__GNUC__)
120 # define alloca __builtin_alloca
122 extern char *alloca ();
123 # endif /* __GNUC__ */
125 #endif /* HAVE_ALLOCA_H */
127 #include "ansidecl.h"
128 #include "libiberty.h"
129 #include "demangle.h"
130 #include "cp-demangle.h"
132 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
133 also rename them via #define to avoid compiler errors when the
134 static definition conflicts with the extern declaration in a header
138 #define CP_STATIC_IF_GLIBCPP_V3 static
140 #define cplus_demangle_fill_name d_fill_name
141 static int d_fill_name (struct demangle_component
*, const char *, int);
143 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
145 d_fill_extended_operator (struct demangle_component
*, int,
146 struct demangle_component
*);
148 #define cplus_demangle_fill_ctor d_fill_ctor
150 d_fill_ctor (struct demangle_component
*, enum gnu_v3_ctor_kinds
,
151 struct demangle_component
*);
153 #define cplus_demangle_fill_dtor d_fill_dtor
155 d_fill_dtor (struct demangle_component
*, enum gnu_v3_dtor_kinds
,
156 struct demangle_component
*);
158 #define cplus_demangle_mangled_name d_mangled_name
159 static struct demangle_component
*d_mangled_name (struct d_info
*, int);
161 #define cplus_demangle_type d_type
162 static struct demangle_component
*d_type (struct d_info
*);
164 #define cplus_demangle_print d_print
165 static char *d_print (int, const struct demangle_component
*, int, size_t *);
167 #define cplus_demangle_print_callback d_print_callback
168 static int d_print_callback (int, const struct demangle_component
*,
169 demangle_callbackref
, void *);
171 #define cplus_demangle_init_info d_init_info
172 static void d_init_info (const char *, int, size_t, struct d_info
*);
174 #else /* ! defined(IN_GLIBCPP_V3) */
175 #define CP_STATIC_IF_GLIBCPP_V3
176 #endif /* ! defined(IN_GLIBCPP_V3) */
178 /* See if the compiler supports dynamic arrays. */
181 #define CP_DYNAMIC_ARRAYS
184 #ifdef __STDC_VERSION__
185 #if __STDC_VERSION__ >= 199901L
186 #define CP_DYNAMIC_ARRAYS
187 #endif /* __STDC__VERSION >= 199901L */
188 #endif /* defined (__STDC_VERSION__) */
189 #endif /* defined (__STDC__) */
190 #endif /* ! defined (__GNUC__) */
192 /* We avoid pulling in the ctype tables, to prevent pulling in
193 additional unresolved symbols when this code is used in a library.
194 FIXME: Is this really a valid reason? This comes from the original
197 As of this writing this file has the following undefined references
198 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
201 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
202 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
203 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
205 /* The prefix prepended by GCC to an identifier represnting the
206 anonymous namespace. */
207 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
208 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
209 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
211 /* Information we keep for the standard substitutions. */
213 struct d_standard_sub_info
215 /* The code for this substitution. */
217 /* The simple string it expands to. */
218 const char *simple_expansion
;
219 /* The length of the simple expansion. */
221 /* The results of a full, verbose, expansion. This is used when
222 qualifying a constructor/destructor, or when in verbose mode. */
223 const char *full_expansion
;
224 /* The length of the full expansion. */
226 /* What to set the last_name field of d_info to; NULL if we should
227 not set it. This is only relevant when qualifying a
228 constructor/destructor. */
229 const char *set_last_name
;
230 /* The length of set_last_name. */
231 int set_last_name_len
;
234 /* Accessors for subtrees of struct demangle_component. */
236 #define d_left(dc) ((dc)->u.s_binary.left)
237 #define d_right(dc) ((dc)->u.s_binary.right)
239 /* A list of templates. This is used while printing. */
241 struct d_print_template
243 /* Next template on the list. */
244 struct d_print_template
*next
;
246 const struct demangle_component
*template_decl
;
249 /* A list of type modifiers. This is used while printing. */
253 /* Next modifier on the list. These are in the reverse of the order
254 in which they appeared in the mangled string. */
255 struct d_print_mod
*next
;
257 const struct demangle_component
*mod
;
258 /* Whether this modifier was printed. */
260 /* The list of templates which applies to this modifier. */
261 struct d_print_template
*templates
;
264 /* We use these structures to hold information during printing. */
266 struct d_growable_string
268 /* Buffer holding the result. */
270 /* Current length of data in buffer. */
272 /* Allocated size of buffer. */
274 /* Set to 1 if we had a memory allocation failure. */
275 int allocation_failure
;
278 enum { D_PRINT_BUFFER_LENGTH
= 256 };
281 /* Fixed-length allocated buffer for demangled data, flushed to the
282 callback with a NUL termination once full. */
283 char buf
[D_PRINT_BUFFER_LENGTH
];
284 /* Current length of data in buffer. */
286 /* The last character printed, saved individually so that it survives
289 /* Callback function to handle demangled buffer flush. */
290 demangle_callbackref callback
;
291 /* Opaque callback argument. */
293 /* The current list of templates, if any. */
294 struct d_print_template
*templates
;
295 /* The current list of modifiers (e.g., pointer, reference, etc.),
297 struct d_print_mod
*modifiers
;
298 /* Set to 1 if we saw a demangling error. */
299 int demangle_failure
;
300 /* The current index into any template argument packs we are using
303 /* Number of d_print_flush calls so far. */
304 unsigned long int flush_count
;
307 #ifdef CP_DEMANGLE_DEBUG
308 static void d_dump (struct demangle_component
*, int);
311 static struct demangle_component
*
312 d_make_empty (struct d_info
*);
314 static struct demangle_component
*
315 d_make_comp (struct d_info
*, enum demangle_component_type
,
316 struct demangle_component
*,
317 struct demangle_component
*);
319 static struct demangle_component
*
320 d_make_name (struct d_info
*, const char *, int);
322 static struct demangle_component
*
323 d_make_demangle_mangled_name (struct d_info
*, const char *);
325 static struct demangle_component
*
326 d_make_builtin_type (struct d_info
*,
327 const struct demangle_builtin_type_info
*);
329 static struct demangle_component
*
330 d_make_operator (struct d_info
*,
331 const struct demangle_operator_info
*);
333 static struct demangle_component
*
334 d_make_extended_operator (struct d_info
*, int,
335 struct demangle_component
*);
337 static struct demangle_component
*
338 d_make_ctor (struct d_info
*, enum gnu_v3_ctor_kinds
,
339 struct demangle_component
*);
341 static struct demangle_component
*
342 d_make_dtor (struct d_info
*, enum gnu_v3_dtor_kinds
,
343 struct demangle_component
*);
345 static struct demangle_component
*
346 d_make_template_param (struct d_info
*, long);
348 static struct demangle_component
*
349 d_make_sub (struct d_info
*, const char *, int);
352 has_return_type (struct demangle_component
*);
355 is_ctor_dtor_or_conversion (struct demangle_component
*);
357 static struct demangle_component
*d_encoding (struct d_info
*, int);
359 static struct demangle_component
*d_name (struct d_info
*);
361 static struct demangle_component
*d_nested_name (struct d_info
*);
363 static struct demangle_component
*d_prefix (struct d_info
*);
365 static struct demangle_component
*d_unqualified_name (struct d_info
*);
367 static struct demangle_component
*d_source_name (struct d_info
*);
369 static long d_number (struct d_info
*);
371 static struct demangle_component
*d_identifier (struct d_info
*, int);
373 static struct demangle_component
*d_operator_name (struct d_info
*);
375 static struct demangle_component
*d_special_name (struct d_info
*);
377 static int d_call_offset (struct d_info
*, int);
379 static struct demangle_component
*d_ctor_dtor_name (struct d_info
*);
381 static struct demangle_component
**
382 d_cv_qualifiers (struct d_info
*, struct demangle_component
**, int);
384 static struct demangle_component
*
385 d_function_type (struct d_info
*);
387 static struct demangle_component
*
388 d_bare_function_type (struct d_info
*, int);
390 static struct demangle_component
*
391 d_class_enum_type (struct d_info
*);
393 static struct demangle_component
*d_array_type (struct d_info
*);
395 static struct demangle_component
*d_vector_type (struct d_info
*);
397 static struct demangle_component
*
398 d_pointer_to_member_type (struct d_info
*);
400 static struct demangle_component
*
401 d_template_param (struct d_info
*);
403 static struct demangle_component
*d_template_args (struct d_info
*);
405 static struct demangle_component
*
406 d_template_arg (struct d_info
*);
408 static struct demangle_component
*d_expression (struct d_info
*);
410 static struct demangle_component
*d_expr_primary (struct d_info
*);
412 static struct demangle_component
*d_local_name (struct d_info
*);
414 static int d_discriminator (struct d_info
*);
416 static struct demangle_component
*d_lambda (struct d_info
*);
418 static struct demangle_component
*d_unnamed_type (struct d_info
*);
421 d_add_substitution (struct d_info
*, struct demangle_component
*);
423 static struct demangle_component
*d_substitution (struct d_info
*, int);
425 static void d_growable_string_init (struct d_growable_string
*, size_t);
428 d_growable_string_resize (struct d_growable_string
*, size_t);
431 d_growable_string_append_buffer (struct d_growable_string
*,
432 const char *, size_t);
434 d_growable_string_callback_adapter (const char *, size_t, void *);
437 d_print_init (struct d_print_info
*, demangle_callbackref
, void *);
439 static inline void d_print_error (struct d_print_info
*);
441 static inline int d_print_saw_error (struct d_print_info
*);
443 static inline void d_print_flush (struct d_print_info
*);
445 static inline void d_append_char (struct d_print_info
*, char);
447 static inline void d_append_buffer (struct d_print_info
*,
448 const char *, size_t);
450 static inline void d_append_string (struct d_print_info
*, const char *);
452 static inline char d_last_char (struct d_print_info
*);
455 d_print_comp (struct d_print_info
*, int, const struct demangle_component
*);
458 d_print_java_identifier (struct d_print_info
*, const char *, int);
461 d_print_mod_list (struct d_print_info
*, int, struct d_print_mod
*, int);
464 d_print_mod (struct d_print_info
*, int, const struct demangle_component
*);
467 d_print_function_type (struct d_print_info
*, int,
468 const struct demangle_component
*,
469 struct d_print_mod
*);
472 d_print_array_type (struct d_print_info
*, int,
473 const struct demangle_component
*,
474 struct d_print_mod
*);
477 d_print_expr_op (struct d_print_info
*, int, const struct demangle_component
*);
480 d_print_cast (struct d_print_info
*, int, const struct demangle_component
*);
482 static int d_demangle_callback (const char *, int,
483 demangle_callbackref
, void *);
484 static char *d_demangle (const char *, int, size_t *);
486 #ifdef CP_DEMANGLE_DEBUG
489 d_dump (struct demangle_component
*dc
, int indent
)
496 printf ("failed demangling\n");
500 for (i
= 0; i
< indent
; ++i
)
505 case DEMANGLE_COMPONENT_NAME
:
506 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
508 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
509 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
511 case DEMANGLE_COMPONENT_CTOR
:
512 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
513 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
515 case DEMANGLE_COMPONENT_DTOR
:
516 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
517 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
519 case DEMANGLE_COMPONENT_SUB_STD
:
520 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
522 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
523 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
525 case DEMANGLE_COMPONENT_OPERATOR
:
526 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
528 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
529 printf ("extended operator with %d args\n",
530 dc
->u
.s_extended_operator
.args
);
531 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
534 case DEMANGLE_COMPONENT_QUAL_NAME
:
535 printf ("qualified name\n");
537 case DEMANGLE_COMPONENT_LOCAL_NAME
:
538 printf ("local name\n");
540 case DEMANGLE_COMPONENT_TYPED_NAME
:
541 printf ("typed name\n");
543 case DEMANGLE_COMPONENT_TEMPLATE
:
544 printf ("template\n");
546 case DEMANGLE_COMPONENT_VTABLE
:
549 case DEMANGLE_COMPONENT_VTT
:
552 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
553 printf ("construction vtable\n");
555 case DEMANGLE_COMPONENT_TYPEINFO
:
556 printf ("typeinfo\n");
558 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
559 printf ("typeinfo name\n");
561 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
562 printf ("typeinfo function\n");
564 case DEMANGLE_COMPONENT_THUNK
:
567 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
568 printf ("virtual thunk\n");
570 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
571 printf ("covariant thunk\n");
573 case DEMANGLE_COMPONENT_JAVA_CLASS
:
574 printf ("java class\n");
576 case DEMANGLE_COMPONENT_GUARD
:
579 case DEMANGLE_COMPONENT_REFTEMP
:
580 printf ("reference temporary\n");
582 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
583 printf ("hidden alias\n");
585 case DEMANGLE_COMPONENT_RESTRICT
:
586 printf ("restrict\n");
588 case DEMANGLE_COMPONENT_VOLATILE
:
589 printf ("volatile\n");
591 case DEMANGLE_COMPONENT_CONST
:
594 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
595 printf ("restrict this\n");
597 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
598 printf ("volatile this\n");
600 case DEMANGLE_COMPONENT_CONST_THIS
:
601 printf ("const this\n");
603 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
604 printf ("vendor type qualifier\n");
606 case DEMANGLE_COMPONENT_POINTER
:
607 printf ("pointer\n");
609 case DEMANGLE_COMPONENT_REFERENCE
:
610 printf ("reference\n");
612 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
613 printf ("rvalue reference\n");
615 case DEMANGLE_COMPONENT_COMPLEX
:
616 printf ("complex\n");
618 case DEMANGLE_COMPONENT_IMAGINARY
:
619 printf ("imaginary\n");
621 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
622 printf ("vendor type\n");
624 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
625 printf ("function type\n");
627 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
628 printf ("array type\n");
630 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
631 printf ("pointer to member type\n");
633 case DEMANGLE_COMPONENT_FIXED_TYPE
:
634 printf ("fixed-point type\n");
636 case DEMANGLE_COMPONENT_ARGLIST
:
637 printf ("argument list\n");
639 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
640 printf ("template argument list\n");
642 case DEMANGLE_COMPONENT_CAST
:
645 case DEMANGLE_COMPONENT_UNARY
:
646 printf ("unary operator\n");
648 case DEMANGLE_COMPONENT_BINARY
:
649 printf ("binary operator\n");
651 case DEMANGLE_COMPONENT_BINARY_ARGS
:
652 printf ("binary operator arguments\n");
654 case DEMANGLE_COMPONENT_TRINARY
:
655 printf ("trinary operator\n");
657 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
658 printf ("trinary operator arguments 1\n");
660 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
661 printf ("trinary operator arguments 1\n");
663 case DEMANGLE_COMPONENT_LITERAL
:
664 printf ("literal\n");
666 case DEMANGLE_COMPONENT_LITERAL_NEG
:
667 printf ("negative literal\n");
669 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
670 printf ("java resource\n");
672 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
673 printf ("compound name\n");
675 case DEMANGLE_COMPONENT_CHARACTER
:
676 printf ("character '%c'\n", dc
->u
.s_character
.character
);
678 case DEMANGLE_COMPONENT_DECLTYPE
:
679 printf ("decltype\n");
681 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
682 printf ("pack expansion\n");
686 d_dump (d_left (dc
), indent
+ 2);
687 d_dump (d_right (dc
), indent
+ 2);
690 #endif /* CP_DEMANGLE_DEBUG */
692 /* Fill in a DEMANGLE_COMPONENT_NAME. */
694 CP_STATIC_IF_GLIBCPP_V3
696 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
698 if (p
== NULL
|| s
== NULL
|| len
== 0)
700 p
->type
= DEMANGLE_COMPONENT_NAME
;
702 p
->u
.s_name
.len
= len
;
706 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
708 CP_STATIC_IF_GLIBCPP_V3
710 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
711 struct demangle_component
*name
)
713 if (p
== NULL
|| args
< 0 || name
== NULL
)
715 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
716 p
->u
.s_extended_operator
.args
= args
;
717 p
->u
.s_extended_operator
.name
= name
;
721 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
723 CP_STATIC_IF_GLIBCPP_V3
725 cplus_demangle_fill_ctor (struct demangle_component
*p
,
726 enum gnu_v3_ctor_kinds kind
,
727 struct demangle_component
*name
)
731 || (int) kind
< gnu_v3_complete_object_ctor
732 || (int) kind
> gnu_v3_complete_object_allocating_ctor
)
734 p
->type
= DEMANGLE_COMPONENT_CTOR
;
735 p
->u
.s_ctor
.kind
= kind
;
736 p
->u
.s_ctor
.name
= name
;
740 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
742 CP_STATIC_IF_GLIBCPP_V3
744 cplus_demangle_fill_dtor (struct demangle_component
*p
,
745 enum gnu_v3_dtor_kinds kind
,
746 struct demangle_component
*name
)
750 || (int) kind
< gnu_v3_deleting_dtor
751 || (int) kind
> gnu_v3_base_object_dtor
)
753 p
->type
= DEMANGLE_COMPONENT_DTOR
;
754 p
->u
.s_dtor
.kind
= kind
;
755 p
->u
.s_dtor
.name
= name
;
759 /* Add a new component. */
761 static struct demangle_component
*
762 d_make_empty (struct d_info
*di
)
764 struct demangle_component
*p
;
766 if (di
->next_comp
>= di
->num_comps
)
768 p
= &di
->comps
[di
->next_comp
];
773 /* Add a new generic component. */
775 static struct demangle_component
*
776 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
777 struct demangle_component
*left
,
778 struct demangle_component
*right
)
780 struct demangle_component
*p
;
782 /* We check for errors here. A typical error would be a NULL return
783 from a subroutine. We catch those here, and return NULL
787 /* These types require two parameters. */
788 case DEMANGLE_COMPONENT_QUAL_NAME
:
789 case DEMANGLE_COMPONENT_LOCAL_NAME
:
790 case DEMANGLE_COMPONENT_TYPED_NAME
:
791 case DEMANGLE_COMPONENT_TEMPLATE
:
792 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
793 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
794 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
795 case DEMANGLE_COMPONENT_UNARY
:
796 case DEMANGLE_COMPONENT_BINARY
:
797 case DEMANGLE_COMPONENT_BINARY_ARGS
:
798 case DEMANGLE_COMPONENT_TRINARY
:
799 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
800 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
801 case DEMANGLE_COMPONENT_LITERAL
:
802 case DEMANGLE_COMPONENT_LITERAL_NEG
:
803 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
804 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
805 if (left
== NULL
|| right
== NULL
)
809 /* These types only require one parameter. */
810 case DEMANGLE_COMPONENT_VTABLE
:
811 case DEMANGLE_COMPONENT_VTT
:
812 case DEMANGLE_COMPONENT_TYPEINFO
:
813 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
814 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
815 case DEMANGLE_COMPONENT_THUNK
:
816 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
817 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
818 case DEMANGLE_COMPONENT_JAVA_CLASS
:
819 case DEMANGLE_COMPONENT_GUARD
:
820 case DEMANGLE_COMPONENT_REFTEMP
:
821 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
822 case DEMANGLE_COMPONENT_POINTER
:
823 case DEMANGLE_COMPONENT_REFERENCE
:
824 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
825 case DEMANGLE_COMPONENT_COMPLEX
:
826 case DEMANGLE_COMPONENT_IMAGINARY
:
827 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
828 case DEMANGLE_COMPONENT_CAST
:
829 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
830 case DEMANGLE_COMPONENT_DECLTYPE
:
831 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
832 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
833 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
838 /* This needs a right parameter, but the left parameter can be
840 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
845 /* These are allowed to have no parameters--in some cases they
846 will be filled in later. */
847 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
848 case DEMANGLE_COMPONENT_RESTRICT
:
849 case DEMANGLE_COMPONENT_VOLATILE
:
850 case DEMANGLE_COMPONENT_CONST
:
851 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
852 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
853 case DEMANGLE_COMPONENT_CONST_THIS
:
854 case DEMANGLE_COMPONENT_ARGLIST
:
855 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
858 /* Other types should not be seen here. */
863 p
= d_make_empty (di
);
867 p
->u
.s_binary
.left
= left
;
868 p
->u
.s_binary
.right
= right
;
873 /* Add a new demangle mangled name component. */
875 static struct demangle_component
*
876 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
878 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
879 return d_make_name (di
, s
, strlen (s
));
881 return d_encoding (di
, 0);
884 /* Add a new name component. */
886 static struct demangle_component
*
887 d_make_name (struct d_info
*di
, const char *s
, int len
)
889 struct demangle_component
*p
;
891 p
= d_make_empty (di
);
892 if (! cplus_demangle_fill_name (p
, s
, len
))
897 /* Add a new builtin type component. */
899 static struct demangle_component
*
900 d_make_builtin_type (struct d_info
*di
,
901 const struct demangle_builtin_type_info
*type
)
903 struct demangle_component
*p
;
907 p
= d_make_empty (di
);
910 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
911 p
->u
.s_builtin
.type
= type
;
916 /* Add a new operator component. */
918 static struct demangle_component
*
919 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
921 struct demangle_component
*p
;
923 p
= d_make_empty (di
);
926 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
927 p
->u
.s_operator
.op
= op
;
932 /* Add a new extended operator component. */
934 static struct demangle_component
*
935 d_make_extended_operator (struct d_info
*di
, int args
,
936 struct demangle_component
*name
)
938 struct demangle_component
*p
;
940 p
= d_make_empty (di
);
941 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
946 static struct demangle_component
*
947 d_make_default_arg (struct d_info
*di
, int num
,
948 struct demangle_component
*sub
)
950 struct demangle_component
*p
= d_make_empty (di
);
953 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
954 p
->u
.s_unary_num
.num
= num
;
955 p
->u
.s_unary_num
.sub
= sub
;
960 /* Add a new constructor component. */
962 static struct demangle_component
*
963 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
964 struct demangle_component
*name
)
966 struct demangle_component
*p
;
968 p
= d_make_empty (di
);
969 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
974 /* Add a new destructor component. */
976 static struct demangle_component
*
977 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
978 struct demangle_component
*name
)
980 struct demangle_component
*p
;
982 p
= d_make_empty (di
);
983 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
988 /* Add a new template parameter. */
990 static struct demangle_component
*
991 d_make_template_param (struct d_info
*di
, long i
)
993 struct demangle_component
*p
;
995 p
= d_make_empty (di
);
998 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
999 p
->u
.s_number
.number
= i
;
1004 /* Add a new function parameter. */
1006 static struct demangle_component
*
1007 d_make_function_param (struct d_info
*di
, long i
)
1009 struct demangle_component
*p
;
1011 p
= d_make_empty (di
);
1014 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1015 p
->u
.s_number
.number
= i
;
1020 /* Add a new standard substitution component. */
1022 static struct demangle_component
*
1023 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1025 struct demangle_component
*p
;
1027 p
= d_make_empty (di
);
1030 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1031 p
->u
.s_string
.string
= name
;
1032 p
->u
.s_string
.len
= len
;
1037 /* <mangled-name> ::= _Z <encoding>
1039 TOP_LEVEL is non-zero when called at the top level. */
1041 CP_STATIC_IF_GLIBCPP_V3
1042 struct demangle_component
*
1043 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1045 if (! d_check_char (di
, '_')
1046 /* Allow missing _ if not at toplevel to work around a
1047 bug in G++ abi-version=2 mangling; see the comment in
1048 write_template_arg. */
1051 if (! d_check_char (di
, 'Z'))
1053 return d_encoding (di
, top_level
);
1056 /* Return whether a function should have a return type. The argument
1057 is the function name, which may be qualified in various ways. The
1058 rules are that template functions have return types with some
1059 exceptions, function types which are not part of a function name
1060 mangling have return types with some exceptions, and non-template
1061 function names do not have return types. The exceptions are that
1062 constructors, destructors, and conversion operators do not have
1066 has_return_type (struct demangle_component
*dc
)
1074 case DEMANGLE_COMPONENT_TEMPLATE
:
1075 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1076 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
1077 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
1078 case DEMANGLE_COMPONENT_CONST_THIS
:
1079 return has_return_type (d_left (dc
));
1083 /* Return whether a name is a constructor, a destructor, or a
1084 conversion operator. */
1087 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1095 case DEMANGLE_COMPONENT_QUAL_NAME
:
1096 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1097 return is_ctor_dtor_or_conversion (d_right (dc
));
1098 case DEMANGLE_COMPONENT_CTOR
:
1099 case DEMANGLE_COMPONENT_DTOR
:
1100 case DEMANGLE_COMPONENT_CAST
:
1105 /* <encoding> ::= <(function) name> <bare-function-type>
1109 TOP_LEVEL is non-zero when called at the top level, in which case
1110 if DMGL_PARAMS is not set we do not demangle the function
1111 parameters. We only set this at the top level, because otherwise
1112 we would not correctly demangle names in local scopes. */
1114 static struct demangle_component
*
1115 d_encoding (struct d_info
*di
, int top_level
)
1117 char peek
= d_peek_char (di
);
1119 if (peek
== 'G' || peek
== 'T')
1120 return d_special_name (di
);
1123 struct demangle_component
*dc
;
1127 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1129 /* Strip off any initial CV-qualifiers, as they really apply
1130 to the `this' parameter, and they were not output by the
1131 v2 demangler without DMGL_PARAMS. */
1132 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1133 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1134 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1137 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1138 there may be CV-qualifiers on its right argument which
1139 really apply here; this happens when parsing a class
1140 which is local to a function. */
1141 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1143 struct demangle_component
*dcr
;
1146 while (dcr
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1147 || dcr
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1148 || dcr
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1150 dc
->u
.s_binary
.right
= dcr
;
1156 peek
= d_peek_char (di
);
1157 if (dc
== NULL
|| peek
== '\0' || peek
== 'E')
1159 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1160 d_bare_function_type (di
, has_return_type (dc
)));
1164 /* <name> ::= <nested-name>
1166 ::= <unscoped-template-name> <template-args>
1169 <unscoped-name> ::= <unqualified-name>
1170 ::= St <unqualified-name>
1172 <unscoped-template-name> ::= <unscoped-name>
1176 static struct demangle_component
*
1177 d_name (struct d_info
*di
)
1179 char peek
= d_peek_char (di
);
1180 struct demangle_component
*dc
;
1185 return d_nested_name (di
);
1188 return d_local_name (di
);
1192 return d_unqualified_name (di
);
1198 if (d_peek_next_char (di
) != 't')
1200 dc
= d_substitution (di
, 0);
1206 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1207 d_make_name (di
, "std", 3),
1208 d_unqualified_name (di
));
1213 if (d_peek_char (di
) != 'I')
1215 /* The grammar does not permit this case to occur if we
1216 called d_substitution() above (i.e., subst == 1). We
1217 don't bother to check. */
1221 /* This is <template-args>, which means that we just saw
1222 <unscoped-template-name>, which is a substitution
1223 candidate if we didn't just get it from a
1227 if (! d_add_substitution (di
, dc
))
1230 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1231 d_template_args (di
));
1238 dc
= d_unqualified_name (di
);
1239 if (d_peek_char (di
) == 'I')
1241 /* This is <template-args>, which means that we just saw
1242 <unscoped-template-name>, which is a substitution
1244 if (! d_add_substitution (di
, dc
))
1246 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1247 d_template_args (di
));
1253 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1254 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1257 static struct demangle_component
*
1258 d_nested_name (struct d_info
*di
)
1260 struct demangle_component
*ret
;
1261 struct demangle_component
**pret
;
1263 if (! d_check_char (di
, 'N'))
1266 pret
= d_cv_qualifiers (di
, &ret
, 1);
1270 *pret
= d_prefix (di
);
1274 if (! d_check_char (di
, 'E'))
1280 /* <prefix> ::= <prefix> <unqualified-name>
1281 ::= <template-prefix> <template-args>
1282 ::= <template-param>
1286 <template-prefix> ::= <prefix> <(template) unqualified-name>
1287 ::= <template-param>
1291 static struct demangle_component
*
1292 d_prefix (struct d_info
*di
)
1294 struct demangle_component
*ret
= NULL
;
1299 enum demangle_component_type comb_type
;
1300 struct demangle_component
*dc
;
1302 peek
= d_peek_char (di
);
1306 /* The older code accepts a <local-name> here, but I don't see
1307 that in the grammar. The older code does not accept a
1308 <template-param> here. */
1310 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1317 dc
= d_unqualified_name (di
);
1318 else if (peek
== 'S')
1319 dc
= d_substitution (di
, 1);
1320 else if (peek
== 'I')
1324 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1325 dc
= d_template_args (di
);
1327 else if (peek
== 'T')
1328 dc
= d_template_param (di
);
1329 else if (peek
== 'E')
1331 else if (peek
== 'M')
1333 /* Initializer scope for a lambda. We don't need to represent
1334 this; the normal code will just treat the variable as a type
1335 scope, which gives appropriate output. */
1347 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1349 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1351 if (! d_add_substitution (di
, ret
))
1357 /* <unqualified-name> ::= <operator-name>
1358 ::= <ctor-dtor-name>
1360 ::= <local-source-name>
1362 <local-source-name> ::= L <source-name> <discriminator>
1365 static struct demangle_component
*
1366 d_unqualified_name (struct d_info
*di
)
1370 peek
= d_peek_char (di
);
1371 if (IS_DIGIT (peek
))
1372 return d_source_name (di
);
1373 else if (IS_LOWER (peek
))
1375 struct demangle_component
*ret
;
1377 ret
= d_operator_name (di
);
1378 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1379 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1382 else if (peek
== 'C' || peek
== 'D')
1383 return d_ctor_dtor_name (di
);
1384 else if (peek
== 'L')
1386 struct demangle_component
* ret
;
1390 ret
= d_source_name (di
);
1393 if (! d_discriminator (di
))
1397 else if (peek
== 'U')
1399 switch (d_peek_next_char (di
))
1402 return d_lambda (di
);
1404 return d_unnamed_type (di
);
1413 /* <source-name> ::= <(positive length) number> <identifier> */
1415 static struct demangle_component
*
1416 d_source_name (struct d_info
*di
)
1419 struct demangle_component
*ret
;
1421 len
= d_number (di
);
1424 ret
= d_identifier (di
, len
);
1425 di
->last_name
= ret
;
1429 /* number ::= [n] <(non-negative decimal integer)> */
1432 d_number (struct d_info
*di
)
1439 peek
= d_peek_char (di
);
1444 peek
= d_peek_char (di
);
1450 if (! IS_DIGIT (peek
))
1456 ret
= ret
* 10 + peek
- '0';
1458 peek
= d_peek_char (di
);
1462 /* Like d_number, but returns a demangle_component. */
1464 static struct demangle_component
*
1465 d_number_component (struct d_info
*di
)
1467 struct demangle_component
*ret
= d_make_empty (di
);
1470 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1471 ret
->u
.s_number
.number
= d_number (di
);
1476 /* identifier ::= <(unqualified source code identifier)> */
1478 static struct demangle_component
*
1479 d_identifier (struct d_info
*di
, int len
)
1485 if (di
->send
- name
< len
)
1488 d_advance (di
, len
);
1490 /* A Java mangled name may have a trailing '$' if it is a C++
1491 keyword. This '$' is not included in the length count. We just
1493 if ((di
->options
& DMGL_JAVA
) != 0
1494 && d_peek_char (di
) == '$')
1497 /* Look for something which looks like a gcc encoding of an
1498 anonymous namespace, and replace it with a more user friendly
1500 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1501 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1502 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1506 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1507 if ((*s
== '.' || *s
== '_' || *s
== '$')
1510 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1511 return d_make_name (di
, "(anonymous namespace)",
1512 sizeof "(anonymous namespace)" - 1);
1516 return d_make_name (di
, name
, len
);
1519 /* operator_name ::= many different two character encodings.
1521 ::= v <digit> <source-name>
1524 #define NL(s) s, (sizeof s) - 1
1526 CP_STATIC_IF_GLIBCPP_V3
1527 const struct demangle_operator_info cplus_demangle_operators
[] =
1529 { "aN", NL ("&="), 2 },
1530 { "aS", NL ("="), 2 },
1531 { "aa", NL ("&&"), 2 },
1532 { "ad", NL ("&"), 1 },
1533 { "an", NL ("&"), 2 },
1534 { "cl", NL ("()"), 2 },
1535 { "cm", NL (","), 2 },
1536 { "co", NL ("~"), 1 },
1537 { "dV", NL ("/="), 2 },
1538 { "da", NL ("delete[]"), 1 },
1539 { "de", NL ("*"), 1 },
1540 { "dl", NL ("delete"), 1 },
1541 { "dt", NL ("."), 2 },
1542 { "dv", NL ("/"), 2 },
1543 { "eO", NL ("^="), 2 },
1544 { "eo", NL ("^"), 2 },
1545 { "eq", NL ("=="), 2 },
1546 { "ge", NL (">="), 2 },
1547 { "gt", NL (">"), 2 },
1548 { "ix", NL ("[]"), 2 },
1549 { "lS", NL ("<<="), 2 },
1550 { "le", NL ("<="), 2 },
1551 { "ls", NL ("<<"), 2 },
1552 { "lt", NL ("<"), 2 },
1553 { "mI", NL ("-="), 2 },
1554 { "mL", NL ("*="), 2 },
1555 { "mi", NL ("-"), 2 },
1556 { "ml", NL ("*"), 2 },
1557 { "mm", NL ("--"), 1 },
1558 { "na", NL ("new[]"), 1 },
1559 { "ne", NL ("!="), 2 },
1560 { "ng", NL ("-"), 1 },
1561 { "nt", NL ("!"), 1 },
1562 { "nw", NL ("new"), 1 },
1563 { "oR", NL ("|="), 2 },
1564 { "oo", NL ("||"), 2 },
1565 { "or", NL ("|"), 2 },
1566 { "pL", NL ("+="), 2 },
1567 { "pl", NL ("+"), 2 },
1568 { "pm", NL ("->*"), 2 },
1569 { "pp", NL ("++"), 1 },
1570 { "ps", NL ("+"), 1 },
1571 { "pt", NL ("->"), 2 },
1572 { "qu", NL ("?"), 3 },
1573 { "rM", NL ("%="), 2 },
1574 { "rS", NL (">>="), 2 },
1575 { "rm", NL ("%"), 2 },
1576 { "rs", NL (">>"), 2 },
1577 { "st", NL ("sizeof "), 1 },
1578 { "sz", NL ("sizeof "), 1 },
1579 { "at", NL ("alignof "), 1 },
1580 { "az", NL ("alignof "), 1 },
1581 { NULL
, NULL
, 0, 0 }
1584 static struct demangle_component
*
1585 d_operator_name (struct d_info
*di
)
1590 c1
= d_next_char (di
);
1591 c2
= d_next_char (di
);
1592 if (c1
== 'v' && IS_DIGIT (c2
))
1593 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1594 else if (c1
== 'c' && c2
== 'v')
1595 return d_make_comp (di
, DEMANGLE_COMPONENT_CAST
,
1596 cplus_demangle_type (di
), NULL
);
1599 /* LOW is the inclusive lower bound. */
1601 /* HIGH is the exclusive upper bound. We subtract one to ignore
1602 the sentinel at the end of the array. */
1603 int high
= ((sizeof (cplus_demangle_operators
)
1604 / sizeof (cplus_demangle_operators
[0]))
1610 const struct demangle_operator_info
*p
;
1612 i
= low
+ (high
- low
) / 2;
1613 p
= cplus_demangle_operators
+ i
;
1615 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1616 return d_make_operator (di
, p
);
1618 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1628 static struct demangle_component
*
1629 d_make_character (struct d_info
*di
, int c
)
1631 struct demangle_component
*p
;
1632 p
= d_make_empty (di
);
1635 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1636 p
->u
.s_character
.character
= c
;
1641 static struct demangle_component
*
1642 d_java_resource (struct d_info
*di
)
1644 struct demangle_component
*p
= NULL
;
1645 struct demangle_component
*next
= NULL
;
1650 len
= d_number (di
);
1654 /* Eat the leading '_'. */
1655 if (d_next_char (di
) != '_')
1668 /* Each chunk is either a '$' escape... */
1686 next
= d_make_character (di
, c
);
1694 /* ... or a sequence of characters. */
1697 while (i
< len
&& str
[i
] && str
[i
] != '$')
1700 next
= d_make_name (di
, str
, i
);
1713 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
1719 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
1724 /* <special-name> ::= TV <type>
1728 ::= GV <(object) name>
1729 ::= T <call-offset> <(base) encoding>
1730 ::= Tc <call-offset> <call-offset> <(base) encoding>
1731 Also g++ extensions:
1732 ::= TC <type> <(offset) number> _ <(base) type>
1737 ::= Gr <resource name>
1740 static struct demangle_component
*
1741 d_special_name (struct d_info
*di
)
1743 di
->expansion
+= 20;
1744 if (d_check_char (di
, 'T'))
1746 switch (d_next_char (di
))
1750 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
1751 cplus_demangle_type (di
), NULL
);
1753 di
->expansion
-= 10;
1754 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
1755 cplus_demangle_type (di
), NULL
);
1757 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
1758 cplus_demangle_type (di
), NULL
);
1760 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
1761 cplus_demangle_type (di
), NULL
);
1764 if (! d_call_offset (di
, 'h'))
1766 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
1767 d_encoding (di
, 0), NULL
);
1770 if (! d_call_offset (di
, 'v'))
1772 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
1773 d_encoding (di
, 0), NULL
);
1776 if (! d_call_offset (di
, '\0'))
1778 if (! d_call_offset (di
, '\0'))
1780 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
1781 d_encoding (di
, 0), NULL
);
1785 struct demangle_component
*derived_type
;
1787 struct demangle_component
*base_type
;
1789 derived_type
= cplus_demangle_type (di
);
1790 offset
= d_number (di
);
1793 if (! d_check_char (di
, '_'))
1795 base_type
= cplus_demangle_type (di
);
1796 /* We don't display the offset. FIXME: We should display
1797 it in verbose mode. */
1799 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
1800 base_type
, derived_type
);
1804 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
1805 cplus_demangle_type (di
), NULL
);
1807 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
1808 cplus_demangle_type (di
), NULL
);
1814 else if (d_check_char (di
, 'G'))
1816 switch (d_next_char (di
))
1819 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
1822 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, d_name (di
),
1826 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
1827 d_encoding (di
, 0), NULL
);
1830 return d_java_resource (di
);
1840 /* <call-offset> ::= h <nv-offset> _
1843 <nv-offset> ::= <(offset) number>
1845 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1847 The C parameter, if not '\0', is a character we just read which is
1848 the start of the <call-offset>.
1850 We don't display the offset information anywhere. FIXME: We should
1851 display it in verbose mode. */
1854 d_call_offset (struct d_info
*di
, int c
)
1857 c
= d_next_char (di
);
1864 if (! d_check_char (di
, '_'))
1871 if (! d_check_char (di
, '_'))
1877 /* <ctor-dtor-name> ::= C1
1885 static struct demangle_component
*
1886 d_ctor_dtor_name (struct d_info
*di
)
1888 if (di
->last_name
!= NULL
)
1890 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
1891 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
1892 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1893 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
1895 switch (d_peek_char (di
))
1899 enum gnu_v3_ctor_kinds kind
;
1901 switch (d_peek_next_char (di
))
1904 kind
= gnu_v3_complete_object_ctor
;
1907 kind
= gnu_v3_base_object_ctor
;
1910 kind
= gnu_v3_complete_object_allocating_ctor
;
1916 return d_make_ctor (di
, kind
, di
->last_name
);
1921 enum gnu_v3_dtor_kinds kind
;
1923 switch (d_peek_next_char (di
))
1926 kind
= gnu_v3_deleting_dtor
;
1929 kind
= gnu_v3_complete_object_dtor
;
1932 kind
= gnu_v3_base_object_dtor
;
1938 return d_make_dtor (di
, kind
, di
->last_name
);
1946 /* <type> ::= <builtin-type>
1948 ::= <class-enum-type>
1950 ::= <pointer-to-member-type>
1951 ::= <template-param>
1952 ::= <template-template-param> <template-args>
1954 ::= <CV-qualifiers> <type>
1957 ::= O <type> (C++0x)
1960 ::= U <source-name> <type>
1962 <builtin-type> ::= various one letter codes
1966 CP_STATIC_IF_GLIBCPP_V3
1967 const struct demangle_builtin_type_info
1968 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
1970 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
1971 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
1972 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
1973 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
1974 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
1975 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
1976 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
1977 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
1978 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
1979 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
1980 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1981 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
1982 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
1983 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
1984 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
1986 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1987 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1988 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1989 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
1990 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
1991 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1992 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
1993 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
1994 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
1995 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
1996 D_PRINT_UNSIGNED_LONG_LONG
},
1997 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
1998 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
1999 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2000 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2001 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2002 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2003 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2004 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2008 CP_STATIC_IF_GLIBCPP_V3
2009 struct demangle_component
*
2010 cplus_demangle_type (struct d_info
*di
)
2013 struct demangle_component
*ret
;
2016 /* The ABI specifies that when CV-qualifiers are used, the base type
2017 is substitutable, and the fully qualified type is substitutable,
2018 but the base type with a strict subset of the CV-qualifiers is
2019 not substitutable. The natural recursive implementation of the
2020 CV-qualifiers would cause subsets to be substitutable, so instead
2021 we pull them all off now.
2023 FIXME: The ABI says that order-insensitive vendor qualifiers
2024 should be handled in the same way, but we have no way to tell
2025 which vendor qualifiers are order-insensitive and which are
2026 order-sensitive. So we just assume that they are all
2027 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2028 __vector, and it treats it as order-sensitive when mangling
2031 peek
= d_peek_char (di
);
2032 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2034 struct demangle_component
**pret
;
2036 pret
= d_cv_qualifiers (di
, &ret
, 0);
2039 *pret
= cplus_demangle_type (di
);
2040 if (! *pret
|| ! d_add_substitution (di
, ret
))
2049 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2050 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2051 case 'o': case 's': case 't':
2052 case 'v': case 'w': case 'x': case 'y': case 'z':
2053 ret
= d_make_builtin_type (di
,
2054 &cplus_demangle_builtin_types
[peek
- 'a']);
2055 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2062 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2063 d_source_name (di
), NULL
);
2067 ret
= d_function_type (di
);
2070 case '0': case '1': case '2': case '3': case '4':
2071 case '5': case '6': case '7': case '8': case '9':
2074 ret
= d_class_enum_type (di
);
2078 ret
= d_array_type (di
);
2082 ret
= d_pointer_to_member_type (di
);
2086 ret
= d_template_param (di
);
2087 if (d_peek_char (di
) == 'I')
2089 /* This is <template-template-param> <template-args>. The
2090 <template-template-param> part is a substitution
2092 if (! d_add_substitution (di
, ret
))
2094 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2095 d_template_args (di
));
2100 /* If this is a special substitution, then it is the start of
2101 <class-enum-type>. */
2105 peek_next
= d_peek_next_char (di
);
2106 if (IS_DIGIT (peek_next
)
2108 || IS_UPPER (peek_next
))
2110 ret
= d_substitution (di
, 0);
2111 /* The substituted name may have been a template name and
2112 may be followed by tepmlate args. */
2113 if (d_peek_char (di
) == 'I')
2114 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2115 d_template_args (di
));
2121 ret
= d_class_enum_type (di
);
2122 /* If the substitution was a complete type, then it is not
2123 a new substitution candidate. However, if the
2124 substitution was followed by template arguments, then
2125 the whole thing is a substitution candidate. */
2126 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2134 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2135 cplus_demangle_type (di
), NULL
);
2140 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2141 cplus_demangle_type (di
), NULL
);
2146 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2147 cplus_demangle_type (di
), NULL
);
2152 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2153 cplus_demangle_type (di
), NULL
);
2158 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2159 cplus_demangle_type (di
), NULL
);
2164 ret
= d_source_name (di
);
2165 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2166 cplus_demangle_type (di
), ret
);
2172 peek
= d_next_char (di
);
2177 /* decltype (expression) */
2178 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2179 d_expression (di
), NULL
);
2180 if (ret
&& d_next_char (di
) != 'E')
2185 /* Pack expansion. */
2186 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2187 cplus_demangle_type (di
), NULL
);
2191 /* 32-bit decimal floating point */
2192 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2193 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2197 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2198 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2202 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2203 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2206 /* 16-bit half-precision FP */
2207 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2208 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2212 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2213 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2217 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2218 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2222 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2223 ret
= d_make_empty (di
);
2224 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2225 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2226 /* For demangling we don't care about the bits. */
2228 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2229 if (ret
->u
.s_fixed
.length
== NULL
)
2232 peek
= d_next_char (di
);
2233 ret
->u
.s_fixed
.sat
= (peek
== 's');
2237 ret
= d_vector_type (di
);
2241 /* decltype(nullptr) */
2242 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2243 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2257 if (! d_add_substitution (di
, ret
))
2264 /* <CV-qualifiers> ::= [r] [V] [K] */
2266 static struct demangle_component
**
2267 d_cv_qualifiers (struct d_info
*di
,
2268 struct demangle_component
**pret
, int member_fn
)
2272 peek
= d_peek_char (di
);
2273 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
2275 enum demangle_component_type t
;
2281 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2282 : DEMANGLE_COMPONENT_RESTRICT
);
2283 di
->expansion
+= sizeof "restrict";
2285 else if (peek
== 'V')
2288 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2289 : DEMANGLE_COMPONENT_VOLATILE
);
2290 di
->expansion
+= sizeof "volatile";
2295 ? DEMANGLE_COMPONENT_CONST_THIS
2296 : DEMANGLE_COMPONENT_CONST
);
2297 di
->expansion
+= sizeof "const";
2300 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
2303 pret
= &d_left (*pret
);
2305 peek
= d_peek_char (di
);
2311 /* <function-type> ::= F [Y] <bare-function-type> E */
2313 static struct demangle_component
*
2314 d_function_type (struct d_info
*di
)
2316 struct demangle_component
*ret
;
2318 if (! d_check_char (di
, 'F'))
2320 if (d_peek_char (di
) == 'Y')
2322 /* Function has C linkage. We don't print this information.
2323 FIXME: We should print it in verbose mode. */
2326 ret
= d_bare_function_type (di
, 1);
2327 if (! d_check_char (di
, 'E'))
2334 static struct demangle_component
*
2335 d_parmlist (struct d_info
*di
)
2337 struct demangle_component
*tl
;
2338 struct demangle_component
**ptl
;
2344 struct demangle_component
*type
;
2346 char peek
= d_peek_char (di
);
2347 if (peek
== '\0' || peek
== 'E')
2349 type
= cplus_demangle_type (di
);
2352 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2355 ptl
= &d_right (*ptl
);
2358 /* There should be at least one parameter type besides the optional
2359 return type. A function which takes no arguments will have a
2360 single parameter type void. */
2364 /* If we have a single parameter type void, omit it. */
2365 if (d_right (tl
) == NULL
2366 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2367 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2369 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2376 /* <bare-function-type> ::= [J]<type>+ */
2378 static struct demangle_component
*
2379 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2381 struct demangle_component
*return_type
;
2382 struct demangle_component
*tl
;
2385 /* Detect special qualifier indicating that the first argument
2386 is the return type. */
2387 peek
= d_peek_char (di
);
2391 has_return_type
= 1;
2394 if (has_return_type
)
2396 return_type
= cplus_demangle_type (di
);
2397 if (return_type
== NULL
)
2403 tl
= d_parmlist (di
);
2407 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2411 /* <class-enum-type> ::= <name> */
2413 static struct demangle_component
*
2414 d_class_enum_type (struct d_info
*di
)
2419 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2420 ::= A [<(dimension) expression>] _ <(element) type>
2423 static struct demangle_component
*
2424 d_array_type (struct d_info
*di
)
2427 struct demangle_component
*dim
;
2429 if (! d_check_char (di
, 'A'))
2432 peek
= d_peek_char (di
);
2435 else if (IS_DIGIT (peek
))
2443 peek
= d_peek_char (di
);
2445 while (IS_DIGIT (peek
));
2446 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2452 dim
= d_expression (di
);
2457 if (! d_check_char (di
, '_'))
2460 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2461 cplus_demangle_type (di
));
2464 /* <vector-type> ::= Dv <number> _ <type>
2465 ::= Dv _ <expression> _ <type> */
2467 static struct demangle_component
*
2468 d_vector_type (struct d_info
*di
)
2471 struct demangle_component
*dim
;
2473 peek
= d_peek_char (di
);
2477 dim
= d_expression (di
);
2480 dim
= d_number_component (di
);
2485 if (! d_check_char (di
, '_'))
2488 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
2489 cplus_demangle_type (di
));
2492 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2494 static struct demangle_component
*
2495 d_pointer_to_member_type (struct d_info
*di
)
2497 struct demangle_component
*cl
;
2498 struct demangle_component
*mem
;
2499 struct demangle_component
**pmem
;
2501 if (! d_check_char (di
, 'M'))
2504 cl
= cplus_demangle_type (di
);
2506 /* The ABI specifies that any type can be a substitution source, and
2507 that M is followed by two types, and that when a CV-qualified
2508 type is seen both the base type and the CV-qualified types are
2509 substitution sources. The ABI also specifies that for a pointer
2510 to a CV-qualified member function, the qualifiers are attached to
2511 the second type. Given the grammar, a plain reading of the ABI
2512 suggests that both the CV-qualified member function and the
2513 non-qualified member function are substitution sources. However,
2514 g++ does not work that way. g++ treats only the CV-qualified
2515 member function as a substitution source. FIXME. So to work
2516 with g++, we need to pull off the CV-qualifiers here, in order to
2517 avoid calling add_substitution() in cplus_demangle_type(). But
2518 for a CV-qualified member which is not a function, g++ does
2519 follow the ABI, so we need to handle that case here by calling
2520 d_add_substitution ourselves. */
2522 pmem
= d_cv_qualifiers (di
, &mem
, 1);
2525 *pmem
= cplus_demangle_type (di
);
2529 if (pmem
!= &mem
&& (*pmem
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
2531 if (! d_add_substitution (di
, mem
))
2535 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
2538 /* <non-negative number> _ */
2541 d_compact_number (struct d_info
*di
)
2544 if (d_peek_char (di
) == '_')
2546 else if (d_peek_char (di
) == 'n')
2549 num
= d_number (di
) + 1;
2551 if (! d_check_char (di
, '_'))
2556 /* <template-param> ::= T_
2557 ::= T <(parameter-2 non-negative) number> _
2560 static struct demangle_component
*
2561 d_template_param (struct d_info
*di
)
2565 if (! d_check_char (di
, 'T'))
2568 param
= d_compact_number (di
);
2574 return d_make_template_param (di
, param
);
2577 /* <template-args> ::= I <template-arg>+ E */
2579 static struct demangle_component
*
2580 d_template_args (struct d_info
*di
)
2582 struct demangle_component
*hold_last_name
;
2583 struct demangle_component
*al
;
2584 struct demangle_component
**pal
;
2586 /* Preserve the last name we saw--don't let the template arguments
2587 clobber it, as that would give us the wrong name for a subsequent
2588 constructor or destructor. */
2589 hold_last_name
= di
->last_name
;
2591 if (! d_check_char (di
, 'I'))
2594 if (d_peek_char (di
) == 'E')
2596 /* An argument pack can be empty. */
2598 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
2605 struct demangle_component
*a
;
2607 a
= d_template_arg (di
);
2611 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
2614 pal
= &d_right (*pal
);
2616 if (d_peek_char (di
) == 'E')
2623 di
->last_name
= hold_last_name
;
2628 /* <template-arg> ::= <type>
2629 ::= X <expression> E
2633 static struct demangle_component
*
2634 d_template_arg (struct d_info
*di
)
2636 struct demangle_component
*ret
;
2638 switch (d_peek_char (di
))
2642 ret
= d_expression (di
);
2643 if (! d_check_char (di
, 'E'))
2648 return d_expr_primary (di
);
2651 /* An argument pack. */
2652 return d_template_args (di
);
2655 return cplus_demangle_type (di
);
2659 /* Subroutine of <expression> ::= cl <expression>+ E */
2661 static struct demangle_component
*
2662 d_exprlist (struct d_info
*di
)
2664 struct demangle_component
*list
= NULL
;
2665 struct demangle_component
**p
= &list
;
2667 if (d_peek_char (di
) == 'E')
2670 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
2675 struct demangle_component
*arg
= d_expression (di
);
2679 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
2684 if (d_peek_char (di
) == 'E')
2694 /* <expression> ::= <(unary) operator-name> <expression>
2695 ::= <(binary) operator-name> <expression> <expression>
2696 ::= <(trinary) operator-name> <expression> <expression> <expression>
2697 ::= cl <expression>+ E
2699 ::= <template-param>
2700 ::= sr <type> <unqualified-name>
2701 ::= sr <type> <unqualified-name> <template-args>
2705 static struct demangle_component
*
2706 d_expression (struct d_info
*di
)
2710 peek
= d_peek_char (di
);
2712 return d_expr_primary (di
);
2713 else if (peek
== 'T')
2714 return d_template_param (di
);
2715 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2717 struct demangle_component
*type
;
2718 struct demangle_component
*name
;
2721 type
= cplus_demangle_type (di
);
2722 name
= d_unqualified_name (di
);
2723 if (d_peek_char (di
) != 'I')
2724 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
2726 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
2727 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2728 d_template_args (di
)));
2730 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
2733 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2734 d_expression (di
), NULL
);
2736 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
2738 /* Function parameter used in a late-specified return type. */
2741 if (d_peek_char (di
) == 'T')
2743 /* 'this' parameter. */
2749 index
= d_compact_number (di
) + 1;
2753 return d_make_function_param (di
, index
);
2755 else if (IS_DIGIT (peek
)
2756 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
2758 /* We can get an unqualified name as an expression in the case of
2759 a dependent function call, i.e. decltype(f(t)). */
2760 struct demangle_component
*name
;
2763 /* operator-function-id, i.e. operator+(t). */
2766 name
= d_unqualified_name (di
);
2769 if (d_peek_char (di
) == 'I')
2770 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2771 d_template_args (di
));
2777 struct demangle_component
*op
;
2780 op
= d_operator_name (di
);
2784 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
2785 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
2787 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
2788 && strcmp (op
->u
.s_operator
.op
->code
, "st") == 0)
2789 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2790 cplus_demangle_type (di
));
2796 case DEMANGLE_COMPONENT_OPERATOR
:
2797 args
= op
->u
.s_operator
.op
->args
;
2799 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
2800 args
= op
->u
.s_extended_operator
.args
;
2802 case DEMANGLE_COMPONENT_CAST
:
2811 struct demangle_component
*operand
;
2812 if (op
->type
== DEMANGLE_COMPONENT_CAST
2813 && d_check_char (di
, '_'))
2814 operand
= d_exprlist (di
);
2816 operand
= d_expression (di
);
2817 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2822 struct demangle_component
*left
;
2823 struct demangle_component
*right
;
2824 const char *code
= op
->u
.s_operator
.op
->code
;
2826 left
= d_expression (di
);
2827 if (!strcmp (code
, "cl"))
2828 right
= d_exprlist (di
);
2829 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
2831 right
= d_unqualified_name (di
);
2832 if (d_peek_char (di
) == 'I')
2833 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
2834 right
, d_template_args (di
));
2837 right
= d_expression (di
);
2839 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
2841 DEMANGLE_COMPONENT_BINARY_ARGS
,
2846 struct demangle_component
*first
;
2847 struct demangle_component
*second
;
2849 first
= d_expression (di
);
2850 second
= d_expression (di
);
2851 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
2853 DEMANGLE_COMPONENT_TRINARY_ARG1
,
2856 DEMANGLE_COMPONENT_TRINARY_ARG2
,
2858 d_expression (di
))));
2866 /* <expr-primary> ::= L <type> <(value) number> E
2867 ::= L <type> <(value) float> E
2868 ::= L <mangled-name> E
2871 static struct demangle_component
*
2872 d_expr_primary (struct d_info
*di
)
2874 struct demangle_component
*ret
;
2876 if (! d_check_char (di
, 'L'))
2878 if (d_peek_char (di
) == '_'
2879 /* Workaround for G++ bug; see comment in write_template_arg. */
2880 || d_peek_char (di
) == 'Z')
2881 ret
= cplus_demangle_mangled_name (di
, 0);
2884 struct demangle_component
*type
;
2885 enum demangle_component_type t
;
2888 type
= cplus_demangle_type (di
);
2892 /* If we have a type we know how to print, we aren't going to
2893 print the type name itself. */
2894 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2895 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
2896 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
2898 /* Rather than try to interpret the literal value, we just
2899 collect it as a string. Note that it's possible to have a
2900 floating point literal here. The ABI specifies that the
2901 format of such literals is machine independent. That's fine,
2902 but what's not fine is that versions of g++ up to 3.2 with
2903 -fabi-version=1 used upper case letters in the hex constant,
2904 and dumped out gcc's internal representation. That makes it
2905 hard to tell where the constant ends, and hard to dump the
2906 constant in any readable form anyhow. We don't attempt to
2907 handle these cases. */
2909 t
= DEMANGLE_COMPONENT_LITERAL
;
2910 if (d_peek_char (di
) == 'n')
2912 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
2916 while (d_peek_char (di
) != 'E')
2918 if (d_peek_char (di
) == '\0')
2922 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
2924 if (! d_check_char (di
, 'E'))
2929 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2930 ::= Z <(function) encoding> E s [<discriminator>]
2933 static struct demangle_component
*
2934 d_local_name (struct d_info
*di
)
2936 struct demangle_component
*function
;
2938 if (! d_check_char (di
, 'Z'))
2941 function
= d_encoding (di
, 0);
2943 if (! d_check_char (di
, 'E'))
2946 if (d_peek_char (di
) == 's')
2949 if (! d_discriminator (di
))
2951 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
2952 d_make_name (di
, "string literal",
2953 sizeof "string literal" - 1));
2957 struct demangle_component
*name
;
2960 if (d_peek_char (di
) == 'd')
2962 /* Default argument scope: d <number> _. */
2964 num
= d_compact_number (di
);
2973 /* Lambdas and unnamed types have internal discriminators. */
2974 case DEMANGLE_COMPONENT_LAMBDA
:
2975 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
2978 if (! d_discriminator (di
))
2982 name
= d_make_default_arg (di
, num
, name
);
2983 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
2987 /* <discriminator> ::= _ <(non-negative) number>
2989 We demangle the discriminator, but we don't print it out. FIXME:
2990 We should print it out in verbose mode. */
2993 d_discriminator (struct d_info
*di
)
2997 if (d_peek_char (di
) != '_')
3000 discrim
= d_number (di
);
3006 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3008 static struct demangle_component
*
3009 d_lambda (struct d_info
*di
)
3011 struct demangle_component
*tl
;
3012 struct demangle_component
*ret
;
3015 if (! d_check_char (di
, 'U'))
3017 if (! d_check_char (di
, 'l'))
3020 tl
= d_parmlist (di
);
3024 if (! d_check_char (di
, 'E'))
3027 num
= d_compact_number (di
);
3031 ret
= d_make_empty (di
);
3034 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3035 ret
->u
.s_unary_num
.sub
= tl
;
3036 ret
->u
.s_unary_num
.num
= num
;
3039 if (! d_add_substitution (di
, ret
))
3045 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3047 static struct demangle_component
*
3048 d_unnamed_type (struct d_info
*di
)
3050 struct demangle_component
*ret
;
3053 if (! d_check_char (di
, 'U'))
3055 if (! d_check_char (di
, 't'))
3058 num
= d_compact_number (di
);
3062 ret
= d_make_empty (di
);
3065 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3066 ret
->u
.s_number
.number
= num
;
3069 if (! d_add_substitution (di
, ret
))
3075 /* Add a new substitution. */
3078 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3082 if (di
->next_sub
>= di
->num_subs
)
3084 di
->subs
[di
->next_sub
] = dc
;
3089 /* <substitution> ::= S <seq-id> _
3099 If PREFIX is non-zero, then this type is being used as a prefix in
3100 a qualified name. In this case, for the standard substitutions, we
3101 need to check whether we are being used as a prefix for a
3102 constructor or destructor, and return a full template name.
3103 Otherwise we will get something like std::iostream::~iostream()
3104 which does not correspond particularly well to any function which
3105 actually appears in the source.
3108 static const struct d_standard_sub_info standard_subs
[] =
3113 { 'a', NL ("std::allocator"),
3114 NL ("std::allocator"),
3116 { 'b', NL ("std::basic_string"),
3117 NL ("std::basic_string"),
3118 NL ("basic_string") },
3119 { 's', NL ("std::string"),
3120 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3121 NL ("basic_string") },
3122 { 'i', NL ("std::istream"),
3123 NL ("std::basic_istream<char, std::char_traits<char> >"),
3124 NL ("basic_istream") },
3125 { 'o', NL ("std::ostream"),
3126 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3127 NL ("basic_ostream") },
3128 { 'd', NL ("std::iostream"),
3129 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3130 NL ("basic_iostream") }
3133 static struct demangle_component
*
3134 d_substitution (struct d_info
*di
, int prefix
)
3138 if (! d_check_char (di
, 'S'))
3141 c
= d_next_char (di
);
3142 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3151 unsigned int new_id
;
3154 new_id
= id
* 36 + c
- '0';
3155 else if (IS_UPPER (c
))
3156 new_id
= id
* 36 + c
- 'A' + 10;
3162 c
= d_next_char (di
);
3169 if (id
>= (unsigned int) di
->next_sub
)
3174 return di
->subs
[id
];
3179 const struct d_standard_sub_info
*p
;
3180 const struct d_standard_sub_info
*pend
;
3182 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3183 if (! verbose
&& prefix
)
3187 peek
= d_peek_char (di
);
3188 if (peek
== 'C' || peek
== 'D')
3192 pend
= (&standard_subs
[0]
3193 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3194 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3201 if (p
->set_last_name
!= NULL
)
3202 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3203 p
->set_last_name_len
);
3206 s
= p
->full_expansion
;
3211 s
= p
->simple_expansion
;
3212 len
= p
->simple_len
;
3214 di
->expansion
+= len
;
3215 return d_make_sub (di
, s
, len
);
3223 /* Initialize a growable string. */
3226 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
3231 dgs
->allocation_failure
= 0;
3234 d_growable_string_resize (dgs
, estimate
);
3237 /* Grow a growable string to a given size. */
3240 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
3245 if (dgs
->allocation_failure
)
3248 /* Start allocation at two bytes to avoid any possibility of confusion
3249 with the special value of 1 used as a return in *palc to indicate
3250 allocation failures. */
3251 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
3252 while (newalc
< need
)
3255 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
3262 dgs
->allocation_failure
= 1;
3269 /* Append a buffer to a growable string. */
3272 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
3273 const char *s
, size_t l
)
3277 need
= dgs
->len
+ l
+ 1;
3278 if (need
> dgs
->alc
)
3279 d_growable_string_resize (dgs
, need
);
3281 if (dgs
->allocation_failure
)
3284 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
3285 dgs
->buf
[dgs
->len
+ l
] = '\0';
3289 /* Bridge growable strings to the callback mechanism. */
3292 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
3294 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
3296 d_growable_string_append_buffer (dgs
, s
, l
);
3299 /* Initialize a print information structure. */
3302 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
3306 dpi
->last_char
= '\0';
3307 dpi
->templates
= NULL
;
3308 dpi
->modifiers
= NULL
;
3309 dpi
->pack_index
= 0;
3310 dpi
->flush_count
= 0;
3312 dpi
->callback
= callback
;
3313 dpi
->opaque
= opaque
;
3315 dpi
->demangle_failure
= 0;
3318 /* Indicate that an error occurred during printing, and test for error. */
3321 d_print_error (struct d_print_info
*dpi
)
3323 dpi
->demangle_failure
= 1;
3327 d_print_saw_error (struct d_print_info
*dpi
)
3329 return dpi
->demangle_failure
!= 0;
3332 /* Flush buffered characters to the callback. */
3335 d_print_flush (struct d_print_info
*dpi
)
3337 dpi
->buf
[dpi
->len
] = '\0';
3338 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
3343 /* Append characters and buffers for printing. */
3346 d_append_char (struct d_print_info
*dpi
, char c
)
3348 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
3349 d_print_flush (dpi
);
3351 dpi
->buf
[dpi
->len
++] = c
;
3356 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
3360 for (i
= 0; i
< l
; i
++)
3361 d_append_char (dpi
, s
[i
]);
3365 d_append_string (struct d_print_info
*dpi
, const char *s
)
3367 d_append_buffer (dpi
, s
, strlen (s
));
3371 d_append_num (struct d_print_info
*dpi
, long l
)
3374 sprintf (buf
,"%ld", l
);
3375 d_append_string (dpi
, buf
);
3379 d_last_char (struct d_print_info
*dpi
)
3381 return dpi
->last_char
;
3384 /* Turn components into a human readable string. OPTIONS is the
3385 options bits passed to the demangler. DC is the tree to print.
3386 CALLBACK is a function to call to flush demangled string segments
3387 as they fill the intermediate buffer, and OPAQUE is a generalized
3388 callback argument. On success, this returns 1. On failure,
3389 it returns 0, indicating a bad parse. It does not use heap
3390 memory to build an output string, so cannot encounter memory
3391 allocation failure. */
3393 CP_STATIC_IF_GLIBCPP_V3
3395 cplus_demangle_print_callback (int options
,
3396 const struct demangle_component
*dc
,
3397 demangle_callbackref callback
, void *opaque
)
3399 struct d_print_info dpi
;
3401 d_print_init (&dpi
, callback
, opaque
);
3403 d_print_comp (&dpi
, options
, dc
);
3405 d_print_flush (&dpi
);
3407 return ! d_print_saw_error (&dpi
);
3410 /* Turn components into a human readable string. OPTIONS is the
3411 options bits passed to the demangler. DC is the tree to print.
3412 ESTIMATE is a guess at the length of the result. This returns a
3413 string allocated by malloc, or NULL on error. On success, this
3414 sets *PALC to the size of the allocated buffer. On failure, this
3415 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3418 CP_STATIC_IF_GLIBCPP_V3
3420 cplus_demangle_print (int options
, const struct demangle_component
*dc
,
3421 int estimate
, size_t *palc
)
3423 struct d_growable_string dgs
;
3425 d_growable_string_init (&dgs
, estimate
);
3427 if (! cplus_demangle_print_callback (options
, dc
,
3428 d_growable_string_callback_adapter
,
3436 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
3440 /* Returns the I'th element of the template arglist ARGS, or NULL on
3443 static struct demangle_component
*
3444 d_index_template_argument (struct demangle_component
*args
, int i
)
3446 struct demangle_component
*a
;
3452 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3458 if (i
!= 0 || a
== NULL
)
3464 /* Returns the template argument from the current context indicated by DC,
3465 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
3467 static struct demangle_component
*
3468 d_lookup_template_argument (struct d_print_info
*dpi
,
3469 const struct demangle_component
*dc
)
3471 if (dpi
->templates
== NULL
)
3473 d_print_error (dpi
);
3477 return d_index_template_argument
3478 (d_right (dpi
->templates
->template_decl
),
3479 dc
->u
.s_number
.number
);
3482 /* Returns a template argument pack used in DC (any will do), or NULL. */
3484 static struct demangle_component
*
3485 d_find_pack (struct d_print_info
*dpi
,
3486 const struct demangle_component
*dc
)
3488 struct demangle_component
*a
;
3494 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3495 a
= d_lookup_template_argument (dpi
, dc
);
3496 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3500 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
3503 case DEMANGLE_COMPONENT_LAMBDA
:
3504 case DEMANGLE_COMPONENT_NAME
:
3505 case DEMANGLE_COMPONENT_OPERATOR
:
3506 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3507 case DEMANGLE_COMPONENT_SUB_STD
:
3508 case DEMANGLE_COMPONENT_CHARACTER
:
3509 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
3512 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3513 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
3514 case DEMANGLE_COMPONENT_CTOR
:
3515 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
3516 case DEMANGLE_COMPONENT_DTOR
:
3517 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
3520 a
= d_find_pack (dpi
, d_left (dc
));
3523 return d_find_pack (dpi
, d_right (dc
));
3527 /* Returns the length of the template argument pack DC. */
3530 d_pack_length (const struct demangle_component
*dc
)
3533 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3534 && d_left (dc
) != NULL
)
3542 /* DC is a component of a mangled expression. Print it, wrapped in parens
3546 d_print_subexpr (struct d_print_info
*dpi
, int options
,
3547 const struct demangle_component
*dc
)
3550 if (dc
->type
== DEMANGLE_COMPONENT_NAME
3551 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
3554 d_append_char (dpi
, '(');
3555 d_print_comp (dpi
, options
, dc
);
3557 d_append_char (dpi
, ')');
3560 /* Subroutine to handle components. */
3563 d_print_comp (struct d_print_info
*dpi
, int options
,
3564 const struct demangle_component
*dc
)
3566 /* Magic variable to let reference smashing skip over the next modifier
3567 without needing to modify *dc. */
3568 const struct demangle_component
*mod_inner
= NULL
;
3572 d_print_error (dpi
);
3575 if (d_print_saw_error (dpi
))
3580 case DEMANGLE_COMPONENT_NAME
:
3581 if ((options
& DMGL_JAVA
) == 0)
3582 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
3584 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
3587 case DEMANGLE_COMPONENT_QUAL_NAME
:
3588 case DEMANGLE_COMPONENT_LOCAL_NAME
:
3589 d_print_comp (dpi
, options
, d_left (dc
));
3590 if ((options
& DMGL_JAVA
) == 0)
3591 d_append_string (dpi
, "::");
3593 d_append_char (dpi
, '.');
3594 d_print_comp (dpi
, options
, d_right (dc
));
3597 case DEMANGLE_COMPONENT_TYPED_NAME
:
3599 struct d_print_mod
*hold_modifiers
;
3600 struct demangle_component
*typed_name
;
3601 struct d_print_mod adpm
[4];
3603 struct d_print_template dpt
;
3605 /* Pass the name down to the type so that it can be printed in
3606 the right place for the type. We also have to pass down
3607 any CV-qualifiers, which apply to the this parameter. */
3608 hold_modifiers
= dpi
->modifiers
;
3611 typed_name
= d_left (dc
);
3612 while (typed_name
!= NULL
)
3614 if (i
>= sizeof adpm
/ sizeof adpm
[0])
3616 d_print_error (dpi
);
3620 adpm
[i
].next
= dpi
->modifiers
;
3621 dpi
->modifiers
= &adpm
[i
];
3622 adpm
[i
].mod
= typed_name
;
3623 adpm
[i
].printed
= 0;
3624 adpm
[i
].templates
= dpi
->templates
;
3627 if (typed_name
->type
!= DEMANGLE_COMPONENT_RESTRICT_THIS
3628 && typed_name
->type
!= DEMANGLE_COMPONENT_VOLATILE_THIS
3629 && typed_name
->type
!= DEMANGLE_COMPONENT_CONST_THIS
)
3632 typed_name
= d_left (typed_name
);
3635 if (typed_name
== NULL
)
3637 d_print_error (dpi
);
3641 /* If typed_name is a template, then it applies to the
3642 function type as well. */
3643 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
3645 dpt
.next
= dpi
->templates
;
3646 dpi
->templates
= &dpt
;
3647 dpt
.template_decl
= typed_name
;
3650 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3651 there may be CV-qualifiers on its right argument which
3652 really apply here; this happens when parsing a class which
3653 is local to a function. */
3654 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
3656 struct demangle_component
*local_name
;
3658 local_name
= d_right (typed_name
);
3659 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
3660 local_name
= local_name
->u
.s_unary_num
.sub
;
3661 while (local_name
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3662 || local_name
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3663 || local_name
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
3665 if (i
>= sizeof adpm
/ sizeof adpm
[0])
3667 d_print_error (dpi
);
3671 adpm
[i
] = adpm
[i
- 1];
3672 adpm
[i
].next
= &adpm
[i
- 1];
3673 dpi
->modifiers
= &adpm
[i
];
3675 adpm
[i
- 1].mod
= local_name
;
3676 adpm
[i
- 1].printed
= 0;
3677 adpm
[i
- 1].templates
= dpi
->templates
;
3680 local_name
= d_left (local_name
);
3684 d_print_comp (dpi
, options
, d_right (dc
));
3686 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
3687 dpi
->templates
= dpt
.next
;
3689 /* If the modifiers didn't get printed by the type, print them
3694 if (! adpm
[i
].printed
)
3696 d_append_char (dpi
, ' ');
3697 d_print_mod (dpi
, options
, adpm
[i
].mod
);
3701 dpi
->modifiers
= hold_modifiers
;
3706 case DEMANGLE_COMPONENT_TEMPLATE
:
3708 struct d_print_mod
*hold_dpm
;
3709 struct demangle_component
*dcl
;
3711 /* Don't push modifiers into a template definition. Doing so
3712 could give the wrong definition for a template argument.
3713 Instead, treat the template essentially as a name. */
3715 hold_dpm
= dpi
->modifiers
;
3716 dpi
->modifiers
= NULL
;
3720 if ((options
& DMGL_JAVA
) != 0
3721 && dcl
->type
== DEMANGLE_COMPONENT_NAME
3722 && dcl
->u
.s_name
.len
== 6
3723 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
3725 /* Special-case Java arrays, so that JArray<TYPE> appears
3726 instead as TYPE[]. */
3728 d_print_comp (dpi
, options
, d_right (dc
));
3729 d_append_string (dpi
, "[]");
3733 d_print_comp (dpi
, options
, dcl
);
3734 if (d_last_char (dpi
) == '<')
3735 d_append_char (dpi
, ' ');
3736 d_append_char (dpi
, '<');
3737 d_print_comp (dpi
, options
, d_right (dc
));
3738 /* Avoid generating two consecutive '>' characters, to avoid
3739 the C++ syntactic ambiguity. */
3740 if (d_last_char (dpi
) == '>')
3741 d_append_char (dpi
, ' ');
3742 d_append_char (dpi
, '>');
3745 dpi
->modifiers
= hold_dpm
;
3750 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3752 struct d_print_template
*hold_dpt
;
3753 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
3755 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3756 a
= d_index_template_argument (a
, dpi
->pack_index
);
3760 d_print_error (dpi
);
3764 /* While processing this parameter, we need to pop the list of
3765 templates. This is because the template parameter may
3766 itself be a reference to a parameter of an outer
3769 hold_dpt
= dpi
->templates
;
3770 dpi
->templates
= hold_dpt
->next
;
3772 d_print_comp (dpi
, options
, a
);
3774 dpi
->templates
= hold_dpt
;
3779 case DEMANGLE_COMPONENT_CTOR
:
3780 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
3783 case DEMANGLE_COMPONENT_DTOR
:
3784 d_append_char (dpi
, '~');
3785 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
3788 case DEMANGLE_COMPONENT_VTABLE
:
3789 d_append_string (dpi
, "vtable for ");
3790 d_print_comp (dpi
, options
, d_left (dc
));
3793 case DEMANGLE_COMPONENT_VTT
:
3794 d_append_string (dpi
, "VTT for ");
3795 d_print_comp (dpi
, options
, d_left (dc
));
3798 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
3799 d_append_string (dpi
, "construction vtable for ");
3800 d_print_comp (dpi
, options
, d_left (dc
));
3801 d_append_string (dpi
, "-in-");
3802 d_print_comp (dpi
, options
, d_right (dc
));
3805 case DEMANGLE_COMPONENT_TYPEINFO
:
3806 d_append_string (dpi
, "typeinfo for ");
3807 d_print_comp (dpi
, options
, d_left (dc
));
3810 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
3811 d_append_string (dpi
, "typeinfo name for ");
3812 d_print_comp (dpi
, options
, d_left (dc
));
3815 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
3816 d_append_string (dpi
, "typeinfo fn for ");
3817 d_print_comp (dpi
, options
, d_left (dc
));
3820 case DEMANGLE_COMPONENT_THUNK
:
3821 d_append_string (dpi
, "non-virtual thunk to ");
3822 d_print_comp (dpi
, options
, d_left (dc
));
3825 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
3826 d_append_string (dpi
, "virtual thunk to ");
3827 d_print_comp (dpi
, options
, d_left (dc
));
3830 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
3831 d_append_string (dpi
, "covariant return thunk to ");
3832 d_print_comp (dpi
, options
, d_left (dc
));
3835 case DEMANGLE_COMPONENT_JAVA_CLASS
:
3836 d_append_string (dpi
, "java Class for ");
3837 d_print_comp (dpi
, options
, d_left (dc
));
3840 case DEMANGLE_COMPONENT_GUARD
:
3841 d_append_string (dpi
, "guard variable for ");
3842 d_print_comp (dpi
, options
, d_left (dc
));
3845 case DEMANGLE_COMPONENT_REFTEMP
:
3846 d_append_string (dpi
, "reference temporary for ");
3847 d_print_comp (dpi
, options
, d_left (dc
));
3850 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
3851 d_append_string (dpi
, "hidden alias for ");
3852 d_print_comp (dpi
, options
, d_left (dc
));
3855 case DEMANGLE_COMPONENT_SUB_STD
:
3856 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
3859 case DEMANGLE_COMPONENT_RESTRICT
:
3860 case DEMANGLE_COMPONENT_VOLATILE
:
3861 case DEMANGLE_COMPONENT_CONST
:
3863 struct d_print_mod
*pdpm
;
3865 /* When printing arrays, it's possible to have cases where the
3866 same CV-qualifier gets pushed on the stack multiple times.
3867 We only need to print it once. */
3869 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
3871 if (! pdpm
->printed
)
3873 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
3874 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
3875 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
3877 if (pdpm
->mod
->type
== dc
->type
)
3879 d_print_comp (dpi
, options
, d_left (dc
));
3887 case DEMANGLE_COMPONENT_REFERENCE
:
3888 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
3890 /* Handle reference smashing: & + && = &. */
3891 const struct demangle_component
*sub
= d_left (dc
);
3892 if (sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
3894 struct demangle_component
*a
= d_lookup_template_argument (dpi
, sub
);
3895 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3896 a
= d_index_template_argument (a
, dpi
->pack_index
);
3900 d_print_error (dpi
);
3907 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
3908 || sub
->type
== dc
->type
)
3910 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
3911 mod_inner
= d_left (sub
);
3915 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3916 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3917 case DEMANGLE_COMPONENT_CONST_THIS
:
3918 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3919 case DEMANGLE_COMPONENT_POINTER
:
3920 case DEMANGLE_COMPONENT_COMPLEX
:
3921 case DEMANGLE_COMPONENT_IMAGINARY
:
3924 /* We keep a list of modifiers on the stack. */
3925 struct d_print_mod dpm
;
3927 dpm
.next
= dpi
->modifiers
;
3928 dpi
->modifiers
= &dpm
;
3931 dpm
.templates
= dpi
->templates
;
3934 mod_inner
= d_left (dc
);
3936 d_print_comp (dpi
, options
, mod_inner
);
3938 /* If the modifier didn't get printed by the type, print it
3941 d_print_mod (dpi
, options
, dc
);
3943 dpi
->modifiers
= dpm
.next
;
3948 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3949 if ((options
& DMGL_JAVA
) == 0)
3950 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
3951 dc
->u
.s_builtin
.type
->len
);
3953 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
3954 dc
->u
.s_builtin
.type
->java_len
);
3957 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
3958 d_print_comp (dpi
, options
, d_left (dc
));
3961 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
3963 if ((options
& DMGL_RET_POSTFIX
) != 0)
3964 d_print_function_type (dpi
,
3965 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
3966 dc
, dpi
->modifiers
);
3968 /* Print return type if present */
3969 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
3970 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
3972 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
3974 struct d_print_mod dpm
;
3976 /* We must pass this type down as a modifier in order to
3977 print it in the right location. */
3978 dpm
.next
= dpi
->modifiers
;
3979 dpi
->modifiers
= &dpm
;
3982 dpm
.templates
= dpi
->templates
;
3984 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
3987 dpi
->modifiers
= dpm
.next
;
3992 /* In standard prefix notation, there is a space between the
3993 return type and the function signature. */
3994 if ((options
& DMGL_RET_POSTFIX
) == 0)
3995 d_append_char (dpi
, ' ');
3998 if ((options
& DMGL_RET_POSTFIX
) == 0)
3999 d_print_function_type (dpi
,
4000 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4001 dc
, dpi
->modifiers
);
4006 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4008 struct d_print_mod
*hold_modifiers
;
4009 struct d_print_mod adpm
[4];
4011 struct d_print_mod
*pdpm
;
4013 /* We must pass this type down as a modifier in order to print
4014 multi-dimensional arrays correctly. If the array itself is
4015 CV-qualified, we act as though the element type were
4016 CV-qualified. We do this by copying the modifiers down
4017 rather than fiddling pointers, so that we don't wind up
4018 with a d_print_mod higher on the stack pointing into our
4019 stack frame after we return. */
4021 hold_modifiers
= dpi
->modifiers
;
4023 adpm
[0].next
= hold_modifiers
;
4024 dpi
->modifiers
= &adpm
[0];
4026 adpm
[0].printed
= 0;
4027 adpm
[0].templates
= dpi
->templates
;
4030 pdpm
= hold_modifiers
;
4032 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
4033 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
4034 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
4036 if (! pdpm
->printed
)
4038 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4040 d_print_error (dpi
);
4045 adpm
[i
].next
= dpi
->modifiers
;
4046 dpi
->modifiers
= &adpm
[i
];
4054 d_print_comp (dpi
, options
, d_right (dc
));
4056 dpi
->modifiers
= hold_modifiers
;
4058 if (adpm
[0].printed
)
4064 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4067 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
4072 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4073 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4075 struct d_print_mod dpm
;
4077 dpm
.next
= dpi
->modifiers
;
4078 dpi
->modifiers
= &dpm
;
4081 dpm
.templates
= dpi
->templates
;
4083 d_print_comp (dpi
, options
, d_right (dc
));
4085 /* If the modifier didn't get printed by the type, print it
4088 d_print_mod (dpi
, options
, dc
);
4090 dpi
->modifiers
= dpm
.next
;
4095 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4096 if (dc
->u
.s_fixed
.sat
)
4097 d_append_string (dpi
, "_Sat ");
4098 /* Don't print "int _Accum". */
4099 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
4100 != &cplus_demangle_builtin_types
['i'-'a'])
4102 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
4103 d_append_char (dpi
, ' ');
4105 if (dc
->u
.s_fixed
.accum
)
4106 d_append_string (dpi
, "_Accum");
4108 d_append_string (dpi
, "_Fract");
4111 case DEMANGLE_COMPONENT_ARGLIST
:
4112 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4113 if (d_left (dc
) != NULL
)
4114 d_print_comp (dpi
, options
, d_left (dc
));
4115 if (d_right (dc
) != NULL
)
4118 unsigned long int flush_count
;
4119 /* Make sure ", " isn't flushed by d_append_string, otherwise
4120 dpi->len -= 2 wouldn't work. */
4121 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
4122 d_print_flush (dpi
);
4123 d_append_string (dpi
, ", ");
4125 flush_count
= dpi
->flush_count
;
4126 d_print_comp (dpi
, options
, d_right (dc
));
4127 /* If that didn't print anything (which can happen with empty
4128 template argument packs), remove the comma and space. */
4129 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
4134 case DEMANGLE_COMPONENT_OPERATOR
:
4138 d_append_string (dpi
, "operator");
4139 c
= dc
->u
.s_operator
.op
->name
[0];
4141 d_append_char (dpi
, ' ');
4142 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
4143 dc
->u
.s_operator
.op
->len
);
4147 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4148 d_append_string (dpi
, "operator ");
4149 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
4152 case DEMANGLE_COMPONENT_CAST
:
4153 d_append_string (dpi
, "operator ");
4154 d_print_cast (dpi
, options
, dc
);
4157 case DEMANGLE_COMPONENT_UNARY
:
4158 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4159 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4160 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '&'
4161 && d_right (dc
)->type
== DEMANGLE_COMPONENT_TYPED_NAME
4162 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_QUAL_NAME
4163 && d_right (d_right (dc
))->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4165 /* Address of a function (therefore in an expression context) must
4166 have its argument list suppressed.
4168 unary operator ... dc
4169 operator & ... d_left (dc)
4170 typed name ... d_right (dc)
4171 qualified name ... d_left (d_right (dc))
4173 function type ... d_right (d_right (dc))
4177 d_print_expr_op (dpi
, options
, d_left (dc
));
4178 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
4181 else if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4182 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4183 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '&'
4184 && d_right (dc
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
)
4186 /* Keep also already processed variant without the argument list.
4188 unary operator ... dc
4189 operator & ... d_left (dc)
4190 qualified name ... d_right (dc)
4193 d_print_expr_op (dpi
, options
, d_left (dc
));
4194 d_print_comp (dpi
, options
, d_right (dc
));
4197 else if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_CAST
)
4198 d_print_expr_op (dpi
, options
, d_left (dc
));
4201 d_append_char (dpi
, '(');
4202 d_print_cast (dpi
, options
, d_left (dc
));
4203 d_append_char (dpi
, ')');
4205 d_print_subexpr (dpi
, options
, d_right (dc
));
4208 case DEMANGLE_COMPONENT_BINARY
:
4209 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
4211 d_print_error (dpi
);
4215 /* We wrap an expression which uses the greater-than operator in
4216 an extra layer of parens so that it does not get confused
4217 with the '>' which ends the template parameters. */
4218 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4219 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4220 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
4221 d_append_char (dpi
, '(');
4223 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
4224 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
4226 /* Function call used in an expression should not have printed types
4227 of the function arguments. Values of the function arguments still
4228 get printed below. */
4230 const struct demangle_component
*func
= d_left (d_right (dc
));
4232 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4233 d_print_error (dpi
);
4234 d_print_subexpr (dpi
, options
, d_left (func
));
4237 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
4238 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
4240 d_append_char (dpi
, '[');
4241 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
4242 d_append_char (dpi
, ']');
4246 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
4247 d_print_expr_op (dpi
, options
, d_left (dc
));
4248 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
4251 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4252 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4253 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
4254 d_append_char (dpi
, ')');
4258 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4259 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
4260 d_print_error (dpi
);
4263 case DEMANGLE_COMPONENT_TRINARY
:
4264 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
4265 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
4267 d_print_error (dpi
);
4270 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
4271 d_print_expr_op (dpi
, options
, d_left (dc
));
4272 d_print_subexpr (dpi
, options
, d_left (d_right (d_right (dc
))));
4273 d_append_string (dpi
, " : ");
4274 d_print_subexpr (dpi
, options
, d_right (d_right (d_right (dc
))));
4277 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4278 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4279 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
4280 d_print_error (dpi
);
4283 case DEMANGLE_COMPONENT_LITERAL
:
4284 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4286 enum d_builtin_type_print tp
;
4288 /* For some builtin types, produce simpler output. */
4289 tp
= D_PRINT_DEFAULT
;
4290 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
4292 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
4296 case D_PRINT_UNSIGNED
:
4298 case D_PRINT_UNSIGNED_LONG
:
4299 case D_PRINT_LONG_LONG
:
4300 case D_PRINT_UNSIGNED_LONG_LONG
:
4301 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
4303 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
4304 d_append_char (dpi
, '-');
4305 d_print_comp (dpi
, options
, d_right (dc
));
4310 case D_PRINT_UNSIGNED
:
4311 d_append_char (dpi
, 'u');
4314 d_append_char (dpi
, 'l');
4316 case D_PRINT_UNSIGNED_LONG
:
4317 d_append_string (dpi
, "ul");
4319 case D_PRINT_LONG_LONG
:
4320 d_append_string (dpi
, "ll");
4322 case D_PRINT_UNSIGNED_LONG_LONG
:
4323 d_append_string (dpi
, "ull");
4331 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
4332 && d_right (dc
)->u
.s_name
.len
== 1
4333 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
4335 switch (d_right (dc
)->u
.s_name
.s
[0])
4338 d_append_string (dpi
, "false");
4341 d_append_string (dpi
, "true");
4354 d_append_char (dpi
, '(');
4355 d_print_comp (dpi
, options
, d_left (dc
));
4356 d_append_char (dpi
, ')');
4357 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
4358 d_append_char (dpi
, '-');
4359 if (tp
== D_PRINT_FLOAT
)
4360 d_append_char (dpi
, '[');
4361 d_print_comp (dpi
, options
, d_right (dc
));
4362 if (tp
== D_PRINT_FLOAT
)
4363 d_append_char (dpi
, ']');
4367 case DEMANGLE_COMPONENT_NUMBER
:
4368 d_append_num (dpi
, dc
->u
.s_number
.number
);
4371 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4372 d_append_string (dpi
, "java resource ");
4373 d_print_comp (dpi
, options
, d_left (dc
));
4376 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4377 d_print_comp (dpi
, options
, d_left (dc
));
4378 d_print_comp (dpi
, options
, d_right (dc
));
4381 case DEMANGLE_COMPONENT_CHARACTER
:
4382 d_append_char (dpi
, dc
->u
.s_character
.character
);
4385 case DEMANGLE_COMPONENT_DECLTYPE
:
4386 d_append_string (dpi
, "decltype (");
4387 d_print_comp (dpi
, options
, d_left (dc
));
4388 d_append_char (dpi
, ')');
4391 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4395 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
4398 /* d_find_pack won't find anything if the only packs involved
4399 in this expansion are function parameter packs; in that
4400 case, just print the pattern and "...". */
4401 d_print_subexpr (dpi
, options
, d_left (dc
));
4402 d_append_string (dpi
, "...");
4406 len
= d_pack_length (a
);
4408 for (i
= 0; i
< len
; ++i
)
4410 dpi
->pack_index
= i
;
4411 d_print_comp (dpi
, options
, dc
);
4413 d_append_string (dpi
, ", ");
4418 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4420 long num
= dc
->u
.s_number
.number
;
4422 d_append_string (dpi
, "this");
4425 d_append_string (dpi
, "{parm#");
4426 d_append_num (dpi
, num
);
4427 d_append_char (dpi
, '}');
4432 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4433 d_append_string (dpi
, "global constructors keyed to ");
4434 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
4437 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4438 d_append_string (dpi
, "global destructors keyed to ");
4439 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
4442 case DEMANGLE_COMPONENT_LAMBDA
:
4443 d_append_string (dpi
, "{lambda(");
4444 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
4445 d_append_string (dpi
, ")#");
4446 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
4447 d_append_char (dpi
, '}');
4450 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4451 d_append_string (dpi
, "{unnamed type#");
4452 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4453 d_append_char (dpi
, '}');
4457 d_print_error (dpi
);
4462 /* Print a Java dentifier. For Java we try to handle encoded extended
4463 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
4464 so we don't it for C++. Characters are encoded as
4468 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
4474 for (p
= name
; p
< end
; ++p
)
4485 for (q
= p
+ 3; q
< end
; ++q
)
4491 else if (*q
>= 'A' && *q
<= 'F')
4492 dig
= *q
- 'A' + 10;
4493 else if (*q
>= 'a' && *q
<= 'f')
4494 dig
= *q
- 'a' + 10;
4500 /* If the Unicode character is larger than 256, we don't try
4501 to deal with it here. FIXME. */
4502 if (q
< end
&& *q
== '_' && c
< 256)
4504 d_append_char (dpi
, c
);
4510 d_append_char (dpi
, *p
);
4514 /* Print a list of modifiers. SUFFIX is 1 if we are printing
4515 qualifiers on this after printing a function. */
4518 d_print_mod_list (struct d_print_info
*dpi
, int options
,
4519 struct d_print_mod
*mods
, int suffix
)
4521 struct d_print_template
*hold_dpt
;
4523 if (mods
== NULL
|| d_print_saw_error (dpi
))
4528 && (mods
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
4529 || mods
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
4530 || mods
->mod
->type
== DEMANGLE_COMPONENT_CONST_THIS
)))
4532 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
4538 hold_dpt
= dpi
->templates
;
4539 dpi
->templates
= mods
->templates
;
4541 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4543 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
4544 dpi
->templates
= hold_dpt
;
4547 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
4549 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
4550 dpi
->templates
= hold_dpt
;
4553 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4555 struct d_print_mod
*hold_modifiers
;
4556 struct demangle_component
*dc
;
4558 /* When this is on the modifier stack, we have pulled any
4559 qualifiers off the right argument already. Otherwise, we
4560 print it as usual, but don't let the left argument see any
4563 hold_modifiers
= dpi
->modifiers
;
4564 dpi
->modifiers
= NULL
;
4565 d_print_comp (dpi
, options
, d_left (mods
->mod
));
4566 dpi
->modifiers
= hold_modifiers
;
4568 if ((options
& DMGL_JAVA
) == 0)
4569 d_append_string (dpi
, "::");
4571 d_append_char (dpi
, '.');
4573 dc
= d_right (mods
->mod
);
4575 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4577 d_append_string (dpi
, "{default arg#");
4578 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
4579 d_append_string (dpi
, "}::");
4580 dc
= dc
->u
.s_unary_num
.sub
;
4583 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
4584 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
4585 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
4588 d_print_comp (dpi
, options
, dc
);
4590 dpi
->templates
= hold_dpt
;
4594 d_print_mod (dpi
, options
, mods
->mod
);
4596 dpi
->templates
= hold_dpt
;
4598 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
4601 /* Print a modifier. */
4604 d_print_mod (struct d_print_info
*dpi
, int options
,
4605 const struct demangle_component
*mod
)
4609 case DEMANGLE_COMPONENT_RESTRICT
:
4610 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4611 d_append_string (dpi
, " restrict");
4613 case DEMANGLE_COMPONENT_VOLATILE
:
4614 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4615 d_append_string (dpi
, " volatile");
4617 case DEMANGLE_COMPONENT_CONST
:
4618 case DEMANGLE_COMPONENT_CONST_THIS
:
4619 d_append_string (dpi
, " const");
4621 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4622 d_append_char (dpi
, ' ');
4623 d_print_comp (dpi
, options
, d_right (mod
));
4625 case DEMANGLE_COMPONENT_POINTER
:
4626 /* There is no pointer symbol in Java. */
4627 if ((options
& DMGL_JAVA
) == 0)
4628 d_append_char (dpi
, '*');
4630 case DEMANGLE_COMPONENT_REFERENCE
:
4631 d_append_char (dpi
, '&');
4633 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4634 d_append_string (dpi
, "&&");
4636 case DEMANGLE_COMPONENT_COMPLEX
:
4637 d_append_string (dpi
, "complex ");
4639 case DEMANGLE_COMPONENT_IMAGINARY
:
4640 d_append_string (dpi
, "imaginary ");
4642 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4643 if (d_last_char (dpi
) != '(')
4644 d_append_char (dpi
, ' ');
4645 d_print_comp (dpi
, options
, d_left (mod
));
4646 d_append_string (dpi
, "::*");
4648 case DEMANGLE_COMPONENT_TYPED_NAME
:
4649 d_print_comp (dpi
, options
, d_left (mod
));
4651 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4652 d_append_string (dpi
, " __vector(");
4653 d_print_comp (dpi
, options
, d_left (mod
));
4654 d_append_char (dpi
, ')');
4658 /* Otherwise, we have something that won't go back on the
4659 modifier stack, so we can just print it. */
4660 d_print_comp (dpi
, options
, mod
);
4665 /* Print a function type, except for the return type. */
4668 d_print_function_type (struct d_print_info
*dpi
, int options
,
4669 const struct demangle_component
*dc
,
4670 struct d_print_mod
*mods
)
4674 struct d_print_mod
*p
;
4675 struct d_print_mod
*hold_modifiers
;
4679 for (p
= mods
; p
!= NULL
; p
= p
->next
)
4684 switch (p
->mod
->type
)
4686 case DEMANGLE_COMPONENT_POINTER
:
4687 case DEMANGLE_COMPONENT_REFERENCE
:
4688 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4691 case DEMANGLE_COMPONENT_RESTRICT
:
4692 case DEMANGLE_COMPONENT_VOLATILE
:
4693 case DEMANGLE_COMPONENT_CONST
:
4694 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4695 case DEMANGLE_COMPONENT_COMPLEX
:
4696 case DEMANGLE_COMPONENT_IMAGINARY
:
4697 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4701 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4702 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4703 case DEMANGLE_COMPONENT_CONST_THIS
:
4716 if (d_last_char (dpi
) != '('
4717 && d_last_char (dpi
) != '*')
4720 if (need_space
&& d_last_char (dpi
) != ' ')
4721 d_append_char (dpi
, ' ');
4722 d_append_char (dpi
, '(');
4725 hold_modifiers
= dpi
->modifiers
;
4726 dpi
->modifiers
= NULL
;
4728 d_print_mod_list (dpi
, options
, mods
, 0);
4731 d_append_char (dpi
, ')');
4733 d_append_char (dpi
, '(');
4735 if (d_right (dc
) != NULL
)
4736 d_print_comp (dpi
, options
, d_right (dc
));
4738 d_append_char (dpi
, ')');
4740 d_print_mod_list (dpi
, options
, mods
, 1);
4742 dpi
->modifiers
= hold_modifiers
;
4745 /* Print an array type, except for the element type. */
4748 d_print_array_type (struct d_print_info
*dpi
, int options
,
4749 const struct demangle_component
*dc
,
4750 struct d_print_mod
*mods
)
4758 struct d_print_mod
*p
;
4761 for (p
= mods
; p
!= NULL
; p
= p
->next
)
4765 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
4780 d_append_string (dpi
, " (");
4782 d_print_mod_list (dpi
, options
, mods
, 0);
4785 d_append_char (dpi
, ')');
4789 d_append_char (dpi
, ' ');
4791 d_append_char (dpi
, '[');
4793 if (d_left (dc
) != NULL
)
4794 d_print_comp (dpi
, options
, d_left (dc
));
4796 d_append_char (dpi
, ']');
4799 /* Print an operator in an expression. */
4802 d_print_expr_op (struct d_print_info
*dpi
, int options
,
4803 const struct demangle_component
*dc
)
4805 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
4806 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
4807 dc
->u
.s_operator
.op
->len
);
4809 d_print_comp (dpi
, options
, dc
);
4815 d_print_cast (struct d_print_info
*dpi
, int options
,
4816 const struct demangle_component
*dc
)
4818 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
4819 d_print_comp (dpi
, options
, d_left (dc
));
4822 struct d_print_mod
*hold_dpm
;
4823 struct d_print_template dpt
;
4825 /* It appears that for a templated cast operator, we need to put
4826 the template parameters in scope for the operator name, but
4827 not for the parameters. The effect is that we need to handle
4828 the template printing here. */
4830 hold_dpm
= dpi
->modifiers
;
4831 dpi
->modifiers
= NULL
;
4833 dpt
.next
= dpi
->templates
;
4834 dpi
->templates
= &dpt
;
4835 dpt
.template_decl
= d_left (dc
);
4837 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
4839 dpi
->templates
= dpt
.next
;
4841 if (d_last_char (dpi
) == '<')
4842 d_append_char (dpi
, ' ');
4843 d_append_char (dpi
, '<');
4844 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
4845 /* Avoid generating two consecutive '>' characters, to avoid
4846 the C++ syntactic ambiguity. */
4847 if (d_last_char (dpi
) == '>')
4848 d_append_char (dpi
, ' ');
4849 d_append_char (dpi
, '>');
4851 dpi
->modifiers
= hold_dpm
;
4855 /* Initialize the information structure we use to pass around
4858 CP_STATIC_IF_GLIBCPP_V3
4860 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
4864 di
->send
= mangled
+ len
;
4865 di
->options
= options
;
4869 /* We can not need more components than twice the number of chars in
4870 the mangled string. Most components correspond directly to
4871 chars, but the ARGLIST types are exceptions. */
4872 di
->num_comps
= 2 * len
;
4875 /* Similarly, we can not need more substitutions than there are
4876 chars in the mangled string. */
4881 di
->last_name
= NULL
;
4886 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
4887 mangled name, return strings in repeated callback giving the demangled
4888 name. OPTIONS is the usual libiberty demangler options. On success,
4889 this returns 1. On failure, returns 0. */
4892 d_demangle_callback (const char *mangled
, int options
,
4893 demangle_callbackref callback
, void *opaque
)
4904 struct demangle_component
*dc
;
4907 if (mangled
[0] == '_' && mangled
[1] == 'Z')
4909 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
4910 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
4911 && (mangled
[9] == 'D' || mangled
[9] == 'I')
4912 && mangled
[10] == '_')
4913 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
4916 if ((options
& DMGL_TYPES
) == 0)
4921 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
4924 #ifdef CP_DYNAMIC_ARRAYS
4925 __extension__
struct demangle_component comps
[di
.num_comps
];
4926 __extension__
struct demangle_component
*subs
[di
.num_subs
];
4931 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
4932 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
4938 dc
= cplus_demangle_type (&di
);
4941 dc
= cplus_demangle_mangled_name (&di
, 1);
4943 case DCT_GLOBAL_CTORS
:
4944 case DCT_GLOBAL_DTORS
:
4945 d_advance (&di
, 11);
4946 dc
= d_make_comp (&di
,
4947 (type
== DCT_GLOBAL_CTORS
4948 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
4949 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
4950 d_make_demangle_mangled_name (&di
, d_str (&di
)),
4952 d_advance (&di
, strlen (d_str (&di
)));
4956 /* If DMGL_PARAMS is set, then if we didn't consume the entire
4957 mangled string, then we didn't successfully demangle it. If
4958 DMGL_PARAMS is not set, we didn't look at the trailing
4960 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
4963 #ifdef CP_DEMANGLE_DEBUG
4967 status
= (dc
!= NULL
)
4968 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
4975 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
4976 name, return a buffer allocated with malloc holding the demangled
4977 name. OPTIONS is the usual libiberty demangler options. On
4978 success, this sets *PALC to the allocated size of the returned
4979 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
4980 a memory allocation failure, and returns NULL. */
4983 d_demangle (const char *mangled
, int options
, size_t *palc
)
4985 struct d_growable_string dgs
;
4988 d_growable_string_init (&dgs
, 0);
4990 status
= d_demangle_callback (mangled
, options
,
4991 d_growable_string_callback_adapter
, &dgs
);
4999 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
5003 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
5005 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
5007 /* ia64 ABI-mandated entry point in the C++ runtime library for
5008 performing demangling. MANGLED_NAME is a NUL-terminated character
5009 string containing the name to be demangled.
5011 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
5012 *LENGTH bytes, into which the demangled name is stored. If
5013 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
5014 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
5015 is placed in a region of memory allocated with malloc.
5017 If LENGTH is non-NULL, the length of the buffer containing the
5018 demangled name, is placed in *LENGTH.
5020 The return value is a pointer to the start of the NUL-terminated
5021 demangled name, or NULL if the demangling fails. The caller is
5022 responsible for deallocating this memory using free.
5024 *STATUS is set to one of the following values:
5025 0: The demangling operation succeeded.
5026 -1: A memory allocation failure occurred.
5027 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5028 -3: One of the arguments is invalid.
5030 The demangling is performed using the C++ ABI mangling rules, with
5034 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
5035 size_t *length
, int *status
)
5040 if (mangled_name
== NULL
)
5047 if (output_buffer
!= NULL
&& length
== NULL
)
5054 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
5056 if (demangled
== NULL
)
5068 if (output_buffer
== NULL
)
5075 if (strlen (demangled
) < *length
)
5077 strcpy (output_buffer
, demangled
);
5079 demangled
= output_buffer
;
5083 free (output_buffer
);
5094 extern int __gcclibcxx_demangle_callback (const char *,
5096 (const char *, size_t, void *),
5099 /* Alternative, allocationless entry point in the C++ runtime library
5100 for performing demangling. MANGLED_NAME is a NUL-terminated character
5101 string containing the name to be demangled.
5103 CALLBACK is a callback function, called with demangled string
5104 segments as demangling progresses; it is called at least once,
5105 but may be called more than once. OPAQUE is a generalized pointer
5106 used as a callback argument.
5108 The return code is one of the following values, equivalent to
5109 the STATUS values of __cxa_demangle() (excluding -1, since this
5110 function performs no memory allocations):
5111 0: The demangling operation succeeded.
5112 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5113 -3: One of the arguments is invalid.
5115 The demangling is performed using the C++ ABI mangling rules, with
5119 __gcclibcxx_demangle_callback (const char *mangled_name
,
5120 void (*callback
) (const char *, size_t, void *),
5125 if (mangled_name
== NULL
|| callback
== NULL
)
5128 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
5136 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5138 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
5139 mangled name, return a buffer allocated with malloc holding the
5140 demangled name. Otherwise, return NULL. */
5143 cplus_demangle_v3 (const char *mangled
, int options
)
5147 return d_demangle (mangled
, options
, &alc
);
5151 cplus_demangle_v3_callback (const char *mangled
, int options
,
5152 demangle_callbackref callback
, void *opaque
)
5154 return d_demangle_callback (mangled
, options
, callback
, opaque
);
5157 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
5158 conventions, but the output formatting is a little different.
5159 This instructs the C++ demangler not to emit pointer characters ("*"), to
5160 use Java's namespace separator symbol ("." instead of "::"), and to output
5161 JArray<TYPE> as TYPE[]. */
5164 java_demangle_v3 (const char *mangled
)
5168 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
5172 java_demangle_v3_callback (const char *mangled
,
5173 demangle_callbackref callback
, void *opaque
)
5175 return d_demangle_callback (mangled
,
5176 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
5180 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5182 #ifndef IN_GLIBCPP_V3
5184 /* Demangle a string in order to find out whether it is a constructor
5185 or destructor. Return non-zero on success. Set *CTOR_KIND and
5186 *DTOR_KIND appropriately. */
5189 is_ctor_or_dtor (const char *mangled
,
5190 enum gnu_v3_ctor_kinds
*ctor_kind
,
5191 enum gnu_v3_dtor_kinds
*dtor_kind
)
5194 struct demangle_component
*dc
;
5197 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
5198 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
5200 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
5203 #ifdef CP_DYNAMIC_ARRAYS
5204 __extension__
struct demangle_component comps
[di
.num_comps
];
5205 __extension__
struct demangle_component
*subs
[di
.num_subs
];
5210 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
5211 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
5214 dc
= cplus_demangle_mangled_name (&di
, 1);
5216 /* Note that because we did not pass DMGL_PARAMS, we don't expect
5217 to demangle the entire string. */
5227 case DEMANGLE_COMPONENT_TYPED_NAME
:
5228 case DEMANGLE_COMPONENT_TEMPLATE
:
5229 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5230 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5231 case DEMANGLE_COMPONENT_CONST_THIS
:
5234 case DEMANGLE_COMPONENT_QUAL_NAME
:
5235 case DEMANGLE_COMPONENT_LOCAL_NAME
:
5238 case DEMANGLE_COMPONENT_CTOR
:
5239 *ctor_kind
= dc
->u
.s_ctor
.kind
;
5243 case DEMANGLE_COMPONENT_DTOR
:
5244 *dtor_kind
= dc
->u
.s_dtor
.kind
;
5255 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5256 name. A non-zero return indicates the type of constructor. */
5258 enum gnu_v3_ctor_kinds
5259 is_gnu_v3_mangled_ctor (const char *name
)
5261 enum gnu_v3_ctor_kinds ctor_kind
;
5262 enum gnu_v3_dtor_kinds dtor_kind
;
5264 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
5265 return (enum gnu_v3_ctor_kinds
) 0;
5270 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5271 name. A non-zero return indicates the type of destructor. */
5273 enum gnu_v3_dtor_kinds
5274 is_gnu_v3_mangled_dtor (const char *name
)
5276 enum gnu_v3_ctor_kinds ctor_kind
;
5277 enum gnu_v3_dtor_kinds dtor_kind
;
5279 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
5280 return (enum gnu_v3_dtor_kinds
) 0;
5284 #endif /* IN_GLIBCPP_V3 */
5286 #ifdef STANDALONE_DEMANGLER
5289 #include "dyn-string.h"
5291 static void print_usage (FILE* fp
, int exit_value
);
5293 #define IS_ALPHA(CHAR) \
5294 (((CHAR) >= 'a' && (CHAR) <= 'z') \
5295 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5297 /* Non-zero if CHAR is a character than can occur in a mangled name. */
5298 #define is_mangled_char(CHAR) \
5299 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
5300 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5302 /* The name of this program, as invoked. */
5303 const char* program_name
;
5305 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
5308 print_usage (FILE* fp
, int exit_value
)
5310 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
5311 fprintf (fp
, "Options:\n");
5312 fprintf (fp
, " -h,--help Display this message.\n");
5313 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
5314 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
5315 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
5320 /* Option specification for getopt_long. */
5321 static const struct option long_options
[] =
5323 { "help", no_argument
, NULL
, 'h' },
5324 { "no-params", no_argument
, NULL
, 'p' },
5325 { "verbose", no_argument
, NULL
, 'v' },
5326 { NULL
, no_argument
, NULL
, 0 },
5329 /* Main entry for a demangling filter executable. It will demangle
5330 its command line arguments, if any. If none are provided, it will
5331 filter stdin to stdout, replacing any recognized mangled C++ names
5332 with their demangled equivalents. */
5335 main (int argc
, char *argv
[])
5339 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
5341 /* Use the program name of this program, as invoked. */
5342 program_name
= argv
[0];
5344 /* Parse options. */
5347 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
5350 case '?': /* Unrecognized option. */
5351 print_usage (stderr
, 1);
5355 print_usage (stdout
, 0);
5359 options
&= ~ DMGL_PARAMS
;
5363 options
|= DMGL_VERBOSE
;
5367 while (opt_char
!= -1);
5370 /* No command line arguments were provided. Filter stdin. */
5372 dyn_string_t mangled
= dyn_string_new (3);
5375 /* Read all of input. */
5376 while (!feof (stdin
))
5380 /* Pile characters into mangled until we hit one that can't
5381 occur in a mangled name. */
5383 while (!feof (stdin
) && is_mangled_char (c
))
5385 dyn_string_append_char (mangled
, c
);
5391 if (dyn_string_length (mangled
) > 0)
5393 #ifdef IN_GLIBCPP_V3
5394 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
5396 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
5406 /* It might not have been a mangled name. Print the
5408 fputs (dyn_string_buf (mangled
), stdout
);
5411 dyn_string_clear (mangled
);
5414 /* If we haven't hit EOF yet, we've read one character that
5415 can't occur in a mangled name, so print it out. */
5420 dyn_string_delete (mangled
);
5423 /* Demangle command line arguments. */
5425 /* Loop over command line arguments. */
5426 for (i
= optind
; i
< argc
; ++i
)
5429 #ifdef IN_GLIBCPP_V3
5433 /* Attempt to demangle. */
5434 #ifdef IN_GLIBCPP_V3
5435 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
5437 s
= cplus_demangle_v3 (argv
[i
], options
);
5440 /* If it worked, print the demangled name. */
5448 #ifdef IN_GLIBCPP_V3
5449 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
5451 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
5460 #endif /* STANDALONE_DEMANGLER */