1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
7 This file is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
31 /* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
33 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 int cplus_demangle_v3_callback(const char *mangled, int options,
46 demangle_callbackref callback)
47 int java_demangle_v3_callback(const char *mangled,
48 demangle_callbackref callback)
49 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
50 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
52 Also, the interface to the component list is public, and defined in
53 demangle.h. The interface consists of these types, which are
54 defined in demangle.h:
55 enum demangle_component_type
56 struct demangle_component
58 and these functions defined in this file:
59 cplus_demangle_fill_name
60 cplus_demangle_fill_extended_operator
61 cplus_demangle_fill_ctor
62 cplus_demangle_fill_dtor
64 cplus_demangle_print_callback
65 and other functions defined in the file cp-demint.c.
67 This file also defines some other functions and variables which are
68 only to be used by the file cp-demint.c.
70 Preprocessor macros you can define while compiling this file:
73 If defined, this file defines the following functions, q.v.:
74 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
76 int __gcclibcxx_demangle_callback (const char *,
78 (const char *, size_t, void *),
80 instead of cplus_demangle_v3[_callback]() and
81 java_demangle_v3[_callback]().
84 If defined, this file defines only __cxa_demangle() and
85 __gcclibcxx_demangle_callback(), and no other publically visible
86 functions or variables.
89 If defined, this file defines a main() function which demangles
90 any arguments, or, if none, demangles stdin.
93 If defined, turns on debugging mode, which prints information on
94 stdout about the mangled string. This is not generally useful.
97 #if defined (_AIX) && !defined (__GNUC__)
119 # define alloca __builtin_alloca
121 extern char *alloca ();
122 # endif /* __GNUC__ */
124 #endif /* HAVE_ALLOCA_H */
126 #include "ansidecl.h"
127 #include "libiberty.h"
128 #include "demangle.h"
129 #include "cp-demangle.h"
131 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
132 also rename them via #define to avoid compiler errors when the
133 static definition conflicts with the extern declaration in a header
137 #define CP_STATIC_IF_GLIBCPP_V3 static
139 #define cplus_demangle_fill_name d_fill_name
140 static int d_fill_name (struct demangle_component
*, const char *, int);
142 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
144 d_fill_extended_operator (struct demangle_component
*, int,
145 struct demangle_component
*);
147 #define cplus_demangle_fill_ctor d_fill_ctor
149 d_fill_ctor (struct demangle_component
*, enum gnu_v3_ctor_kinds
,
150 struct demangle_component
*);
152 #define cplus_demangle_fill_dtor d_fill_dtor
154 d_fill_dtor (struct demangle_component
*, enum gnu_v3_dtor_kinds
,
155 struct demangle_component
*);
157 #define cplus_demangle_mangled_name d_mangled_name
158 static struct demangle_component
*d_mangled_name (struct d_info
*, int);
160 #define cplus_demangle_type d_type
161 static struct demangle_component
*d_type (struct d_info
*);
163 #define cplus_demangle_print d_print
164 static char *d_print (int, const struct demangle_component
*, int, size_t *);
166 #define cplus_demangle_print_callback d_print_callback
167 static int d_print_callback (int, const struct demangle_component
*,
168 demangle_callbackref
, void *);
170 #define cplus_demangle_init_info d_init_info
171 static void d_init_info (const char *, int, size_t, struct d_info
*);
173 #else /* ! defined(IN_GLIBCPP_V3) */
174 #define CP_STATIC_IF_GLIBCPP_V3
175 #endif /* ! defined(IN_GLIBCPP_V3) */
177 /* See if the compiler supports dynamic arrays. */
180 #define CP_DYNAMIC_ARRAYS
183 #ifdef __STDC_VERSION__
184 #if __STDC_VERSION__ >= 199901L
185 #define CP_DYNAMIC_ARRAYS
186 #endif /* __STDC__VERSION >= 199901L */
187 #endif /* defined (__STDC_VERSION__) */
188 #endif /* defined (__STDC__) */
189 #endif /* ! defined (__GNUC__) */
191 /* We avoid pulling in the ctype tables, to prevent pulling in
192 additional unresolved symbols when this code is used in a library.
193 FIXME: Is this really a valid reason? This comes from the original
196 As of this writing this file has the following undefined references
197 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
200 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
201 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
202 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
204 /* The prefix prepended by GCC to an identifier represnting the
205 anonymous namespace. */
206 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
207 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
208 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
210 /* Information we keep for the standard substitutions. */
212 struct d_standard_sub_info
214 /* The code for this substitution. */
216 /* The simple string it expands to. */
217 const char *simple_expansion
;
218 /* The length of the simple expansion. */
220 /* The results of a full, verbose, expansion. This is used when
221 qualifying a constructor/destructor, or when in verbose mode. */
222 const char *full_expansion
;
223 /* The length of the full expansion. */
225 /* What to set the last_name field of d_info to; NULL if we should
226 not set it. This is only relevant when qualifying a
227 constructor/destructor. */
228 const char *set_last_name
;
229 /* The length of set_last_name. */
230 int set_last_name_len
;
233 /* Accessors for subtrees of struct demangle_component. */
235 #define d_left(dc) ((dc)->u.s_binary.left)
236 #define d_right(dc) ((dc)->u.s_binary.right)
238 /* A list of templates. This is used while printing. */
240 struct d_print_template
242 /* Next template on the list. */
243 struct d_print_template
*next
;
245 const struct demangle_component
*template_decl
;
248 /* A list of type modifiers. This is used while printing. */
252 /* Next modifier on the list. These are in the reverse of the order
253 in which they appeared in the mangled string. */
254 struct d_print_mod
*next
;
256 const struct demangle_component
*mod
;
257 /* Whether this modifier was printed. */
259 /* The list of templates which applies to this modifier. */
260 struct d_print_template
*templates
;
263 /* We use these structures to hold information during printing. */
265 struct d_growable_string
267 /* Buffer holding the result. */
269 /* Current length of data in buffer. */
271 /* Allocated size of buffer. */
273 /* Set to 1 if we had a memory allocation failure. */
274 int allocation_failure
;
277 enum { D_PRINT_BUFFER_LENGTH
= 256 };
280 /* The options passed to the demangler. */
282 /* Fixed-length allocated buffer for demangled data, flushed to the
283 callback with a NUL termination once full. */
284 char buf
[D_PRINT_BUFFER_LENGTH
];
285 /* Current length of data in buffer. */
287 /* The last character printed, saved individually so that it survives
290 /* Callback function to handle demangled buffer flush. */
291 demangle_callbackref callback
;
292 /* Opaque callback argument. */
294 /* The current list of templates, if any. */
295 struct d_print_template
*templates
;
296 /* The current list of modifiers (e.g., pointer, reference, etc.),
298 struct d_print_mod
*modifiers
;
299 /* Set to 1 if we saw a demangling error. */
300 int demangle_failure
;
303 #ifdef CP_DEMANGLE_DEBUG
304 static void d_dump (struct demangle_component
*, int);
307 static struct demangle_component
*
308 d_make_empty (struct d_info
*);
310 static struct demangle_component
*
311 d_make_comp (struct d_info
*, enum demangle_component_type
,
312 struct demangle_component
*,
313 struct demangle_component
*);
315 static struct demangle_component
*
316 d_make_name (struct d_info
*, const char *, int);
318 static struct demangle_component
*
319 d_make_builtin_type (struct d_info
*,
320 const struct demangle_builtin_type_info
*);
322 static struct demangle_component
*
323 d_make_operator (struct d_info
*,
324 const struct demangle_operator_info
*);
326 static struct demangle_component
*
327 d_make_extended_operator (struct d_info
*, int,
328 struct demangle_component
*);
330 static struct demangle_component
*
331 d_make_ctor (struct d_info
*, enum gnu_v3_ctor_kinds
,
332 struct demangle_component
*);
334 static struct demangle_component
*
335 d_make_dtor (struct d_info
*, enum gnu_v3_dtor_kinds
,
336 struct demangle_component
*);
338 static struct demangle_component
*
339 d_make_template_param (struct d_info
*, long);
341 static struct demangle_component
*
342 d_make_sub (struct d_info
*, const char *, int);
345 has_return_type (struct demangle_component
*);
348 is_ctor_dtor_or_conversion (struct demangle_component
*);
350 static struct demangle_component
*d_encoding (struct d_info
*, int);
352 static struct demangle_component
*d_name (struct d_info
*);
354 static struct demangle_component
*d_nested_name (struct d_info
*);
356 static struct demangle_component
*d_prefix (struct d_info
*);
358 static struct demangle_component
*d_unqualified_name (struct d_info
*);
360 static struct demangle_component
*d_source_name (struct d_info
*);
362 static long d_number (struct d_info
*);
364 static struct demangle_component
*d_identifier (struct d_info
*, int);
366 static struct demangle_component
*d_operator_name (struct d_info
*);
368 static struct demangle_component
*d_special_name (struct d_info
*);
370 static int d_call_offset (struct d_info
*, int);
372 static struct demangle_component
*d_ctor_dtor_name (struct d_info
*);
374 static struct demangle_component
**
375 d_cv_qualifiers (struct d_info
*, struct demangle_component
**, int);
377 static struct demangle_component
*
378 d_function_type (struct d_info
*);
380 static struct demangle_component
*
381 d_bare_function_type (struct d_info
*, int);
383 static struct demangle_component
*
384 d_class_enum_type (struct d_info
*);
386 static struct demangle_component
*d_array_type (struct d_info
*);
388 static struct demangle_component
*
389 d_pointer_to_member_type (struct d_info
*);
391 static struct demangle_component
*
392 d_template_param (struct d_info
*);
394 static struct demangle_component
*d_template_args (struct d_info
*);
396 static struct demangle_component
*
397 d_template_arg (struct d_info
*);
399 static struct demangle_component
*d_expression (struct d_info
*);
401 static struct demangle_component
*d_expr_primary (struct d_info
*);
403 static struct demangle_component
*d_local_name (struct d_info
*);
405 static int d_discriminator (struct d_info
*);
408 d_add_substitution (struct d_info
*, struct demangle_component
*);
410 static struct demangle_component
*d_substitution (struct d_info
*, int);
412 static void d_growable_string_init (struct d_growable_string
*, size_t);
415 d_growable_string_resize (struct d_growable_string
*, size_t);
418 d_growable_string_append_buffer (struct d_growable_string
*,
419 const char *, size_t);
421 d_growable_string_callback_adapter (const char *, size_t, void *);
424 d_print_init (struct d_print_info
*, int, demangle_callbackref
, void *);
426 static inline void d_print_error (struct d_print_info
*);
428 static inline int d_print_saw_error (struct d_print_info
*);
430 static inline void d_print_flush (struct d_print_info
*);
432 static inline void d_append_char (struct d_print_info
*, char);
434 static inline void d_append_buffer (struct d_print_info
*,
435 const char *, size_t);
437 static inline void d_append_string (struct d_print_info
*, const char *);
439 static inline char d_last_char (struct d_print_info
*);
442 d_print_comp (struct d_print_info
*, const struct demangle_component
*);
445 d_print_java_identifier (struct d_print_info
*, const char *, int);
448 d_print_mod_list (struct d_print_info
*, struct d_print_mod
*, int);
451 d_print_mod (struct d_print_info
*, const struct demangle_component
*);
454 d_print_function_type (struct d_print_info
*,
455 const struct demangle_component
*,
456 struct d_print_mod
*);
459 d_print_array_type (struct d_print_info
*,
460 const struct demangle_component
*,
461 struct d_print_mod
*);
464 d_print_expr_op (struct d_print_info
*, const struct demangle_component
*);
467 d_print_cast (struct d_print_info
*, const struct demangle_component
*);
469 static int d_demangle_callback (const char *, int,
470 demangle_callbackref
, void *);
471 static char *d_demangle (const char *, int, size_t *);
473 #ifdef CP_DEMANGLE_DEBUG
476 d_dump (struct demangle_component
*dc
, int indent
)
483 printf ("failed demangling\n");
487 for (i
= 0; i
< indent
; ++i
)
492 case DEMANGLE_COMPONENT_NAME
:
493 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
495 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
496 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
498 case DEMANGLE_COMPONENT_CTOR
:
499 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
500 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
502 case DEMANGLE_COMPONENT_DTOR
:
503 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
504 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
506 case DEMANGLE_COMPONENT_SUB_STD
:
507 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
509 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
510 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
512 case DEMANGLE_COMPONENT_OPERATOR
:
513 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
515 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
516 printf ("extended operator with %d args\n",
517 dc
->u
.s_extended_operator
.args
);
518 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
521 case DEMANGLE_COMPONENT_QUAL_NAME
:
522 printf ("qualified name\n");
524 case DEMANGLE_COMPONENT_LOCAL_NAME
:
525 printf ("local name\n");
527 case DEMANGLE_COMPONENT_TYPED_NAME
:
528 printf ("typed name\n");
530 case DEMANGLE_COMPONENT_TEMPLATE
:
531 printf ("template\n");
533 case DEMANGLE_COMPONENT_VTABLE
:
536 case DEMANGLE_COMPONENT_VTT
:
539 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
540 printf ("construction vtable\n");
542 case DEMANGLE_COMPONENT_TYPEINFO
:
543 printf ("typeinfo\n");
545 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
546 printf ("typeinfo name\n");
548 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
549 printf ("typeinfo function\n");
551 case DEMANGLE_COMPONENT_THUNK
:
554 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
555 printf ("virtual thunk\n");
557 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
558 printf ("covariant thunk\n");
560 case DEMANGLE_COMPONENT_JAVA_CLASS
:
561 printf ("java class\n");
563 case DEMANGLE_COMPONENT_GUARD
:
566 case DEMANGLE_COMPONENT_REFTEMP
:
567 printf ("reference temporary\n");
569 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
570 printf ("hidden alias\n");
572 case DEMANGLE_COMPONENT_RESTRICT
:
573 printf ("restrict\n");
575 case DEMANGLE_COMPONENT_VOLATILE
:
576 printf ("volatile\n");
578 case DEMANGLE_COMPONENT_CONST
:
581 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
582 printf ("restrict this\n");
584 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
585 printf ("volatile this\n");
587 case DEMANGLE_COMPONENT_CONST_THIS
:
588 printf ("const this\n");
590 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
591 printf ("vendor type qualifier\n");
593 case DEMANGLE_COMPONENT_POINTER
:
594 printf ("pointer\n");
596 case DEMANGLE_COMPONENT_REFERENCE
:
597 printf ("reference\n");
599 case DEMANGLE_COMPONENT_COMPLEX
:
600 printf ("complex\n");
602 case DEMANGLE_COMPONENT_IMAGINARY
:
603 printf ("imaginary\n");
605 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
606 printf ("vendor type\n");
608 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
609 printf ("function type\n");
611 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
612 printf ("array type\n");
614 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
615 printf ("pointer to member type\n");
617 case DEMANGLE_COMPONENT_ARGLIST
:
618 printf ("argument list\n");
620 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
621 printf ("template argument list\n");
623 case DEMANGLE_COMPONENT_CAST
:
626 case DEMANGLE_COMPONENT_UNARY
:
627 printf ("unary operator\n");
629 case DEMANGLE_COMPONENT_BINARY
:
630 printf ("binary operator\n");
632 case DEMANGLE_COMPONENT_BINARY_ARGS
:
633 printf ("binary operator arguments\n");
635 case DEMANGLE_COMPONENT_TRINARY
:
636 printf ("trinary operator\n");
638 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
639 printf ("trinary operator arguments 1\n");
641 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
642 printf ("trinary operator arguments 1\n");
644 case DEMANGLE_COMPONENT_LITERAL
:
645 printf ("literal\n");
647 case DEMANGLE_COMPONENT_LITERAL_NEG
:
648 printf ("negative literal\n");
652 d_dump (d_left (dc
), indent
+ 2);
653 d_dump (d_right (dc
), indent
+ 2);
656 #endif /* CP_DEMANGLE_DEBUG */
658 /* Fill in a DEMANGLE_COMPONENT_NAME. */
660 CP_STATIC_IF_GLIBCPP_V3
662 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
664 if (p
== NULL
|| s
== NULL
|| len
== 0)
666 p
->type
= DEMANGLE_COMPONENT_NAME
;
668 p
->u
.s_name
.len
= len
;
672 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
674 CP_STATIC_IF_GLIBCPP_V3
676 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
677 struct demangle_component
*name
)
679 if (p
== NULL
|| args
< 0 || name
== NULL
)
681 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
682 p
->u
.s_extended_operator
.args
= args
;
683 p
->u
.s_extended_operator
.name
= name
;
687 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
689 CP_STATIC_IF_GLIBCPP_V3
691 cplus_demangle_fill_ctor (struct demangle_component
*p
,
692 enum gnu_v3_ctor_kinds kind
,
693 struct demangle_component
*name
)
697 || (kind
< gnu_v3_complete_object_ctor
698 && kind
> gnu_v3_complete_object_allocating_ctor
))
700 p
->type
= DEMANGLE_COMPONENT_CTOR
;
701 p
->u
.s_ctor
.kind
= kind
;
702 p
->u
.s_ctor
.name
= name
;
706 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
708 CP_STATIC_IF_GLIBCPP_V3
710 cplus_demangle_fill_dtor (struct demangle_component
*p
,
711 enum gnu_v3_dtor_kinds kind
,
712 struct demangle_component
*name
)
716 || (kind
< gnu_v3_deleting_dtor
717 && kind
> gnu_v3_base_object_dtor
))
719 p
->type
= DEMANGLE_COMPONENT_DTOR
;
720 p
->u
.s_dtor
.kind
= kind
;
721 p
->u
.s_dtor
.name
= name
;
725 /* Add a new component. */
727 static struct demangle_component
*
728 d_make_empty (struct d_info
*di
)
730 struct demangle_component
*p
;
732 if (di
->next_comp
>= di
->num_comps
)
734 p
= &di
->comps
[di
->next_comp
];
739 /* Add a new generic component. */
741 static struct demangle_component
*
742 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
743 struct demangle_component
*left
,
744 struct demangle_component
*right
)
746 struct demangle_component
*p
;
748 /* We check for errors here. A typical error would be a NULL return
749 from a subroutine. We catch those here, and return NULL
753 /* These types require two parameters. */
754 case DEMANGLE_COMPONENT_QUAL_NAME
:
755 case DEMANGLE_COMPONENT_LOCAL_NAME
:
756 case DEMANGLE_COMPONENT_TYPED_NAME
:
757 case DEMANGLE_COMPONENT_TEMPLATE
:
758 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
759 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
760 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
761 case DEMANGLE_COMPONENT_UNARY
:
762 case DEMANGLE_COMPONENT_BINARY
:
763 case DEMANGLE_COMPONENT_BINARY_ARGS
:
764 case DEMANGLE_COMPONENT_TRINARY
:
765 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
766 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
767 case DEMANGLE_COMPONENT_LITERAL
:
768 case DEMANGLE_COMPONENT_LITERAL_NEG
:
769 if (left
== NULL
|| right
== NULL
)
773 /* These types only require one parameter. */
774 case DEMANGLE_COMPONENT_VTABLE
:
775 case DEMANGLE_COMPONENT_VTT
:
776 case DEMANGLE_COMPONENT_TYPEINFO
:
777 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
778 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
779 case DEMANGLE_COMPONENT_THUNK
:
780 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
781 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
782 case DEMANGLE_COMPONENT_JAVA_CLASS
:
783 case DEMANGLE_COMPONENT_GUARD
:
784 case DEMANGLE_COMPONENT_REFTEMP
:
785 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
786 case DEMANGLE_COMPONENT_POINTER
:
787 case DEMANGLE_COMPONENT_REFERENCE
:
788 case DEMANGLE_COMPONENT_COMPLEX
:
789 case DEMANGLE_COMPONENT_IMAGINARY
:
790 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
791 case DEMANGLE_COMPONENT_ARGLIST
:
792 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
793 case DEMANGLE_COMPONENT_CAST
:
798 /* This needs a right parameter, but the left parameter can be
800 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
805 /* These are allowed to have no parameters--in some cases they
806 will be filled in later. */
807 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
808 case DEMANGLE_COMPONENT_RESTRICT
:
809 case DEMANGLE_COMPONENT_VOLATILE
:
810 case DEMANGLE_COMPONENT_CONST
:
811 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
812 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
813 case DEMANGLE_COMPONENT_CONST_THIS
:
816 /* Other types should not be seen here. */
821 p
= d_make_empty (di
);
825 p
->u
.s_binary
.left
= left
;
826 p
->u
.s_binary
.right
= right
;
831 /* Add a new name component. */
833 static struct demangle_component
*
834 d_make_name (struct d_info
*di
, const char *s
, int len
)
836 struct demangle_component
*p
;
838 p
= d_make_empty (di
);
839 if (! cplus_demangle_fill_name (p
, s
, len
))
844 /* Add a new builtin type component. */
846 static struct demangle_component
*
847 d_make_builtin_type (struct d_info
*di
,
848 const struct demangle_builtin_type_info
*type
)
850 struct demangle_component
*p
;
854 p
= d_make_empty (di
);
857 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
858 p
->u
.s_builtin
.type
= type
;
863 /* Add a new operator component. */
865 static struct demangle_component
*
866 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
868 struct demangle_component
*p
;
870 p
= d_make_empty (di
);
873 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
874 p
->u
.s_operator
.op
= op
;
879 /* Add a new extended operator component. */
881 static struct demangle_component
*
882 d_make_extended_operator (struct d_info
*di
, int args
,
883 struct demangle_component
*name
)
885 struct demangle_component
*p
;
887 p
= d_make_empty (di
);
888 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
893 /* Add a new constructor component. */
895 static struct demangle_component
*
896 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
897 struct demangle_component
*name
)
899 struct demangle_component
*p
;
901 p
= d_make_empty (di
);
902 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
907 /* Add a new destructor component. */
909 static struct demangle_component
*
910 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
911 struct demangle_component
*name
)
913 struct demangle_component
*p
;
915 p
= d_make_empty (di
);
916 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
921 /* Add a new template parameter. */
923 static struct demangle_component
*
924 d_make_template_param (struct d_info
*di
, long i
)
926 struct demangle_component
*p
;
928 p
= d_make_empty (di
);
931 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
932 p
->u
.s_number
.number
= i
;
937 /* Add a new standard substitution component. */
939 static struct demangle_component
*
940 d_make_sub (struct d_info
*di
, const char *name
, int len
)
942 struct demangle_component
*p
;
944 p
= d_make_empty (di
);
947 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
948 p
->u
.s_string
.string
= name
;
949 p
->u
.s_string
.len
= len
;
954 /* <mangled-name> ::= _Z <encoding>
956 TOP_LEVEL is non-zero when called at the top level. */
958 CP_STATIC_IF_GLIBCPP_V3
959 struct demangle_component
*
960 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
962 if (! d_check_char (di
, '_'))
964 if (! d_check_char (di
, 'Z'))
966 return d_encoding (di
, top_level
);
969 /* Return whether a function should have a return type. The argument
970 is the function name, which may be qualified in various ways. The
971 rules are that template functions have return types with some
972 exceptions, function types which are not part of a function name
973 mangling have return types with some exceptions, and non-template
974 function names do not have return types. The exceptions are that
975 constructors, destructors, and conversion operators do not have
979 has_return_type (struct demangle_component
*dc
)
987 case DEMANGLE_COMPONENT_TEMPLATE
:
988 return ! is_ctor_dtor_or_conversion (d_left (dc
));
989 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
990 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
991 case DEMANGLE_COMPONENT_CONST_THIS
:
992 return has_return_type (d_left (dc
));
996 /* Return whether a name is a constructor, a destructor, or a
997 conversion operator. */
1000 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1008 case DEMANGLE_COMPONENT_QUAL_NAME
:
1009 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1010 return is_ctor_dtor_or_conversion (d_right (dc
));
1011 case DEMANGLE_COMPONENT_CTOR
:
1012 case DEMANGLE_COMPONENT_DTOR
:
1013 case DEMANGLE_COMPONENT_CAST
:
1018 /* <encoding> ::= <(function) name> <bare-function-type>
1022 TOP_LEVEL is non-zero when called at the top level, in which case
1023 if DMGL_PARAMS is not set we do not demangle the function
1024 parameters. We only set this at the top level, because otherwise
1025 we would not correctly demangle names in local scopes. */
1027 static struct demangle_component
*
1028 d_encoding (struct d_info
*di
, int top_level
)
1030 char peek
= d_peek_char (di
);
1032 if (peek
== 'G' || peek
== 'T')
1033 return d_special_name (di
);
1036 struct demangle_component
*dc
;
1040 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1042 /* Strip off any initial CV-qualifiers, as they really apply
1043 to the `this' parameter, and they were not output by the
1044 v2 demangler without DMGL_PARAMS. */
1045 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1046 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1047 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1050 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1051 there may be CV-qualifiers on its right argument which
1052 really apply here; this happens when parsing a class
1053 which is local to a function. */
1054 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1056 struct demangle_component
*dcr
;
1059 while (dcr
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1060 || dcr
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1061 || dcr
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1063 dc
->u
.s_binary
.right
= dcr
;
1069 peek
= d_peek_char (di
);
1070 if (dc
== NULL
|| peek
== '\0' || peek
== 'E')
1072 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1073 d_bare_function_type (di
, has_return_type (dc
)));
1077 /* <name> ::= <nested-name>
1079 ::= <unscoped-template-name> <template-args>
1082 <unscoped-name> ::= <unqualified-name>
1083 ::= St <unqualified-name>
1085 <unscoped-template-name> ::= <unscoped-name>
1089 static struct demangle_component
*
1090 d_name (struct d_info
*di
)
1092 char peek
= d_peek_char (di
);
1093 struct demangle_component
*dc
;
1098 return d_nested_name (di
);
1101 return d_local_name (di
);
1104 return d_unqualified_name (di
);
1110 if (d_peek_next_char (di
) != 't')
1112 dc
= d_substitution (di
, 0);
1118 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1119 d_make_name (di
, "std", 3),
1120 d_unqualified_name (di
));
1125 if (d_peek_char (di
) != 'I')
1127 /* The grammar does not permit this case to occur if we
1128 called d_substitution() above (i.e., subst == 1). We
1129 don't bother to check. */
1133 /* This is <template-args>, which means that we just saw
1134 <unscoped-template-name>, which is a substitution
1135 candidate if we didn't just get it from a
1139 if (! d_add_substitution (di
, dc
))
1142 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1143 d_template_args (di
));
1150 dc
= d_unqualified_name (di
);
1151 if (d_peek_char (di
) == 'I')
1153 /* This is <template-args>, which means that we just saw
1154 <unscoped-template-name>, which is a substitution
1156 if (! d_add_substitution (di
, dc
))
1158 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1159 d_template_args (di
));
1165 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1166 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1169 static struct demangle_component
*
1170 d_nested_name (struct d_info
*di
)
1172 struct demangle_component
*ret
;
1173 struct demangle_component
**pret
;
1175 if (! d_check_char (di
, 'N'))
1178 pret
= d_cv_qualifiers (di
, &ret
, 1);
1182 *pret
= d_prefix (di
);
1186 if (! d_check_char (di
, 'E'))
1192 /* <prefix> ::= <prefix> <unqualified-name>
1193 ::= <template-prefix> <template-args>
1194 ::= <template-param>
1198 <template-prefix> ::= <prefix> <(template) unqualified-name>
1199 ::= <template-param>
1203 static struct demangle_component
*
1204 d_prefix (struct d_info
*di
)
1206 struct demangle_component
*ret
= NULL
;
1211 enum demangle_component_type comb_type
;
1212 struct demangle_component
*dc
;
1214 peek
= d_peek_char (di
);
1218 /* The older code accepts a <local-name> here, but I don't see
1219 that in the grammar. The older code does not accept a
1220 <template-param> here. */
1222 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1228 dc
= d_unqualified_name (di
);
1229 else if (peek
== 'S')
1230 dc
= d_substitution (di
, 1);
1231 else if (peek
== 'I')
1235 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1236 dc
= d_template_args (di
);
1238 else if (peek
== 'T')
1239 dc
= d_template_param (di
);
1240 else if (peek
== 'E')
1248 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1250 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1252 if (! d_add_substitution (di
, ret
))
1258 /* <unqualified-name> ::= <operator-name>
1259 ::= <ctor-dtor-name>
1261 ::= <local-source-name>
1263 <local-source-name> ::= L <source-name> <discriminator>
1266 static struct demangle_component
*
1267 d_unqualified_name (struct d_info
*di
)
1271 peek
= d_peek_char (di
);
1272 if (IS_DIGIT (peek
))
1273 return d_source_name (di
);
1274 else if (IS_LOWER (peek
))
1276 struct demangle_component
*ret
;
1278 ret
= d_operator_name (di
);
1279 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1280 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1283 else if (peek
== 'C' || peek
== 'D')
1284 return d_ctor_dtor_name (di
);
1285 else if (peek
== 'L')
1287 struct demangle_component
* ret
;
1291 ret
= d_source_name (di
);
1294 if (! d_discriminator (di
))
1302 /* <source-name> ::= <(positive length) number> <identifier> */
1304 static struct demangle_component
*
1305 d_source_name (struct d_info
*di
)
1308 struct demangle_component
*ret
;
1310 len
= d_number (di
);
1313 ret
= d_identifier (di
, len
);
1314 di
->last_name
= ret
;
1318 /* number ::= [n] <(non-negative decimal integer)> */
1321 d_number (struct d_info
*di
)
1328 peek
= d_peek_char (di
);
1333 peek
= d_peek_char (di
);
1339 if (! IS_DIGIT (peek
))
1345 ret
= ret
* 10 + peek
- '0';
1347 peek
= d_peek_char (di
);
1351 /* identifier ::= <(unqualified source code identifier)> */
1353 static struct demangle_component
*
1354 d_identifier (struct d_info
*di
, int len
)
1360 if (di
->send
- name
< len
)
1363 d_advance (di
, len
);
1365 /* A Java mangled name may have a trailing '$' if it is a C++
1366 keyword. This '$' is not included in the length count. We just
1368 if ((di
->options
& DMGL_JAVA
) != 0
1369 && d_peek_char (di
) == '$')
1372 /* Look for something which looks like a gcc encoding of an
1373 anonymous namespace, and replace it with a more user friendly
1375 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1376 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1377 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1381 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1382 if ((*s
== '.' || *s
== '_' || *s
== '$')
1385 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1386 return d_make_name (di
, "(anonymous namespace)",
1387 sizeof "(anonymous namespace)" - 1);
1391 return d_make_name (di
, name
, len
);
1394 /* operator_name ::= many different two character encodings.
1396 ::= v <digit> <source-name>
1399 #define NL(s) s, (sizeof s) - 1
1401 CP_STATIC_IF_GLIBCPP_V3
1402 const struct demangle_operator_info cplus_demangle_operators
[] =
1404 { "aN", NL ("&="), 2 },
1405 { "aS", NL ("="), 2 },
1406 { "aa", NL ("&&"), 2 },
1407 { "ad", NL ("&"), 1 },
1408 { "an", NL ("&"), 2 },
1409 { "cl", NL ("()"), 0 },
1410 { "cm", NL (","), 2 },
1411 { "co", NL ("~"), 1 },
1412 { "dV", NL ("/="), 2 },
1413 { "da", NL ("delete[]"), 1 },
1414 { "de", NL ("*"), 1 },
1415 { "dl", NL ("delete"), 1 },
1416 { "dv", NL ("/"), 2 },
1417 { "eO", NL ("^="), 2 },
1418 { "eo", NL ("^"), 2 },
1419 { "eq", NL ("=="), 2 },
1420 { "ge", NL (">="), 2 },
1421 { "gt", NL (">"), 2 },
1422 { "ix", NL ("[]"), 2 },
1423 { "lS", NL ("<<="), 2 },
1424 { "le", NL ("<="), 2 },
1425 { "ls", NL ("<<"), 2 },
1426 { "lt", NL ("<"), 2 },
1427 { "mI", NL ("-="), 2 },
1428 { "mL", NL ("*="), 2 },
1429 { "mi", NL ("-"), 2 },
1430 { "ml", NL ("*"), 2 },
1431 { "mm", NL ("--"), 1 },
1432 { "na", NL ("new[]"), 1 },
1433 { "ne", NL ("!="), 2 },
1434 { "ng", NL ("-"), 1 },
1435 { "nt", NL ("!"), 1 },
1436 { "nw", NL ("new"), 1 },
1437 { "oR", NL ("|="), 2 },
1438 { "oo", NL ("||"), 2 },
1439 { "or", NL ("|"), 2 },
1440 { "pL", NL ("+="), 2 },
1441 { "pl", NL ("+"), 2 },
1442 { "pm", NL ("->*"), 2 },
1443 { "pp", NL ("++"), 1 },
1444 { "ps", NL ("+"), 1 },
1445 { "pt", NL ("->"), 2 },
1446 { "qu", NL ("?"), 3 },
1447 { "rM", NL ("%="), 2 },
1448 { "rS", NL (">>="), 2 },
1449 { "rm", NL ("%"), 2 },
1450 { "rs", NL (">>"), 2 },
1451 { "st", NL ("sizeof "), 1 },
1452 { "sz", NL ("sizeof "), 1 },
1453 { NULL
, NULL
, 0, 0 }
1456 static struct demangle_component
*
1457 d_operator_name (struct d_info
*di
)
1462 c1
= d_next_char (di
);
1463 c2
= d_next_char (di
);
1464 if (c1
== 'v' && IS_DIGIT (c2
))
1465 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1466 else if (c1
== 'c' && c2
== 'v')
1467 return d_make_comp (di
, DEMANGLE_COMPONENT_CAST
,
1468 cplus_demangle_type (di
), NULL
);
1471 /* LOW is the inclusive lower bound. */
1473 /* HIGH is the exclusive upper bound. We subtract one to ignore
1474 the sentinel at the end of the array. */
1475 int high
= ((sizeof (cplus_demangle_operators
)
1476 / sizeof (cplus_demangle_operators
[0]))
1482 const struct demangle_operator_info
*p
;
1484 i
= low
+ (high
- low
) / 2;
1485 p
= cplus_demangle_operators
+ i
;
1487 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1488 return d_make_operator (di
, p
);
1490 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1500 /* <special-name> ::= TV <type>
1504 ::= GV <(object) name>
1505 ::= T <call-offset> <(base) encoding>
1506 ::= Tc <call-offset> <call-offset> <(base) encoding>
1507 Also g++ extensions:
1508 ::= TC <type> <(offset) number> _ <(base) type>
1515 static struct demangle_component
*
1516 d_special_name (struct d_info
*di
)
1518 di
->expansion
+= 20;
1519 if (d_check_char (di
, 'T'))
1521 switch (d_next_char (di
))
1525 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
1526 cplus_demangle_type (di
), NULL
);
1528 di
->expansion
-= 10;
1529 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
1530 cplus_demangle_type (di
), NULL
);
1532 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
1533 cplus_demangle_type (di
), NULL
);
1535 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
1536 cplus_demangle_type (di
), NULL
);
1539 if (! d_call_offset (di
, 'h'))
1541 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
1542 d_encoding (di
, 0), NULL
);
1545 if (! d_call_offset (di
, 'v'))
1547 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
1548 d_encoding (di
, 0), NULL
);
1551 if (! d_call_offset (di
, '\0'))
1553 if (! d_call_offset (di
, '\0'))
1555 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
1556 d_encoding (di
, 0), NULL
);
1560 struct demangle_component
*derived_type
;
1562 struct demangle_component
*base_type
;
1564 derived_type
= cplus_demangle_type (di
);
1565 offset
= d_number (di
);
1568 if (! d_check_char (di
, '_'))
1570 base_type
= cplus_demangle_type (di
);
1571 /* We don't display the offset. FIXME: We should display
1572 it in verbose mode. */
1574 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
1575 base_type
, derived_type
);
1579 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
1580 cplus_demangle_type (di
), NULL
);
1582 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
1583 cplus_demangle_type (di
), NULL
);
1589 else if (d_check_char (di
, 'G'))
1591 switch (d_next_char (di
))
1594 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
1597 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, d_name (di
),
1601 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
1602 d_encoding (di
, 0), NULL
);
1612 /* <call-offset> ::= h <nv-offset> _
1615 <nv-offset> ::= <(offset) number>
1617 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1619 The C parameter, if not '\0', is a character we just read which is
1620 the start of the <call-offset>.
1622 We don't display the offset information anywhere. FIXME: We should
1623 display it in verbose mode. */
1626 d_call_offset (struct d_info
*di
, int c
)
1629 c
= d_next_char (di
);
1636 if (! d_check_char (di
, '_'))
1643 if (! d_check_char (di
, '_'))
1649 /* <ctor-dtor-name> ::= C1
1657 static struct demangle_component
*
1658 d_ctor_dtor_name (struct d_info
*di
)
1660 if (di
->last_name
!= NULL
)
1662 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
1663 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
1664 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1665 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
1667 switch (d_peek_char (di
))
1671 enum gnu_v3_ctor_kinds kind
;
1673 switch (d_peek_next_char (di
))
1676 kind
= gnu_v3_complete_object_ctor
;
1679 kind
= gnu_v3_base_object_ctor
;
1682 kind
= gnu_v3_complete_object_allocating_ctor
;
1688 return d_make_ctor (di
, kind
, di
->last_name
);
1693 enum gnu_v3_dtor_kinds kind
;
1695 switch (d_peek_next_char (di
))
1698 kind
= gnu_v3_deleting_dtor
;
1701 kind
= gnu_v3_complete_object_dtor
;
1704 kind
= gnu_v3_base_object_dtor
;
1710 return d_make_dtor (di
, kind
, di
->last_name
);
1718 /* <type> ::= <builtin-type>
1720 ::= <class-enum-type>
1722 ::= <pointer-to-member-type>
1723 ::= <template-param>
1724 ::= <template-template-param> <template-args>
1726 ::= <CV-qualifiers> <type>
1731 ::= U <source-name> <type>
1733 <builtin-type> ::= various one letter codes
1737 CP_STATIC_IF_GLIBCPP_V3
1738 const struct demangle_builtin_type_info
1739 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
1741 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
1742 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
1743 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
1744 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
1745 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
1746 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
1747 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
1748 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
1749 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
1750 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
1751 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1752 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
1753 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
1754 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
1755 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
1757 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1758 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1759 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1760 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
1761 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
1762 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1763 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
1764 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
1765 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
1766 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
1767 D_PRINT_UNSIGNED_LONG_LONG
},
1768 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
1771 CP_STATIC_IF_GLIBCPP_V3
1772 struct demangle_component
*
1773 cplus_demangle_type (struct d_info
*di
)
1776 struct demangle_component
*ret
;
1779 /* The ABI specifies that when CV-qualifiers are used, the base type
1780 is substitutable, and the fully qualified type is substitutable,
1781 but the base type with a strict subset of the CV-qualifiers is
1782 not substitutable. The natural recursive implementation of the
1783 CV-qualifiers would cause subsets to be substitutable, so instead
1784 we pull them all off now.
1786 FIXME: The ABI says that order-insensitive vendor qualifiers
1787 should be handled in the same way, but we have no way to tell
1788 which vendor qualifiers are order-insensitive and which are
1789 order-sensitive. So we just assume that they are all
1790 order-sensitive. g++ 3.4 supports only one vendor qualifier,
1791 __vector, and it treats it as order-sensitive when mangling
1794 peek
= d_peek_char (di
);
1795 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
1797 struct demangle_component
**pret
;
1799 pret
= d_cv_qualifiers (di
, &ret
, 0);
1802 *pret
= cplus_demangle_type (di
);
1803 if (! *pret
|| ! d_add_substitution (di
, ret
))
1812 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1813 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
1814 case 'o': case 's': case 't':
1815 case 'v': case 'w': case 'x': case 'y': case 'z':
1816 ret
= d_make_builtin_type (di
,
1817 &cplus_demangle_builtin_types
[peek
- 'a']);
1818 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
1825 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
1826 d_source_name (di
), NULL
);
1830 ret
= d_function_type (di
);
1833 case '0': case '1': case '2': case '3': case '4':
1834 case '5': case '6': case '7': case '8': case '9':
1837 ret
= d_class_enum_type (di
);
1841 ret
= d_array_type (di
);
1845 ret
= d_pointer_to_member_type (di
);
1849 ret
= d_template_param (di
);
1850 if (d_peek_char (di
) == 'I')
1852 /* This is <template-template-param> <template-args>. The
1853 <template-template-param> part is a substitution
1855 if (! d_add_substitution (di
, ret
))
1857 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
1858 d_template_args (di
));
1863 /* If this is a special substitution, then it is the start of
1864 <class-enum-type>. */
1868 peek_next
= d_peek_next_char (di
);
1869 if (IS_DIGIT (peek_next
)
1871 || IS_UPPER (peek_next
))
1873 ret
= d_substitution (di
, 0);
1874 /* The substituted name may have been a template name and
1875 may be followed by tepmlate args. */
1876 if (d_peek_char (di
) == 'I')
1877 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
1878 d_template_args (di
));
1884 ret
= d_class_enum_type (di
);
1885 /* If the substitution was a complete type, then it is not
1886 a new substitution candidate. However, if the
1887 substitution was followed by template arguments, then
1888 the whole thing is a substitution candidate. */
1889 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1897 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
1898 cplus_demangle_type (di
), NULL
);
1903 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
1904 cplus_demangle_type (di
), NULL
);
1909 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
1910 cplus_demangle_type (di
), NULL
);
1915 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
1916 cplus_demangle_type (di
), NULL
);
1921 ret
= d_source_name (di
);
1922 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
1923 cplus_demangle_type (di
), ret
);
1932 if (! d_add_substitution (di
, ret
))
1939 /* <CV-qualifiers> ::= [r] [V] [K] */
1941 static struct demangle_component
**
1942 d_cv_qualifiers (struct d_info
*di
,
1943 struct demangle_component
**pret
, int member_fn
)
1947 peek
= d_peek_char (di
);
1948 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
1950 enum demangle_component_type t
;
1956 ? DEMANGLE_COMPONENT_RESTRICT_THIS
1957 : DEMANGLE_COMPONENT_RESTRICT
);
1958 di
->expansion
+= sizeof "restrict";
1960 else if (peek
== 'V')
1963 ? DEMANGLE_COMPONENT_VOLATILE_THIS
1964 : DEMANGLE_COMPONENT_VOLATILE
);
1965 di
->expansion
+= sizeof "volatile";
1970 ? DEMANGLE_COMPONENT_CONST_THIS
1971 : DEMANGLE_COMPONENT_CONST
);
1972 di
->expansion
+= sizeof "const";
1975 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
1978 pret
= &d_left (*pret
);
1980 peek
= d_peek_char (di
);
1986 /* <function-type> ::= F [Y] <bare-function-type> E */
1988 static struct demangle_component
*
1989 d_function_type (struct d_info
*di
)
1991 struct demangle_component
*ret
;
1993 if (! d_check_char (di
, 'F'))
1995 if (d_peek_char (di
) == 'Y')
1997 /* Function has C linkage. We don't print this information.
1998 FIXME: We should print it in verbose mode. */
2001 ret
= d_bare_function_type (di
, 1);
2002 if (! d_check_char (di
, 'E'))
2007 /* <bare-function-type> ::= [J]<type>+ */
2009 static struct demangle_component
*
2010 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2012 struct demangle_component
*return_type
;
2013 struct demangle_component
*tl
;
2014 struct demangle_component
**ptl
;
2017 /* Detect special qualifier indicating that the first argument
2018 is the return type. */
2019 peek
= d_peek_char (di
);
2023 has_return_type
= 1;
2031 struct demangle_component
*type
;
2033 peek
= d_peek_char (di
);
2034 if (peek
== '\0' || peek
== 'E')
2036 type
= cplus_demangle_type (di
);
2039 if (has_return_type
)
2042 has_return_type
= 0;
2046 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2049 ptl
= &d_right (*ptl
);
2053 /* There should be at least one parameter type besides the optional
2054 return type. A function which takes no arguments will have a
2055 single parameter type void. */
2059 /* If we have a single parameter type void, omit it. */
2060 if (d_right (tl
) == NULL
2061 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2062 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2064 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2068 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
, return_type
, tl
);
2071 /* <class-enum-type> ::= <name> */
2073 static struct demangle_component
*
2074 d_class_enum_type (struct d_info
*di
)
2079 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2080 ::= A [<(dimension) expression>] _ <(element) type>
2083 static struct demangle_component
*
2084 d_array_type (struct d_info
*di
)
2087 struct demangle_component
*dim
;
2089 if (! d_check_char (di
, 'A'))
2092 peek
= d_peek_char (di
);
2095 else if (IS_DIGIT (peek
))
2103 peek
= d_peek_char (di
);
2105 while (IS_DIGIT (peek
));
2106 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2112 dim
= d_expression (di
);
2117 if (! d_check_char (di
, '_'))
2120 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2121 cplus_demangle_type (di
));
2124 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2126 static struct demangle_component
*
2127 d_pointer_to_member_type (struct d_info
*di
)
2129 struct demangle_component
*cl
;
2130 struct demangle_component
*mem
;
2131 struct demangle_component
**pmem
;
2133 if (! d_check_char (di
, 'M'))
2136 cl
= cplus_demangle_type (di
);
2138 /* The ABI specifies that any type can be a substitution source, and
2139 that M is followed by two types, and that when a CV-qualified
2140 type is seen both the base type and the CV-qualified types are
2141 substitution sources. The ABI also specifies that for a pointer
2142 to a CV-qualified member function, the qualifiers are attached to
2143 the second type. Given the grammar, a plain reading of the ABI
2144 suggests that both the CV-qualified member function and the
2145 non-qualified member function are substitution sources. However,
2146 g++ does not work that way. g++ treats only the CV-qualified
2147 member function as a substitution source. FIXME. So to work
2148 with g++, we need to pull off the CV-qualifiers here, in order to
2149 avoid calling add_substitution() in cplus_demangle_type(). But
2150 for a CV-qualified member which is not a function, g++ does
2151 follow the ABI, so we need to handle that case here by calling
2152 d_add_substitution ourselves. */
2154 pmem
= d_cv_qualifiers (di
, &mem
, 1);
2157 *pmem
= cplus_demangle_type (di
);
2161 if (pmem
!= &mem
&& (*pmem
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
2163 if (! d_add_substitution (di
, mem
))
2167 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
2170 /* <template-param> ::= T_
2171 ::= T <(parameter-2 non-negative) number> _
2174 static struct demangle_component
*
2175 d_template_param (struct d_info
*di
)
2179 if (! d_check_char (di
, 'T'))
2182 if (d_peek_char (di
) == '_')
2186 param
= d_number (di
);
2192 if (! d_check_char (di
, '_'))
2197 return d_make_template_param (di
, param
);
2200 /* <template-args> ::= I <template-arg>+ E */
2202 static struct demangle_component
*
2203 d_template_args (struct d_info
*di
)
2205 struct demangle_component
*hold_last_name
;
2206 struct demangle_component
*al
;
2207 struct demangle_component
**pal
;
2209 /* Preserve the last name we saw--don't let the template arguments
2210 clobber it, as that would give us the wrong name for a subsequent
2211 constructor or destructor. */
2212 hold_last_name
= di
->last_name
;
2214 if (! d_check_char (di
, 'I'))
2221 struct demangle_component
*a
;
2223 a
= d_template_arg (di
);
2227 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
2230 pal
= &d_right (*pal
);
2232 if (d_peek_char (di
) == 'E')
2239 di
->last_name
= hold_last_name
;
2244 /* <template-arg> ::= <type>
2245 ::= X <expression> E
2249 static struct demangle_component
*
2250 d_template_arg (struct d_info
*di
)
2252 struct demangle_component
*ret
;
2254 switch (d_peek_char (di
))
2258 ret
= d_expression (di
);
2259 if (! d_check_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
*
2282 d_expression (struct d_info
*di
)
2286 peek
= d_peek_char (di
);
2288 return d_expr_primary (di
);
2289 else if (peek
== 'T')
2290 return d_template_param (di
);
2291 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2293 struct demangle_component
*type
;
2294 struct demangle_component
*name
;
2297 type
= cplus_demangle_type (di
);
2298 name
= d_unqualified_name (di
);
2299 if (d_peek_char (di
) != 'I')
2300 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
2302 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
2303 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2304 d_template_args (di
)));
2308 struct demangle_component
*op
;
2311 op
= d_operator_name (di
);
2315 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
2316 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
2318 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
2319 && strcmp (op
->u
.s_operator
.op
->code
, "st") == 0)
2320 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2321 cplus_demangle_type (di
));
2327 case DEMANGLE_COMPONENT_OPERATOR
:
2328 args
= op
->u
.s_operator
.op
->args
;
2330 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
2331 args
= op
->u
.s_extended_operator
.args
;
2333 case DEMANGLE_COMPONENT_CAST
:
2341 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2345 struct demangle_component
*left
;
2347 left
= d_expression (di
);
2348 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
2350 DEMANGLE_COMPONENT_BINARY_ARGS
,
2352 d_expression (di
)));
2356 struct demangle_component
*first
;
2357 struct demangle_component
*second
;
2359 first
= d_expression (di
);
2360 second
= d_expression (di
);
2361 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
2363 DEMANGLE_COMPONENT_TRINARY_ARG1
,
2366 DEMANGLE_COMPONENT_TRINARY_ARG2
,
2368 d_expression (di
))));
2376 /* <expr-primary> ::= L <type> <(value) number> E
2377 ::= L <type> <(value) float> E
2378 ::= L <mangled-name> E
2381 static struct demangle_component
*
2382 d_expr_primary (struct d_info
*di
)
2384 struct demangle_component
*ret
;
2386 if (! d_check_char (di
, 'L'))
2388 if (d_peek_char (di
) == '_')
2389 ret
= cplus_demangle_mangled_name (di
, 0);
2392 struct demangle_component
*type
;
2393 enum demangle_component_type t
;
2396 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 if (d_peek_char (di
) == '\0')
2430 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
2432 if (! d_check_char (di
, 'E'))
2437 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2438 ::= Z <(function) encoding> E s [<discriminator>]
2441 static struct demangle_component
*
2442 d_local_name (struct d_info
*di
)
2444 struct demangle_component
*function
;
2446 if (! d_check_char (di
, 'Z'))
2449 function
= d_encoding (di
, 0);
2451 if (! d_check_char (di
, 'E'))
2454 if (d_peek_char (di
) == 's')
2457 if (! d_discriminator (di
))
2459 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
2460 d_make_name (di
, "string literal",
2461 sizeof "string literal" - 1));
2465 struct demangle_component
*name
;
2468 if (! d_discriminator (di
))
2470 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
2474 /* <discriminator> ::= _ <(non-negative) number>
2476 We demangle the discriminator, but we don't print it out. FIXME:
2477 We should print it out in verbose mode. */
2480 d_discriminator (struct d_info
*di
)
2484 if (d_peek_char (di
) != '_')
2487 discrim
= d_number (di
);
2493 /* Add a new substitution. */
2496 d_add_substitution (struct d_info
*di
, 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 (struct d_info
*di
, int prefix
)
2556 if (! d_check_char (di
, 'S'))
2559 c
= d_next_char (di
);
2560 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
2570 id
= id
* 36 + c
- '0';
2571 else if (IS_UPPER (c
))
2572 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 /* Initialize a growable string. */
2641 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
2646 dgs
->allocation_failure
= 0;
2649 d_growable_string_resize (dgs
, estimate
);
2652 /* Grow a growable string to a given size. */
2655 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
2660 if (dgs
->allocation_failure
)
2663 /* Start allocation at two bytes to avoid any possibility of confusion
2664 with the special value of 1 used as a return in *palc to indicate
2665 allocation failures. */
2666 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
2667 while (newalc
< need
)
2670 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
2677 dgs
->allocation_failure
= 1;
2684 /* Append a buffer to a growable string. */
2687 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
2688 const char *s
, size_t l
)
2692 need
= dgs
->len
+ l
+ 1;
2693 if (need
> dgs
->alc
)
2694 d_growable_string_resize (dgs
, need
);
2696 if (dgs
->allocation_failure
)
2699 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
2700 dgs
->buf
[dgs
->len
+ l
] = '\0';
2704 /* Bridge growable strings to the callback mechanism. */
2707 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
2709 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
2711 d_growable_string_append_buffer (dgs
, s
, l
);
2714 /* Initialize a print information structure. */
2717 d_print_init (struct d_print_info
*dpi
, int options
,
2718 demangle_callbackref callback
, void *opaque
)
2720 dpi
->options
= options
;
2722 dpi
->last_char
= '\0';
2723 dpi
->templates
= NULL
;
2724 dpi
->modifiers
= NULL
;
2726 dpi
->callback
= callback
;
2727 dpi
->opaque
= opaque
;
2729 dpi
->demangle_failure
= 0;
2732 /* Indicate that an error occurred during printing, and test for error. */
2735 d_print_error (struct d_print_info
*dpi
)
2737 dpi
->demangle_failure
= 1;
2741 d_print_saw_error (struct d_print_info
*dpi
)
2743 return dpi
->demangle_failure
!= 0;
2746 /* Flush buffered characters to the callback. */
2749 d_print_flush (struct d_print_info
*dpi
)
2751 dpi
->buf
[dpi
->len
] = '\0';
2752 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
2756 /* Append characters and buffers for printing. */
2759 d_append_char (struct d_print_info
*dpi
, char c
)
2761 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
2762 d_print_flush (dpi
);
2764 dpi
->buf
[dpi
->len
++] = c
;
2769 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
2773 for (i
= 0; i
< l
; i
++)
2774 d_append_char (dpi
, s
[i
]);
2778 d_append_string (struct d_print_info
*dpi
, const char *s
)
2780 d_append_buffer (dpi
, s
, strlen (s
));
2784 d_last_char (struct d_print_info
*dpi
)
2786 return dpi
->last_char
;
2789 /* Turn components into a human readable string. OPTIONS is the
2790 options bits passed to the demangler. DC is the tree to print.
2791 CALLBACK is a function to call to flush demangled string segments
2792 as they fill the intermediate buffer, and OPAQUE is a generalized
2793 callback argument. On success, this returns 1. On failure,
2794 it returns 0, indicating a bad parse. It does not use heap
2795 memory to build an output string, so cannot encounter memory
2796 allocation failure. */
2798 CP_STATIC_IF_GLIBCPP_V3
2800 cplus_demangle_print_callback (int options
,
2801 const struct demangle_component
*dc
,
2802 demangle_callbackref callback
, void *opaque
)
2804 struct d_print_info dpi
;
2806 d_print_init (&dpi
, options
, callback
, opaque
);
2808 d_print_comp (&dpi
, dc
);
2810 d_print_flush (&dpi
);
2812 return ! d_print_saw_error (&dpi
);
2815 /* Turn components into a human readable string. OPTIONS is the
2816 options bits passed to the demangler. DC is the tree to print.
2817 ESTIMATE is a guess at the length of the result. This returns a
2818 string allocated by malloc, or NULL on error. On success, this
2819 sets *PALC to the size of the allocated buffer. On failure, this
2820 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
2823 CP_STATIC_IF_GLIBCPP_V3
2825 cplus_demangle_print (int options
, const struct demangle_component
*dc
,
2826 int estimate
, size_t *palc
)
2828 struct d_growable_string dgs
;
2830 d_growable_string_init (&dgs
, estimate
);
2832 if (! cplus_demangle_print_callback (options
, dc
,
2833 d_growable_string_callback_adapter
,
2841 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
2845 /* Subroutine to handle components. */
2848 d_print_comp (struct d_print_info
*dpi
,
2849 const struct demangle_component
*dc
)
2853 d_print_error (dpi
);
2856 if (d_print_saw_error (dpi
))
2861 case DEMANGLE_COMPONENT_NAME
:
2862 if ((dpi
->options
& DMGL_JAVA
) == 0)
2863 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2865 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2868 case DEMANGLE_COMPONENT_QUAL_NAME
:
2869 case DEMANGLE_COMPONENT_LOCAL_NAME
:
2870 d_print_comp (dpi
, d_left (dc
));
2871 if ((dpi
->options
& DMGL_JAVA
) == 0)
2872 d_append_string (dpi
, "::");
2874 d_append_char (dpi
, '.');
2875 d_print_comp (dpi
, d_right (dc
));
2878 case DEMANGLE_COMPONENT_TYPED_NAME
:
2880 struct d_print_mod
*hold_modifiers
;
2881 struct demangle_component
*typed_name
;
2882 struct d_print_mod adpm
[4];
2884 struct d_print_template dpt
;
2886 /* Pass the name down to the type so that it can be printed in
2887 the right place for the type. We also have to pass down
2888 any CV-qualifiers, which apply to the this parameter. */
2889 hold_modifiers
= dpi
->modifiers
;
2891 typed_name
= d_left (dc
);
2892 while (typed_name
!= NULL
)
2894 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2896 d_print_error (dpi
);
2900 adpm
[i
].next
= dpi
->modifiers
;
2901 dpi
->modifiers
= &adpm
[i
];
2902 adpm
[i
].mod
= typed_name
;
2903 adpm
[i
].printed
= 0;
2904 adpm
[i
].templates
= dpi
->templates
;
2907 if (typed_name
->type
!= DEMANGLE_COMPONENT_RESTRICT_THIS
2908 && typed_name
->type
!= DEMANGLE_COMPONENT_VOLATILE_THIS
2909 && typed_name
->type
!= DEMANGLE_COMPONENT_CONST_THIS
)
2912 typed_name
= d_left (typed_name
);
2915 if (typed_name
== NULL
)
2917 d_print_error (dpi
);
2921 /* If typed_name is a template, then it applies to the
2922 function type as well. */
2923 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
2925 dpt
.next
= dpi
->templates
;
2926 dpi
->templates
= &dpt
;
2927 dpt
.template_decl
= typed_name
;
2930 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
2931 there may be CV-qualifiers on its right argument which
2932 really apply here; this happens when parsing a class which
2933 is local to a function. */
2934 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
2936 struct demangle_component
*local_name
;
2938 local_name
= d_right (typed_name
);
2939 while (local_name
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
2940 || local_name
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
2941 || local_name
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
2943 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2945 d_print_error (dpi
);
2949 adpm
[i
] = adpm
[i
- 1];
2950 adpm
[i
].next
= &adpm
[i
- 1];
2951 dpi
->modifiers
= &adpm
[i
];
2953 adpm
[i
- 1].mod
= local_name
;
2954 adpm
[i
- 1].printed
= 0;
2955 adpm
[i
- 1].templates
= dpi
->templates
;
2958 local_name
= d_left (local_name
);
2962 d_print_comp (dpi
, d_right (dc
));
2964 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
2965 dpi
->templates
= dpt
.next
;
2967 /* If the modifiers didn't get printed by the type, print them
2972 if (! adpm
[i
].printed
)
2974 d_append_char (dpi
, ' ');
2975 d_print_mod (dpi
, adpm
[i
].mod
);
2979 dpi
->modifiers
= hold_modifiers
;
2984 case DEMANGLE_COMPONENT_TEMPLATE
:
2986 struct d_print_mod
*hold_dpm
;
2987 struct demangle_component
*dcl
;
2989 /* Don't push modifiers into a template definition. Doing so
2990 could give the wrong definition for a template argument.
2991 Instead, treat the template essentially as a name. */
2993 hold_dpm
= dpi
->modifiers
;
2994 dpi
->modifiers
= NULL
;
2998 if ((dpi
->options
& DMGL_JAVA
) != 0
2999 && dcl
->type
== DEMANGLE_COMPONENT_NAME
3000 && dcl
->u
.s_name
.len
== 6
3001 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
3003 /* Special-case Java arrays, so that JArray<TYPE> appears
3004 instead as TYPE[]. */
3006 d_print_comp (dpi
, d_right (dc
));
3007 d_append_string (dpi
, "[]");
3011 d_print_comp (dpi
, dcl
);
3012 if (d_last_char (dpi
) == '<')
3013 d_append_char (dpi
, ' ');
3014 d_append_char (dpi
, '<');
3015 d_print_comp (dpi
, d_right (dc
));
3016 /* Avoid generating two consecutive '>' characters, to avoid
3017 the C++ syntactic ambiguity. */
3018 if (d_last_char (dpi
) == '>')
3019 d_append_char (dpi
, ' ');
3020 d_append_char (dpi
, '>');
3023 dpi
->modifiers
= hold_dpm
;
3028 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3031 struct demangle_component
*a
;
3032 struct d_print_template
*hold_dpt
;
3034 if (dpi
->templates
== NULL
)
3036 d_print_error (dpi
);
3039 i
= dc
->u
.s_number
.number
;
3040 for (a
= d_right (dpi
->templates
->template_decl
);
3044 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3046 d_print_error (dpi
);
3053 if (i
!= 0 || a
== NULL
)
3055 d_print_error (dpi
);
3059 /* While processing this parameter, we need to pop the list of
3060 templates. This is because the template parameter may
3061 itself be a reference to a parameter of an outer
3064 hold_dpt
= dpi
->templates
;
3065 dpi
->templates
= hold_dpt
->next
;
3067 d_print_comp (dpi
, d_left (a
));
3069 dpi
->templates
= hold_dpt
;
3074 case DEMANGLE_COMPONENT_CTOR
:
3075 d_print_comp (dpi
, dc
->u
.s_ctor
.name
);
3078 case DEMANGLE_COMPONENT_DTOR
:
3079 d_append_char (dpi
, '~');
3080 d_print_comp (dpi
, dc
->u
.s_dtor
.name
);
3083 case DEMANGLE_COMPONENT_VTABLE
:
3084 d_append_string (dpi
, "vtable for ");
3085 d_print_comp (dpi
, d_left (dc
));
3088 case DEMANGLE_COMPONENT_VTT
:
3089 d_append_string (dpi
, "VTT for ");
3090 d_print_comp (dpi
, d_left (dc
));
3093 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
3094 d_append_string (dpi
, "construction vtable for ");
3095 d_print_comp (dpi
, d_left (dc
));
3096 d_append_string (dpi
, "-in-");
3097 d_print_comp (dpi
, d_right (dc
));
3100 case DEMANGLE_COMPONENT_TYPEINFO
:
3101 d_append_string (dpi
, "typeinfo for ");
3102 d_print_comp (dpi
, d_left (dc
));
3105 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
3106 d_append_string (dpi
, "typeinfo name for ");
3107 d_print_comp (dpi
, d_left (dc
));
3110 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
3111 d_append_string (dpi
, "typeinfo fn for ");
3112 d_print_comp (dpi
, d_left (dc
));
3115 case DEMANGLE_COMPONENT_THUNK
:
3116 d_append_string (dpi
, "non-virtual thunk to ");
3117 d_print_comp (dpi
, d_left (dc
));
3120 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
3121 d_append_string (dpi
, "virtual thunk to ");
3122 d_print_comp (dpi
, d_left (dc
));
3125 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
3126 d_append_string (dpi
, "covariant return thunk to ");
3127 d_print_comp (dpi
, d_left (dc
));
3130 case DEMANGLE_COMPONENT_JAVA_CLASS
:
3131 d_append_string (dpi
, "java Class for ");
3132 d_print_comp (dpi
, d_left (dc
));
3135 case DEMANGLE_COMPONENT_GUARD
:
3136 d_append_string (dpi
, "guard variable for ");
3137 d_print_comp (dpi
, d_left (dc
));
3140 case DEMANGLE_COMPONENT_REFTEMP
:
3141 d_append_string (dpi
, "reference temporary for ");
3142 d_print_comp (dpi
, d_left (dc
));
3145 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
3146 d_append_string (dpi
, "hidden alias for ");
3147 d_print_comp (dpi
, d_left (dc
));
3150 case DEMANGLE_COMPONENT_SUB_STD
:
3151 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
3154 case DEMANGLE_COMPONENT_RESTRICT
:
3155 case DEMANGLE_COMPONENT_VOLATILE
:
3156 case DEMANGLE_COMPONENT_CONST
:
3158 struct d_print_mod
*pdpm
;
3160 /* When printing arrays, it's possible to have cases where the
3161 same CV-qualifier gets pushed on the stack multiple times.
3162 We only need to print it once. */
3164 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
3166 if (! pdpm
->printed
)
3168 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
3169 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
3170 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
3172 if (pdpm
->mod
->type
== dc
->type
)
3174 d_print_comp (dpi
, d_left (dc
));
3181 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3182 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3183 case DEMANGLE_COMPONENT_CONST_THIS
:
3184 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3185 case DEMANGLE_COMPONENT_POINTER
:
3186 case DEMANGLE_COMPONENT_REFERENCE
:
3187 case DEMANGLE_COMPONENT_COMPLEX
:
3188 case DEMANGLE_COMPONENT_IMAGINARY
:
3190 /* We keep a list of modifiers on the stack. */
3191 struct d_print_mod dpm
;
3193 dpm
.next
= dpi
->modifiers
;
3194 dpi
->modifiers
= &dpm
;
3197 dpm
.templates
= dpi
->templates
;
3199 d_print_comp (dpi
, d_left (dc
));
3201 /* If the modifier didn't get printed by the type, print it
3204 d_print_mod (dpi
, dc
);
3206 dpi
->modifiers
= dpm
.next
;
3211 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3212 if ((dpi
->options
& DMGL_JAVA
) == 0)
3213 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
3214 dc
->u
.s_builtin
.type
->len
);
3216 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
3217 dc
->u
.s_builtin
.type
->java_len
);
3220 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
3221 d_print_comp (dpi
, d_left (dc
));
3224 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
3226 if ((dpi
->options
& DMGL_RET_POSTFIX
) != 0)
3227 d_print_function_type (dpi
, dc
, dpi
->modifiers
);
3229 /* Print return type if present */
3230 if (d_left (dc
) != NULL
)
3232 struct d_print_mod dpm
;
3234 /* We must pass this type down as a modifier in order to
3235 print it in the right location. */
3236 dpm
.next
= dpi
->modifiers
;
3237 dpi
->modifiers
= &dpm
;
3240 dpm
.templates
= dpi
->templates
;
3242 d_print_comp (dpi
, d_left (dc
));
3244 dpi
->modifiers
= dpm
.next
;
3249 /* In standard prefix notation, there is a space between the
3250 return type and the function signature. */
3251 if ((dpi
->options
& DMGL_RET_POSTFIX
) == 0)
3252 d_append_char (dpi
, ' ');
3255 if ((dpi
->options
& DMGL_RET_POSTFIX
) == 0)
3256 d_print_function_type (dpi
, dc
, dpi
->modifiers
);
3261 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
3263 struct d_print_mod
*hold_modifiers
;
3264 struct d_print_mod adpm
[4];
3266 struct d_print_mod
*pdpm
;
3268 /* We must pass this type down as a modifier in order to print
3269 multi-dimensional arrays correctly. If the array itself is
3270 CV-qualified, we act as though the element type were
3271 CV-qualified. We do this by copying the modifiers down
3272 rather than fiddling pointers, so that we don't wind up
3273 with a d_print_mod higher on the stack pointing into our
3274 stack frame after we return. */
3276 hold_modifiers
= dpi
->modifiers
;
3278 adpm
[0].next
= hold_modifiers
;
3279 dpi
->modifiers
= &adpm
[0];
3281 adpm
[0].printed
= 0;
3282 adpm
[0].templates
= dpi
->templates
;
3285 pdpm
= hold_modifiers
;
3287 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
3288 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
3289 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
3291 if (! pdpm
->printed
)
3293 if (i
>= sizeof adpm
/ sizeof adpm
[0])
3295 d_print_error (dpi
);
3300 adpm
[i
].next
= dpi
->modifiers
;
3301 dpi
->modifiers
= &adpm
[i
];
3309 d_print_comp (dpi
, d_right (dc
));
3311 dpi
->modifiers
= hold_modifiers
;
3313 if (adpm
[0].printed
)
3319 d_print_mod (dpi
, adpm
[i
].mod
);
3322 d_print_array_type (dpi
, dc
, dpi
->modifiers
);
3327 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3329 struct d_print_mod dpm
;
3331 dpm
.next
= dpi
->modifiers
;
3332 dpi
->modifiers
= &dpm
;
3335 dpm
.templates
= dpi
->templates
;
3337 d_print_comp (dpi
, d_right (dc
));
3339 /* If the modifier didn't get printed by the type, print it
3343 d_append_char (dpi
, ' ');
3344 d_print_comp (dpi
, d_left (dc
));
3345 d_append_string (dpi
, "::*");
3348 dpi
->modifiers
= dpm
.next
;
3353 case DEMANGLE_COMPONENT_ARGLIST
:
3354 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
3355 d_print_comp (dpi
, d_left (dc
));
3356 if (d_right (dc
) != NULL
)
3358 d_append_string (dpi
, ", ");
3359 d_print_comp (dpi
, d_right (dc
));
3363 case DEMANGLE_COMPONENT_OPERATOR
:
3367 d_append_string (dpi
, "operator");
3368 c
= dc
->u
.s_operator
.op
->name
[0];
3370 d_append_char (dpi
, ' ');
3371 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
3372 dc
->u
.s_operator
.op
->len
);
3376 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3377 d_append_string (dpi
, "operator ");
3378 d_print_comp (dpi
, dc
->u
.s_extended_operator
.name
);
3381 case DEMANGLE_COMPONENT_CAST
:
3382 d_append_string (dpi
, "operator ");
3383 d_print_cast (dpi
, dc
);
3386 case DEMANGLE_COMPONENT_UNARY
:
3387 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_CAST
)
3388 d_print_expr_op (dpi
, d_left (dc
));
3391 d_append_char (dpi
, '(');
3392 d_print_cast (dpi
, d_left (dc
));
3393 d_append_char (dpi
, ')');
3395 d_append_char (dpi
, '(');
3396 d_print_comp (dpi
, d_right (dc
));
3397 d_append_char (dpi
, ')');
3400 case DEMANGLE_COMPONENT_BINARY
:
3401 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
3403 d_print_error (dpi
);
3407 /* We wrap an expression which uses the greater-than operator in
3408 an extra layer of parens so that it does not get confused
3409 with the '>' which ends the template parameters. */
3410 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
3411 && d_left (dc
)->u
.s_operator
.op
->len
== 1
3412 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
3413 d_append_char (dpi
, '(');
3415 d_append_char (dpi
, '(');
3416 d_print_comp (dpi
, d_left (d_right (dc
)));
3417 d_append_string (dpi
, ") ");
3418 d_print_expr_op (dpi
, d_left (dc
));
3419 d_append_string (dpi
, " (");
3420 d_print_comp (dpi
, d_right (d_right (dc
)));
3421 d_append_char (dpi
, ')');
3423 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
3424 && d_left (dc
)->u
.s_operator
.op
->len
== 1
3425 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
3426 d_append_char (dpi
, ')');
3430 case DEMANGLE_COMPONENT_BINARY_ARGS
:
3431 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
3432 d_print_error (dpi
);
3435 case DEMANGLE_COMPONENT_TRINARY
:
3436 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
3437 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
3439 d_print_error (dpi
);
3442 d_append_char (dpi
, '(');
3443 d_print_comp (dpi
, d_left (d_right (dc
)));
3444 d_append_string (dpi
, ") ");
3445 d_print_expr_op (dpi
, d_left (dc
));
3446 d_append_string (dpi
, " (");
3447 d_print_comp (dpi
, d_left (d_right (d_right (dc
))));
3448 d_append_string (dpi
, ") : (");
3449 d_print_comp (dpi
, d_right (d_right (d_right (dc
))));
3450 d_append_char (dpi
, ')');
3453 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
3454 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
3455 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
3456 d_print_error (dpi
);
3459 case DEMANGLE_COMPONENT_LITERAL
:
3460 case DEMANGLE_COMPONENT_LITERAL_NEG
:
3462 enum d_builtin_type_print tp
;
3464 /* For some builtin types, produce simpler output. */
3465 tp
= D_PRINT_DEFAULT
;
3466 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
3468 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
3472 case D_PRINT_UNSIGNED
:
3474 case D_PRINT_UNSIGNED_LONG
:
3475 case D_PRINT_LONG_LONG
:
3476 case D_PRINT_UNSIGNED_LONG_LONG
:
3477 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
3479 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3480 d_append_char (dpi
, '-');
3481 d_print_comp (dpi
, d_right (dc
));
3486 case D_PRINT_UNSIGNED
:
3487 d_append_char (dpi
, 'u');
3490 d_append_char (dpi
, 'l');
3492 case D_PRINT_UNSIGNED_LONG
:
3493 d_append_string (dpi
, "ul");
3495 case D_PRINT_LONG_LONG
:
3496 d_append_string (dpi
, "ll");
3498 case D_PRINT_UNSIGNED_LONG_LONG
:
3499 d_append_string (dpi
, "ull");
3507 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
3508 && d_right (dc
)->u
.s_name
.len
== 1
3509 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
3511 switch (d_right (dc
)->u
.s_name
.s
[0])
3514 d_append_string (dpi
, "false");
3517 d_append_string (dpi
, "true");
3530 d_append_char (dpi
, '(');
3531 d_print_comp (dpi
, d_left (dc
));
3532 d_append_char (dpi
, ')');
3533 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3534 d_append_char (dpi
, '-');
3535 if (tp
== D_PRINT_FLOAT
)
3536 d_append_char (dpi
, '[');
3537 d_print_comp (dpi
, d_right (dc
));
3538 if (tp
== D_PRINT_FLOAT
)
3539 d_append_char (dpi
, ']');
3544 d_print_error (dpi
);
3549 /* Print a Java dentifier. For Java we try to handle encoded extended
3550 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
3551 so we don't it for C++. Characters are encoded as
3555 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
3561 for (p
= name
; p
< end
; ++p
)
3572 for (q
= p
+ 3; q
< end
; ++q
)
3578 else if (*q
>= 'A' && *q
<= 'F')
3579 dig
= *q
- 'A' + 10;
3580 else if (*q
>= 'a' && *q
<= 'f')
3581 dig
= *q
- 'a' + 10;
3587 /* If the Unicode character is larger than 256, we don't try
3588 to deal with it here. FIXME. */
3589 if (q
< end
&& *q
== '_' && c
< 256)
3591 d_append_char (dpi
, c
);
3597 d_append_char (dpi
, *p
);
3601 /* Print a list of modifiers. SUFFIX is 1 if we are printing
3602 qualifiers on this after printing a function. */
3605 d_print_mod_list (struct d_print_info
*dpi
,
3606 struct d_print_mod
*mods
, int suffix
)
3608 struct d_print_template
*hold_dpt
;
3610 if (mods
== NULL
|| d_print_saw_error (dpi
))
3615 && (mods
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3616 || mods
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3617 || mods
->mod
->type
== DEMANGLE_COMPONENT_CONST_THIS
)))
3619 d_print_mod_list (dpi
, mods
->next
, suffix
);
3625 hold_dpt
= dpi
->templates
;
3626 dpi
->templates
= mods
->templates
;
3628 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3630 d_print_function_type (dpi
, mods
->mod
, mods
->next
);
3631 dpi
->templates
= hold_dpt
;
3634 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
3636 d_print_array_type (dpi
, mods
->mod
, mods
->next
);
3637 dpi
->templates
= hold_dpt
;
3640 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
3642 struct d_print_mod
*hold_modifiers
;
3643 struct demangle_component
*dc
;
3645 /* When this is on the modifier stack, we have pulled any
3646 qualifiers off the right argument already. Otherwise, we
3647 print it as usual, but don't let the left argument see any
3650 hold_modifiers
= dpi
->modifiers
;
3651 dpi
->modifiers
= NULL
;
3652 d_print_comp (dpi
, d_left (mods
->mod
));
3653 dpi
->modifiers
= hold_modifiers
;
3655 if ((dpi
->options
& DMGL_JAVA
) == 0)
3656 d_append_string (dpi
, "::");
3658 d_append_char (dpi
, '.');
3660 dc
= d_right (mods
->mod
);
3661 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3662 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3663 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
3666 d_print_comp (dpi
, dc
);
3668 dpi
->templates
= hold_dpt
;
3672 d_print_mod (dpi
, mods
->mod
);
3674 dpi
->templates
= hold_dpt
;
3676 d_print_mod_list (dpi
, mods
->next
, suffix
);
3679 /* Print a modifier. */
3682 d_print_mod (struct d_print_info
*dpi
,
3683 const struct demangle_component
*mod
)
3687 case DEMANGLE_COMPONENT_RESTRICT
:
3688 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3689 d_append_string (dpi
, " restrict");
3691 case DEMANGLE_COMPONENT_VOLATILE
:
3692 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3693 d_append_string (dpi
, " volatile");
3695 case DEMANGLE_COMPONENT_CONST
:
3696 case DEMANGLE_COMPONENT_CONST_THIS
:
3697 d_append_string (dpi
, " const");
3699 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3700 d_append_char (dpi
, ' ');
3701 d_print_comp (dpi
, d_right (mod
));
3703 case DEMANGLE_COMPONENT_POINTER
:
3704 /* There is no pointer symbol in Java. */
3705 if ((dpi
->options
& DMGL_JAVA
) == 0)
3706 d_append_char (dpi
, '*');
3708 case DEMANGLE_COMPONENT_REFERENCE
:
3709 d_append_char (dpi
, '&');
3711 case DEMANGLE_COMPONENT_COMPLEX
:
3712 d_append_string (dpi
, "complex ");
3714 case DEMANGLE_COMPONENT_IMAGINARY
:
3715 d_append_string (dpi
, "imaginary ");
3717 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3718 if (d_last_char (dpi
) != '(')
3719 d_append_char (dpi
, ' ');
3720 d_print_comp (dpi
, d_left (mod
));
3721 d_append_string (dpi
, "::*");
3723 case DEMANGLE_COMPONENT_TYPED_NAME
:
3724 d_print_comp (dpi
, d_left (mod
));
3727 /* Otherwise, we have something that won't go back on the
3728 modifier stack, so we can just print it. */
3729 d_print_comp (dpi
, mod
);
3734 /* Print a function type, except for the return type. */
3737 d_print_function_type (struct d_print_info
*dpi
,
3738 const struct demangle_component
*dc
,
3739 struct d_print_mod
*mods
)
3744 struct d_print_mod
*p
;
3745 struct d_print_mod
*hold_modifiers
;
3750 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3756 switch (p
->mod
->type
)
3758 case DEMANGLE_COMPONENT_POINTER
:
3759 case DEMANGLE_COMPONENT_REFERENCE
:
3762 case DEMANGLE_COMPONENT_RESTRICT
:
3763 case DEMANGLE_COMPONENT_VOLATILE
:
3764 case DEMANGLE_COMPONENT_CONST
:
3765 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3766 case DEMANGLE_COMPONENT_COMPLEX
:
3767 case DEMANGLE_COMPONENT_IMAGINARY
:
3768 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3772 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3773 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3774 case DEMANGLE_COMPONENT_CONST_THIS
:
3783 if (d_left (dc
) != NULL
&& ! saw_mod
)
3790 if (d_last_char (dpi
) != '('
3791 && d_last_char (dpi
) != '*')
3794 if (need_space
&& d_last_char (dpi
) != ' ')
3795 d_append_char (dpi
, ' ');
3796 d_append_char (dpi
, '(');
3799 hold_modifiers
= dpi
->modifiers
;
3800 dpi
->modifiers
= NULL
;
3802 d_print_mod_list (dpi
, mods
, 0);
3805 d_append_char (dpi
, ')');
3807 d_append_char (dpi
, '(');
3809 if (d_right (dc
) != NULL
)
3810 d_print_comp (dpi
, d_right (dc
));
3812 d_append_char (dpi
, ')');
3814 d_print_mod_list (dpi
, mods
, 1);
3816 dpi
->modifiers
= hold_modifiers
;
3819 /* Print an array type, except for the element type. */
3822 d_print_array_type (struct d_print_info
*dpi
,
3823 const struct demangle_component
*dc
,
3824 struct d_print_mod
*mods
)
3832 struct d_print_mod
*p
;
3835 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3839 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
3854 d_append_string (dpi
, " (");
3856 d_print_mod_list (dpi
, mods
, 0);
3859 d_append_char (dpi
, ')');
3863 d_append_char (dpi
, ' ');
3865 d_append_char (dpi
, '[');
3867 if (d_left (dc
) != NULL
)
3868 d_print_comp (dpi
, d_left (dc
));
3870 d_append_char (dpi
, ']');
3873 /* Print an operator in an expression. */
3876 d_print_expr_op (struct d_print_info
*dpi
,
3877 const struct demangle_component
*dc
)
3879 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3880 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
3881 dc
->u
.s_operator
.op
->len
);
3883 d_print_comp (dpi
, dc
);
3889 d_print_cast (struct d_print_info
*dpi
,
3890 const struct demangle_component
*dc
)
3892 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
3893 d_print_comp (dpi
, d_left (dc
));
3896 struct d_print_mod
*hold_dpm
;
3897 struct d_print_template dpt
;
3899 /* It appears that for a templated cast operator, we need to put
3900 the template parameters in scope for the operator name, but
3901 not for the parameters. The effect is that we need to handle
3902 the template printing here. */
3904 hold_dpm
= dpi
->modifiers
;
3905 dpi
->modifiers
= NULL
;
3907 dpt
.next
= dpi
->templates
;
3908 dpi
->templates
= &dpt
;
3909 dpt
.template_decl
= d_left (dc
);
3911 d_print_comp (dpi
, d_left (d_left (dc
)));
3913 dpi
->templates
= dpt
.next
;
3915 if (d_last_char (dpi
) == '<')
3916 d_append_char (dpi
, ' ');
3917 d_append_char (dpi
, '<');
3918 d_print_comp (dpi
, d_right (d_left (dc
)));
3919 /* Avoid generating two consecutive '>' characters, to avoid
3920 the C++ syntactic ambiguity. */
3921 if (d_last_char (dpi
) == '>')
3922 d_append_char (dpi
, ' ');
3923 d_append_char (dpi
, '>');
3925 dpi
->modifiers
= hold_dpm
;
3929 /* Initialize the information structure we use to pass around
3932 CP_STATIC_IF_GLIBCPP_V3
3934 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
3938 di
->send
= mangled
+ len
;
3939 di
->options
= options
;
3943 /* We can not need more components than twice the number of chars in
3944 the mangled string. Most components correspond directly to
3945 chars, but the ARGLIST types are exceptions. */
3946 di
->num_comps
= 2 * len
;
3949 /* Similarly, we can not need more substitutions than there are
3950 chars in the mangled string. */
3955 di
->last_name
= NULL
;
3960 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
3961 mangled name, return strings in repeated callback giving the demangled
3962 name. OPTIONS is the usual libiberty demangler options. On success,
3963 this returns 1. On failure, returns 0. */
3966 d_demangle_callback (const char *mangled
, int options
,
3967 demangle_callbackref callback
, void *opaque
)
3971 struct demangle_component
*dc
;
3974 if (mangled
[0] == '_' && mangled
[1] == 'Z')
3976 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
3977 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
3978 && (mangled
[9] == 'D' || mangled
[9] == 'I')
3979 && mangled
[10] == '_')
3983 intro
= (mangled
[9] == 'I')
3984 ? "global constructors keyed to "
3985 : "global destructors keyed to ";
3987 callback (intro
, strlen (intro
), opaque
);
3988 callback (mangled
+ 11, strlen (mangled
+ 11), opaque
);
3993 if ((options
& DMGL_TYPES
) == 0)
3998 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
4001 #ifdef CP_DYNAMIC_ARRAYS
4002 __extension__
struct demangle_component comps
[di
.num_comps
];
4003 __extension__
struct demangle_component
*subs
[di
.num_subs
];
4008 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
4009 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
4013 dc
= cplus_demangle_type (&di
);
4015 dc
= cplus_demangle_mangled_name (&di
, 1);
4017 /* If DMGL_PARAMS is set, then if we didn't consume the entire
4018 mangled string, then we didn't successfully demangle it. If
4019 DMGL_PARAMS is not set, we didn't look at the trailing
4021 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
4024 #ifdef CP_DEMANGLE_DEBUG
4028 status
= (dc
!= NULL
)
4029 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
4036 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
4037 name, return a buffer allocated with malloc holding the demangled
4038 name. OPTIONS is the usual libiberty demangler options. On
4039 success, this sets *PALC to the allocated size of the returned
4040 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
4041 a memory allocation failure, and returns NULL. */
4044 d_demangle (const char *mangled
, int options
, size_t *palc
)
4046 struct d_growable_string dgs
;
4049 d_growable_string_init (&dgs
, 0);
4051 status
= d_demangle_callback (mangled
, options
,
4052 d_growable_string_callback_adapter
, &dgs
);
4060 *palc
= dgs
.allocation_failure
? 1 : 0;
4064 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
4066 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
4068 /* ia64 ABI-mandated entry point in the C++ runtime library for
4069 performing demangling. MANGLED_NAME is a NUL-terminated character
4070 string containing the name to be demangled.
4072 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4073 *LENGTH bytes, into which the demangled name is stored. If
4074 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4075 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4076 is placed in a region of memory allocated with malloc.
4078 If LENGTH is non-NULL, the length of the buffer containing the
4079 demangled name, is placed in *LENGTH.
4081 The return value is a pointer to the start of the NUL-terminated
4082 demangled name, or NULL if the demangling fails. The caller is
4083 responsible for deallocating this memory using free.
4085 *STATUS is set to one of the following values:
4086 0: The demangling operation succeeded.
4087 -1: A memory allocation failure occurred.
4088 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4089 -3: One of the arguments is invalid.
4091 The demangling is performed using the C++ ABI mangling rules, with
4095 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
4096 size_t *length
, int *status
)
4101 if (mangled_name
== NULL
)
4108 if (output_buffer
!= NULL
&& length
== NULL
)
4115 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
4117 if (demangled
== NULL
)
4129 if (output_buffer
== NULL
)
4136 if (strlen (demangled
) < *length
)
4138 strcpy (output_buffer
, demangled
);
4140 demangled
= output_buffer
;
4144 free (output_buffer
);
4155 extern int __gcclibcxx_demangle_callback (const char *,
4157 (const char *, size_t, void *),
4160 /* Alternative, allocationless entry point in the C++ runtime library
4161 for performing demangling. MANGLED_NAME is a NUL-terminated character
4162 string containing the name to be demangled.
4164 CALLBACK is a callback function, called with demangled string
4165 segments as demangling progresses; it is called at least once,
4166 but may be called more than once. OPAQUE is a generalized pointer
4167 used as a callback argument.
4169 The return code is one of the following values, equivalent to
4170 the STATUS values of __cxa_demangle() (excluding -1, since this
4171 function performs no memory allocations):
4172 0: The demangling operation succeeded.
4173 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4174 -3: One of the arguments is invalid.
4176 The demangling is performed using the C++ ABI mangling rules, with
4180 __gcclibcxx_demangle_callback (const char *mangled_name
,
4181 void (*callback
) (const char *, size_t, void *),
4186 if (mangled_name
== NULL
|| callback
== NULL
)
4189 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
4197 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
4199 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
4200 mangled name, return a buffer allocated with malloc holding the
4201 demangled name. Otherwise, return NULL. */
4204 cplus_demangle_v3 (const char *mangled
, int options
)
4208 return d_demangle (mangled
, options
, &alc
);
4212 cplus_demangle_v3_callback (const char *mangled
, int options
,
4213 demangle_callbackref callback
, void *opaque
)
4215 return d_demangle_callback (mangled
, options
, callback
, opaque
);
4218 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
4219 conventions, but the output formatting is a little different.
4220 This instructs the C++ demangler not to emit pointer characters ("*"), to
4221 use Java's namespace separator symbol ("." instead of "::"), and to output
4222 JArray<TYPE> as TYPE[]. */
4225 java_demangle_v3 (const char *mangled
)
4229 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
4233 java_demangle_v3_callback (const char *mangled
,
4234 demangle_callbackref callback
, void *opaque
)
4236 return d_demangle_callback (mangled
,
4237 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
4241 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4243 #ifndef IN_GLIBCPP_V3
4245 /* Demangle a string in order to find out whether it is a constructor
4246 or destructor. Return non-zero on success. Set *CTOR_KIND and
4247 *DTOR_KIND appropriately. */
4250 is_ctor_or_dtor (const char *mangled
,
4251 enum gnu_v3_ctor_kinds
*ctor_kind
,
4252 enum gnu_v3_dtor_kinds
*dtor_kind
)
4255 struct demangle_component
*dc
;
4258 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
4259 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
4261 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
4264 #ifdef CP_DYNAMIC_ARRAYS
4265 __extension__
struct demangle_component comps
[di
.num_comps
];
4266 __extension__
struct demangle_component
*subs
[di
.num_subs
];
4271 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
4272 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
4275 dc
= cplus_demangle_mangled_name (&di
, 1);
4277 /* Note that because we did not pass DMGL_PARAMS, we don't expect
4278 to demangle the entire string. */
4288 case DEMANGLE_COMPONENT_TYPED_NAME
:
4289 case DEMANGLE_COMPONENT_TEMPLATE
:
4290 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4291 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4292 case DEMANGLE_COMPONENT_CONST_THIS
:
4295 case DEMANGLE_COMPONENT_QUAL_NAME
:
4296 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4299 case DEMANGLE_COMPONENT_CTOR
:
4300 *ctor_kind
= dc
->u
.s_ctor
.kind
;
4304 case DEMANGLE_COMPONENT_DTOR
:
4305 *dtor_kind
= dc
->u
.s_dtor
.kind
;
4316 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4317 name. A non-zero return indicates the type of constructor. */
4319 enum gnu_v3_ctor_kinds
4320 is_gnu_v3_mangled_ctor (const char *name
)
4322 enum gnu_v3_ctor_kinds ctor_kind
;
4323 enum gnu_v3_dtor_kinds dtor_kind
;
4325 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
4326 return (enum gnu_v3_ctor_kinds
) 0;
4331 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4332 name. A non-zero return indicates the type of destructor. */
4334 enum gnu_v3_dtor_kinds
4335 is_gnu_v3_mangled_dtor (const char *name
)
4337 enum gnu_v3_ctor_kinds ctor_kind
;
4338 enum gnu_v3_dtor_kinds dtor_kind
;
4340 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
4341 return (enum gnu_v3_dtor_kinds
) 0;
4345 #endif /* IN_GLIBCPP_V3 */
4347 #ifdef STANDALONE_DEMANGLER
4350 #include "dyn-string.h"
4352 static void print_usage (FILE* fp
, int exit_value
);
4354 #define IS_ALPHA(CHAR) \
4355 (((CHAR) >= 'a' && (CHAR) <= 'z') \
4356 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4358 /* Non-zero if CHAR is a character than can occur in a mangled name. */
4359 #define is_mangled_char(CHAR) \
4360 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
4361 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
4363 /* The name of this program, as invoked. */
4364 const char* program_name
;
4366 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
4369 print_usage (FILE* fp
, int exit_value
)
4371 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
4372 fprintf (fp
, "Options:\n");
4373 fprintf (fp
, " -h,--help Display this message.\n");
4374 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
4375 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
4376 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
4381 /* Option specification for getopt_long. */
4382 static const struct option long_options
[] =
4384 { "help", no_argument
, NULL
, 'h' },
4385 { "no-params", no_argument
, NULL
, 'p' },
4386 { "verbose", no_argument
, NULL
, 'v' },
4387 { NULL
, no_argument
, NULL
, 0 },
4390 /* Main entry for a demangling filter executable. It will demangle
4391 its command line arguments, if any. If none are provided, it will
4392 filter stdin to stdout, replacing any recognized mangled C++ names
4393 with their demangled equivalents. */
4396 main (int argc
, char *argv
[])
4400 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
4402 /* Use the program name of this program, as invoked. */
4403 program_name
= argv
[0];
4405 /* Parse options. */
4408 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
4411 case '?': /* Unrecognized option. */
4412 print_usage (stderr
, 1);
4416 print_usage (stdout
, 0);
4420 options
&= ~ DMGL_PARAMS
;
4424 options
|= DMGL_VERBOSE
;
4428 while (opt_char
!= -1);
4431 /* No command line arguments were provided. Filter stdin. */
4433 dyn_string_t mangled
= dyn_string_new (3);
4436 /* Read all of input. */
4437 while (!feof (stdin
))
4441 /* Pile characters into mangled until we hit one that can't
4442 occur in a mangled name. */
4444 while (!feof (stdin
) && is_mangled_char (c
))
4446 dyn_string_append_char (mangled
, c
);
4452 if (dyn_string_length (mangled
) > 0)
4454 #ifdef IN_GLIBCPP_V3
4455 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
4457 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
4467 /* It might not have been a mangled name. Print the
4469 fputs (dyn_string_buf (mangled
), stdout
);
4472 dyn_string_clear (mangled
);
4475 /* If we haven't hit EOF yet, we've read one character that
4476 can't occur in a mangled name, so print it out. */
4481 dyn_string_delete (mangled
);
4484 /* Demangle command line arguments. */
4486 /* Loop over command line arguments. */
4487 for (i
= optind
; i
< argc
; ++i
)
4490 #ifdef IN_GLIBCPP_V3
4494 /* Attempt to demangle. */
4495 #ifdef IN_GLIBCPP_V3
4496 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
4498 s
= cplus_demangle_v3 (argv
[i
], options
);
4501 /* If it worked, print the demangled name. */
4509 #ifdef IN_GLIBCPP_V3
4510 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
4512 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
4521 #endif /* STANDALONE_DEMANGLER */