1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
7 This file is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
45 #include "libiberty.h"
48 /* This code implements a demangler for the g++ V3 ABI. The ABI is
49 described on this web page:
50 http://www.codesourcery.com/cxx-abi/abi.html#mangling
52 This code was written while looking at the demangler written by
53 Alex Samuel <samuel@codesourcery.com>.
55 This code first pulls the mangled name apart into a list of
56 components, and then walks the list generating the demangled
59 /* Avoid pulling in the ctype tables for this simple usage. */
60 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
62 /* The prefix prepended by GCC to an identifier represnting the
63 anonymous namespace. */
64 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
65 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
66 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
68 /* Information we keep for operators. */
70 struct d_operator_info
76 /* Number of arguments. */
80 /* How to print the value of a builtin type. */
82 enum d_builtin_type_print
84 /* Print as (type)val. */
86 /* Print as integer. */
88 /* Print as long, with trailing `l'. */
92 /* Print in usual way, but here to detect void. */
96 /* Information we keep for a builtin type. */
98 struct d_builtin_type_info
102 /* Type name when using Java. */
103 const char *java_name
;
104 /* How to print a value of this type. */
105 enum d_builtin_type_print print
;
108 /* Component types found in mangled names. */
114 /* A qualified name. */
120 /* A template parameter. */
121 D_COMP_TEMPLATE_PARAM
,
128 /* A VTT structure. */
130 /* A construction vtable. */
131 D_COMP_CONSTRUCTION_VTABLE
,
132 /* A typeinfo structure. */
134 /* A typeinfo name. */
135 D_COMP_TYPEINFO_NAME
,
136 /* A typeinfo function. */
140 /* A virtual thunk. */
141 D_COMP_VIRTUAL_THUNK
,
142 /* A covariant thunk. */
143 D_COMP_COVARIANT_THUNK
,
146 /* A guard variable. */
148 /* A reference temporary. */
150 /* A standard substitution. */
152 /* The restrict qualifier. */
154 /* The volatile qualifier. */
156 /* The const qualifier. */
158 /* A vendor qualifier. */
159 D_COMP_VENDOR_TYPE_QUAL
,
164 /* A complex type. */
166 /* An imaginary type. */
168 /* A builtin type. */
170 /* A vendor's builtin type. */
172 /* A function type. */
173 D_COMP_FUNCTION_TYPE
,
176 /* A pointer to member type. */
178 /* An argument list. */
180 /* A template argument list. */
181 D_COMP_TEMPLATE_ARGLIST
,
184 /* An extended operator. */
185 D_COMP_EXTENDED_OPERATOR
,
188 /* A unary expression. */
190 /* A binary expression. */
192 /* Arguments to a binary expression. */
194 /* A trinary expression. */
196 /* Arguments to a trinary expression. */
203 /* A component of the mangled name. */
207 /* The type of this component. */
208 enum d_comp_type type
;
211 /* For D_COMP_NAME. */
214 /* A pointer to the name (not NULL terminated) and it's
220 /* For D_COMP_OPERATOR. */
224 const struct d_operator_info
*op
;
227 /* For D_COMP_EXTENDED_OPERATOR. */
230 /* Number of arguments. */
234 } s_extended_operator
;
236 /* For D_COMP_CTOR. */
239 enum gnu_v3_ctor_kinds kind
;
243 /* For D_COMP_DTOR. */
246 enum gnu_v3_dtor_kinds kind
;
250 /* For D_COMP_BUILTIN_TYPE. */
253 const struct d_builtin_type_info
*type
;
256 /* For D_COMP_SUB_STD. */
262 /* For D_COMP_TEMPLATE_PARAM. */
268 /* For other types. */
272 struct d_comp
*right
;
278 #define d_left(dc) ((dc)->u.s_binary.left)
279 #define d_right(dc) ((dc)->u.s_binary.right)
281 /* The information structure we pass around. */
285 /* The string we are demangling. */
287 /* The options passed to the demangler. */
289 /* The next character in the string to consider. */
291 /* The array of components. */
292 struct d_comp
*comps
;
293 /* The index of the next available component. */
295 /* The number of available component structures. */
297 /* The array of substitutions. */
298 struct d_comp
**subs
;
299 /* The index of the next substitution. */
301 /* The number of available entries in the subs array. */
303 /* The last name we saw, for constructors and destructors. */
304 struct d_comp
*last_name
;
307 #define d_peek_char(di) (*((di)->n))
308 #define d_peek_next_char(di) ((di)->n[1])
309 #define d_advance(di, i) ((di)->n += (i))
310 #define d_next_char(di) (*((di)->n++))
311 #define d_str(di) ((di)->n)
313 /* A list of templates. This is used while printing. */
315 struct d_print_template
317 /* Next template on the list. */
318 struct d_print_template
*next
;
320 const struct d_comp
*template;
323 /* A list of type modifiers. This is used while printing. */
327 /* Next modifier on the list. These are in the reverse of the order
328 in which they appeared in the mangled string. */
329 struct d_print_mod
*next
;
331 const struct d_comp
*mod
;
332 /* Whether this modifier was printed. */
336 /* We use this structure to hold information during printing. */
340 /* The options passed to the demangler. */
342 /* Buffer holding the result. */
344 /* Current length of data in buffer. */
346 /* Allocated size of buffer. */
348 /* The current list of templates, if any. */
349 struct d_print_template
*templates
;
350 /* The current list of modifiers (e.g., pointer, reference, etc.),
352 struct d_print_mod
*modifiers
;
353 /* Set to 1 if we had a memory allocation failure. */
354 int allocation_failure
;
357 #define d_print_saw_error(dpi) ((dpi)->buf == NULL)
359 #define d_append_char(dpi, c) \
362 if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
363 (dpi)->buf[(dpi)->len++] = (c); \
365 d_print_append_char ((dpi), (c)); \
369 #define d_append_buffer(dpi, s, l) \
372 if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
374 memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
378 d_print_append_buffer ((dpi), (s), (l)); \
382 #define d_append_string(dpi, s) \
385 size_t d_append_string_len = strlen (s); \
386 d_append_buffer ((dpi), (s), d_append_string_len); \
390 #ifdef CP_DEMANGLE_DEBUG
391 static void d_dump
PARAMS ((struct d_comp
*, int));
393 static struct d_comp
*d_make_empty
PARAMS ((struct d_info
*,
395 static struct d_comp
*d_make_comp
PARAMS ((struct d_info
*, enum d_comp_type
,
396 struct d_comp
*, struct d_comp
*));
397 static struct d_comp
*d_make_name
PARAMS ((struct d_info
*, const char *,
399 static struct d_comp
*d_make_builtin_type
PARAMS ((struct d_info
*,
400 const struct d_builtin_type_info
*));
401 static struct d_comp
*d_make_operator
PARAMS ((struct d_info
*,
402 const struct d_operator_info
*));
403 static struct d_comp
*d_make_extended_operator
PARAMS ((struct d_info
*,
406 static struct d_comp
*d_make_ctor
PARAMS ((struct d_info
*,
407 enum gnu_v3_ctor_kinds
,
409 static struct d_comp
*d_make_dtor
PARAMS ((struct d_info
*,
410 enum gnu_v3_dtor_kinds
,
412 static struct d_comp
*d_make_template_param
PARAMS ((struct d_info
*, long));
413 static struct d_comp
*d_make_sub
PARAMS ((struct d_info
*, const char *));
414 static struct d_comp
*d_mangled_name
PARAMS ((struct d_info
*));
415 static int has_return_type
PARAMS ((struct d_comp
*));
416 static int is_ctor_dtor_or_conversion
PARAMS ((struct d_comp
*));
417 static struct d_comp
*d_encoding
PARAMS ((struct d_info
*));
418 static struct d_comp
*d_name
PARAMS ((struct d_info
*));
419 static struct d_comp
*d_nested_name
PARAMS ((struct d_info
*));
420 static struct d_comp
*d_prefix
PARAMS ((struct d_info
*));
421 static struct d_comp
*d_unqualified_name
PARAMS ((struct d_info
*));
422 static struct d_comp
*d_source_name
PARAMS ((struct d_info
*));
423 static long d_number
PARAMS ((struct d_info
*));
424 static struct d_comp
*d_identifier
PARAMS ((struct d_info
*, int));
425 static struct d_comp
*d_operator_name
PARAMS ((struct d_info
*));
426 static struct d_comp
*d_special_name
PARAMS ((struct d_info
*));
427 static int d_call_offset
PARAMS ((struct d_info
*, int));
428 static struct d_comp
*d_ctor_dtor_name
PARAMS ((struct d_info
*));
429 static struct d_comp
*d_type
PARAMS ((struct d_info
*));
430 static struct d_comp
**d_cv_qualifiers
PARAMS ((struct d_info
*,
432 static struct d_comp
*d_function_type
PARAMS ((struct d_info
*));
433 static struct d_comp
*d_bare_function_type
PARAMS ((struct d_info
*, int));
434 static struct d_comp
*d_class_enum_type
PARAMS ((struct d_info
*));
435 static struct d_comp
*d_array_type
PARAMS ((struct d_info
*));
436 static struct d_comp
*d_pointer_to_member_type
PARAMS ((struct d_info
*));
437 static struct d_comp
*d_template_param
PARAMS ((struct d_info
*));
438 static struct d_comp
*d_template_args
PARAMS ((struct d_info
*));
439 static struct d_comp
*d_template_arg
PARAMS ((struct d_info
*));
440 static struct d_comp
*d_expression
PARAMS ((struct d_info
*));
441 static struct d_comp
*d_expr_primary
PARAMS ((struct d_info
*));
442 static struct d_comp
*d_local_name
PARAMS ((struct d_info
*));
443 static int d_discriminator
PARAMS ((struct d_info
*));
444 static int d_add_substitution
PARAMS ((struct d_info
*, struct d_comp
*));
445 static struct d_comp
*d_substitution
PARAMS ((struct d_info
*));
446 static void d_print_resize
PARAMS ((struct d_print_info
*, size_t));
447 static void d_print_append_char
PARAMS ((struct d_print_info
*, int));
448 static void d_print_append_buffer
PARAMS ((struct d_print_info
*, const char *,
450 static void d_print_error
PARAMS ((struct d_print_info
*));
451 static char *d_print
PARAMS ((int, const struct d_comp
*, size_t *));
452 static void d_print_comp
PARAMS ((struct d_print_info
*,
453 const struct d_comp
*));
454 static void d_print_identifier
PARAMS ((struct d_print_info
*, const char *,
456 static void d_print_mod_list
PARAMS ((struct d_print_info
*,
457 struct d_print_mod
*));
458 static void d_print_mod
PARAMS ((struct d_print_info
*,
459 const struct d_comp
*));
460 static void d_print_function_type
PARAMS ((struct d_print_info
*,
461 const struct d_comp
*,
462 struct d_print_mod
*));
463 static void d_print_array_type
PARAMS ((struct d_print_info
*,
464 const struct d_comp
*,
465 struct d_print_mod
*));
466 static void d_print_expr_op
PARAMS ((struct d_print_info
*,
467 const struct d_comp
*));
468 static void d_print_cast
PARAMS ((struct d_print_info
*,
469 const struct d_comp
*));
470 static int d_init_info
PARAMS ((const char *, int, size_t, struct d_info
*));
471 static char *d_demangle
PARAMS ((const char *, int, size_t *));
473 #ifdef CP_DEMANGLE_DEBUG
485 for (i
= 0; i
< indent
; ++i
)
491 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
493 case D_COMP_TEMPLATE_PARAM
:
494 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
497 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
498 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
501 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
502 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
505 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
507 case D_COMP_BUILTIN_TYPE
:
508 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
510 case D_COMP_OPERATOR
:
511 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
513 case D_COMP_EXTENDED_OPERATOR
:
514 printf ("extended operator with %d args\n",
515 dc
->u
.s_extended_operator
.args
);
516 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
519 case D_COMP_QUAL_NAME
:
520 printf ("qualified name\n");
522 case D_COMP_TYPED_NAME
:
523 printf ("typed name\n");
525 case D_COMP_TEMPLATE
:
526 printf ("template\n");
534 case D_COMP_CONSTRUCTION_VTABLE
:
535 printf ("construction vtable\n");
537 case D_COMP_TYPEINFO
:
538 printf ("typeinfo\n");
540 case D_COMP_TYPEINFO_NAME
:
541 printf ("typeinfo name\n");
543 case D_COMP_TYPEINFO_FN
:
544 printf ("typeinfo function\n");
549 case D_COMP_VIRTUAL_THUNK
:
550 printf ("virtual thunk\n");
552 case D_COMP_COVARIANT_THUNK
:
553 printf ("covariant thunk\n");
555 case D_COMP_JAVA_CLASS
:
556 printf ("java class\n");
562 printf ("reference temporary\n");
564 case D_COMP_RESTRICT
:
565 printf ("restrict\n");
567 case D_COMP_VOLATILE
:
568 printf ("volatile\n");
573 case D_COMP_VENDOR_TYPE_QUAL
:
574 printf ("vendor type qualifier\n");
577 printf ("pointer\n");
579 case D_COMP_REFERENCE
:
580 printf ("reference\n");
583 printf ("complex\n");
585 case D_COMP_IMAGINARY
:
586 printf ("imaginary\n");
588 case D_COMP_VENDOR_TYPE
:
589 printf ("vendor type\n");
591 case D_COMP_FUNCTION_TYPE
:
592 printf ("function type\n");
594 case D_COMP_ARRAY_TYPE
:
595 printf ("array type\n");
597 case D_COMP_PTRMEM_TYPE
:
598 printf ("pointer to member type\n");
601 printf ("argument list\n");
603 case D_COMP_TEMPLATE_ARGLIST
:
604 printf ("template argument list\n");
610 printf ("unary operator\n");
613 printf ("binary operator\n");
615 case D_COMP_BINARY_ARGS
:
616 printf ("binary operator arguments\n");
619 printf ("trinary operator\n");
621 case D_COMP_TRINARY_ARG1
:
622 printf ("trinary operator arguments 1\n");
624 case D_COMP_TRINARY_ARG2
:
625 printf ("trinary operator arguments 1\n");
628 printf ("literal\n");
632 d_dump (d_left (dc
), indent
+ 2);
633 d_dump (d_right (dc
), indent
+ 2);
636 #endif /* CP_DEMANGLE_DEBUG */
638 /* Add a new component. */
640 static struct d_comp
*
641 d_make_empty (di
, type
)
643 enum d_comp_type type
;
647 if (di
->next_comp
>= di
->num_comps
)
649 p
= &di
->comps
[di
->next_comp
];
655 /* Add a new generic component. */
657 static struct d_comp
*
658 d_make_comp (di
, type
, left
, right
)
660 enum d_comp_type type
;
662 struct d_comp
*right
;
666 /* We check for errors here. A typical error would be a NULL return
667 from a subroutine. We catch here, and return NULL on upward. */
670 /* These types require two parameters. */
671 case D_COMP_QUAL_NAME
:
672 case D_COMP_TYPED_NAME
:
673 case D_COMP_TEMPLATE
:
674 case D_COMP_VENDOR_TYPE_QUAL
:
675 case D_COMP_PTRMEM_TYPE
:
678 case D_COMP_BINARY_ARGS
:
680 case D_COMP_TRINARY_ARG1
:
681 case D_COMP_TRINARY_ARG2
:
683 if (left
== NULL
|| right
== NULL
)
687 /* These types only require one parameter. */
690 case D_COMP_CONSTRUCTION_VTABLE
:
691 case D_COMP_TYPEINFO
:
692 case D_COMP_TYPEINFO_NAME
:
693 case D_COMP_TYPEINFO_FN
:
695 case D_COMP_VIRTUAL_THUNK
:
696 case D_COMP_COVARIANT_THUNK
:
697 case D_COMP_JAVA_CLASS
:
701 case D_COMP_REFERENCE
:
703 case D_COMP_IMAGINARY
:
704 case D_COMP_VENDOR_TYPE
:
706 case D_COMP_TEMPLATE_ARGLIST
:
712 /* This needs a right parameter, but the left parameter can be
714 case D_COMP_ARRAY_TYPE
:
719 /* These are allowed to have no parameters--in some cases they
720 will be filled in later. */
721 case D_COMP_FUNCTION_TYPE
:
722 case D_COMP_RESTRICT
:
723 case D_COMP_VOLATILE
:
727 /* Other types should not be seen here. */
732 p
= d_make_empty (di
, type
);
735 p
->u
.s_binary
.left
= left
;
736 p
->u
.s_binary
.right
= right
;
741 /* Add a new name component. */
743 static struct d_comp
*
744 d_make_name (di
, s
, len
)
751 p
= d_make_empty (di
, D_COMP_NAME
);
755 p
->u
.s_name
.len
= len
;
760 /* Add a new builtin type component. */
762 static struct d_comp
*
763 d_make_builtin_type (di
, type
)
765 const struct d_builtin_type_info
*type
;
769 p
= d_make_empty (di
, D_COMP_BUILTIN_TYPE
);
771 p
->u
.s_builtin
.type
= type
;
775 /* Add a new operator component. */
777 static struct d_comp
*
778 d_make_operator (di
, op
)
780 const struct d_operator_info
*op
;
784 p
= d_make_empty (di
, D_COMP_OPERATOR
);
786 p
->u
.s_operator
.op
= op
;
790 /* Add a new extended operator component. */
792 static struct d_comp
*
793 d_make_extended_operator (di
, args
, name
)
800 p
= d_make_empty (di
, D_COMP_EXTENDED_OPERATOR
);
803 p
->u
.s_extended_operator
.args
= args
;
804 p
->u
.s_extended_operator
.name
= name
;
809 /* Add a new constructor component. */
811 static struct d_comp
*
812 d_make_ctor (di
, kind
, name
)
814 enum gnu_v3_ctor_kinds kind
;
819 p
= d_make_empty (di
, D_COMP_CTOR
);
822 p
->u
.s_ctor
.kind
= kind
;
823 p
->u
.s_ctor
.name
= name
;
828 /* Add a new destructor component. */
830 static struct d_comp
*
831 d_make_dtor (di
, kind
, name
)
833 enum gnu_v3_dtor_kinds kind
;
838 p
= d_make_empty (di
, D_COMP_DTOR
);
841 p
->u
.s_dtor
.kind
= kind
;
842 p
->u
.s_dtor
.name
= name
;
847 /* Add a new template parameter. */
849 static struct d_comp
*
850 d_make_template_param (di
, i
)
856 p
= d_make_empty (di
, D_COMP_TEMPLATE_PARAM
);
858 p
->u
.s_number
.number
= i
;
862 /* Add a new standard substitution component. */
864 static struct d_comp
*
865 d_make_sub (di
, name
)
871 p
= d_make_empty (di
, D_COMP_SUB_STD
);
873 p
->u
.s_string
.string
= name
;
877 /* <mangled-name> ::= _Z <encoding> */
879 static struct d_comp
*
883 if (d_next_char (di
) != '_')
885 if (d_next_char (di
) != 'Z')
887 return d_encoding (di
);
890 /* Return whether a function should have a return type. The argument
891 is the function name, which may be qualified in various ways. The
892 rules are that template functions have return types with some
893 exceptions, function types which are not part of a function name
894 mangling have return types with some exceptions, and non-template
895 function names do not have return types. The exceptions are that
896 constructors, destructors, and conversion operators do not have
909 case D_COMP_TEMPLATE
:
910 return ! is_ctor_dtor_or_conversion (d_left (dc
));
914 /* Return whether a name is a constructor, a destructor, or a
915 conversion operator. */
918 is_ctor_dtor_or_conversion (dc
)
927 case D_COMP_QUAL_NAME
:
928 return is_ctor_dtor_or_conversion (d_right (dc
));
936 /* <encoding> ::= <(function) name> <bare-function-type>
938 ::= <special-name> */
940 static struct d_comp
*
944 char peek
= d_peek_char (di
);
946 if (peek
== 'G' || peek
== 'T')
947 return d_special_name (di
);
953 peek
= d_peek_char (di
);
954 if (peek
== '\0' || peek
== 'E')
956 return d_make_comp (di
, D_COMP_TYPED_NAME
, dc
,
957 d_bare_function_type (di
, has_return_type (dc
)));
961 /* <name> ::= <nested-name>
963 ::= <unscoped-template-name> <template-args>
966 <unscoped-name> ::= <unqualified-name>
967 ::= St <unqualified-name>
969 <unscoped-template-name> ::= <unscoped-name>
973 static struct d_comp
*
977 char peek
= d_peek_char (di
);
983 return d_nested_name (di
);
986 return d_local_name (di
);
992 if (d_peek_next_char (di
) != 't')
994 dc
= d_substitution (di
);
1000 dc
= d_make_comp (di
, D_COMP_QUAL_NAME
, d_make_name (di
, "std", 3),
1001 d_unqualified_name (di
));
1005 if (d_peek_char (di
) != 'I')
1007 /* The grammar does not permit this case to occur if we
1008 called d_substitution() above (i.e., subst == 1). We
1009 don't bother to check. */
1013 /* This is <template-args>, which means that we just saw
1014 <unscoped-template-name>, which is a substitution
1015 candidate if we didn't just get it from a
1019 if (! d_add_substitution (di
, dc
))
1022 dc
= d_make_comp (di
, D_COMP_TEMPLATE
, dc
, d_template_args (di
));
1029 dc
= d_unqualified_name (di
);
1030 if (d_peek_char (di
) == 'I')
1032 /* This is <template-args>, which means that we just saw
1033 <unscoped-template-name>, which is a substitution
1035 if (! d_add_substitution (di
, dc
))
1037 dc
= d_make_comp (di
, D_COMP_TEMPLATE
, dc
, d_template_args (di
));
1043 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1044 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1047 static struct d_comp
*
1052 struct d_comp
**pret
;
1054 if (d_next_char (di
) != 'N')
1057 pret
= d_cv_qualifiers (di
, &ret
);
1061 *pret
= d_prefix (di
);
1065 if (d_next_char (di
) != 'E')
1071 /* <prefix> ::= <prefix> <unqualified-name>
1072 ::= <template-prefix> <template-args>
1073 ::= <template-param>
1077 <template-prefix> ::= <prefix> <(template) unqualified-name>
1078 ::= <template-param>
1082 static struct d_comp
*
1086 struct d_comp
*ret
= NULL
;
1091 enum d_comp_type comb_type
;
1094 peek
= d_peek_char (di
);
1098 /* The older code accepts a <local-name> here, but I don't see
1099 that in the grammar. The older code does not accept a
1100 <template-param> here. */
1102 comb_type
= D_COMP_QUAL_NAME
;
1104 || (peek
>= 'a' && peek
<= 'z')
1107 dc
= d_unqualified_name (di
);
1108 else if (peek
== 'S')
1109 dc
= d_substitution (di
);
1110 else if (peek
== 'I')
1114 comb_type
= D_COMP_TEMPLATE
;
1115 dc
= d_template_args (di
);
1117 else if (peek
== 'T')
1118 dc
= d_template_param (di
);
1119 else if (peek
== 'E')
1127 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1129 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1131 if (! d_add_substitution (di
, ret
))
1137 /* <unqualified-name> ::= <operator-name>
1138 ::= <ctor-dtor-name>
1142 static struct d_comp
*
1143 d_unqualified_name (di
)
1148 peek
= d_peek_char (di
);
1149 if (IS_DIGIT (peek
))
1150 return d_source_name (di
);
1151 else if (peek
>= 'a' && peek
<= 'z')
1152 return d_operator_name (di
);
1153 else if (peek
== 'C' || peek
== 'D')
1154 return d_ctor_dtor_name (di
);
1159 /* <source-name> ::= <(positive length) number> <identifier> */
1161 static struct d_comp
*
1168 len
= d_number (di
);
1171 ret
= d_identifier (di
, len
);
1172 di
->last_name
= ret
;
1176 /* number ::= [n] <(non-negative decimal integer)> */
1187 peek
= d_peek_char (di
);
1192 peek
= d_peek_char (di
);
1198 if (! IS_DIGIT (peek
))
1200 ret
= ret
* 10 + peek
- '0';
1202 peek
= d_peek_char (di
);
1206 /* identifier ::= <(unqualified source code identifier)> */
1208 static struct d_comp
*
1209 d_identifier (di
, len
)
1216 d_advance (di
, len
);
1218 /* Look for something which looks like a gcc encoding of an
1219 anonymous namespace, and replace it with a more user friendly
1221 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1222 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1223 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1227 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1228 if ((*s
== '.' || *s
== '_' || *s
== '$')
1230 return d_make_name (di
, "(anonymous namespace)",
1231 sizeof "(anonymous namespace)" - 1);
1234 return d_make_name (di
, name
, len
);
1237 /* operator_name ::= many different two character encodings.
1239 ::= v <digit> <source-name>
1242 static const struct d_operator_info d_operators
[] =
1253 { "da", "delete[]", 1 },
1255 { "dl", "delete", 1 },
1272 { "na", "new[]", 1 },
1291 { "st", "sizeof ", 1 },
1292 { "sz", "sizeof ", 1 }
1295 static struct d_comp
*
1296 d_operator_name (di
)
1302 c1
= d_next_char (di
);
1303 c2
= d_next_char (di
);
1304 if (c1
== 'v' && IS_DIGIT (c2
))
1305 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1306 else if (c1
== 'c' && c2
== 'v')
1307 return d_make_comp (di
, D_COMP_CAST
, d_type (di
), NULL
);
1311 int high
= sizeof (d_operators
) / sizeof (d_operators
[0]);
1316 const struct d_operator_info
*p
;
1318 i
= low
+ (high
- low
) / 2;
1319 p
= d_operators
+ i
;
1321 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1322 return d_make_operator (di
, p
);
1324 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1334 /* <special-name> ::= TV <type>
1338 ::= GV <(object) name>
1339 ::= T <call-offset> <(base) encoding>
1340 ::= Tc <call-offset> <call-offset> <(base) encoding>
1341 Also g++ extensions:
1342 ::= TC <type> <(offset) number> _ <(base) type>
1348 static struct d_comp
*
1354 c
= d_next_char (di
);
1357 switch (d_next_char (di
))
1360 return d_make_comp (di
, D_COMP_VTABLE
, d_type (di
), NULL
);
1362 return d_make_comp (di
, D_COMP_VTT
, d_type (di
), NULL
);
1364 return d_make_comp (di
, D_COMP_TYPEINFO
, d_type (di
), NULL
);
1366 return d_make_comp (di
, D_COMP_TYPEINFO_NAME
, d_type (di
), NULL
);
1369 if (! d_call_offset (di
, 'h'))
1371 return d_make_comp (di
, D_COMP_THUNK
, d_encoding (di
), NULL
);
1374 if (! d_call_offset (di
, 'v'))
1376 return d_make_comp (di
, D_COMP_VIRTUAL_THUNK
, d_encoding (di
),
1380 if (! d_call_offset (di
, '\0'))
1382 if (! d_call_offset (di
, '\0'))
1384 return d_make_comp (di
, D_COMP_COVARIANT_THUNK
, d_encoding (di
),
1389 struct d_comp
*derived_type
;
1391 struct d_comp
*base_type
;
1393 derived_type
= d_type (di
);
1394 offset
= d_number (di
);
1397 if (d_next_char (di
) != '_')
1399 base_type
= d_type (di
);
1400 /* We don't display the offset. FIXME: We should display
1401 it in verbose mode. */
1402 return d_make_comp (di
, D_COMP_CONSTRUCTION_VTABLE
, base_type
,
1407 return d_make_comp (di
, D_COMP_TYPEINFO_FN
, d_type (di
), NULL
);
1409 return d_make_comp (di
, D_COMP_JAVA_CLASS
, d_type (di
), NULL
);
1417 switch (d_next_char (di
))
1420 return d_make_comp (di
, D_COMP_GUARD
, d_name (di
), NULL
);
1423 return d_make_comp (di
, D_COMP_REFTEMP
, d_name (di
), NULL
);
1433 /* <call-offset> ::= h <nv-offset> _
1436 <nv-offset> ::= <(offset) number>
1438 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1440 The C parameter, if not '\0', is a character we just read which is
1441 the start of the <call-offset>.
1443 We don't display the offset information anywhere. FIXME: We should
1444 display it in verbose mode. */
1447 d_call_offset (di
, c
)
1452 long virtual_offset
;
1455 c
= d_next_char (di
);
1458 offset
= d_number (di
);
1461 offset
= d_number (di
);
1462 if (d_next_char (di
) != '_')
1464 virtual_offset
= d_number (di
);
1469 if (d_next_char (di
) != '_')
1475 /* <ctor-dtor-name> ::= C1
1483 static struct d_comp
*
1484 d_ctor_dtor_name (di
)
1487 switch (d_next_char (di
))
1491 enum gnu_v3_ctor_kinds kind
;
1493 switch (d_next_char (di
))
1496 kind
= gnu_v3_complete_object_ctor
;
1499 kind
= gnu_v3_base_object_ctor
;
1502 kind
= gnu_v3_complete_object_allocating_ctor
;
1507 return d_make_ctor (di
, kind
, di
->last_name
);
1512 enum gnu_v3_dtor_kinds kind
;
1514 switch (d_next_char (di
))
1517 kind
= gnu_v3_deleting_dtor
;
1520 kind
= gnu_v3_complete_object_dtor
;
1523 kind
= gnu_v3_base_object_dtor
;
1528 return d_make_dtor (di
, kind
, di
->last_name
);
1536 /* <type> ::= <builtin-type>
1538 ::= <class-enum-type>
1540 ::= <pointer-to-member-type>
1541 ::= <template-param>
1542 ::= <template-template-param> <template-args>
1544 ::= <CV-qualifiers> <type>
1549 ::= U <source-name> <type>
1551 <builtin-type> ::= various one letter codes
1555 static const struct d_builtin_type_info d_builtin_types
[26] =
1557 /* a */ { "signed char", "signed char", D_PRINT_INT
},
1558 /* b */ { "bool", "boolean", D_PRINT_BOOL
},
1559 /* c */ { "char", "byte", D_PRINT_INT
},
1560 /* d */ { "double", "double", D_PRINT_DEFAULT
},
1561 /* e */ { "long double", "long double", D_PRINT_DEFAULT
},
1562 /* f */ { "float", "float", D_PRINT_DEFAULT
},
1563 /* g */ { "__float128", "__float128", D_PRINT_DEFAULT
},
1564 /* h */ { "unsigned char", "unsigned char", D_PRINT_INT
},
1565 /* i */ { "int", "int", D_PRINT_INT
},
1566 /* j */ { "unsigned int", "unsigned", D_PRINT_INT
},
1567 /* k */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1568 /* l */ { "long", "long", D_PRINT_LONG
},
1569 /* m */ { "unsigned long", "unsigned long", D_PRINT_LONG
},
1570 /* n */ { "__int128", "__int128", D_PRINT_DEFAULT
},
1571 /* o */ { "unsigned __int128", "unsigned __int128", D_PRINT_DEFAULT
},
1572 /* p */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1573 /* q */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1574 /* r */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1575 /* s */ { "short", "short", D_PRINT_INT
},
1576 /* t */ { "unsigned short", "unsigned short", D_PRINT_INT
},
1577 /* u */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1578 /* v */ { "void", "void", D_PRINT_VOID
},
1579 /* w */ { "wchar_t", "char", D_PRINT_INT
},
1580 /* x */ { "long long", "long", D_PRINT_DEFAULT
},
1581 /* y */ { "unsigned long long", "unsigned long long", D_PRINT_DEFAULT
},
1582 /* z */ { "...", "...", D_PRINT_DEFAULT
},
1585 static struct d_comp
*
1593 /* The ABI specifies that when CV-qualifiers are used, the base type
1594 is substitutable, and the fully qualified type is substitutable,
1595 but the base type with a strict subset of the CV-qualifiers is
1596 not substitutable. The natural recursive implementation of the
1597 CV-qualifiers would cause subsets to be substitutable, so instead
1598 we pull them all off now.
1600 FIXME: The ABI specifies that vendor qualifiers are handled just
1601 like the standard CV-qualifiers with respect to subsetting and
1602 substitution, but g++ does not appear to work this way. */
1604 peek
= d_peek_char (di
);
1605 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
1607 struct d_comp
**pret
;
1609 pret
= d_cv_qualifiers (di
, &ret
);
1610 *pret
= d_type (di
);
1611 if (! d_add_substitution (di
, ret
))
1620 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1621 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
1622 case 'o': case 's': case 't':
1623 case 'v': case 'w': case 'x': case 'y': case 'z':
1624 /* FIXME: The old demangler handles Java types here. */
1625 ret
= d_make_builtin_type (di
, &d_builtin_types
[peek
- 'a']);
1632 ret
= d_make_comp (di
, D_COMP_VENDOR_TYPE
, d_source_name (di
), NULL
);
1636 ret
= d_function_type (di
);
1639 case '0': case '1': case '2': case '3': case '4':
1640 case '5': case '6': case '7': case '8': case '9':
1643 ret
= d_class_enum_type (di
);
1647 ret
= d_array_type (di
);
1651 ret
= d_pointer_to_member_type (di
);
1655 ret
= d_template_param (di
);
1656 if (d_peek_char (di
) == 'I')
1658 /* This is <template-template-param> <template-args>. The
1659 <template-template-param> part is a substitution
1661 if (! d_add_substitution (di
, ret
))
1663 ret
= d_make_comp (di
, D_COMP_TEMPLATE
, ret
, d_template_args (di
));
1668 /* If this is a special substitution, then it is the start of
1669 <class-enum-type>. */
1673 peek_next
= d_peek_next_char (di
);
1674 if (IS_DIGIT (peek_next
)
1676 || (peek_next
>= 'A' && peek_next
<= 'Z'))
1678 ret
= d_substitution (di
);
1679 /* The substituted name may have been a template name and
1680 may be followed by tepmlate args. */
1681 if (d_peek_char (di
) == 'I')
1682 ret
= d_make_comp (di
, D_COMP_TEMPLATE
, ret
,
1683 d_template_args (di
));
1689 ret
= d_class_enum_type (di
);
1690 /* If the substitution was a complete type, then it is not
1691 a new substitution candidate. However, if the
1692 substitution was followed by template arguments, then
1693 the whole thing is a substitution candidate. */
1694 if (ret
->type
== D_COMP_SUB_STD
)
1702 ret
= d_make_comp (di
, D_COMP_POINTER
, d_type (di
), NULL
);
1707 ret
= d_make_comp (di
, D_COMP_REFERENCE
, d_type (di
), NULL
);
1712 ret
= d_make_comp (di
, D_COMP_COMPLEX
, d_type (di
), NULL
);
1717 ret
= d_make_comp (di
, D_COMP_IMAGINARY
, d_type (di
), NULL
);
1722 ret
= d_source_name (di
);
1723 ret
= d_make_comp (di
, D_COMP_VENDOR_TYPE_QUAL
, d_type (di
), ret
);
1732 if (! d_add_substitution (di
, ret
))
1739 /* <CV-qualifiers> ::= [r] [V] [K] */
1741 static struct d_comp
**
1742 d_cv_qualifiers (di
, pret
)
1744 struct d_comp
**pret
;
1748 peek
= d_peek_char (di
);
1749 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
1755 t
= D_COMP_RESTRICT
;
1756 else if (peek
== 'V')
1757 t
= D_COMP_VOLATILE
;
1761 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
1764 pret
= &d_left (*pret
);
1766 peek
= d_peek_char (di
);
1772 /* <function-type> ::= F [Y] <bare-function-type> E */
1774 static struct d_comp
*
1775 d_function_type (di
)
1780 if (d_next_char (di
) != 'F')
1782 if (d_peek_char (di
) == 'Y')
1784 /* Function has C linkage. We don't print this information.
1785 FIXME: We should print it in verbose mode. */
1788 ret
= d_bare_function_type (di
, 1);
1789 if (d_next_char (di
) != 'E')
1794 /* <bare-function-type> ::= <type>+ */
1796 static struct d_comp
*
1797 d_bare_function_type (di
, has_return_type
)
1799 int has_return_type
;
1801 struct d_comp
*return_type
;
1803 struct d_comp
**ptl
;
1811 struct d_comp
*type
;
1813 peek
= d_peek_char (di
);
1814 if (peek
== '\0' || peek
== 'E')
1819 if (has_return_type
)
1822 has_return_type
= 0;
1826 *ptl
= d_make_comp (di
, D_COMP_ARGLIST
, type
, NULL
);
1827 ptl
= &d_right (*ptl
);
1831 /* There should be at least one parameter type besides the optional
1832 return type. A function which takes no arguments will have a
1833 single parameter type void. */
1837 /* If we have a single parameter type void, omit it. */
1838 if (d_right (tl
) == NULL
1839 && d_left (tl
)->type
== D_COMP_BUILTIN_TYPE
1840 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
1843 return d_make_comp (di
, D_COMP_FUNCTION_TYPE
, return_type
, tl
);
1846 /* <class-enum-type> ::= <name> */
1848 static struct d_comp
*
1849 d_class_enum_type (di
)
1855 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
1856 ::= A [<(dimension) expression>] _ <(element) type>
1859 static struct d_comp
*
1866 if (d_next_char (di
) != 'A')
1869 peek
= d_peek_char (di
);
1872 else if (IS_DIGIT (peek
))
1880 peek
= d_peek_char (di
);
1882 while (IS_DIGIT (peek
));
1883 dim
= d_make_name (di
, s
, d_str (di
) - s
);
1887 dim
= d_expression (di
);
1892 if (d_next_char (di
) != '_')
1895 return d_make_comp (di
, D_COMP_ARRAY_TYPE
, dim
, d_type (di
));
1898 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
1900 static struct d_comp
*
1901 d_pointer_to_member_type (di
)
1906 struct d_comp
**pmem
;
1908 if (d_next_char (di
) != 'M')
1913 /* The ABI specifies that any type can be a substitution source, and
1914 that M is followed by two types, and that when a CV-qualified
1915 type is seen both the base type and the CV-qualified types are
1916 substitution sources. The ABI also specifies that for a pointer
1917 to a CV-qualified member function, the qualifiers are attached to
1918 the second type. Given the grammar, a plain reading of the ABI
1919 suggests that both the CV-qualified member function and the
1920 non-qualified member function are substitution sources. However,
1921 g++ does not work that way. g++ treats only the CV-qualified
1922 member function as a substitution source. FIXME. So to work
1923 with g++, we need to pull off the CV-qualifiers here, in order to
1924 avoid calling add_substitution() in d_type(). */
1926 pmem
= d_cv_qualifiers (di
, &mem
);
1927 *pmem
= d_type (di
);
1929 return d_make_comp (di
, D_COMP_PTRMEM_TYPE
, cl
, mem
);
1932 /* <template-param> ::= T_
1933 ::= T <(parameter-2 non-negative) number> _
1936 static struct d_comp
*
1937 d_template_param (di
)
1942 if (d_next_char (di
) != 'T')
1945 if (d_peek_char (di
) == '_')
1949 param
= d_number (di
);
1955 if (d_next_char (di
) != '_')
1958 return d_make_template_param (di
, param
);
1961 /* <template-args> ::= I <template-arg>+ E */
1963 static struct d_comp
*
1964 d_template_args (di
)
1967 struct d_comp
*hold_last_name
;
1969 struct d_comp
**pal
;
1971 /* Preserve the last name we saw--don't let the template arguments
1972 clobber it, as that would give us the wrong name for a subsequent
1973 constructor or destructor. */
1974 hold_last_name
= di
->last_name
;
1976 if (d_next_char (di
) != 'I')
1985 a
= d_template_arg (di
);
1989 *pal
= d_make_comp (di
, D_COMP_TEMPLATE_ARGLIST
, a
, NULL
);
1990 pal
= &d_right (*pal
);
1992 if (d_peek_char (di
) == 'E')
1999 di
->last_name
= hold_last_name
;
2004 /* <template-arg> ::= <type>
2005 ::= X <expression> E
2009 static struct d_comp
*
2015 switch (d_peek_char (di
))
2019 ret
= d_expression (di
);
2020 if (d_next_char (di
) != 'E')
2025 return d_expr_primary (di
);
2032 /* <expression> ::= <(unary) operator-name> <expression>
2033 ::= <(binary) operator-name> <expression> <expression>
2034 ::= <(trinary) operator-name> <expression> <expression> <expression>
2036 ::= <template-param>
2037 ::= sr <type> <unqualified-name>
2038 ::= sr <type> <unqualified-name> <template-args>
2042 static struct d_comp
*
2048 peek
= d_peek_char (di
);
2050 return d_expr_primary (di
);
2051 else if (peek
== 'T')
2052 return d_template_param (di
);
2053 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2055 struct d_comp
*type
;
2056 struct d_comp
*name
;
2060 name
= d_unqualified_name (di
);
2061 if (d_peek_char (di
) != 'I')
2062 return d_make_comp (di
, D_COMP_QUAL_NAME
, type
, name
);
2064 return d_make_comp (di
, D_COMP_QUAL_NAME
, type
,
2065 d_make_comp (di
, D_COMP_TEMPLATE
, name
,
2066 d_template_args (di
)));
2073 op
= d_operator_name (di
);
2077 if (op
->type
== D_COMP_OPERATOR
2078 && strcmp (op
->u
.s_operator
.op
->code
, "st") == 0)
2079 return d_make_comp (di
, D_COMP_UNARY
, op
, d_type (di
));
2085 case D_COMP_OPERATOR
:
2086 args
= op
->u
.s_operator
.op
->args
;
2088 case D_COMP_EXTENDED_OPERATOR
:
2089 args
= op
->u
.s_extended_operator
.args
;
2099 return d_make_comp (di
, D_COMP_UNARY
, op
, d_expression (di
));
2102 struct d_comp
*left
;
2104 left
= d_expression (di
);
2105 return d_make_comp (di
, D_COMP_BINARY
, op
,
2106 d_make_comp (di
, D_COMP_BINARY_ARGS
, left
,
2107 d_expression (di
)));
2111 struct d_comp
*first
;
2112 struct d_comp
*second
;
2114 first
= d_expression (di
);
2115 second
= d_expression (di
);
2116 return d_make_comp (di
, D_COMP_TRINARY
, op
,
2117 d_make_comp (di
, D_COMP_TRINARY_ARG1
, first
,
2119 D_COMP_TRINARY_ARG2
,
2121 d_expression (di
))));
2129 /* <expr-primary> ::= L <type> <(value) number> E
2130 ::= L <type> <(value) float> E
2131 ::= L <mangled-name> E
2134 static struct d_comp
*
2140 if (d_next_char (di
) != 'L')
2142 if (d_peek_char (di
) == '_')
2143 ret
= d_mangled_name (di
);
2146 struct d_comp
*type
;
2151 /* Rather than try to interpret the literal value, we just
2152 collect it as a string. Note that it's possible to have a
2153 floating point literal here. The ABI specifies that the
2154 format of such literals is machine independent. That's fine,
2155 but what's not fine is that versions of g++ up to 3.2 with
2156 -fabi-version=1 used upper case letters in the hex constant,
2157 and dumped out gcc's internal representation. That makes it
2158 hard to tell where the constant ends, and hard to dump the
2159 constant in any readable form anyhow. We don't attempt to
2160 handle these cases. */
2163 while (d_peek_char (di
) != 'E')
2165 ret
= d_make_comp (di
, D_COMP_LITERAL
, type
,
2166 d_make_name (di
, s
, d_str (di
) - s
));
2168 if (d_next_char (di
) != 'E')
2173 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2174 ::= Z <(function) encoding> E s [<discriminator>]
2177 static struct d_comp
*
2181 struct d_comp
*function
;
2183 if (d_next_char (di
) != 'Z')
2186 function
= d_encoding (di
);
2188 if (d_next_char (di
) != 'E')
2191 if (d_peek_char (di
) == 's')
2194 if (! d_discriminator (di
))
2196 return d_make_comp (di
, D_COMP_QUAL_NAME
, function
,
2197 d_make_name (di
, "string literal",
2198 sizeof "string literal" - 1));
2202 struct d_comp
*name
;
2205 if (! d_discriminator (di
))
2207 return d_make_comp (di
, D_COMP_QUAL_NAME
, function
, name
);
2211 /* <discriminator> ::= _ <(non-negative) number>
2213 We demangle the discriminator, but we don't print it out. FIXME:
2214 We should print it out in verbose mode. */
2217 d_discriminator (di
)
2222 if (d_peek_char (di
) != '_')
2225 discrim
= d_number (di
);
2231 /* Add a new substitution. */
2234 d_add_substitution (di
, dc
)
2238 if (di
->next_sub
>= di
->num_subs
)
2240 di
->subs
[di
->next_sub
] = dc
;
2245 /* <substitution> ::= S <seq-id> _
2256 static struct d_comp
*
2262 if (d_next_char (di
) != 'S')
2265 c
= d_next_char (di
);
2266 if (c
== '_' || IS_DIGIT (c
) || (c
>= 'A' && c
<= 'Z'))
2276 id
= id
* 36 + c
- '0';
2277 else if (c
>= 'A' && c
<= 'Z')
2278 id
= id
* 36 + c
- 'A' + 10;
2281 c
= d_next_char (di
);
2288 if (id
>= di
->next_sub
)
2291 return di
->subs
[id
];
2298 return d_make_sub (di
, "std");
2300 di
->last_name
= d_make_sub (di
, "allocator");
2301 return d_make_sub (di
, "std::allocator");
2303 di
->last_name
= d_make_sub (di
, "basic_string");
2304 return d_make_sub (di
, "std::basic_string");
2306 di
->last_name
= d_make_sub (di
, "string");
2307 return d_make_sub (di
, "std::string");
2309 di
->last_name
= d_make_sub (di
, "istream");
2310 return d_make_sub (di
, "std::istream");
2312 di
->last_name
= d_make_sub (di
, "ostream");
2313 return d_make_sub (di
, "std::ostream");
2315 di
->last_name
= d_make_sub (di
, "iostream");
2316 return d_make_sub (di
, "std::iostream");
2323 /* Resize the print buffer. */
2326 d_print_resize (dpi
, add
)
2327 struct d_print_info
*dpi
;
2332 need
= dpi
->len
+ add
;
2333 while (need
> dpi
->alc
)
2338 newalc
= dpi
->alc
* 2;
2339 newbuf
= realloc (dpi
->buf
, newalc
);
2344 dpi
->allocation_failure
= 1;
2352 /* Append a character to the print buffer. */
2355 d_print_append_char (dpi
, c
)
2356 struct d_print_info
*dpi
;
2359 if (dpi
->buf
!= NULL
)
2361 if (dpi
->len
>= dpi
->alc
)
2363 d_print_resize (dpi
, 1);
2364 if (dpi
->buf
== NULL
)
2368 dpi
->buf
[dpi
->len
] = c
;
2373 /* Append a buffer to the print buffer. */
2376 d_print_append_buffer (dpi
, s
, l
)
2377 struct d_print_info
*dpi
;
2381 if (dpi
->buf
!= NULL
)
2383 if (dpi
->len
+ l
> dpi
->alc
)
2385 d_print_resize (dpi
, l
);
2386 if (dpi
->buf
== NULL
)
2390 memcpy (dpi
->buf
+ dpi
->len
, s
, l
);
2395 /* Indicate that an error occurred during printing. */
2399 struct d_print_info
*dpi
;
2405 /* Turn components into a human readable string. Returns a string
2406 allocated by malloc, or NULL on error. On success, this sets *PALC
2407 to the size of the allocated buffer. On failure, this sets *PALC
2408 to 0 for a bad parse, or to 1 for a memory allocation failure. */
2411 d_print (options
, dc
, palc
)
2413 const struct d_comp
*dc
;
2416 struct d_print_info dpi
;
2418 dpi
.options
= options
;
2421 dpi
.buf
= malloc (dpi
.alc
);
2422 if (dpi
.buf
== NULL
)
2429 dpi
.templates
= NULL
;
2430 dpi
.modifiers
= NULL
;
2432 dpi
.allocation_failure
= 0;
2434 d_print_comp (&dpi
, dc
);
2436 d_append_char (&dpi
, '\0');
2438 if (dpi
.buf
!= NULL
)
2441 *palc
= dpi
.allocation_failure
;
2446 /* Subroutine to handle components. */
2449 d_print_comp (dpi
, dc
)
2450 struct d_print_info
*dpi
;
2451 const struct d_comp
*dc
;
2455 d_print_error (dpi
);
2458 if (d_print_saw_error (dpi
))
2464 d_print_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2467 case D_COMP_QUAL_NAME
:
2468 d_print_comp (dpi
, d_left (dc
));
2469 d_append_string (dpi
, (dpi
->options
& DMGL_JAVA
) == 0 ? "::" : ".");
2470 d_print_comp (dpi
, d_right (dc
));
2473 case D_COMP_TYPED_NAME
:
2475 const struct d_comp
*typed_name
;
2476 struct d_print_mod dpm
;
2477 struct d_print_template dpt
;
2479 /* Pass the name down to the type so that it can be printed in
2480 the right place for the type. If the name has
2481 CV-qualifiers, they are really method qualifiers; pull them
2482 off now and print them after everything else. Note that we
2483 don't handle D_COMP_VENDOR_TYPE_QUAL here; it's not
2484 accepted by d_cv_qualifiers() either. */
2485 typed_name
= d_left (dc
);
2486 while (typed_name
!= NULL
2487 && (typed_name
->type
== D_COMP_RESTRICT
2488 || typed_name
->type
== D_COMP_VOLATILE
2489 || typed_name
->type
== D_COMP_CONST
))
2490 typed_name
= d_left (typed_name
);
2492 dpm
.next
= dpi
->modifiers
;
2493 dpi
->modifiers
= &dpm
;
2494 dpm
.mod
= typed_name
;
2497 /* If typed_name is a template, then it applies to the
2498 function type as well. */
2499 if (typed_name
->type
== D_COMP_TEMPLATE
)
2501 dpt
.next
= dpi
->templates
;
2502 dpi
->templates
= &dpt
;
2503 dpt
.template = typed_name
;
2506 d_print_comp (dpi
, d_right (dc
));
2508 if (typed_name
->type
== D_COMP_TEMPLATE
)
2509 dpi
->templates
= dpt
.next
;
2511 /* If the modifier didn't get printed by the type, print it
2515 d_append_char (dpi
, ' ');
2516 d_print_comp (dpi
, typed_name
);
2519 dpi
->modifiers
= dpm
.next
;
2521 /* Now print any CV-qualifiers on the type. */
2522 typed_name
= d_left (dc
);
2523 while (typed_name
!= NULL
2524 && (typed_name
->type
== D_COMP_RESTRICT
2525 || typed_name
->type
== D_COMP_VOLATILE
2526 || typed_name
->type
== D_COMP_CONST
))
2528 d_print_mod (dpi
, typed_name
);
2529 typed_name
= d_left (typed_name
);
2535 case D_COMP_TEMPLATE
:
2536 d_print_comp (dpi
, d_left (dc
));
2537 d_append_char (dpi
, '<');
2538 d_print_comp (dpi
, d_right (dc
));
2539 /* Avoid generating two consecutive '>' characters, to avoid the
2540 C++ syntactic ambiguity. */
2541 if (dpi
->buf
[dpi
->len
- 1] == '>')
2542 d_append_char (dpi
, ' ');
2543 d_append_char (dpi
, '>');
2546 case D_COMP_TEMPLATE_PARAM
:
2550 struct d_print_template
*hold_dpt
;
2552 if (dpi
->templates
== NULL
)
2554 d_print_error (dpi
);
2557 i
= dc
->u
.s_number
.number
;
2558 for (a
= d_right (dpi
->templates
->template);
2562 if (a
->type
!= D_COMP_TEMPLATE_ARGLIST
)
2564 d_print_error (dpi
);
2571 if (i
!= 0 || a
== NULL
)
2573 d_print_error (dpi
);
2577 /* While processing this parameter, we need to pop the list of
2578 templates. This is because the template parameter may
2579 itself be a reference to a parameter of an outer
2582 hold_dpt
= dpi
->templates
;
2583 dpi
->templates
= hold_dpt
->next
;
2585 d_print_comp (dpi
, d_left (a
));
2587 dpi
->templates
= hold_dpt
;
2593 d_print_comp (dpi
, dc
->u
.s_ctor
.name
);
2597 d_append_char (dpi
, '~');
2598 d_print_comp (dpi
, dc
->u
.s_dtor
.name
);
2602 d_append_string (dpi
, "vtable for ");
2603 d_print_comp (dpi
, d_left (dc
));
2607 d_append_string (dpi
, "VTT for ");
2608 d_print_comp (dpi
, d_left (dc
));
2611 case D_COMP_CONSTRUCTION_VTABLE
:
2612 d_append_string (dpi
, "construction vtable for ");
2613 d_print_comp (dpi
, d_left (dc
));
2614 d_append_string (dpi
, "-in-");
2615 d_print_comp (dpi
, d_right (dc
));
2618 case D_COMP_TYPEINFO
:
2619 d_append_string (dpi
, "typeinfo for ");
2620 d_print_comp (dpi
, d_left (dc
));
2623 case D_COMP_TYPEINFO_NAME
:
2624 d_append_string (dpi
, "typeinfo name for ");
2625 d_print_comp (dpi
, d_left (dc
));
2628 case D_COMP_TYPEINFO_FN
:
2629 d_append_string (dpi
, "typeinfo fn for ");
2630 d_print_comp (dpi
, d_left (dc
));
2634 d_append_string (dpi
, "non-virtual thunk to ");
2635 d_print_comp (dpi
, d_left (dc
));
2638 case D_COMP_VIRTUAL_THUNK
:
2639 d_append_string (dpi
, "virtual thunk to ");
2640 d_print_comp (dpi
, d_left (dc
));
2643 case D_COMP_COVARIANT_THUNK
:
2644 d_append_string (dpi
, "covariant return thunk to ");
2645 d_print_comp (dpi
, d_left (dc
));
2648 case D_COMP_JAVA_CLASS
:
2649 d_append_string (dpi
, "java Class for ");
2650 d_print_comp (dpi
, d_left (dc
));
2654 d_append_string (dpi
, "guard variable for ");
2655 d_print_comp (dpi
, d_left (dc
));
2658 case D_COMP_REFTEMP
:
2659 d_append_string (dpi
, "reference temporary for ");
2660 d_print_comp (dpi
, d_left (dc
));
2663 case D_COMP_SUB_STD
:
2664 d_append_string (dpi
, dc
->u
.s_string
.string
);
2667 case D_COMP_RESTRICT
:
2668 case D_COMP_VOLATILE
:
2670 case D_COMP_VENDOR_TYPE_QUAL
:
2671 case D_COMP_POINTER
:
2672 case D_COMP_REFERENCE
:
2673 case D_COMP_COMPLEX
:
2674 case D_COMP_IMAGINARY
:
2676 /* We keep a list of modifiers on the stack. */
2677 struct d_print_mod dpm
;
2679 dpm
.next
= dpi
->modifiers
;
2680 dpi
->modifiers
= &dpm
;
2684 d_print_comp (dpi
, d_left (dc
));
2686 /* If the modifier didn't get printed by the type, print it
2689 d_print_mod (dpi
, dc
);
2691 dpi
->modifiers
= dpm
.next
;
2696 case D_COMP_BUILTIN_TYPE
:
2697 if ((dpi
->options
& DMGL_JAVA
) == 0)
2698 d_append_string (dpi
, dc
->u
.s_builtin
.type
->name
);
2700 d_append_string (dpi
, dc
->u
.s_builtin
.type
->java_name
);
2703 case D_COMP_VENDOR_TYPE
:
2704 d_print_comp (dpi
, d_left (dc
));
2707 case D_COMP_FUNCTION_TYPE
:
2709 if (d_left (dc
) != NULL
)
2711 struct d_print_mod dpm
;
2713 /* We must pass this type down as a modifier in order to
2714 print it in the right location. */
2716 dpm
.next
= dpi
->modifiers
;
2717 dpi
->modifiers
= &dpm
;
2721 d_print_comp (dpi
, d_left (dc
));
2723 dpi
->modifiers
= dpm
.next
;
2728 d_append_char (dpi
, ' ');
2731 d_print_function_type (dpi
, dc
, dpi
->modifiers
);
2736 case D_COMP_ARRAY_TYPE
:
2738 struct d_print_mod dpm
;
2740 /* We must pass this type down as a modifier in order to print
2741 multi-dimensional arrays correctly. */
2743 dpm
.next
= dpi
->modifiers
;
2744 dpi
->modifiers
= &dpm
;
2748 d_print_comp (dpi
, d_right (dc
));
2750 dpi
->modifiers
= dpm
.next
;
2755 d_print_array_type (dpi
, dc
, dpi
->modifiers
);
2760 case D_COMP_PTRMEM_TYPE
:
2762 const struct d_comp
*target_type
;
2763 struct d_print_mod dpm
;
2765 /* Pass the name down to the type so that it can be printed in
2766 the right place for the type. If the type has
2767 CV-qualifiers, they are really method qualifiers; pull them
2768 off now and print them after everything else. */
2769 target_type
= d_right (dc
);
2770 while (target_type
!= NULL
2771 && (target_type
->type
== D_COMP_RESTRICT
2772 || target_type
->type
== D_COMP_VOLATILE
2773 || target_type
->type
== D_COMP_CONST
))
2774 target_type
= d_left (target_type
);
2776 dpm
.next
= dpi
->modifiers
;
2777 dpi
->modifiers
= &dpm
;
2781 d_print_comp (dpi
, target_type
);
2783 /* If the modifier didn't get printed by the type, print it
2787 d_append_char (dpi
, ' ');
2788 d_print_comp (dpi
, d_left (dc
));
2789 d_append_string (dpi
, "::*");
2792 dpi
->modifiers
= dpm
.next
;
2794 /* Now print any CV-qualifiers on the type. */
2795 target_type
= d_right (dc
);
2796 while (target_type
!= NULL
2797 && (target_type
->type
== D_COMP_RESTRICT
2798 || target_type
->type
== D_COMP_VOLATILE
2799 || target_type
->type
== D_COMP_CONST
))
2801 d_print_mod (dpi
, target_type
);
2802 target_type
= d_left (target_type
);
2808 case D_COMP_ARGLIST
:
2809 case D_COMP_TEMPLATE_ARGLIST
:
2810 d_print_comp (dpi
, d_left (dc
));
2811 if (d_right (dc
) != NULL
)
2813 d_append_string (dpi
, ", ");
2814 d_print_comp (dpi
, d_right (dc
));
2818 case D_COMP_OPERATOR
:
2822 d_append_string (dpi
, "operator");
2823 c
= dc
->u
.s_operator
.op
->name
[0];
2824 if (c
>= 'a' && c
<= 'z')
2825 d_append_char (dpi
, ' ');
2826 d_append_string (dpi
, dc
->u
.s_operator
.op
->name
);
2830 case D_COMP_EXTENDED_OPERATOR
:
2831 d_append_string (dpi
, "operator ");
2832 d_print_comp (dpi
, dc
->u
.s_extended_operator
.name
);
2836 d_append_string (dpi
, "operator ");
2837 d_print_cast (dpi
, dc
);
2841 if (d_left (dc
)->type
!= D_COMP_CAST
)
2842 d_print_expr_op (dpi
, d_left (dc
));
2845 d_append_string (dpi
, "((");
2846 d_print_cast (dpi
, d_left (dc
));
2847 d_append_char (dpi
, ')');
2849 d_append_char (dpi
, '(');
2850 d_print_comp (dpi
, d_right (dc
));
2851 d_append_char (dpi
, ')');
2852 if (d_left (dc
)->type
== D_COMP_CAST
)
2853 d_append_char (dpi
, ')');
2857 if (d_right (dc
)->type
!= D_COMP_BINARY_ARGS
)
2859 d_print_error (dpi
);
2862 d_append_char (dpi
, '(');
2863 d_print_comp (dpi
, d_left (d_right (dc
)));
2864 d_append_string (dpi
, ") ");
2865 d_print_expr_op (dpi
, d_left (dc
));
2866 d_append_string (dpi
, " (");
2867 d_print_comp (dpi
, d_right (d_right (dc
)));
2868 d_append_char (dpi
, ')');
2871 case D_COMP_BINARY_ARGS
:
2872 /* We should only see this as part of D_COMP_BINARY. */
2873 d_print_error (dpi
);
2876 case D_COMP_TRINARY
:
2877 if (d_right (dc
)->type
!= D_COMP_TRINARY_ARG1
2878 || d_right (d_right (dc
))->type
!= D_COMP_TRINARY_ARG2
)
2880 d_print_error (dpi
);
2883 d_append_char (dpi
, '(');
2884 d_print_comp (dpi
, d_left (d_right (dc
)));
2885 d_append_string (dpi
, ") ");
2886 d_print_expr_op (dpi
, d_left (dc
));
2887 d_append_string (dpi
, " (");
2888 d_print_comp (dpi
, d_left (d_right (d_right (dc
))));
2889 d_append_string (dpi
, ") : (");
2890 d_print_comp (dpi
, d_right (d_right (d_right (dc
))));
2891 d_append_char (dpi
, ')');
2894 case D_COMP_TRINARY_ARG1
:
2895 case D_COMP_TRINARY_ARG2
:
2896 /* We should only see these are part of D_COMP_TRINARY. */
2897 d_print_error (dpi
);
2900 case D_COMP_LITERAL
:
2901 /* For some builtin types, produce simpler output. */
2902 if (d_left (dc
)->type
== D_COMP_BUILTIN_TYPE
)
2904 switch (d_left (dc
)->u
.s_builtin
.type
->print
)
2907 if (d_right (dc
)->type
== D_COMP_NAME
)
2909 d_print_comp (dpi
, d_right (dc
));
2915 if (d_right (dc
)->type
== D_COMP_NAME
)
2917 d_print_comp (dpi
, d_right (dc
));
2918 d_append_char (dpi
, 'l');
2924 if (d_right (dc
)->type
== D_COMP_NAME
2925 && d_right (dc
)->u
.s_name
.len
== 1)
2927 switch (d_right (dc
)->u
.s_name
.s
[0])
2930 d_append_string (dpi
, "false");
2933 d_append_string (dpi
, "true");
2946 d_append_char (dpi
, '(');
2947 d_print_comp (dpi
, d_left (dc
));
2948 d_append_char (dpi
, ')');
2949 d_print_comp (dpi
, d_right (dc
));
2953 d_print_error (dpi
);
2958 /* Print an identifier. */
2961 d_print_identifier (dpi
, name
, len
)
2962 struct d_print_info
*dpi
;
2966 if ((dpi
->options
& DMGL_JAVA
) == 0)
2967 d_append_buffer (dpi
, name
, len
);
2973 /* For Java we try to handle encoded extended Unicode
2974 characters. The C++ ABI doesn't mention Unicode encoding, so
2975 we don't it for C++. Characters are encoded as
2978 for (p
= name
; p
< end
; ++p
)
2989 for (q
= p
+ 3; q
< end
; ++q
)
2993 if (*q
>= '0' && *q
<= '9')
2995 else if (*q
>= 'A' && *q
<= 'F')
2996 dig
= *q
- 'A' + 10;
2997 else if (*q
>= 'a' && *q
<= 'f')
2998 dig
= *q
- 'a' + 10;
3004 /* If the Unicode character is larger than 256, we don't
3005 try to deal with it here. FIXME. */
3006 if (q
< end
&& *q
== '_' && c
< 256)
3008 d_append_char (dpi
, c
);
3014 d_append_char (dpi
, *p
);
3019 /* Print a list of modifiers. */
3022 d_print_mod_list (dpi
, mods
)
3023 struct d_print_info
*dpi
;
3024 struct d_print_mod
*mods
;
3026 if (mods
== NULL
|| mods
->printed
|| d_print_saw_error (dpi
))
3029 if (mods
->mod
->type
== D_COMP_FUNCTION_TYPE
)
3032 d_print_function_type (dpi
, mods
->mod
, mods
->next
);
3035 else if (mods
->mod
->type
== D_COMP_ARRAY_TYPE
)
3038 d_print_array_type (dpi
, mods
->mod
, mods
->next
);
3044 d_print_mod (dpi
, mods
->mod
);
3046 d_print_mod_list (dpi
, mods
->next
);
3049 /* Print a modifier. */
3052 d_print_mod (dpi
, mod
)
3053 struct d_print_info
*dpi
;
3054 const struct d_comp
*mod
;
3058 case D_COMP_RESTRICT
:
3059 d_append_string (dpi
, " restrict");
3061 case D_COMP_VOLATILE
:
3062 d_append_string (dpi
, " volatile");
3065 d_append_string (dpi
, " const");
3067 case D_COMP_VENDOR_TYPE_QUAL
:
3068 d_append_char (dpi
, ' ');
3069 d_print_comp (dpi
, d_right (mod
));
3071 case D_COMP_POINTER
:
3072 /* There is no pointer symbol in Java. */
3073 if ((dpi
->options
& DMGL_JAVA
) == 0)
3074 d_append_char (dpi
, '*');
3076 case D_COMP_REFERENCE
:
3077 d_append_char (dpi
, '&');
3079 case D_COMP_COMPLEX
:
3080 d_append_string (dpi
, "complex ");
3082 case D_COMP_IMAGINARY
:
3083 d_append_string (dpi
, "imaginary ");
3085 case D_COMP_PTRMEM_TYPE
:
3086 if (dpi
->buf
[dpi
->len
- 1] != '(')
3087 d_append_char (dpi
, ' ');
3088 d_print_comp (dpi
, d_left (mod
));
3089 d_append_string (dpi
, "::*");
3091 case D_COMP_TYPED_NAME
:
3092 d_print_comp (dpi
, d_left (mod
));
3095 /* Otherwise, we have something that won't go back on the
3096 modifier stack, so we can just print it. */
3097 d_print_comp (dpi
, mod
);
3102 /* Print a function type, except for the return type. */
3105 d_print_function_type (dpi
, dc
, mods
)
3106 struct d_print_info
*dpi
;
3107 const struct d_comp
*dc
;
3108 struct d_print_mod
*mods
;
3114 struct d_print_mod
*p
;
3118 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3124 switch (p
->mod
->type
)
3126 case D_COMP_RESTRICT
:
3127 case D_COMP_VOLATILE
:
3129 case D_COMP_VENDOR_TYPE_QUAL
:
3130 case D_COMP_POINTER
:
3131 case D_COMP_REFERENCE
:
3132 case D_COMP_COMPLEX
:
3133 case D_COMP_IMAGINARY
:
3134 case D_COMP_PTRMEM_TYPE
:
3144 if (d_left (dc
) != NULL
&& ! saw_mod
)
3148 d_append_char (dpi
, '(');
3150 d_print_mod_list (dpi
, mods
);
3153 d_append_char (dpi
, ')');
3156 d_append_char (dpi
, '(');
3158 if (d_right (dc
) != NULL
)
3159 d_print_comp (dpi
, d_right (dc
));
3161 d_append_char (dpi
, ')');
3164 /* Print an array type, except for the element type. */
3167 d_print_array_type (dpi
, dc
, mods
)
3168 struct d_print_info
*dpi
;
3169 const struct d_comp
*dc
;
3170 struct d_print_mod
*mods
;
3178 struct d_print_mod
*p
;
3181 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3186 if (p
->mod
->type
== D_COMP_ARRAY_TYPE
)
3200 d_append_string (dpi
, " (");
3202 d_print_mod_list (dpi
, mods
);
3205 d_append_char (dpi
, ')');
3209 d_append_char (dpi
, ' ');
3211 d_append_char (dpi
, '[');
3213 if (d_left (dc
) != NULL
)
3214 d_print_comp (dpi
, d_left (dc
));
3216 d_append_char (dpi
, ']');
3219 /* Print an operator in an expression. */
3222 d_print_expr_op (dpi
, dc
)
3223 struct d_print_info
*dpi
;
3224 const struct d_comp
*dc
;
3226 if (dc
->type
== D_COMP_OPERATOR
)
3227 d_append_string (dpi
, dc
->u
.s_operator
.op
->name
);
3229 d_print_comp (dpi
, dc
);
3235 d_print_cast (dpi
, dc
)
3236 struct d_print_info
*dpi
;
3237 const struct d_comp
*dc
;
3239 if (d_left (dc
)->type
!= D_COMP_TEMPLATE
)
3240 d_print_comp (dpi
, d_left (dc
));
3243 struct d_print_template dpt
;
3245 /* It appears that for a templated cast operator, we need to put
3246 the template parameters in scope for the operator name, but
3247 not for the parameters. The effect is that we need to handle
3248 the template printing here. FIXME: Verify this. */
3250 dpt
.next
= dpi
->templates
;
3251 dpi
->templates
= &dpt
;
3252 dpt
.template = d_left (dc
);
3254 d_print_comp (dpi
, d_left (d_left (dc
)));
3256 dpi
->templates
= dpt
.next
;
3258 d_append_char (dpi
, '<');
3259 d_print_comp (dpi
, d_right (d_left (dc
)));
3260 /* Avoid generating two consecutive '>' characters, to avoid
3261 the C++ syntactic ambiguity. */
3262 if (dpi
->buf
[dpi
->len
- 1] == '>')
3263 d_append_char (dpi
, ' ');
3264 d_append_char (dpi
, '>');
3268 /* Initialize the information structure we use to pass around
3272 d_init_info (mangled
, options
, len
, di
)
3273 const char *mangled
;
3279 di
->options
= options
;
3283 /* We can not need more components than twice the number of chars in
3284 the mangled string. Most components correspond directly to
3285 chars, but the ARGLIST types are exceptions. */
3286 di
->num_comps
= 2 * len
;
3287 di
->comps
= (struct d_comp
*) malloc (di
->num_comps
3288 * sizeof (struct d_comp
));
3291 /* Similarly, we can not need more substitutions than there are
3292 chars in the mangled string divided by 2, since it takes at least
3293 two chars to refer to a substitution. */
3294 di
->num_subs
= (len
+ 1) / 2;
3295 di
->subs
= (struct d_comp
**) malloc (di
->num_subs
3296 * sizeof (struct d_comp
*));
3299 di
->last_name
= NULL
;
3301 if (di
->comps
== NULL
|| di
->subs
== NULL
)
3303 if (di
->comps
!= NULL
)
3305 if (di
->subs
!= NULL
)
3313 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
3314 name, return a buffer allocated with malloc holding the demangled
3315 name. OPTIONS is the usual libiberty demangler options. On
3316 success, this sets *PALC to the allocated size of the returned
3317 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
3318 a memory allocation failure. On failure, this returns NULL. */
3321 d_demangle (mangled
, options
, palc
)
3322 const char* mangled
;
3334 len
= strlen (mangled
);
3336 if (mangled
[0] == '_' && mangled
[1] == 'Z')
3338 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
3339 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
3340 && (mangled
[9] == 'D' || mangled
[9] == 'I')
3341 && mangled
[10] == '_')
3345 r
= malloc (40 + len
- 11);
3350 if (mangled
[9] == 'I')
3351 strcpy (r
, "global constructors keyed to ");
3353 strcpy (r
, "global destructors keyed to ");
3354 strcat (r
, mangled
+ 11);
3360 if ((options
& DMGL_TYPES
) == 0)
3365 if (! d_init_info (mangled
, options
, len
, &di
))
3372 dc
= d_mangled_name (&di
);
3376 #ifdef CP_DEMANGLE_DEBUG
3378 printf ("failed demangling\n");
3388 ret
= d_print (options
, dc
, palc
);
3395 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
3397 extern char *__cxa_demangle
PARAMS ((const char *, char *, size_t *, int *));
3399 /* ia64 ABI-mandated entry point in the C++ runtime library for
3400 performing demangling. MANGLED_NAME is a NUL-terminated character
3401 string containing the name to be demangled.
3403 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
3404 *LENGTH bytes, into which the demangled name is stored. If
3405 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
3406 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
3407 is placed in a region of memory allocated with malloc.
3409 If LENGTH is non-NULL, the length of the buffer conaining the
3410 demangled name, is placed in *LENGTH.
3412 The return value is a pointer to the start of the NUL-terminated
3413 demangled name, or NULL if the demangling fails. The caller is
3414 responsible for deallocating this memory using free.
3416 *STATUS is set to one of the following values:
3417 0: The demangling operation succeeded.
3418 -1: A memory allocation failure occurred.
3419 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
3420 -3: One of the arguments is invalid.
3422 The demangling is performed using the C++ ABI mangling rules, with
3426 __cxa_demangle (mangled_name
, output_buffer
, length
, status
)
3427 const char *mangled_name
;
3428 char *output_buffer
;
3438 if (mangled_name
== NULL
)
3444 if (output_buffer
!= NULL
&& length
== NULL
)
3450 demangled
= d_demangle (mangled_name
, DMGL_TYPES
, &alc
);
3452 if (demangled
== NULL
)
3461 if (output_buffer
== NULL
)
3468 if (strlen (demangled
) < *length
)
3470 strcpy (output_buffer
, demangled
);
3472 demangled
= output_buffer
;
3476 free (output_buffer
);
3486 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
3488 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
3489 mangled name, return a buffer allocated with malloc holding the
3490 demangled name. Otherwise, return NULL. */
3493 cplus_demangle_v3 (mangled
, options
)
3494 const char* mangled
;
3499 return d_demangle (mangled
, options
, &alc
);
3502 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
3503 conventions, but the output formatting is a little different.
3504 This instructs the C++ demangler not to emit pointer characters ("*"), and
3505 to use Java's namespace separator symbol ("." instead of "::"). It then
3506 does an additional pass over the demangled output to replace instances
3507 of JArray<TYPE> with TYPE[]. */
3510 java_demangle_v3 (mangled
)
3511 const char* mangled
;
3519 demangled
= d_demangle (mangled
, DMGL_JAVA
, &alc
);
3521 if (demangled
== NULL
)
3527 while (*from
!= '\0')
3529 if (strncmp (from
, "JArray<", 7) == 0)
3534 else if (nesting
> 0 && *from
== '>')
3536 while (to
> demangled
&& to
[-1] == ' ')
3552 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
3554 #ifndef IN_GLIBCPP_V3
3556 /* Demangle a string in order to find out whether it is a constructor
3557 or destructor. Return non-zero on success. Set *CTOR_KIND and
3558 *DTOR_KIND appropriately. */
3561 is_ctor_or_dtor (mangled
, ctor_kind
, dtor_kind
)
3562 const char *mangled
;
3563 enum gnu_v3_ctor_kinds
*ctor_kind
;
3564 enum gnu_v3_dtor_kinds
*dtor_kind
;
3569 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
3570 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
3572 if (! d_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
))
3575 dc
= d_mangled_name (&di
);
3586 case D_COMP_TYPED_NAME
:
3587 case D_COMP_TEMPLATE
:
3588 case D_COMP_RESTRICT
:
3589 case D_COMP_VOLATILE
:
3591 case D_COMP_VENDOR_TYPE_QUAL
:
3594 case D_COMP_QUAL_NAME
:
3598 *ctor_kind
= dc
->u
.s_ctor
.kind
;
3601 *dtor_kind
= dc
->u
.s_dtor
.kind
;
3609 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
3610 name. A non-zero return indicates the type of constructor. */
3612 enum gnu_v3_ctor_kinds
3613 is_gnu_v3_mangled_ctor (name
)
3616 enum gnu_v3_ctor_kinds ctor_kind
;
3617 enum gnu_v3_dtor_kinds dtor_kind
;
3619 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
3620 return (enum gnu_v3_ctor_kinds
) 0;
3625 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
3626 name. A non-zero return indicates the type of destructor. */
3628 enum gnu_v3_dtor_kinds
3629 is_gnu_v3_mangled_dtor (name
)
3632 enum gnu_v3_ctor_kinds ctor_kind
;
3633 enum gnu_v3_dtor_kinds dtor_kind
;
3635 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
3636 return (enum gnu_v3_dtor_kinds
) 0;
3640 #endif /* IN_GLIBCPP_V3 */
3642 #ifdef STANDALONE_DEMANGLER
3645 #include "dyn-string.h"
3647 static void print_usage
PARAMS ((FILE* fp
, int exit_value
));
3649 #define IS_ALPHA(CHAR) \
3650 (((CHAR) >= 'a' && (CHAR) <= 'z') \
3651 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
3653 /* Non-zero if CHAR is a character than can occur in a mangled name. */
3654 #define is_mangled_char(CHAR) \
3655 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
3656 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
3658 /* The name of this program, as invoked. */
3659 const char* program_name
;
3661 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
3664 print_usage (fp
, exit_value
)
3668 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
3669 fprintf (fp
, "Options:\n");
3670 fprintf (fp
, " -h,--help Display this message.\n");
3671 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
3672 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
3677 /* Option specification for getopt_long. */
3678 static const struct option long_options
[] =
3680 { "help", no_argument
, NULL
, 'h' },
3681 { "verbose", no_argument
, NULL
, 'v' },
3682 { NULL
, no_argument
, NULL
, 0 },
3685 /* Main entry for a demangling filter executable. It will demangle
3686 its command line arguments, if any. If none are provided, it will
3687 filter stdin to stdout, replacing any recognized mangled C++ names
3688 with their demangled equivalents. */
3697 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
3699 /* Use the program name of this program, as invoked. */
3700 program_name
= argv
[0];
3702 /* Parse options. */
3705 opt_char
= getopt_long (argc
, argv
, "hv", long_options
, NULL
);
3708 case '?': /* Unrecognized option. */
3709 print_usage (stderr
, 1);
3713 print_usage (stdout
, 0);
3717 options
|= DMGL_VERBOSE
;
3721 while (opt_char
!= -1);
3724 /* No command line arguments were provided. Filter stdin. */
3726 dyn_string_t mangled
= dyn_string_new (3);
3729 /* Read all of input. */
3730 while (!feof (stdin
))
3734 /* Pile characters into mangled until we hit one that can't
3735 occur in a mangled name. */
3737 while (!feof (stdin
) && is_mangled_char (c
))
3739 dyn_string_append_char (mangled
, c
);
3745 if (dyn_string_length (mangled
) > 0)
3747 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
3756 /* It might not have been a mangled name. Print the
3758 fputs (dyn_string_buf (mangled
), stdout
);
3761 dyn_string_clear (mangled
);
3764 /* If we haven't hit EOF yet, we've read one character that
3765 can't occur in a mangled name, so print it out. */
3770 dyn_string_delete (mangled
);
3773 /* Demangle command line arguments. */
3775 /* Loop over command line arguments. */
3776 for (i
= optind
; i
< argc
; ++i
)
3780 /* Attempt to demangle. */
3781 s
= cplus_demangle_v3 (argv
[i
], options
);
3783 /* If it worked, print the demangled name. */
3790 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
3797 #endif /* STANDALONE_DEMANGLER */