1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
7 This file is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
31 /* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
33 http://www.codesourcery.com/cxx-abi/abi.html#mangling
35 This code was written while looking at the demangler written by
36 Alex Samuel <samuel@codesourcery.com>.
38 This code first pulls the mangled name apart into a list of
39 components, and then walks the list generating the demangled
42 This file will normally define the following functions, q.v.:
43 char *cplus_demangle_v3(const char *mangled, int options)
44 char *java_demangle_v3(const char *mangled)
45 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
46 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
48 Also, the interface to the component list is public, and defined in
49 demangle.h. The interface consists of these types, which are
50 defined in demangle.h:
51 enum demangle_component_type
52 struct demangle_component
53 and these functions defined in this file:
54 cplus_demangle_fill_name
55 cplus_demangle_fill_extended_operator
56 cplus_demangle_fill_ctor
57 cplus_demangle_fill_dtor
59 and other functions defined in the file cp-demint.c.
61 This file also defines some other functions and variables which are
62 only to be used by the file cp-demint.c.
64 Preprocessor macros you can define while compiling this file:
67 If defined, this file defines the following function, q.v.:
68 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
70 instead of cplus_demangle_v3() and java_demangle_v3().
73 If defined, this file defines only __cxa_demangle(), and no other
74 publically visible functions or variables.
77 If defined, this file defines a main() function which demangles
78 any arguments, or, if none, demangles stdin.
81 If defined, turns on debugging mode, which prints information on
82 stdout about the mangled string. This is not generally useful.
99 #include "libiberty.h"
100 #include "demangle.h"
101 #include "cp-demangle.h"
103 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
104 also rename them via #define to avoid compiler errors when the
105 static definition conflicts with the extern declaration in a header
109 #define CP_STATIC_IF_GLIBCPP_V3 static
111 #define cplus_demangle_fill_name d_fill_name
113 d_fill_name
PARAMS ((struct demangle_component
*, const char *, int));
115 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
117 d_fill_extended_operator
PARAMS ((struct demangle_component
*, int,
118 struct demangle_component
*));
120 #define cplus_demangle_fill_ctor d_fill_ctor
122 d_fill_ctor
PARAMS ((struct demangle_component
*, enum gnu_v3_ctor_kinds
,
123 struct demangle_component
*));
125 #define cplus_demangle_fill_dtor d_fill_dtor
127 d_fill_dtor
PARAMS ((struct demangle_component
*, enum gnu_v3_dtor_kinds
,
128 struct demangle_component
*));
130 #define cplus_demangle_mangled_name d_mangled_name
131 static struct demangle_component
*
132 d_mangled_name
PARAMS ((struct d_info
*, int));
134 #define cplus_demangle_type d_type
135 static struct demangle_component
*
136 d_type
PARAMS ((struct d_info
*));
138 #define cplus_demangle_print d_print
140 d_print
PARAMS ((int, const struct demangle_component
*, int, size_t *));
142 #define cplus_demangle_init_info d_init_info
144 d_init_info
PARAMS ((const char *, int, size_t, struct d_info
*));
146 #else /* ! defined(IN_GLIBCPP_V3) */
147 #define CP_STATIC_IF_GLIBCPP_V3
148 #endif /* ! defined(IN_GLIBCPP_V3) */
150 /* See if the compiler supports dynamic arrays. */
153 #define CP_DYNAMIC_ARRAYS
156 #ifdef __STDC_VERSION__
157 #if __STDC_VERSION__ >= 199901L
158 #define CP_DYNAMIC_ARRAYS
159 #endif /* __STDC__VERSION >= 199901L */
160 #endif /* defined (__STDC_VERSION__) */
161 #endif /* defined (__STDC__) */
162 #endif /* ! defined (__GNUC__) */
164 /* We avoid pulling in the ctype tables, to prevent pulling in
165 additional unresolved symbols when this code is used in a library.
166 FIXME: Is this really a valid reason? This comes from the original
169 As of this writing this file has the following undefined references
170 when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy,
171 strcpy, strcat, strlen. */
173 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
174 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
175 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
177 /* The prefix prepended by GCC to an identifier represnting the
178 anonymous namespace. */
179 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
180 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
181 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
183 /* Information we keep for the standard substitutions. */
185 struct d_standard_sub_info
187 /* The code for this substitution. */
189 /* The simple string it expands to. */
190 const char *simple_expansion
;
191 /* The length of the simple expansion. */
193 /* The results of a full, verbose, expansion. This is used when
194 qualifying a constructor/destructor, or when in verbose mode. */
195 const char *full_expansion
;
196 /* The length of the full expansion. */
198 /* What to set the last_name field of d_info to; NULL if we should
199 not set it. This is only relevant when qualifying a
200 constructor/destructor. */
201 const char *set_last_name
;
202 /* The length of set_last_name. */
203 int set_last_name_len
;
206 /* Accessors for subtrees of struct demangle_component. */
208 #define d_left(dc) ((dc)->u.s_binary.left)
209 #define d_right(dc) ((dc)->u.s_binary.right)
211 /* A list of templates. This is used while printing. */
213 struct d_print_template
215 /* Next template on the list. */
216 struct d_print_template
*next
;
218 const struct demangle_component
*template;
221 /* A list of type modifiers. This is used while printing. */
225 /* Next modifier on the list. These are in the reverse of the order
226 in which they appeared in the mangled string. */
227 struct d_print_mod
*next
;
229 const struct demangle_component
*mod
;
230 /* Whether this modifier was printed. */
232 /* The list of templates which applies to this modifier. */
233 struct d_print_template
*templates
;
236 /* We use this structure to hold information during printing. */
240 /* The options passed to the demangler. */
242 /* Buffer holding the result. */
244 /* Current length of data in buffer. */
246 /* Allocated size of buffer. */
248 /* The current list of templates, if any. */
249 struct d_print_template
*templates
;
250 /* The current list of modifiers (e.g., pointer, reference, etc.),
252 struct d_print_mod
*modifiers
;
253 /* Set to 1 if we had a memory allocation failure. */
254 int allocation_failure
;
257 #define d_print_saw_error(dpi) ((dpi)->buf == NULL)
259 #define d_append_char(dpi, c) \
262 if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
263 (dpi)->buf[(dpi)->len++] = (c); \
265 d_print_append_char ((dpi), (c)); \
269 #define d_append_buffer(dpi, s, l) \
272 if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
274 memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
278 d_print_append_buffer ((dpi), (s), (l)); \
282 #define d_append_string_constant(dpi, s) \
283 d_append_buffer (dpi, (s), sizeof (s) - 1)
285 #define d_last_char(dpi) \
286 ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
288 #ifdef CP_DEMANGLE_DEBUG
290 d_dump
PARAMS ((struct demangle_component
*, int));
293 static struct demangle_component
*
294 d_make_empty
PARAMS ((struct d_info
*));
296 static struct demangle_component
*
297 d_make_comp
PARAMS ((struct d_info
*, enum demangle_component_type
,
298 struct demangle_component
*,
299 struct demangle_component
*));
301 static struct demangle_component
*
302 d_make_name
PARAMS ((struct d_info
*, const char *, int));
304 static struct demangle_component
*
305 d_make_builtin_type
PARAMS ((struct d_info
*,
306 const struct demangle_builtin_type_info
*));
308 static struct demangle_component
*
309 d_make_operator
PARAMS ((struct d_info
*,
310 const struct demangle_operator_info
*));
312 static struct demangle_component
*
313 d_make_extended_operator
PARAMS ((struct d_info
*, int,
314 struct demangle_component
*));
316 static struct demangle_component
*
317 d_make_ctor
PARAMS ((struct d_info
*, enum gnu_v3_ctor_kinds
,
318 struct demangle_component
*));
320 static struct demangle_component
*
321 d_make_dtor
PARAMS ((struct d_info
*, enum gnu_v3_dtor_kinds
,
322 struct demangle_component
*));
324 static struct demangle_component
*
325 d_make_template_param
PARAMS ((struct d_info
*, long));
327 static struct demangle_component
*
328 d_make_sub
PARAMS ((struct d_info
*, const char *, int));
331 has_return_type
PARAMS ((struct demangle_component
*));
334 is_ctor_dtor_or_conversion
PARAMS ((struct demangle_component
*));
336 static struct demangle_component
*
337 d_encoding
PARAMS ((struct d_info
*, int));
339 static struct demangle_component
*
340 d_name
PARAMS ((struct d_info
*));
342 static struct demangle_component
*
343 d_nested_name
PARAMS ((struct d_info
*));
345 static struct demangle_component
*
346 d_prefix
PARAMS ((struct d_info
*));
348 static struct demangle_component
*
349 d_unqualified_name
PARAMS ((struct d_info
*));
351 static struct demangle_component
*
352 d_source_name
PARAMS ((struct d_info
*));
355 d_number
PARAMS ((struct d_info
*));
357 static struct demangle_component
*
358 d_identifier
PARAMS ((struct d_info
*, int));
360 static struct demangle_component
*
361 d_operator_name
PARAMS ((struct d_info
*));
363 static struct demangle_component
*
364 d_special_name
PARAMS ((struct d_info
*));
367 d_call_offset
PARAMS ((struct d_info
*, int));
369 static struct demangle_component
*
370 d_ctor_dtor_name
PARAMS ((struct d_info
*));
372 static struct demangle_component
**
373 d_cv_qualifiers
PARAMS ((struct d_info
*, struct demangle_component
**, int));
375 static struct demangle_component
*
376 d_function_type
PARAMS ((struct d_info
*));
378 static struct demangle_component
*
379 d_bare_function_type
PARAMS ((struct d_info
*, int));
381 static struct demangle_component
*
382 d_class_enum_type
PARAMS ((struct d_info
*));
384 static struct demangle_component
*
385 d_array_type
PARAMS ((struct d_info
*));
387 static struct demangle_component
*
388 d_pointer_to_member_type
PARAMS ((struct d_info
*));
390 static struct demangle_component
*
391 d_template_param
PARAMS ((struct d_info
*));
393 static struct demangle_component
*
394 d_template_args
PARAMS ((struct d_info
*));
396 static struct demangle_component
*
397 d_template_arg
PARAMS ((struct d_info
*));
399 static struct demangle_component
*
400 d_expression
PARAMS ((struct d_info
*));
402 static struct demangle_component
*
403 d_expr_primary
PARAMS ((struct d_info
*));
405 static struct demangle_component
*
406 d_local_name
PARAMS ((struct d_info
*));
409 d_discriminator
PARAMS ((struct d_info
*));
412 d_add_substitution
PARAMS ((struct d_info
*, struct demangle_component
*));
414 static struct demangle_component
*
415 d_substitution
PARAMS ((struct d_info
*, int));
418 d_print_resize
PARAMS ((struct d_print_info
*, size_t));
421 d_print_append_char
PARAMS ((struct d_print_info
*, int));
424 d_print_append_buffer
PARAMS ((struct d_print_info
*, const char *, size_t));
427 d_print_error
PARAMS ((struct d_print_info
*));
430 d_print_comp
PARAMS ((struct d_print_info
*,
431 const struct demangle_component
*));
434 d_print_java_identifier
PARAMS ((struct d_print_info
*, const char *, int));
437 d_print_mod_list
PARAMS ((struct d_print_info
*, struct d_print_mod
*, int));
440 d_print_mod
PARAMS ((struct d_print_info
*,
441 const struct demangle_component
*));
444 d_print_function_type
PARAMS ((struct d_print_info
*,
445 const struct demangle_component
*,
446 struct d_print_mod
*));
449 d_print_array_type
PARAMS ((struct d_print_info
*,
450 const struct demangle_component
*,
451 struct d_print_mod
*));
454 d_print_expr_op
PARAMS ((struct d_print_info
*,
455 const struct demangle_component
*));
458 d_print_cast
PARAMS ((struct d_print_info
*,
459 const struct demangle_component
*));
462 d_demangle
PARAMS ((const char *, int, size_t *));
464 #ifdef CP_DEMANGLE_DEBUG
468 struct demangle_component
*dc
;
476 for (i
= 0; i
< indent
; ++i
)
481 case DEMANGLE_COMPONENT_NAME
:
482 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
484 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
485 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
487 case DEMANGLE_COMPONENT_CTOR
:
488 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
489 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
491 case DEMANGLE_COMPONENT_DTOR
:
492 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
493 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
495 case DEMANGLE_COMPONENT_SUB_STD
:
496 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
498 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
499 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
501 case DEMANGLE_COMPONENT_OPERATOR
:
502 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
504 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
505 printf ("extended operator with %d args\n",
506 dc
->u
.s_extended_operator
.args
);
507 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
510 case DEMANGLE_COMPONENT_QUAL_NAME
:
511 printf ("qualified name\n");
513 case DEMANGLE_COMPONENT_LOCAL_NAME
:
514 printf ("local name\n");
516 case DEMANGLE_COMPONENT_TYPED_NAME
:
517 printf ("typed name\n");
519 case DEMANGLE_COMPONENT_TEMPLATE
:
520 printf ("template\n");
522 case DEMANGLE_COMPONENT_VTABLE
:
525 case DEMANGLE_COMPONENT_VTT
:
528 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
529 printf ("construction vtable\n");
531 case DEMANGLE_COMPONENT_TYPEINFO
:
532 printf ("typeinfo\n");
534 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
535 printf ("typeinfo name\n");
537 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
538 printf ("typeinfo function\n");
540 case DEMANGLE_COMPONENT_THUNK
:
543 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
544 printf ("virtual thunk\n");
546 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
547 printf ("covariant thunk\n");
549 case DEMANGLE_COMPONENT_JAVA_CLASS
:
550 printf ("java class\n");
552 case DEMANGLE_COMPONENT_GUARD
:
555 case DEMANGLE_COMPONENT_REFTEMP
:
556 printf ("reference temporary\n");
558 case DEMANGLE_COMPONENT_RESTRICT
:
559 printf ("restrict\n");
561 case DEMANGLE_COMPONENT_VOLATILE
:
562 printf ("volatile\n");
564 case DEMANGLE_COMPONENT_CONST
:
567 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
568 printf ("restrict this\n");
570 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
571 printf ("volatile this\n");
573 case DEMANGLE_COMPONENT_CONST_THIS
:
574 printf ("const this\n");
576 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
577 printf ("vendor type qualifier\n");
579 case DEMANGLE_COMPONENT_POINTER
:
580 printf ("pointer\n");
582 case DEMANGLE_COMPONENT_REFERENCE
:
583 printf ("reference\n");
585 case DEMANGLE_COMPONENT_COMPLEX
:
586 printf ("complex\n");
588 case DEMANGLE_COMPONENT_IMAGINARY
:
589 printf ("imaginary\n");
591 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
592 printf ("vendor type\n");
594 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
595 printf ("function type\n");
597 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
598 printf ("array type\n");
600 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
601 printf ("pointer to member type\n");
603 case DEMANGLE_COMPONENT_ARGLIST
:
604 printf ("argument list\n");
606 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
607 printf ("template argument list\n");
609 case DEMANGLE_COMPONENT_CAST
:
612 case DEMANGLE_COMPONENT_UNARY
:
613 printf ("unary operator\n");
615 case DEMANGLE_COMPONENT_BINARY
:
616 printf ("binary operator\n");
618 case DEMANGLE_COMPONENT_BINARY_ARGS
:
619 printf ("binary operator arguments\n");
621 case DEMANGLE_COMPONENT_TRINARY
:
622 printf ("trinary operator\n");
624 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
625 printf ("trinary operator arguments 1\n");
627 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
628 printf ("trinary operator arguments 1\n");
630 case DEMANGLE_COMPONENT_LITERAL
:
631 printf ("literal\n");
633 case DEMANGLE_COMPONENT_LITERAL_NEG
:
634 printf ("negative literal\n");
638 d_dump (d_left (dc
), indent
+ 2);
639 d_dump (d_right (dc
), indent
+ 2);
642 #endif /* CP_DEMANGLE_DEBUG */
644 /* Fill in a DEMANGLE_COMPONENT_NAME. */
646 CP_STATIC_IF_GLIBCPP_V3
648 cplus_demangle_fill_name (p
, s
, len
)
649 struct demangle_component
*p
;
653 if (p
== NULL
|| s
== NULL
|| len
== 0)
655 p
->type
= DEMANGLE_COMPONENT_NAME
;
657 p
->u
.s_name
.len
= len
;
661 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
663 CP_STATIC_IF_GLIBCPP_V3
665 cplus_demangle_fill_extended_operator (p
, args
, name
)
666 struct demangle_component
*p
;
668 struct demangle_component
*name
;
670 if (p
== NULL
|| args
< 0 || name
== NULL
)
672 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
673 p
->u
.s_extended_operator
.args
= args
;
674 p
->u
.s_extended_operator
.name
= name
;
678 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
680 CP_STATIC_IF_GLIBCPP_V3
682 cplus_demangle_fill_ctor (p
, kind
, name
)
683 struct demangle_component
*p
;
684 enum gnu_v3_ctor_kinds kind
;
685 struct demangle_component
*name
;
689 || (kind
< gnu_v3_complete_object_ctor
690 && kind
> gnu_v3_complete_object_allocating_ctor
))
692 p
->type
= DEMANGLE_COMPONENT_CTOR
;
693 p
->u
.s_ctor
.kind
= kind
;
694 p
->u
.s_ctor
.name
= name
;
698 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
700 CP_STATIC_IF_GLIBCPP_V3
702 cplus_demangle_fill_dtor (p
, kind
, name
)
703 struct demangle_component
*p
;
704 enum gnu_v3_dtor_kinds kind
;
705 struct demangle_component
*name
;
709 || (kind
< gnu_v3_deleting_dtor
710 && kind
> gnu_v3_base_object_dtor
))
712 p
->type
= DEMANGLE_COMPONENT_DTOR
;
713 p
->u
.s_dtor
.kind
= kind
;
714 p
->u
.s_dtor
.name
= name
;
718 /* Add a new component. */
720 static struct demangle_component
*
724 struct demangle_component
*p
;
726 if (di
->next_comp
>= di
->num_comps
)
728 p
= &di
->comps
[di
->next_comp
];
733 /* Add a new generic component. */
735 static struct demangle_component
*
736 d_make_comp (di
, type
, left
, right
)
738 enum demangle_component_type type
;
739 struct demangle_component
*left
;
740 struct demangle_component
*right
;
742 struct demangle_component
*p
;
744 /* We check for errors here. A typical error would be a NULL return
745 from a subroutine. We catch those here, and return NULL
749 /* These types require two parameters. */
750 case DEMANGLE_COMPONENT_QUAL_NAME
:
751 case DEMANGLE_COMPONENT_LOCAL_NAME
:
752 case DEMANGLE_COMPONENT_TYPED_NAME
:
753 case DEMANGLE_COMPONENT_TEMPLATE
:
754 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
755 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
756 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
757 case DEMANGLE_COMPONENT_UNARY
:
758 case DEMANGLE_COMPONENT_BINARY
:
759 case DEMANGLE_COMPONENT_BINARY_ARGS
:
760 case DEMANGLE_COMPONENT_TRINARY
:
761 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
762 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
763 case DEMANGLE_COMPONENT_LITERAL
:
764 case DEMANGLE_COMPONENT_LITERAL_NEG
:
765 if (left
== NULL
|| right
== NULL
)
769 /* These types only require one parameter. */
770 case DEMANGLE_COMPONENT_VTABLE
:
771 case DEMANGLE_COMPONENT_VTT
:
772 case DEMANGLE_COMPONENT_TYPEINFO
:
773 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
774 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
775 case DEMANGLE_COMPONENT_THUNK
:
776 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
777 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
778 case DEMANGLE_COMPONENT_JAVA_CLASS
:
779 case DEMANGLE_COMPONENT_GUARD
:
780 case DEMANGLE_COMPONENT_REFTEMP
:
781 case DEMANGLE_COMPONENT_POINTER
:
782 case DEMANGLE_COMPONENT_REFERENCE
:
783 case DEMANGLE_COMPONENT_COMPLEX
:
784 case DEMANGLE_COMPONENT_IMAGINARY
:
785 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
786 case DEMANGLE_COMPONENT_ARGLIST
:
787 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
788 case DEMANGLE_COMPONENT_CAST
:
793 /* This needs a right parameter, but the left parameter can be
795 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
800 /* These are allowed to have no parameters--in some cases they
801 will be filled in later. */
802 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
803 case DEMANGLE_COMPONENT_RESTRICT
:
804 case DEMANGLE_COMPONENT_VOLATILE
:
805 case DEMANGLE_COMPONENT_CONST
:
806 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
807 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
808 case DEMANGLE_COMPONENT_CONST_THIS
:
811 /* Other types should not be seen here. */
816 p
= d_make_empty (di
);
820 p
->u
.s_binary
.left
= left
;
821 p
->u
.s_binary
.right
= right
;
826 /* Add a new name component. */
828 static struct demangle_component
*
829 d_make_name (di
, s
, len
)
834 struct demangle_component
*p
;
836 p
= d_make_empty (di
);
837 if (! cplus_demangle_fill_name (p
, s
, len
))
842 /* Add a new builtin type component. */
844 static struct demangle_component
*
845 d_make_builtin_type (di
, type
)
847 const struct demangle_builtin_type_info
*type
;
849 struct demangle_component
*p
;
853 p
= d_make_empty (di
);
856 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
857 p
->u
.s_builtin
.type
= type
;
862 /* Add a new operator component. */
864 static struct demangle_component
*
865 d_make_operator (di
, op
)
867 const struct demangle_operator_info
*op
;
869 struct demangle_component
*p
;
871 p
= d_make_empty (di
);
874 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
875 p
->u
.s_operator
.op
= op
;
880 /* Add a new extended operator component. */
882 static struct demangle_component
*
883 d_make_extended_operator (di
, args
, name
)
886 struct demangle_component
*name
;
888 struct demangle_component
*p
;
890 p
= d_make_empty (di
);
891 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
896 /* Add a new constructor component. */
898 static struct demangle_component
*
899 d_make_ctor (di
, kind
, name
)
901 enum gnu_v3_ctor_kinds kind
;
902 struct demangle_component
*name
;
904 struct demangle_component
*p
;
906 p
= d_make_empty (di
);
907 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
912 /* Add a new destructor component. */
914 static struct demangle_component
*
915 d_make_dtor (di
, kind
, name
)
917 enum gnu_v3_dtor_kinds kind
;
918 struct demangle_component
*name
;
920 struct demangle_component
*p
;
922 p
= d_make_empty (di
);
923 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
928 /* Add a new template parameter. */
930 static struct demangle_component
*
931 d_make_template_param (di
, i
)
935 struct demangle_component
*p
;
937 p
= d_make_empty (di
);
940 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
941 p
->u
.s_number
.number
= i
;
946 /* Add a new standard substitution component. */
948 static struct demangle_component
*
949 d_make_sub (di
, name
, len
)
954 struct demangle_component
*p
;
956 p
= d_make_empty (di
);
959 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
960 p
->u
.s_string
.string
= name
;
961 p
->u
.s_string
.len
= len
;
966 /* <mangled-name> ::= _Z <encoding>
968 TOP_LEVEL is non-zero when called at the top level. */
970 CP_STATIC_IF_GLIBCPP_V3
971 struct demangle_component
*
972 cplus_demangle_mangled_name (di
, top_level
)
976 if (d_next_char (di
) != '_')
978 if (d_next_char (di
) != 'Z')
980 return d_encoding (di
, top_level
);
983 /* Return whether a function should have a return type. The argument
984 is the function name, which may be qualified in various ways. The
985 rules are that template functions have return types with some
986 exceptions, function types which are not part of a function name
987 mangling have return types with some exceptions, and non-template
988 function names do not have return types. The exceptions are that
989 constructors, destructors, and conversion operators do not have
994 struct demangle_component
*dc
;
1002 case DEMANGLE_COMPONENT_TEMPLATE
:
1003 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1004 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
1005 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
1006 case DEMANGLE_COMPONENT_CONST_THIS
:
1007 return has_return_type (d_left (dc
));
1011 /* Return whether a name is a constructor, a destructor, or a
1012 conversion operator. */
1015 is_ctor_dtor_or_conversion (dc
)
1016 struct demangle_component
*dc
;
1024 case DEMANGLE_COMPONENT_QUAL_NAME
:
1025 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1026 return is_ctor_dtor_or_conversion (d_right (dc
));
1027 case DEMANGLE_COMPONENT_CTOR
:
1028 case DEMANGLE_COMPONENT_DTOR
:
1029 case DEMANGLE_COMPONENT_CAST
:
1034 /* <encoding> ::= <(function) name> <bare-function-type>
1038 TOP_LEVEL is non-zero when called at the top level, in which case
1039 if DMGL_PARAMS is not set we do not demangle the function
1040 parameters. We only set this at the top level, because otherwise
1041 we would not correctly demangle names in local scopes. */
1043 static struct demangle_component
*
1044 d_encoding (di
, top_level
)
1048 char peek
= d_peek_char (di
);
1050 if (peek
== 'G' || peek
== 'T')
1051 return d_special_name (di
);
1054 struct demangle_component
*dc
;
1058 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1060 /* Strip off any initial CV-qualifiers, as they really apply
1061 to the `this' parameter, and they were not output by the
1062 v2 demangler without DMGL_PARAMS. */
1063 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1064 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1065 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1068 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1069 there may be CV-qualifiers on its right argument which
1070 really apply here; this happens when parsing a class
1071 which is local to a function. */
1072 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1074 struct demangle_component
*dcr
;
1077 while (dcr
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1078 || dcr
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1079 || dcr
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1081 dc
->u
.s_binary
.right
= dcr
;
1087 peek
= d_peek_char (di
);
1088 if (peek
== '\0' || peek
== 'E')
1090 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1091 d_bare_function_type (di
, has_return_type (dc
)));
1095 /* <name> ::= <nested-name>
1097 ::= <unscoped-template-name> <template-args>
1100 <unscoped-name> ::= <unqualified-name>
1101 ::= St <unqualified-name>
1103 <unscoped-template-name> ::= <unscoped-name>
1107 static struct demangle_component
*
1111 char peek
= d_peek_char (di
);
1112 struct demangle_component
*dc
;
1117 return d_nested_name (di
);
1120 return d_local_name (di
);
1126 if (d_peek_next_char (di
) != 't')
1128 dc
= d_substitution (di
, 0);
1134 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1135 d_make_name (di
, "std", 3),
1136 d_unqualified_name (di
));
1141 if (d_peek_char (di
) != 'I')
1143 /* The grammar does not permit this case to occur if we
1144 called d_substitution() above (i.e., subst == 1). We
1145 don't bother to check. */
1149 /* This is <template-args>, which means that we just saw
1150 <unscoped-template-name>, which is a substitution
1151 candidate if we didn't just get it from a
1155 if (! d_add_substitution (di
, dc
))
1158 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1159 d_template_args (di
));
1166 dc
= d_unqualified_name (di
);
1167 if (d_peek_char (di
) == 'I')
1169 /* This is <template-args>, which means that we just saw
1170 <unscoped-template-name>, which is a substitution
1172 if (! d_add_substitution (di
, dc
))
1174 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1175 d_template_args (di
));
1181 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1182 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1185 static struct demangle_component
*
1189 struct demangle_component
*ret
;
1190 struct demangle_component
**pret
;
1192 if (d_next_char (di
) != 'N')
1195 pret
= d_cv_qualifiers (di
, &ret
, 1);
1199 *pret
= d_prefix (di
);
1203 if (d_next_char (di
) != 'E')
1209 /* <prefix> ::= <prefix> <unqualified-name>
1210 ::= <template-prefix> <template-args>
1211 ::= <template-param>
1215 <template-prefix> ::= <prefix> <(template) unqualified-name>
1216 ::= <template-param>
1220 static struct demangle_component
*
1224 struct demangle_component
*ret
= NULL
;
1229 enum demangle_component_type comb_type
;
1230 struct demangle_component
*dc
;
1232 peek
= d_peek_char (di
);
1236 /* The older code accepts a <local-name> here, but I don't see
1237 that in the grammar. The older code does not accept a
1238 <template-param> here. */
1240 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1245 dc
= d_unqualified_name (di
);
1246 else if (peek
== 'S')
1247 dc
= d_substitution (di
, 1);
1248 else if (peek
== 'I')
1252 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1253 dc
= d_template_args (di
);
1255 else if (peek
== 'T')
1256 dc
= d_template_param (di
);
1257 else if (peek
== 'E')
1265 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1267 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1269 if (! d_add_substitution (di
, ret
))
1275 /* <unqualified-name> ::= <operator-name>
1276 ::= <ctor-dtor-name>
1280 static struct demangle_component
*
1281 d_unqualified_name (di
)
1286 peek
= d_peek_char (di
);
1287 if (IS_DIGIT (peek
))
1288 return d_source_name (di
);
1289 else if (IS_LOWER (peek
))
1291 struct demangle_component
*ret
;
1293 ret
= d_operator_name (di
);
1294 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1295 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1298 else if (peek
== 'C' || peek
== 'D')
1299 return d_ctor_dtor_name (di
);
1304 /* <source-name> ::= <(positive length) number> <identifier> */
1306 static struct demangle_component
*
1311 struct demangle_component
*ret
;
1313 len
= d_number (di
);
1316 ret
= d_identifier (di
, len
);
1317 di
->last_name
= ret
;
1321 /* number ::= [n] <(non-negative decimal integer)> */
1332 peek
= d_peek_char (di
);
1337 peek
= d_peek_char (di
);
1343 if (! IS_DIGIT (peek
))
1349 ret
= ret
* 10 + peek
- '0';
1351 peek
= d_peek_char (di
);
1355 /* identifier ::= <(unqualified source code identifier)> */
1357 static struct demangle_component
*
1358 d_identifier (di
, len
)
1366 if (di
->send
- name
< len
)
1369 d_advance (di
, len
);
1371 /* A Java mangled name may have a trailing '$' if it is a C++
1372 keyword. This '$' is not included in the length count. We just
1374 if ((di
->options
& DMGL_JAVA
) != 0
1375 && d_peek_char (di
) == '$')
1378 /* Look for something which looks like a gcc encoding of an
1379 anonymous namespace, and replace it with a more user friendly
1381 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1382 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1383 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1387 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1388 if ((*s
== '.' || *s
== '_' || *s
== '$')
1391 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1392 return d_make_name (di
, "(anonymous namespace)",
1393 sizeof "(anonymous namespace)" - 1);
1397 return d_make_name (di
, name
, len
);
1400 /* operator_name ::= many different two character encodings.
1402 ::= v <digit> <source-name>
1405 #define NL(s) s, (sizeof s) - 1
1407 CP_STATIC_IF_GLIBCPP_V3
1408 const struct demangle_operator_info cplus_demangle_operators
[] =
1410 { "aN", NL ("&="), 2 },
1411 { "aS", NL ("="), 2 },
1412 { "aa", NL ("&&"), 2 },
1413 { "ad", NL ("&"), 1 },
1414 { "an", NL ("&"), 2 },
1415 { "cl", NL ("()"), 0 },
1416 { "cm", NL (","), 2 },
1417 { "co", NL ("~"), 1 },
1418 { "dV", NL ("/="), 2 },
1419 { "da", NL ("delete[]"), 1 },
1420 { "de", NL ("*"), 1 },
1421 { "dl", NL ("delete"), 1 },
1422 { "dv", NL ("/"), 2 },
1423 { "eO", NL ("^="), 2 },
1424 { "eo", NL ("^"), 2 },
1425 { "eq", NL ("=="), 2 },
1426 { "ge", NL (">="), 2 },
1427 { "gt", NL (">"), 2 },
1428 { "ix", NL ("[]"), 2 },
1429 { "lS", NL ("<<="), 2 },
1430 { "le", NL ("<="), 2 },
1431 { "ls", NL ("<<"), 2 },
1432 { "lt", NL ("<"), 2 },
1433 { "mI", NL ("-="), 2 },
1434 { "mL", NL ("*="), 2 },
1435 { "mi", NL ("-"), 2 },
1436 { "ml", NL ("*"), 2 },
1437 { "mm", NL ("--"), 1 },
1438 { "na", NL ("new[]"), 1 },
1439 { "ne", NL ("!="), 2 },
1440 { "ng", NL ("-"), 1 },
1441 { "nt", NL ("!"), 1 },
1442 { "nw", NL ("new"), 1 },
1443 { "oR", NL ("|="), 2 },
1444 { "oo", NL ("||"), 2 },
1445 { "or", NL ("|"), 2 },
1446 { "pL", NL ("+="), 2 },
1447 { "pl", NL ("+"), 2 },
1448 { "pm", NL ("->*"), 2 },
1449 { "pp", NL ("++"), 1 },
1450 { "ps", NL ("+"), 1 },
1451 { "pt", NL ("->"), 2 },
1452 { "qu", NL ("?"), 3 },
1453 { "rM", NL ("%="), 2 },
1454 { "rS", NL (">>="), 2 },
1455 { "rm", NL ("%"), 2 },
1456 { "rs", NL (">>"), 2 },
1457 { "st", NL ("sizeof "), 1 },
1458 { "sz", NL ("sizeof "), 1 },
1459 { NULL
, NULL
, 0, 0 }
1462 static struct demangle_component
*
1463 d_operator_name (di
)
1469 c1
= d_next_char (di
);
1470 c2
= d_next_char (di
);
1471 if (c1
== 'v' && IS_DIGIT (c2
))
1472 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1473 else if (c1
== 'c' && c2
== 'v')
1474 return d_make_comp (di
, DEMANGLE_COMPONENT_CAST
,
1475 cplus_demangle_type (di
), NULL
);
1478 /* LOW is the inclusive lower bound. */
1480 /* HIGH is the exclusive upper bound. We subtract one to ignore
1481 the sentinel at the end of the array. */
1482 int high
= ((sizeof (cplus_demangle_operators
)
1483 / sizeof (cplus_demangle_operators
[0]))
1489 const struct demangle_operator_info
*p
;
1491 i
= low
+ (high
- low
) / 2;
1492 p
= cplus_demangle_operators
+ i
;
1494 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1495 return d_make_operator (di
, p
);
1497 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1507 /* <special-name> ::= TV <type>
1511 ::= GV <(object) name>
1512 ::= T <call-offset> <(base) encoding>
1513 ::= Tc <call-offset> <call-offset> <(base) encoding>
1514 Also g++ extensions:
1515 ::= TC <type> <(offset) number> _ <(base) type>
1521 static struct demangle_component
*
1527 di
->expansion
+= 20;
1528 c
= d_next_char (di
);
1531 switch (d_next_char (di
))
1535 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
1536 cplus_demangle_type (di
), NULL
);
1538 di
->expansion
-= 10;
1539 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
1540 cplus_demangle_type (di
), NULL
);
1542 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
1543 cplus_demangle_type (di
), NULL
);
1545 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
1546 cplus_demangle_type (di
), NULL
);
1549 if (! d_call_offset (di
, 'h'))
1551 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
1552 d_encoding (di
, 0), NULL
);
1555 if (! d_call_offset (di
, 'v'))
1557 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
1558 d_encoding (di
, 0), NULL
);
1561 if (! d_call_offset (di
, '\0'))
1563 if (! d_call_offset (di
, '\0'))
1565 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
1566 d_encoding (di
, 0), NULL
);
1570 struct demangle_component
*derived_type
;
1572 struct demangle_component
*base_type
;
1574 derived_type
= cplus_demangle_type (di
);
1575 offset
= d_number (di
);
1578 if (d_next_char (di
) != '_')
1580 base_type
= cplus_demangle_type (di
);
1581 /* We don't display the offset. FIXME: We should display
1582 it in verbose mode. */
1584 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
1585 base_type
, derived_type
);
1589 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
1590 cplus_demangle_type (di
), NULL
);
1592 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
1593 cplus_demangle_type (di
), NULL
);
1601 switch (d_next_char (di
))
1604 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
1607 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, d_name (di
),
1618 /* <call-offset> ::= h <nv-offset> _
1621 <nv-offset> ::= <(offset) number>
1623 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1625 The C parameter, if not '\0', is a character we just read which is
1626 the start of the <call-offset>.
1628 We don't display the offset information anywhere. FIXME: We should
1629 display it in verbose mode. */
1632 d_call_offset (di
, c
)
1637 long virtual_offset
;
1640 c
= d_next_char (di
);
1643 offset
= d_number (di
);
1646 offset
= d_number (di
);
1647 if (d_next_char (di
) != '_')
1649 virtual_offset
= d_number (di
);
1654 if (d_next_char (di
) != '_')
1660 /* <ctor-dtor-name> ::= C1
1668 static struct demangle_component
*
1669 d_ctor_dtor_name (di
)
1672 if (di
->last_name
!= NULL
)
1674 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
1675 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
1676 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1677 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
1679 switch (d_next_char (di
))
1683 enum gnu_v3_ctor_kinds kind
;
1685 switch (d_next_char (di
))
1688 kind
= gnu_v3_complete_object_ctor
;
1691 kind
= gnu_v3_base_object_ctor
;
1694 kind
= gnu_v3_complete_object_allocating_ctor
;
1699 return d_make_ctor (di
, kind
, di
->last_name
);
1704 enum gnu_v3_dtor_kinds kind
;
1706 switch (d_next_char (di
))
1709 kind
= gnu_v3_deleting_dtor
;
1712 kind
= gnu_v3_complete_object_dtor
;
1715 kind
= gnu_v3_base_object_dtor
;
1720 return d_make_dtor (di
, kind
, di
->last_name
);
1728 /* <type> ::= <builtin-type>
1730 ::= <class-enum-type>
1732 ::= <pointer-to-member-type>
1733 ::= <template-param>
1734 ::= <template-template-param> <template-args>
1736 ::= <CV-qualifiers> <type>
1741 ::= U <source-name> <type>
1743 <builtin-type> ::= various one letter codes
1747 CP_STATIC_IF_GLIBCPP_V3
1748 const struct demangle_builtin_type_info
1749 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
1751 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT
},
1752 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
1753 /* c */ { NL ("char"), NL ("byte"), D_PRINT_INT
},
1754 /* d */ { NL ("double"), NL ("double"), D_PRINT_DEFAULT
},
1755 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_DEFAULT
},
1756 /* f */ { NL ("float"), NL ("float"), D_PRINT_DEFAULT
},
1757 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_DEFAULT
},
1758 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_INT
},
1759 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
1760 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_INT
},
1761 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1762 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
1763 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_LONG
},
1764 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
1765 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), D_PRINT_DEFAULT
},
1766 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1767 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1768 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1769 /* s */ { NL ("short"), NL ("short"), D_PRINT_INT
},
1770 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_INT
},
1771 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1772 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
1773 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_INT
},
1774 /* x */ { NL ("long long"), NL ("long"), D_PRINT_DEFAULT
},
1775 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), D_PRINT_DEFAULT
},
1776 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
1779 CP_STATIC_IF_GLIBCPP_V3
1780 struct demangle_component
*
1781 cplus_demangle_type (di
)
1785 struct demangle_component
*ret
;
1788 /* The ABI specifies that when CV-qualifiers are used, the base type
1789 is substitutable, and the fully qualified type is substitutable,
1790 but the base type with a strict subset of the CV-qualifiers is
1791 not substitutable. The natural recursive implementation of the
1792 CV-qualifiers would cause subsets to be substitutable, so instead
1793 we pull them all off now.
1795 FIXME: The ABI says that order-insensitive vendor qualifiers
1796 should be handled in the same way, but we have no way to tell
1797 which vendor qualifiers are order-insensitive and which are
1798 order-sensitive. So we just assume that they are all
1799 order-sensitive. g++ 3.4 supports only one vendor qualifier,
1800 __vector, and it treats it as order-sensitive when mangling
1803 peek
= d_peek_char (di
);
1804 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
1806 struct demangle_component
**pret
;
1808 pret
= d_cv_qualifiers (di
, &ret
, 0);
1811 *pret
= cplus_demangle_type (di
);
1812 if (! d_add_substitution (di
, ret
))
1821 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1822 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
1823 case 'o': case 's': case 't':
1824 case 'v': case 'w': case 'x': case 'y': case 'z':
1825 ret
= d_make_builtin_type (di
,
1826 &cplus_demangle_builtin_types
[peek
- 'a']);
1827 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
1834 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
1835 d_source_name (di
), NULL
);
1839 ret
= d_function_type (di
);
1842 case '0': case '1': case '2': case '3': case '4':
1843 case '5': case '6': case '7': case '8': case '9':
1846 ret
= d_class_enum_type (di
);
1850 ret
= d_array_type (di
);
1854 ret
= d_pointer_to_member_type (di
);
1858 ret
= d_template_param (di
);
1859 if (d_peek_char (di
) == 'I')
1861 /* This is <template-template-param> <template-args>. The
1862 <template-template-param> part is a substitution
1864 if (! d_add_substitution (di
, ret
))
1866 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
1867 d_template_args (di
));
1872 /* If this is a special substitution, then it is the start of
1873 <class-enum-type>. */
1877 peek_next
= d_peek_next_char (di
);
1878 if (IS_DIGIT (peek_next
)
1880 || IS_UPPER (peek_next
))
1882 ret
= d_substitution (di
, 0);
1883 /* The substituted name may have been a template name and
1884 may be followed by tepmlate args. */
1885 if (d_peek_char (di
) == 'I')
1886 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
1887 d_template_args (di
));
1893 ret
= d_class_enum_type (di
);
1894 /* If the substitution was a complete type, then it is not
1895 a new substitution candidate. However, if the
1896 substitution was followed by template arguments, then
1897 the whole thing is a substitution candidate. */
1898 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1906 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
1907 cplus_demangle_type (di
), NULL
);
1912 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
1913 cplus_demangle_type (di
), NULL
);
1918 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
1919 cplus_demangle_type (di
), NULL
);
1924 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
1925 cplus_demangle_type (di
), NULL
);
1930 ret
= d_source_name (di
);
1931 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
1932 cplus_demangle_type (di
), ret
);
1941 if (! d_add_substitution (di
, ret
))
1948 /* <CV-qualifiers> ::= [r] [V] [K] */
1950 static struct demangle_component
**
1951 d_cv_qualifiers (di
, pret
, member_fn
)
1953 struct demangle_component
**pret
;
1958 peek
= d_peek_char (di
);
1959 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
1961 enum demangle_component_type t
;
1967 ? DEMANGLE_COMPONENT_RESTRICT_THIS
1968 : DEMANGLE_COMPONENT_RESTRICT
);
1969 di
->expansion
+= sizeof "restrict";
1971 else if (peek
== 'V')
1974 ? DEMANGLE_COMPONENT_VOLATILE_THIS
1975 : DEMANGLE_COMPONENT_VOLATILE
);
1976 di
->expansion
+= sizeof "volatile";
1981 ? DEMANGLE_COMPONENT_CONST_THIS
1982 : DEMANGLE_COMPONENT_CONST
);
1983 di
->expansion
+= sizeof "const";
1986 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
1989 pret
= &d_left (*pret
);
1991 peek
= d_peek_char (di
);
1997 /* <function-type> ::= F [Y] <bare-function-type> E */
1999 static struct demangle_component
*
2000 d_function_type (di
)
2003 struct demangle_component
*ret
;
2005 if (d_next_char (di
) != 'F')
2007 if (d_peek_char (di
) == 'Y')
2009 /* Function has C linkage. We don't print this information.
2010 FIXME: We should print it in verbose mode. */
2013 ret
= d_bare_function_type (di
, 1);
2014 if (d_next_char (di
) != 'E')
2019 /* <bare-function-type> ::= <type>+ */
2021 static struct demangle_component
*
2022 d_bare_function_type (di
, has_return_type
)
2024 int has_return_type
;
2026 struct demangle_component
*return_type
;
2027 struct demangle_component
*tl
;
2028 struct demangle_component
**ptl
;
2036 struct demangle_component
*type
;
2038 peek
= d_peek_char (di
);
2039 if (peek
== '\0' || peek
== 'E')
2041 type
= cplus_demangle_type (di
);
2044 if (has_return_type
)
2047 has_return_type
= 0;
2051 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2054 ptl
= &d_right (*ptl
);
2058 /* There should be at least one parameter type besides the optional
2059 return type. A function which takes no arguments will have a
2060 single parameter type void. */
2064 /* If we have a single parameter type void, omit it. */
2065 if (d_right (tl
) == NULL
2066 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2067 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2069 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2073 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
, return_type
, tl
);
2076 /* <class-enum-type> ::= <name> */
2078 static struct demangle_component
*
2079 d_class_enum_type (di
)
2085 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2086 ::= A [<(dimension) expression>] _ <(element) type>
2089 static struct demangle_component
*
2094 struct demangle_component
*dim
;
2096 if (d_next_char (di
) != 'A')
2099 peek
= d_peek_char (di
);
2102 else if (IS_DIGIT (peek
))
2110 peek
= d_peek_char (di
);
2112 while (IS_DIGIT (peek
));
2113 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2119 dim
= d_expression (di
);
2124 if (d_next_char (di
) != '_')
2127 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2128 cplus_demangle_type (di
));
2131 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2133 static struct demangle_component
*
2134 d_pointer_to_member_type (di
)
2137 struct demangle_component
*cl
;
2138 struct demangle_component
*mem
;
2139 struct demangle_component
**pmem
;
2141 if (d_next_char (di
) != 'M')
2144 cl
= cplus_demangle_type (di
);
2146 /* The ABI specifies that any type can be a substitution source, and
2147 that M is followed by two types, and that when a CV-qualified
2148 type is seen both the base type and the CV-qualified types are
2149 substitution sources. The ABI also specifies that for a pointer
2150 to a CV-qualified member function, the qualifiers are attached to
2151 the second type. Given the grammar, a plain reading of the ABI
2152 suggests that both the CV-qualified member function and the
2153 non-qualified member function are substitution sources. However,
2154 g++ does not work that way. g++ treats only the CV-qualified
2155 member function as a substitution source. FIXME. So to work
2156 with g++, we need to pull off the CV-qualifiers here, in order to
2157 avoid calling add_substitution() in cplus_demangle_type(). */
2159 pmem
= d_cv_qualifiers (di
, &mem
, 1);
2162 *pmem
= cplus_demangle_type (di
);
2164 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
2167 /* <template-param> ::= T_
2168 ::= T <(parameter-2 non-negative) number> _
2171 static struct demangle_component
*
2172 d_template_param (di
)
2177 if (d_next_char (di
) != 'T')
2180 if (d_peek_char (di
) == '_')
2184 param
= d_number (di
);
2190 if (d_next_char (di
) != '_')
2195 return d_make_template_param (di
, param
);
2198 /* <template-args> ::= I <template-arg>+ E */
2200 static struct demangle_component
*
2201 d_template_args (di
)
2204 struct demangle_component
*hold_last_name
;
2205 struct demangle_component
*al
;
2206 struct demangle_component
**pal
;
2208 /* Preserve the last name we saw--don't let the template arguments
2209 clobber it, as that would give us the wrong name for a subsequent
2210 constructor or destructor. */
2211 hold_last_name
= di
->last_name
;
2213 if (d_next_char (di
) != 'I')
2220 struct demangle_component
*a
;
2222 a
= d_template_arg (di
);
2226 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
2229 pal
= &d_right (*pal
);
2231 if (d_peek_char (di
) == 'E')
2238 di
->last_name
= hold_last_name
;
2243 /* <template-arg> ::= <type>
2244 ::= X <expression> E
2248 static struct demangle_component
*
2252 struct demangle_component
*ret
;
2254 switch (d_peek_char (di
))
2258 ret
= d_expression (di
);
2259 if (d_next_char (di
) != 'E')
2264 return d_expr_primary (di
);
2267 return cplus_demangle_type (di
);
2271 /* <expression> ::= <(unary) operator-name> <expression>
2272 ::= <(binary) operator-name> <expression> <expression>
2273 ::= <(trinary) operator-name> <expression> <expression> <expression>
2275 ::= <template-param>
2276 ::= sr <type> <unqualified-name>
2277 ::= sr <type> <unqualified-name> <template-args>
2281 static struct demangle_component
*
2287 peek
= d_peek_char (di
);
2289 return d_expr_primary (di
);
2290 else if (peek
== 'T')
2291 return d_template_param (di
);
2292 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2294 struct demangle_component
*type
;
2295 struct demangle_component
*name
;
2298 type
= cplus_demangle_type (di
);
2299 name
= d_unqualified_name (di
);
2300 if (d_peek_char (di
) != 'I')
2301 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
2303 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
2304 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2305 d_template_args (di
)));
2309 struct demangle_component
*op
;
2312 op
= d_operator_name (di
);
2316 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
2317 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
2319 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
2320 && strcmp (op
->u
.s_operator
.op
->code
, "st") == 0)
2321 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2322 cplus_demangle_type (di
));
2328 case DEMANGLE_COMPONENT_OPERATOR
:
2329 args
= op
->u
.s_operator
.op
->args
;
2331 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
2332 args
= op
->u
.s_extended_operator
.args
;
2334 case DEMANGLE_COMPONENT_CAST
:
2342 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2346 struct demangle_component
*left
;
2348 left
= d_expression (di
);
2349 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
2351 DEMANGLE_COMPONENT_BINARY_ARGS
,
2353 d_expression (di
)));
2357 struct demangle_component
*first
;
2358 struct demangle_component
*second
;
2360 first
= d_expression (di
);
2361 second
= d_expression (di
);
2362 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
2364 DEMANGLE_COMPONENT_TRINARY_ARG1
,
2367 DEMANGLE_COMPONENT_TRINARY_ARG2
,
2369 d_expression (di
))));
2377 /* <expr-primary> ::= L <type> <(value) number> E
2378 ::= L <type> <(value) float> E
2379 ::= L <mangled-name> E
2382 static struct demangle_component
*
2386 struct demangle_component
*ret
;
2388 if (d_next_char (di
) != 'L')
2390 if (d_peek_char (di
) == '_')
2391 ret
= cplus_demangle_mangled_name (di
, 0);
2394 struct demangle_component
*type
;
2395 enum demangle_component_type t
;
2398 type
= cplus_demangle_type (di
);
2400 /* If we have a type we know how to print, we aren't going to
2401 print the type name itself. */
2402 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2403 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
2404 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
2406 /* Rather than try to interpret the literal value, we just
2407 collect it as a string. Note that it's possible to have a
2408 floating point literal here. The ABI specifies that the
2409 format of such literals is machine independent. That's fine,
2410 but what's not fine is that versions of g++ up to 3.2 with
2411 -fabi-version=1 used upper case letters in the hex constant,
2412 and dumped out gcc's internal representation. That makes it
2413 hard to tell where the constant ends, and hard to dump the
2414 constant in any readable form anyhow. We don't attempt to
2415 handle these cases. */
2417 t
= DEMANGLE_COMPONENT_LITERAL
;
2418 if (d_peek_char (di
) == 'n')
2420 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
2424 while (d_peek_char (di
) != 'E')
2426 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
2428 if (d_next_char (di
) != 'E')
2433 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2434 ::= Z <(function) encoding> E s [<discriminator>]
2437 static struct demangle_component
*
2441 struct demangle_component
*function
;
2443 if (d_next_char (di
) != 'Z')
2446 function
= d_encoding (di
, 0);
2448 if (d_next_char (di
) != 'E')
2451 if (d_peek_char (di
) == 's')
2454 if (! d_discriminator (di
))
2456 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
2457 d_make_name (di
, "string literal",
2458 sizeof "string literal" - 1));
2462 struct demangle_component
*name
;
2465 if (! d_discriminator (di
))
2467 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
2471 /* <discriminator> ::= _ <(non-negative) number>
2473 We demangle the discriminator, but we don't print it out. FIXME:
2474 We should print it out in verbose mode. */
2477 d_discriminator (di
)
2482 if (d_peek_char (di
) != '_')
2485 discrim
= d_number (di
);
2491 /* Add a new substitution. */
2494 d_add_substitution (di
, dc
)
2496 struct demangle_component
*dc
;
2500 if (di
->next_sub
>= di
->num_subs
)
2502 di
->subs
[di
->next_sub
] = dc
;
2507 /* <substitution> ::= S <seq-id> _
2517 If PREFIX is non-zero, then this type is being used as a prefix in
2518 a qualified name. In this case, for the standard substitutions, we
2519 need to check whether we are being used as a prefix for a
2520 constructor or destructor, and return a full template name.
2521 Otherwise we will get something like std::iostream::~iostream()
2522 which does not correspond particularly well to any function which
2523 actually appears in the source.
2526 static const struct d_standard_sub_info standard_subs
[] =
2531 { 'a', NL ("std::allocator"),
2532 NL ("std::allocator"),
2534 { 'b', NL ("std::basic_string"),
2535 NL ("std::basic_string"),
2536 NL ("basic_string") },
2537 { 's', NL ("std::string"),
2538 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
2539 NL ("basic_string") },
2540 { 'i', NL ("std::istream"),
2541 NL ("std::basic_istream<char, std::char_traits<char> >"),
2542 NL ("basic_istream") },
2543 { 'o', NL ("std::ostream"),
2544 NL ("std::basic_ostream<char, std::char_traits<char> >"),
2545 NL ("basic_ostream") },
2546 { 'd', NL ("std::iostream"),
2547 NL ("std::basic_iostream<char, std::char_traits<char> >"),
2548 NL ("basic_iostream") }
2551 static struct demangle_component
*
2552 d_substitution (di
, prefix
)
2558 if (d_next_char (di
) != 'S')
2561 c
= d_next_char (di
);
2562 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
2572 id
= id
* 36 + c
- '0';
2573 else if (IS_UPPER (c
))
2574 id
= id
* 36 + c
- 'A' + 10;
2577 c
= d_next_char (di
);
2584 if (id
>= di
->next_sub
)
2589 return di
->subs
[id
];
2594 const struct d_standard_sub_info
*p
;
2595 const struct d_standard_sub_info
*pend
;
2597 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
2598 if (! verbose
&& prefix
)
2602 peek
= d_peek_char (di
);
2603 if (peek
== 'C' || peek
== 'D')
2607 pend
= (&standard_subs
[0]
2608 + sizeof standard_subs
/ sizeof standard_subs
[0]);
2609 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
2616 if (p
->set_last_name
!= NULL
)
2617 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
2618 p
->set_last_name_len
);
2621 s
= p
->full_expansion
;
2626 s
= p
->simple_expansion
;
2627 len
= p
->simple_len
;
2629 di
->expansion
+= len
;
2630 return d_make_sub (di
, s
, len
);
2638 /* Resize the print buffer. */
2641 d_print_resize (dpi
, add
)
2642 struct d_print_info
*dpi
;
2647 if (dpi
->buf
== NULL
)
2649 need
= dpi
->len
+ add
;
2650 while (need
> dpi
->alc
)
2655 newalc
= dpi
->alc
* 2;
2656 newbuf
= realloc (dpi
->buf
, newalc
);
2661 dpi
->allocation_failure
= 1;
2669 /* Append a character to the print buffer. */
2672 d_print_append_char (dpi
, c
)
2673 struct d_print_info
*dpi
;
2676 if (dpi
->buf
!= NULL
)
2678 if (dpi
->len
>= dpi
->alc
)
2680 d_print_resize (dpi
, 1);
2681 if (dpi
->buf
== NULL
)
2685 dpi
->buf
[dpi
->len
] = c
;
2690 /* Append a buffer to the print buffer. */
2693 d_print_append_buffer (dpi
, s
, l
)
2694 struct d_print_info
*dpi
;
2698 if (dpi
->buf
!= NULL
)
2700 if (dpi
->len
+ l
> dpi
->alc
)
2702 d_print_resize (dpi
, l
);
2703 if (dpi
->buf
== NULL
)
2707 memcpy (dpi
->buf
+ dpi
->len
, s
, l
);
2712 /* Indicate that an error occurred during printing. */
2716 struct d_print_info
*dpi
;
2722 /* Turn components into a human readable string. OPTIONS is the
2723 options bits passed to the demangler. DC is the tree to print.
2724 ESTIMATE is a guess at the length of the result. This returns a
2725 string allocated by malloc, or NULL on error. On success, this
2726 sets *PALC to the size of the allocated buffer. On failure, this
2727 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
2730 CP_STATIC_IF_GLIBCPP_V3
2732 cplus_demangle_print (options
, dc
, estimate
, palc
)
2734 const struct demangle_component
*dc
;
2738 struct d_print_info dpi
;
2740 dpi
.options
= options
;
2742 dpi
.alc
= estimate
+ 1;
2743 dpi
.buf
= malloc (dpi
.alc
);
2744 if (dpi
.buf
== NULL
)
2751 dpi
.templates
= NULL
;
2752 dpi
.modifiers
= NULL
;
2754 dpi
.allocation_failure
= 0;
2756 d_print_comp (&dpi
, dc
);
2758 d_append_char (&dpi
, '\0');
2760 if (dpi
.buf
!= NULL
)
2763 *palc
= dpi
.allocation_failure
;
2768 /* Subroutine to handle components. */
2771 d_print_comp (dpi
, dc
)
2772 struct d_print_info
*dpi
;
2773 const struct demangle_component
*dc
;
2777 d_print_error (dpi
);
2780 if (d_print_saw_error (dpi
))
2785 case DEMANGLE_COMPONENT_NAME
:
2786 if ((dpi
->options
& DMGL_JAVA
) == 0)
2787 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2789 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2792 case DEMANGLE_COMPONENT_QUAL_NAME
:
2793 case DEMANGLE_COMPONENT_LOCAL_NAME
:
2794 d_print_comp (dpi
, d_left (dc
));
2795 if ((dpi
->options
& DMGL_JAVA
) == 0)
2796 d_append_string_constant (dpi
, "::");
2798 d_append_char (dpi
, '.');
2799 d_print_comp (dpi
, d_right (dc
));
2802 case DEMANGLE_COMPONENT_TYPED_NAME
:
2804 struct d_print_mod
*hold_modifiers
;
2805 struct demangle_component
*typed_name
;
2806 struct d_print_mod adpm
[4];
2808 struct d_print_template dpt
;
2810 /* Pass the name down to the type so that it can be printed in
2811 the right place for the type. We also have to pass down
2812 any CV-qualifiers, which apply to the this parameter. */
2813 hold_modifiers
= dpi
->modifiers
;
2815 typed_name
= d_left (dc
);
2816 while (typed_name
!= NULL
)
2818 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2820 d_print_error (dpi
);
2824 adpm
[i
].next
= dpi
->modifiers
;
2825 dpi
->modifiers
= &adpm
[i
];
2826 adpm
[i
].mod
= typed_name
;
2827 adpm
[i
].printed
= 0;
2828 adpm
[i
].templates
= dpi
->templates
;
2831 if (typed_name
->type
!= DEMANGLE_COMPONENT_RESTRICT_THIS
2832 && typed_name
->type
!= DEMANGLE_COMPONENT_VOLATILE_THIS
2833 && typed_name
->type
!= DEMANGLE_COMPONENT_CONST_THIS
)
2836 typed_name
= d_left (typed_name
);
2839 /* If typed_name is a template, then it applies to the
2840 function type as well. */
2841 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
2843 dpt
.next
= dpi
->templates
;
2844 dpi
->templates
= &dpt
;
2845 dpt
.template = typed_name
;
2848 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
2849 there may be CV-qualifiers on its right argument which
2850 really apply here; this happens when parsing a class which
2851 is local to a function. */
2852 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
2854 struct demangle_component
*local_name
;
2856 local_name
= d_right (typed_name
);
2857 while (local_name
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
2858 || local_name
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
2859 || local_name
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
2861 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2863 d_print_error (dpi
);
2867 adpm
[i
] = adpm
[i
- 1];
2868 adpm
[i
].next
= &adpm
[i
- 1];
2869 dpi
->modifiers
= &adpm
[i
];
2871 adpm
[i
- 1].mod
= local_name
;
2872 adpm
[i
- 1].printed
= 0;
2873 adpm
[i
- 1].templates
= dpi
->templates
;
2876 local_name
= d_left (local_name
);
2880 d_print_comp (dpi
, d_right (dc
));
2882 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
2883 dpi
->templates
= dpt
.next
;
2885 /* If the modifiers didn't get printed by the type, print them
2890 if (! adpm
[i
].printed
)
2892 d_append_char (dpi
, ' ');
2893 d_print_mod (dpi
, adpm
[i
].mod
);
2897 dpi
->modifiers
= hold_modifiers
;
2902 case DEMANGLE_COMPONENT_TEMPLATE
:
2904 struct d_print_mod
*hold_dpm
;
2906 /* Don't push modifiers into a template definition. Doing so
2907 could give the wrong definition for a template argument.
2908 Instead, treat the template essentially as a name. */
2910 hold_dpm
= dpi
->modifiers
;
2911 dpi
->modifiers
= NULL
;
2913 d_print_comp (dpi
, d_left (dc
));
2914 if (d_last_char (dpi
) == '<')
2915 d_append_char (dpi
, ' ');
2916 d_append_char (dpi
, '<');
2917 d_print_comp (dpi
, d_right (dc
));
2918 /* Avoid generating two consecutive '>' characters, to avoid
2919 the C++ syntactic ambiguity. */
2920 if (d_last_char (dpi
) == '>')
2921 d_append_char (dpi
, ' ');
2922 d_append_char (dpi
, '>');
2924 dpi
->modifiers
= hold_dpm
;
2929 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
2932 struct demangle_component
*a
;
2933 struct d_print_template
*hold_dpt
;
2935 if (dpi
->templates
== NULL
)
2937 d_print_error (dpi
);
2940 i
= dc
->u
.s_number
.number
;
2941 for (a
= d_right (dpi
->templates
->template);
2945 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
2947 d_print_error (dpi
);
2954 if (i
!= 0 || a
== NULL
)
2956 d_print_error (dpi
);
2960 /* While processing this parameter, we need to pop the list of
2961 templates. This is because the template parameter may
2962 itself be a reference to a parameter of an outer
2965 hold_dpt
= dpi
->templates
;
2966 dpi
->templates
= hold_dpt
->next
;
2968 d_print_comp (dpi
, d_left (a
));
2970 dpi
->templates
= hold_dpt
;
2975 case DEMANGLE_COMPONENT_CTOR
:
2976 d_print_comp (dpi
, dc
->u
.s_ctor
.name
);
2979 case DEMANGLE_COMPONENT_DTOR
:
2980 d_append_char (dpi
, '~');
2981 d_print_comp (dpi
, dc
->u
.s_dtor
.name
);
2984 case DEMANGLE_COMPONENT_VTABLE
:
2985 d_append_string_constant (dpi
, "vtable for ");
2986 d_print_comp (dpi
, d_left (dc
));
2989 case DEMANGLE_COMPONENT_VTT
:
2990 d_append_string_constant (dpi
, "VTT for ");
2991 d_print_comp (dpi
, d_left (dc
));
2994 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
2995 d_append_string_constant (dpi
, "construction vtable for ");
2996 d_print_comp (dpi
, d_left (dc
));
2997 d_append_string_constant (dpi
, "-in-");
2998 d_print_comp (dpi
, d_right (dc
));
3001 case DEMANGLE_COMPONENT_TYPEINFO
:
3002 d_append_string_constant (dpi
, "typeinfo for ");
3003 d_print_comp (dpi
, d_left (dc
));
3006 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
3007 d_append_string_constant (dpi
, "typeinfo name for ");
3008 d_print_comp (dpi
, d_left (dc
));
3011 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
3012 d_append_string_constant (dpi
, "typeinfo fn for ");
3013 d_print_comp (dpi
, d_left (dc
));
3016 case DEMANGLE_COMPONENT_THUNK
:
3017 d_append_string_constant (dpi
, "non-virtual thunk to ");
3018 d_print_comp (dpi
, d_left (dc
));
3021 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
3022 d_append_string_constant (dpi
, "virtual thunk to ");
3023 d_print_comp (dpi
, d_left (dc
));
3026 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
3027 d_append_string_constant (dpi
, "covariant return thunk to ");
3028 d_print_comp (dpi
, d_left (dc
));
3031 case DEMANGLE_COMPONENT_JAVA_CLASS
:
3032 d_append_string_constant (dpi
, "java Class for ");
3033 d_print_comp (dpi
, d_left (dc
));
3036 case DEMANGLE_COMPONENT_GUARD
:
3037 d_append_string_constant (dpi
, "guard variable for ");
3038 d_print_comp (dpi
, d_left (dc
));
3041 case DEMANGLE_COMPONENT_REFTEMP
:
3042 d_append_string_constant (dpi
, "reference temporary for ");
3043 d_print_comp (dpi
, d_left (dc
));
3046 case DEMANGLE_COMPONENT_SUB_STD
:
3047 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
3050 case DEMANGLE_COMPONENT_RESTRICT
:
3051 case DEMANGLE_COMPONENT_VOLATILE
:
3052 case DEMANGLE_COMPONENT_CONST
:
3054 struct d_print_mod
*pdpm
;
3056 /* When printing arrays, it's possible to have cases where the
3057 same CV-qualifier gets pushed on the stack multiple times.
3058 We only need to print it once. */
3060 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
3062 if (! pdpm
->printed
)
3064 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
3065 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
3066 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
3068 if (pdpm
->mod
->type
== dc
->type
)
3070 d_print_comp (dpi
, d_left (dc
));
3077 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3078 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3079 case DEMANGLE_COMPONENT_CONST_THIS
:
3080 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3081 case DEMANGLE_COMPONENT_POINTER
:
3082 case DEMANGLE_COMPONENT_REFERENCE
:
3083 case DEMANGLE_COMPONENT_COMPLEX
:
3084 case DEMANGLE_COMPONENT_IMAGINARY
:
3086 /* We keep a list of modifiers on the stack. */
3087 struct d_print_mod dpm
;
3089 dpm
.next
= dpi
->modifiers
;
3090 dpi
->modifiers
= &dpm
;
3093 dpm
.templates
= dpi
->templates
;
3095 d_print_comp (dpi
, d_left (dc
));
3097 /* If the modifier didn't get printed by the type, print it
3100 d_print_mod (dpi
, dc
);
3102 dpi
->modifiers
= dpm
.next
;
3107 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3108 if ((dpi
->options
& DMGL_JAVA
) == 0)
3109 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
3110 dc
->u
.s_builtin
.type
->len
);
3112 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
3113 dc
->u
.s_builtin
.type
->java_len
);
3116 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
3117 d_print_comp (dpi
, d_left (dc
));
3120 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
3122 if (d_left (dc
) != NULL
)
3124 struct d_print_mod dpm
;
3126 /* We must pass this type down as a modifier in order to
3127 print it in the right location. */
3129 dpm
.next
= dpi
->modifiers
;
3130 dpi
->modifiers
= &dpm
;
3133 dpm
.templates
= dpi
->templates
;
3135 d_print_comp (dpi
, d_left (dc
));
3137 dpi
->modifiers
= dpm
.next
;
3142 d_append_char (dpi
, ' ');
3145 d_print_function_type (dpi
, dc
, dpi
->modifiers
);
3150 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
3152 struct d_print_mod
*hold_modifiers
;
3153 struct d_print_mod adpm
[4];
3155 struct d_print_mod
*pdpm
;
3157 /* We must pass this type down as a modifier in order to print
3158 multi-dimensional arrays correctly. If the array itself is
3159 CV-qualified, we act as though the element type were
3160 CV-qualified. We do this by copying the modifiers down
3161 rather than fiddling pointers, so that we don't wind up
3162 with a d_print_mod higher on the stack pointing into our
3163 stack frame after we return. */
3165 hold_modifiers
= dpi
->modifiers
;
3167 adpm
[0].next
= hold_modifiers
;
3168 dpi
->modifiers
= &adpm
[0];
3170 adpm
[0].printed
= 0;
3171 adpm
[0].templates
= dpi
->templates
;
3174 pdpm
= hold_modifiers
;
3176 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
3177 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
3178 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
3180 if (! pdpm
->printed
)
3182 if (i
>= sizeof adpm
/ sizeof adpm
[0])
3184 d_print_error (dpi
);
3189 adpm
[i
].next
= dpi
->modifiers
;
3190 dpi
->modifiers
= &adpm
[i
];
3198 d_print_comp (dpi
, d_right (dc
));
3200 dpi
->modifiers
= hold_modifiers
;
3202 if (adpm
[0].printed
)
3208 d_print_mod (dpi
, adpm
[i
].mod
);
3211 d_print_array_type (dpi
, dc
, dpi
->modifiers
);
3216 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3218 struct d_print_mod dpm
;
3220 dpm
.next
= dpi
->modifiers
;
3221 dpi
->modifiers
= &dpm
;
3224 dpm
.templates
= dpi
->templates
;
3226 d_print_comp (dpi
, d_right (dc
));
3228 /* If the modifier didn't get printed by the type, print it
3232 d_append_char (dpi
, ' ');
3233 d_print_comp (dpi
, d_left (dc
));
3234 d_append_string_constant (dpi
, "::*");
3237 dpi
->modifiers
= dpm
.next
;
3242 case DEMANGLE_COMPONENT_ARGLIST
:
3243 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
3244 d_print_comp (dpi
, d_left (dc
));
3245 if (d_right (dc
) != NULL
)
3247 d_append_string_constant (dpi
, ", ");
3248 d_print_comp (dpi
, d_right (dc
));
3252 case DEMANGLE_COMPONENT_OPERATOR
:
3256 d_append_string_constant (dpi
, "operator");
3257 c
= dc
->u
.s_operator
.op
->name
[0];
3259 d_append_char (dpi
, ' ');
3260 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
3261 dc
->u
.s_operator
.op
->len
);
3265 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3266 d_append_string_constant (dpi
, "operator ");
3267 d_print_comp (dpi
, dc
->u
.s_extended_operator
.name
);
3270 case DEMANGLE_COMPONENT_CAST
:
3271 d_append_string_constant (dpi
, "operator ");
3272 d_print_cast (dpi
, dc
);
3275 case DEMANGLE_COMPONENT_UNARY
:
3276 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_CAST
)
3277 d_print_expr_op (dpi
, d_left (dc
));
3280 d_append_char (dpi
, '(');
3281 d_print_cast (dpi
, d_left (dc
));
3282 d_append_char (dpi
, ')');
3284 d_append_char (dpi
, '(');
3285 d_print_comp (dpi
, d_right (dc
));
3286 d_append_char (dpi
, ')');
3289 case DEMANGLE_COMPONENT_BINARY
:
3290 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
3292 d_print_error (dpi
);
3296 /* We wrap an expression which uses the greater-than operator in
3297 an extra layer of parens so that it does not get confused
3298 with the '>' which ends the template parameters. */
3299 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
3300 && d_left (dc
)->u
.s_operator
.op
->len
== 1
3301 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
3302 d_append_char (dpi
, '(');
3304 d_append_char (dpi
, '(');
3305 d_print_comp (dpi
, d_left (d_right (dc
)));
3306 d_append_string_constant (dpi
, ") ");
3307 d_print_expr_op (dpi
, d_left (dc
));
3308 d_append_string_constant (dpi
, " (");
3309 d_print_comp (dpi
, d_right (d_right (dc
)));
3310 d_append_char (dpi
, ')');
3312 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
3313 && d_left (dc
)->u
.s_operator
.op
->len
== 1
3314 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
3315 d_append_char (dpi
, ')');
3319 case DEMANGLE_COMPONENT_BINARY_ARGS
:
3320 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
3321 d_print_error (dpi
);
3324 case DEMANGLE_COMPONENT_TRINARY
:
3325 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
3326 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
3328 d_print_error (dpi
);
3331 d_append_char (dpi
, '(');
3332 d_print_comp (dpi
, d_left (d_right (dc
)));
3333 d_append_string_constant (dpi
, ") ");
3334 d_print_expr_op (dpi
, d_left (dc
));
3335 d_append_string_constant (dpi
, " (");
3336 d_print_comp (dpi
, d_left (d_right (d_right (dc
))));
3337 d_append_string_constant (dpi
, ") : (");
3338 d_print_comp (dpi
, d_right (d_right (d_right (dc
))));
3339 d_append_char (dpi
, ')');
3342 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
3343 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
3344 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
3345 d_print_error (dpi
);
3348 case DEMANGLE_COMPONENT_LITERAL
:
3349 case DEMANGLE_COMPONENT_LITERAL_NEG
:
3350 /* For some builtin types, produce simpler output. */
3351 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
3353 switch (d_left (dc
)->u
.s_builtin
.type
->print
)
3356 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
3358 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3359 d_append_char (dpi
, '-');
3360 d_print_comp (dpi
, d_right (dc
));
3366 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
3368 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3369 d_append_char (dpi
, '-');
3370 d_print_comp (dpi
, d_right (dc
));
3371 d_append_char (dpi
, 'l');
3377 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
3378 && d_right (dc
)->u
.s_name
.len
== 1
3379 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
3381 switch (d_right (dc
)->u
.s_name
.s
[0])
3384 d_append_string_constant (dpi
, "false");
3387 d_append_string_constant (dpi
, "true");
3400 d_append_char (dpi
, '(');
3401 d_print_comp (dpi
, d_left (dc
));
3402 d_append_char (dpi
, ')');
3403 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3404 d_append_char (dpi
, '-');
3405 d_print_comp (dpi
, d_right (dc
));
3409 d_print_error (dpi
);
3414 /* Print a Java dentifier. For Java we try to handle encoded extended
3415 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
3416 so we don't it for C++. Characters are encoded as
3420 d_print_java_identifier (dpi
, name
, len
)
3421 struct d_print_info
*dpi
;
3429 for (p
= name
; p
< end
; ++p
)
3440 for (q
= p
+ 3; q
< end
; ++q
)
3446 else if (*q
>= 'A' && *q
<= 'F')
3447 dig
= *q
- 'A' + 10;
3448 else if (*q
>= 'a' && *q
<= 'f')
3449 dig
= *q
- 'a' + 10;
3455 /* If the Unicode character is larger than 256, we don't try
3456 to deal with it here. FIXME. */
3457 if (q
< end
&& *q
== '_' && c
< 256)
3459 d_append_char (dpi
, c
);
3465 d_append_char (dpi
, *p
);
3469 /* Print a list of modifiers. SUFFIX is 1 if we are printing
3470 qualifiers on this after printing a function. */
3473 d_print_mod_list (dpi
, mods
, suffix
)
3474 struct d_print_info
*dpi
;
3475 struct d_print_mod
*mods
;
3478 struct d_print_template
*hold_dpt
;
3480 if (mods
== NULL
|| d_print_saw_error (dpi
))
3485 && (mods
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3486 || mods
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3487 || mods
->mod
->type
== DEMANGLE_COMPONENT_CONST_THIS
)))
3489 d_print_mod_list (dpi
, mods
->next
, suffix
);
3495 hold_dpt
= dpi
->templates
;
3496 dpi
->templates
= mods
->templates
;
3498 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3500 d_print_function_type (dpi
, mods
->mod
, mods
->next
);
3501 dpi
->templates
= hold_dpt
;
3504 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
3506 d_print_array_type (dpi
, mods
->mod
, mods
->next
);
3507 dpi
->templates
= hold_dpt
;
3510 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
3512 struct d_print_mod
*hold_modifiers
;
3513 struct demangle_component
*dc
;
3515 /* When this is on the modifier stack, we have pulled any
3516 qualifiers off the right argument already. Otherwise, we
3517 print it as usual, but don't let the left argument see any
3520 hold_modifiers
= dpi
->modifiers
;
3521 dpi
->modifiers
= NULL
;
3522 d_print_comp (dpi
, d_left (mods
->mod
));
3523 dpi
->modifiers
= hold_modifiers
;
3525 if ((dpi
->options
& DMGL_JAVA
) == 0)
3526 d_append_string_constant (dpi
, "::");
3528 d_append_char (dpi
, '.');
3530 dc
= d_right (mods
->mod
);
3531 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3532 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3533 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
3536 d_print_comp (dpi
, dc
);
3538 dpi
->templates
= hold_dpt
;
3542 d_print_mod (dpi
, mods
->mod
);
3544 dpi
->templates
= hold_dpt
;
3546 d_print_mod_list (dpi
, mods
->next
, suffix
);
3549 /* Print a modifier. */
3552 d_print_mod (dpi
, mod
)
3553 struct d_print_info
*dpi
;
3554 const struct demangle_component
*mod
;
3558 case DEMANGLE_COMPONENT_RESTRICT
:
3559 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3560 d_append_string_constant (dpi
, " restrict");
3562 case DEMANGLE_COMPONENT_VOLATILE
:
3563 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3564 d_append_string_constant (dpi
, " volatile");
3566 case DEMANGLE_COMPONENT_CONST
:
3567 case DEMANGLE_COMPONENT_CONST_THIS
:
3568 d_append_string_constant (dpi
, " const");
3570 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3571 d_append_char (dpi
, ' ');
3572 d_print_comp (dpi
, d_right (mod
));
3574 case DEMANGLE_COMPONENT_POINTER
:
3575 /* There is no pointer symbol in Java. */
3576 if ((dpi
->options
& DMGL_JAVA
) == 0)
3577 d_append_char (dpi
, '*');
3579 case DEMANGLE_COMPONENT_REFERENCE
:
3580 d_append_char (dpi
, '&');
3582 case DEMANGLE_COMPONENT_COMPLEX
:
3583 d_append_string_constant (dpi
, "complex ");
3585 case DEMANGLE_COMPONENT_IMAGINARY
:
3586 d_append_string_constant (dpi
, "imaginary ");
3588 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3589 if (d_last_char (dpi
) != '(')
3590 d_append_char (dpi
, ' ');
3591 d_print_comp (dpi
, d_left (mod
));
3592 d_append_string_constant (dpi
, "::*");
3594 case DEMANGLE_COMPONENT_TYPED_NAME
:
3595 d_print_comp (dpi
, d_left (mod
));
3598 /* Otherwise, we have something that won't go back on the
3599 modifier stack, so we can just print it. */
3600 d_print_comp (dpi
, mod
);
3605 /* Print a function type, except for the return type. */
3608 d_print_function_type (dpi
, dc
, mods
)
3609 struct d_print_info
*dpi
;
3610 const struct demangle_component
*dc
;
3611 struct d_print_mod
*mods
;
3615 struct d_print_mod
*p
;
3616 struct d_print_mod
*hold_modifiers
;
3620 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3626 switch (p
->mod
->type
)
3628 case DEMANGLE_COMPONENT_RESTRICT
:
3629 case DEMANGLE_COMPONENT_VOLATILE
:
3630 case DEMANGLE_COMPONENT_CONST
:
3631 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3632 case DEMANGLE_COMPONENT_POINTER
:
3633 case DEMANGLE_COMPONENT_REFERENCE
:
3634 case DEMANGLE_COMPONENT_COMPLEX
:
3635 case DEMANGLE_COMPONENT_IMAGINARY
:
3636 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3639 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3640 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3641 case DEMANGLE_COMPONENT_CONST_THIS
:
3650 if (d_left (dc
) != NULL
&& ! saw_mod
)
3655 switch (d_last_char (dpi
))
3663 d_append_char (dpi
, ' ');
3667 d_append_char (dpi
, '(');
3670 hold_modifiers
= dpi
->modifiers
;
3671 dpi
->modifiers
= NULL
;
3673 d_print_mod_list (dpi
, mods
, 0);
3676 d_append_char (dpi
, ')');
3678 d_append_char (dpi
, '(');
3680 if (d_right (dc
) != NULL
)
3681 d_print_comp (dpi
, d_right (dc
));
3683 d_append_char (dpi
, ')');
3685 d_print_mod_list (dpi
, mods
, 1);
3687 dpi
->modifiers
= hold_modifiers
;
3690 /* Print an array type, except for the element type. */
3693 d_print_array_type (dpi
, dc
, mods
)
3694 struct d_print_info
*dpi
;
3695 const struct demangle_component
*dc
;
3696 struct d_print_mod
*mods
;
3704 struct d_print_mod
*p
;
3707 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3711 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
3726 d_append_string_constant (dpi
, " (");
3728 d_print_mod_list (dpi
, mods
, 0);
3731 d_append_char (dpi
, ')');
3735 d_append_char (dpi
, ' ');
3737 d_append_char (dpi
, '[');
3739 if (d_left (dc
) != NULL
)
3740 d_print_comp (dpi
, d_left (dc
));
3742 d_append_char (dpi
, ']');
3745 /* Print an operator in an expression. */
3748 d_print_expr_op (dpi
, dc
)
3749 struct d_print_info
*dpi
;
3750 const struct demangle_component
*dc
;
3752 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3753 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
3754 dc
->u
.s_operator
.op
->len
);
3756 d_print_comp (dpi
, dc
);
3762 d_print_cast (dpi
, dc
)
3763 struct d_print_info
*dpi
;
3764 const struct demangle_component
*dc
;
3766 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
3767 d_print_comp (dpi
, d_left (dc
));
3770 struct d_print_mod
*hold_dpm
;
3771 struct d_print_template dpt
;
3773 /* It appears that for a templated cast operator, we need to put
3774 the template parameters in scope for the operator name, but
3775 not for the parameters. The effect is that we need to handle
3776 the template printing here. */
3778 hold_dpm
= dpi
->modifiers
;
3779 dpi
->modifiers
= NULL
;
3781 dpt
.next
= dpi
->templates
;
3782 dpi
->templates
= &dpt
;
3783 dpt
.template = d_left (dc
);
3785 d_print_comp (dpi
, d_left (d_left (dc
)));
3787 dpi
->templates
= dpt
.next
;
3789 if (d_last_char (dpi
) == '<')
3790 d_append_char (dpi
, ' ');
3791 d_append_char (dpi
, '<');
3792 d_print_comp (dpi
, d_right (d_left (dc
)));
3793 /* Avoid generating two consecutive '>' characters, to avoid
3794 the C++ syntactic ambiguity. */
3795 if (d_last_char (dpi
) == '>')
3796 d_append_char (dpi
, ' ');
3797 d_append_char (dpi
, '>');
3799 dpi
->modifiers
= hold_dpm
;
3803 /* Initialize the information structure we use to pass around
3806 CP_STATIC_IF_GLIBCPP_V3
3808 cplus_demangle_init_info (mangled
, options
, len
, di
)
3809 const char *mangled
;
3815 di
->send
= mangled
+ len
;
3816 di
->options
= options
;
3820 /* We can not need more components than twice the number of chars in
3821 the mangled string. Most components correspond directly to
3822 chars, but the ARGLIST types are exceptions. */
3823 di
->num_comps
= 2 * len
;
3826 /* Similarly, we can not need more substitutions than there are
3827 chars in the mangled string. */
3832 di
->last_name
= NULL
;
3837 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
3838 name, return a buffer allocated with malloc holding the demangled
3839 name. OPTIONS is the usual libiberty demangler options. On
3840 success, this sets *PALC to the allocated size of the returned
3841 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
3842 a memory allocation failure. On failure, this returns NULL. */
3845 d_demangle (mangled
, options
, palc
)
3846 const char* mangled
;
3853 struct demangle_component
*dc
;
3859 len
= strlen (mangled
);
3861 if (mangled
[0] == '_' && mangled
[1] == 'Z')
3863 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
3864 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
3865 && (mangled
[9] == 'D' || mangled
[9] == 'I')
3866 && mangled
[10] == '_')
3870 r
= malloc (40 + len
- 11);
3875 if (mangled
[9] == 'I')
3876 strcpy (r
, "global constructors keyed to ");
3878 strcpy (r
, "global destructors keyed to ");
3879 strcat (r
, mangled
+ 11);
3885 if ((options
& DMGL_TYPES
) == 0)
3890 cplus_demangle_init_info (mangled
, options
, len
, &di
);
3893 #ifdef CP_DYNAMIC_ARRAYS
3894 __extension__
struct demangle_component comps
[di
.num_comps
];
3895 __extension__
struct demangle_component
*subs
[di
.num_subs
];
3897 di
.comps
= &comps
[0];
3900 di
.comps
= ((struct demangle_component
*)
3901 malloc (di
.num_comps
* sizeof (struct demangle_component
)));
3902 di
.subs
= ((struct demangle_component
**)
3903 malloc (di
.num_subs
* sizeof (struct demangle_component
*)));
3904 if (di
.comps
== NULL
|| di
.subs
== NULL
)
3906 if (di
.comps
!= NULL
)
3908 if (di
.subs
!= NULL
)
3916 dc
= cplus_demangle_mangled_name (&di
, 1);
3918 dc
= cplus_demangle_type (&di
);
3920 /* If DMGL_PARAMS is set, then if we didn't consume the entire
3921 mangled string, then we didn't successfully demangle it. If
3922 DMGL_PARAMS is not set, we didn't look at the trailing
3924 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
3927 #ifdef CP_DEMANGLE_DEBUG
3929 printf ("failed demangling\n");
3934 /* We try to guess the length of the demangled string, to minimize
3935 calls to realloc during demangling. */
3936 estimate
= len
+ di
.expansion
+ 10 * di
.did_subs
;
3937 estimate
+= estimate
/ 8;
3941 ret
= cplus_demangle_print (options
, dc
, estimate
, palc
);
3943 #ifndef CP_DYNAMIC_ARRAYS
3948 #ifdef CP_DEMANGLE_DEBUG
3953 rlen
= strlen (ret
);
3954 if (rlen
> 2 * estimate
)
3955 printf ("*** Length %d much greater than estimate %d\n",
3957 else if (rlen
> estimate
)
3958 printf ("*** Length %d greater than estimate %d\n",
3960 else if (rlen
< estimate
/ 2)
3961 printf ("*** Length %d much less than estimate %d\n",
3970 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
3972 extern char *__cxa_demangle
PARAMS ((const char *, char *, size_t *, int *));
3974 /* ia64 ABI-mandated entry point in the C++ runtime library for
3975 performing demangling. MANGLED_NAME is a NUL-terminated character
3976 string containing the name to be demangled.
3978 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
3979 *LENGTH bytes, into which the demangled name is stored. If
3980 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
3981 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
3982 is placed in a region of memory allocated with malloc.
3984 If LENGTH is non-NULL, the length of the buffer conaining the
3985 demangled name, is placed in *LENGTH.
3987 The return value is a pointer to the start of the NUL-terminated
3988 demangled name, or NULL if the demangling fails. The caller is
3989 responsible for deallocating this memory using free.
3991 *STATUS is set to one of the following values:
3992 0: The demangling operation succeeded.
3993 -1: A memory allocation failure occurred.
3994 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
3995 -3: One of the arguments is invalid.
3997 The demangling is performed using the C++ ABI mangling rules, with
4001 __cxa_demangle (mangled_name
, output_buffer
, length
, status
)
4002 const char *mangled_name
;
4003 char *output_buffer
;
4010 if (mangled_name
== NULL
)
4017 if (output_buffer
!= NULL
&& length
== NULL
)
4024 /* The specification for __cxa_demangle() is that if the mangled
4025 name could be either an extern "C" identifier, or an internal
4026 built-in type name, then we resolve it as the identifier. All
4027 internal built-in type names are a single lower case character.
4028 Frankly, this simplistic disambiguation doesn't make sense to me,
4029 but it is documented, so we implement it here. */
4030 if (IS_LOWER (mangled_name
[0])
4031 && mangled_name
[1] == '\0'
4032 && cplus_demangle_builtin_types
[mangled_name
[0] - 'a'].name
!= NULL
)
4039 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
4041 if (demangled
== NULL
)
4053 if (output_buffer
== NULL
)
4060 if (strlen (demangled
) < *length
)
4062 strcpy (output_buffer
, demangled
);
4064 demangled
= output_buffer
;
4068 free (output_buffer
);
4079 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
4081 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
4082 mangled name, return a buffer allocated with malloc holding the
4083 demangled name. Otherwise, return NULL. */
4086 cplus_demangle_v3 (mangled
, options
)
4087 const char* mangled
;
4092 return d_demangle (mangled
, options
, &alc
);
4095 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
4096 conventions, but the output formatting is a little different.
4097 This instructs the C++ demangler not to emit pointer characters ("*"), and
4098 to use Java's namespace separator symbol ("." instead of "::"). It then
4099 does an additional pass over the demangled output to replace instances
4100 of JArray<TYPE> with TYPE[]. */
4103 java_demangle_v3 (mangled
)
4104 const char* mangled
;
4112 demangled
= d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
, &alc
);
4114 if (demangled
== NULL
)
4120 while (*from
!= '\0')
4122 if (strncmp (from
, "JArray<", 7) == 0)
4127 else if (nesting
> 0 && *from
== '>')
4129 while (to
> demangled
&& to
[-1] == ' ')
4145 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4147 #ifndef IN_GLIBCPP_V3
4149 /* Demangle a string in order to find out whether it is a constructor
4150 or destructor. Return non-zero on success. Set *CTOR_KIND and
4151 *DTOR_KIND appropriately. */
4154 is_ctor_or_dtor (mangled
, ctor_kind
, dtor_kind
)
4155 const char *mangled
;
4156 enum gnu_v3_ctor_kinds
*ctor_kind
;
4157 enum gnu_v3_dtor_kinds
*dtor_kind
;
4160 struct demangle_component
*dc
;
4163 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
4164 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
4166 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
4169 #ifdef CP_DYNAMIC_ARRAYS
4170 __extension__
struct demangle_component comps
[di
.num_comps
];
4171 __extension__
struct demangle_component
*subs
[di
.num_subs
];
4173 di
.comps
= &comps
[0];
4176 di
.comps
= ((struct demangle_component
*)
4177 malloc (di
.num_comps
* sizeof (struct demangle_component
)));
4178 di
.subs
= ((struct demangle_component
**)
4179 malloc (di
.num_subs
* sizeof (struct demangle_component
*)));
4180 if (di
.comps
== NULL
|| di
.subs
== NULL
)
4182 if (di
.comps
!= NULL
)
4184 if (di
.subs
!= NULL
)
4190 dc
= cplus_demangle_mangled_name (&di
, 1);
4192 /* Note that because we did not pass DMGL_PARAMS, we don't expect
4193 to demangle the entire string. */
4203 case DEMANGLE_COMPONENT_TYPED_NAME
:
4204 case DEMANGLE_COMPONENT_TEMPLATE
:
4205 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4206 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4207 case DEMANGLE_COMPONENT_CONST_THIS
:
4210 case DEMANGLE_COMPONENT_QUAL_NAME
:
4211 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4214 case DEMANGLE_COMPONENT_CTOR
:
4215 *ctor_kind
= dc
->u
.s_ctor
.kind
;
4219 case DEMANGLE_COMPONENT_DTOR
:
4220 *dtor_kind
= dc
->u
.s_dtor
.kind
;
4227 #ifndef CP_DYNAMIC_ARRAYS
4236 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4237 name. A non-zero return indicates the type of constructor. */
4239 enum gnu_v3_ctor_kinds
4240 is_gnu_v3_mangled_ctor (name
)
4243 enum gnu_v3_ctor_kinds ctor_kind
;
4244 enum gnu_v3_dtor_kinds dtor_kind
;
4246 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
4247 return (enum gnu_v3_ctor_kinds
) 0;
4252 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4253 name. A non-zero return indicates the type of destructor. */
4255 enum gnu_v3_dtor_kinds
4256 is_gnu_v3_mangled_dtor (name
)
4259 enum gnu_v3_ctor_kinds ctor_kind
;
4260 enum gnu_v3_dtor_kinds dtor_kind
;
4262 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
4263 return (enum gnu_v3_dtor_kinds
) 0;
4267 #endif /* IN_GLIBCPP_V3 */
4269 #ifdef STANDALONE_DEMANGLER
4272 #include "dyn-string.h"
4274 static void print_usage
PARAMS ((FILE* fp
, int exit_value
));
4276 #define IS_ALPHA(CHAR) \
4277 (((CHAR) >= 'a' && (CHAR) <= 'z') \
4278 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4280 /* Non-zero if CHAR is a character than can occur in a mangled name. */
4281 #define is_mangled_char(CHAR) \
4282 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
4283 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
4285 /* The name of this program, as invoked. */
4286 const char* program_name
;
4288 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
4291 print_usage (fp
, exit_value
)
4295 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
4296 fprintf (fp
, "Options:\n");
4297 fprintf (fp
, " -h,--help Display this message.\n");
4298 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
4299 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
4300 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
4305 /* Option specification for getopt_long. */
4306 static const struct option long_options
[] =
4308 { "help", no_argument
, NULL
, 'h' },
4309 { "no-params", no_argument
, NULL
, 'p' },
4310 { "verbose", no_argument
, NULL
, 'v' },
4311 { NULL
, no_argument
, NULL
, 0 },
4314 /* Main entry for a demangling filter executable. It will demangle
4315 its command line arguments, if any. If none are provided, it will
4316 filter stdin to stdout, replacing any recognized mangled C++ names
4317 with their demangled equivalents. */
4326 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
4328 /* Use the program name of this program, as invoked. */
4329 program_name
= argv
[0];
4331 /* Parse options. */
4334 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
4337 case '?': /* Unrecognized option. */
4338 print_usage (stderr
, 1);
4342 print_usage (stdout
, 0);
4346 options
&= ~ DMGL_PARAMS
;
4350 options
|= DMGL_VERBOSE
;
4354 while (opt_char
!= -1);
4357 /* No command line arguments were provided. Filter stdin. */
4359 dyn_string_t mangled
= dyn_string_new (3);
4362 /* Read all of input. */
4363 while (!feof (stdin
))
4367 /* Pile characters into mangled until we hit one that can't
4368 occur in a mangled name. */
4370 while (!feof (stdin
) && is_mangled_char (c
))
4372 dyn_string_append_char (mangled
, c
);
4378 if (dyn_string_length (mangled
) > 0)
4380 #ifdef IN_GLIBCPP_V3
4381 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
4383 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
4393 /* It might not have been a mangled name. Print the
4395 fputs (dyn_string_buf (mangled
), stdout
);
4398 dyn_string_clear (mangled
);
4401 /* If we haven't hit EOF yet, we've read one character that
4402 can't occur in a mangled name, so print it out. */
4407 dyn_string_delete (mangled
);
4410 /* Demangle command line arguments. */
4412 /* Loop over command line arguments. */
4413 for (i
= optind
; i
< argc
; ++i
)
4416 #ifdef IN_GLIBCPP_V3
4420 /* Attempt to demangle. */
4421 #ifdef IN_GLIBCPP_V3
4422 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
4424 s
= cplus_demangle_v3 (argv
[i
], options
);
4427 /* If it worked, print the demangled name. */
4435 #ifdef IN_GLIBCPP_V3
4436 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
4438 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
4447 #endif /* STANDALONE_DEMANGLER */