1 /* Demangler for GNU C++
2 Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 Free Software Foundation, Inc.
4 Written by James Clark (jjc@jclark.uucp)
5 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
6 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
8 This file is part of the libiberty library.
9 Libiberty is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Library General Public
11 License as published by the Free Software Foundation; either
12 version 2 of the License, or (at your option) any later version.
14 Libiberty is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Library General Public License for more details.
19 You should have received a copy of the GNU Library General Public
20 License along with libiberty; see the file COPYING.LIB. If
21 not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
26 This file imports xmalloc and xrealloc, which are like malloc and
27 realloc except that they generate a fatal error if there is no
30 /* This file lives in both GCC and libiberty. When making changes, please
31 try not to break either. */
37 #include "safe-ctype.h"
39 #include <sys/types.h>
51 #undef CURRENT_DEMANGLING_STYLE
52 #define CURRENT_DEMANGLING_STYLE work->options
54 #include "libiberty.h"
56 static char *ada_demangle
PARAMS ((const char *, int));
58 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
60 /* A value at least one greater than the maximum number of characters
61 that will be output when using the `%d' format with `printf'. */
62 #define INTBUF_SIZE 32
64 extern void fancy_abort
PARAMS ((void)) ATTRIBUTE_NORETURN
;
66 /* In order to allow a single demangler executable to demangle strings
67 using various common values of CPLUS_MARKER, as well as any specific
68 one set at compile time, we maintain a string containing all the
69 commonly used ones, and check to see if the marker we are looking for
70 is in that string. CPLUS_MARKER is usually '$' on systems where the
71 assembler can deal with that. Where the assembler can't, it's usually
72 '.' (but on many systems '.' is used for other things). We put the
73 current defined CPLUS_MARKER first (which defaults to '$'), followed
74 by the next most common value, followed by an explicit '$' in case
75 the value of CPLUS_MARKER is not '$'.
77 We could avoid this if we could just get g++ to tell us what the actual
78 cplus marker character is as part of the debug information, perhaps by
79 ensuring that it is the character that terminates the gcc<n>_compiled
80 marker symbol (FIXME). */
82 #if !defined (CPLUS_MARKER)
83 #define CPLUS_MARKER '$'
86 enum demangling_styles current_demangling_style
= auto_demangling
;
88 static char cplus_markers
[] = { CPLUS_MARKER
, '.', '$', '\0' };
90 static char char_str
[2] = { '\000', '\000' };
93 set_cplus_marker_for_demangling (ch
)
96 cplus_markers
[0] = ch
;
99 typedef struct string
/* Beware: these aren't required to be */
100 { /* '\0' terminated. */
101 char *b
; /* pointer to start of string */
102 char *p
; /* pointer after last character */
103 char *e
; /* pointer after end of allocated space */
106 /* Stuff that is shared between sub-routines.
107 Using a shared structure allows cplus_demangle to be reentrant. */
123 int static_type
; /* A static member function */
124 int temp_start
; /* index in demangled to start of template args */
125 int type_quals
; /* The type qualifiers. */
126 int dllimported
; /* Symbol imported from a PE DLL */
127 char **tmpl_argvec
; /* Template function arguments. */
128 int ntmpl_args
; /* The number of template function arguments. */
129 int forgetting_types
; /* Nonzero if we are not remembering the types
131 string
* previous_argument
; /* The last function argument demangled. */
132 int nrepeats
; /* The number of times to repeat the previous
136 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
137 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
139 static const struct optable
141 const char *const in
;
142 const char *const out
;
145 {"nw", " new", DMGL_ANSI
}, /* new (1.92, ansi) */
146 {"dl", " delete", DMGL_ANSI
}, /* new (1.92, ansi) */
147 {"new", " new", 0}, /* old (1.91, and 1.x) */
148 {"delete", " delete", 0}, /* old (1.91, and 1.x) */
149 {"vn", " new []", DMGL_ANSI
}, /* GNU, pending ansi */
150 {"vd", " delete []", DMGL_ANSI
}, /* GNU, pending ansi */
151 {"as", "=", DMGL_ANSI
}, /* ansi */
152 {"ne", "!=", DMGL_ANSI
}, /* old, ansi */
153 {"eq", "==", DMGL_ANSI
}, /* old, ansi */
154 {"ge", ">=", DMGL_ANSI
}, /* old, ansi */
155 {"gt", ">", DMGL_ANSI
}, /* old, ansi */
156 {"le", "<=", DMGL_ANSI
}, /* old, ansi */
157 {"lt", "<", DMGL_ANSI
}, /* old, ansi */
158 {"plus", "+", 0}, /* old */
159 {"pl", "+", DMGL_ANSI
}, /* ansi */
160 {"apl", "+=", DMGL_ANSI
}, /* ansi */
161 {"minus", "-", 0}, /* old */
162 {"mi", "-", DMGL_ANSI
}, /* ansi */
163 {"ami", "-=", DMGL_ANSI
}, /* ansi */
164 {"mult", "*", 0}, /* old */
165 {"ml", "*", DMGL_ANSI
}, /* ansi */
166 {"amu", "*=", DMGL_ANSI
}, /* ansi (ARM/Lucid) */
167 {"aml", "*=", DMGL_ANSI
}, /* ansi (GNU/g++) */
168 {"convert", "+", 0}, /* old (unary +) */
169 {"negate", "-", 0}, /* old (unary -) */
170 {"trunc_mod", "%", 0}, /* old */
171 {"md", "%", DMGL_ANSI
}, /* ansi */
172 {"amd", "%=", DMGL_ANSI
}, /* ansi */
173 {"trunc_div", "/", 0}, /* old */
174 {"dv", "/", DMGL_ANSI
}, /* ansi */
175 {"adv", "/=", DMGL_ANSI
}, /* ansi */
176 {"truth_andif", "&&", 0}, /* old */
177 {"aa", "&&", DMGL_ANSI
}, /* ansi */
178 {"truth_orif", "||", 0}, /* old */
179 {"oo", "||", DMGL_ANSI
}, /* ansi */
180 {"truth_not", "!", 0}, /* old */
181 {"nt", "!", DMGL_ANSI
}, /* ansi */
182 {"postincrement","++", 0}, /* old */
183 {"pp", "++", DMGL_ANSI
}, /* ansi */
184 {"postdecrement","--", 0}, /* old */
185 {"mm", "--", DMGL_ANSI
}, /* ansi */
186 {"bit_ior", "|", 0}, /* old */
187 {"or", "|", DMGL_ANSI
}, /* ansi */
188 {"aor", "|=", DMGL_ANSI
}, /* ansi */
189 {"bit_xor", "^", 0}, /* old */
190 {"er", "^", DMGL_ANSI
}, /* ansi */
191 {"aer", "^=", DMGL_ANSI
}, /* ansi */
192 {"bit_and", "&", 0}, /* old */
193 {"ad", "&", DMGL_ANSI
}, /* ansi */
194 {"aad", "&=", DMGL_ANSI
}, /* ansi */
195 {"bit_not", "~", 0}, /* old */
196 {"co", "~", DMGL_ANSI
}, /* ansi */
197 {"call", "()", 0}, /* old */
198 {"cl", "()", DMGL_ANSI
}, /* ansi */
199 {"alshift", "<<", 0}, /* old */
200 {"ls", "<<", DMGL_ANSI
}, /* ansi */
201 {"als", "<<=", DMGL_ANSI
}, /* ansi */
202 {"arshift", ">>", 0}, /* old */
203 {"rs", ">>", DMGL_ANSI
}, /* ansi */
204 {"ars", ">>=", DMGL_ANSI
}, /* ansi */
205 {"component", "->", 0}, /* old */
206 {"pt", "->", DMGL_ANSI
}, /* ansi; Lucid C++ form */
207 {"rf", "->", DMGL_ANSI
}, /* ansi; ARM/GNU form */
208 {"indirect", "*", 0}, /* old */
209 {"method_call", "->()", 0}, /* old */
210 {"addr", "&", 0}, /* old (unary &) */
211 {"array", "[]", 0}, /* old */
212 {"vc", "[]", DMGL_ANSI
}, /* ansi */
213 {"compound", ", ", 0}, /* old */
214 {"cm", ", ", DMGL_ANSI
}, /* ansi */
215 {"cond", "?:", 0}, /* old */
216 {"cn", "?:", DMGL_ANSI
}, /* pseudo-ansi */
217 {"max", ">?", 0}, /* old */
218 {"mx", ">?", DMGL_ANSI
}, /* pseudo-ansi */
219 {"min", "<?", 0}, /* old */
220 {"mn", "<?", DMGL_ANSI
}, /* pseudo-ansi */
221 {"nop", "", 0}, /* old (for operator=) */
222 {"rm", "->*", DMGL_ANSI
}, /* ansi */
223 {"sz", "sizeof ", DMGL_ANSI
} /* pseudo-ansi */
226 /* These values are used to indicate the various type varieties.
227 They are all non-zero so that they can be used as `success'
229 typedef enum type_kind_t
240 const struct demangler_engine libiberty_demanglers
[] =
243 NO_DEMANGLING_STYLE_STRING
,
245 "Demangling disabled"
249 AUTO_DEMANGLING_STYLE_STRING
,
251 "Automatic selection based on executable"
255 GNU_DEMANGLING_STYLE_STRING
,
257 "GNU (g++) style demangling"
261 LUCID_DEMANGLING_STYLE_STRING
,
263 "Lucid (lcc) style demangling"
267 ARM_DEMANGLING_STYLE_STRING
,
269 "ARM style demangling"
273 HP_DEMANGLING_STYLE_STRING
,
275 "HP (aCC) style demangling"
279 EDG_DEMANGLING_STYLE_STRING
,
281 "EDG style demangling"
285 GNU_V3_DEMANGLING_STYLE_STRING
,
287 "GNU (g++) V3 ABI-style demangling"
291 JAVA_DEMANGLING_STYLE_STRING
,
293 "Java style demangling"
297 GNAT_DEMANGLING_STYLE_STRING
,
299 "GNAT style demangling"
303 NULL
, unknown_demangling
, NULL
307 #define STRING_EMPTY(str) ((str) -> b == (str) -> p)
308 #define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
309 string_prepend(str, " ");}
310 #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
311 string_append(str, " ");}
312 #define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
314 /* The scope separator appropriate for the language being demangled. */
316 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
318 #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
319 #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
321 /* Prototypes for local functions */
324 delete_work_stuff
PARAMS ((struct work_stuff
*));
327 delete_non_B_K_work_stuff
PARAMS ((struct work_stuff
*));
330 mop_up
PARAMS ((struct work_stuff
*, string
*, int));
333 squangle_mop_up
PARAMS ((struct work_stuff
*));
336 work_stuff_copy_to_from
PARAMS ((struct work_stuff
*, struct work_stuff
*));
340 demangle_method_args
PARAMS ((struct work_stuff
*, const char **, string
*));
344 internal_cplus_demangle
PARAMS ((struct work_stuff
*, const char *));
347 demangle_template_template_parm
PARAMS ((struct work_stuff
*work
,
348 const char **, string
*));
351 demangle_template
PARAMS ((struct work_stuff
*work
, const char **, string
*,
352 string
*, int, int));
355 arm_pt
PARAMS ((struct work_stuff
*, const char *, int, const char **,
359 demangle_class_name
PARAMS ((struct work_stuff
*, const char **, string
*));
362 demangle_qualified
PARAMS ((struct work_stuff
*, const char **, string
*,
366 demangle_class
PARAMS ((struct work_stuff
*, const char **, string
*));
369 demangle_fund_type
PARAMS ((struct work_stuff
*, const char **, string
*));
372 demangle_signature
PARAMS ((struct work_stuff
*, const char **, string
*));
375 demangle_prefix
PARAMS ((struct work_stuff
*, const char **, string
*));
378 gnu_special
PARAMS ((struct work_stuff
*, const char **, string
*));
381 arm_special
PARAMS ((const char **, string
*));
384 string_need
PARAMS ((string
*, int));
387 string_delete
PARAMS ((string
*));
390 string_init
PARAMS ((string
*));
393 string_clear
PARAMS ((string
*));
397 string_empty
PARAMS ((string
*));
401 string_append
PARAMS ((string
*, const char *));
404 string_appends
PARAMS ((string
*, string
*));
407 string_appendn
PARAMS ((string
*, const char *, int));
410 string_prepend
PARAMS ((string
*, const char *));
413 string_prependn
PARAMS ((string
*, const char *, int));
416 string_append_template_idx
PARAMS ((string
*, int));
419 get_count
PARAMS ((const char **, int *));
422 consume_count
PARAMS ((const char **));
425 consume_count_with_underscores
PARAMS ((const char**));
428 demangle_args
PARAMS ((struct work_stuff
*, const char **, string
*));
431 demangle_nested_args
PARAMS ((struct work_stuff
*, const char**, string
*));
434 do_type
PARAMS ((struct work_stuff
*, const char **, string
*));
437 do_arg
PARAMS ((struct work_stuff
*, const char **, string
*));
440 demangle_function_name
PARAMS ((struct work_stuff
*, const char **, string
*,
444 iterate_demangle_function
PARAMS ((struct work_stuff
*,
445 const char **, string
*, const char *));
448 remember_type
PARAMS ((struct work_stuff
*, const char *, int));
451 remember_Btype
PARAMS ((struct work_stuff
*, const char *, int, int));
454 register_Btype
PARAMS ((struct work_stuff
*));
457 remember_Ktype
PARAMS ((struct work_stuff
*, const char *, int));
460 forget_types
PARAMS ((struct work_stuff
*));
463 forget_B_and_K_types
PARAMS ((struct work_stuff
*));
466 string_prepends
PARAMS ((string
*, string
*));
469 demangle_template_value_parm
PARAMS ((struct work_stuff
*, const char**,
470 string
*, type_kind_t
));
473 do_hpacc_template_const_value
PARAMS ((struct work_stuff
*, const char **, string
*));
476 do_hpacc_template_literal
PARAMS ((struct work_stuff
*, const char **, string
*));
479 snarf_numeric_literal
PARAMS ((const char **, string
*));
481 /* There is a TYPE_QUAL value for each type qualifier. They can be
482 combined by bitwise-or to form the complete set of qualifiers for a
485 #define TYPE_UNQUALIFIED 0x0
486 #define TYPE_QUAL_CONST 0x1
487 #define TYPE_QUAL_VOLATILE 0x2
488 #define TYPE_QUAL_RESTRICT 0x4
491 code_for_qualifier
PARAMS ((int));
494 qualifier_string
PARAMS ((int));
497 demangle_qualifier
PARAMS ((int));
500 demangle_expression
PARAMS ((struct work_stuff
*, const char **, string
*,
504 demangle_integral_value
PARAMS ((struct work_stuff
*, const char **,
508 demangle_real_value
PARAMS ((struct work_stuff
*, const char **, string
*));
511 demangle_arm_hp_template
PARAMS ((struct work_stuff
*, const char **, int,
515 recursively_demangle
PARAMS ((struct work_stuff
*, const char **, string
*,
519 grow_vect
PARAMS ((void **, size_t *, size_t, int));
521 /* Translate count to integer, consuming tokens in the process.
522 Conversion terminates on the first non-digit character.
524 Trying to consume something that isn't a count results in no
525 consumption of input and a return of -1.
527 Overflow consumes the rest of the digits, and returns -1. */
535 if (! ISDIGIT ((unsigned char)**type
))
538 while (ISDIGIT ((unsigned char)**type
))
542 /* Check for overflow.
543 We assume that count is represented using two's-complement;
544 no power of two is divisible by ten, so if an overflow occurs
545 when multiplying by ten, the result will not be a multiple of
547 if ((count
% 10) != 0)
549 while (ISDIGIT ((unsigned char) **type
))
554 count
+= **type
- '0';
565 /* Like consume_count, but for counts that are preceded and followed
566 by '_' if they are greater than 10. Also, -1 is returned for
567 failure, since 0 can be a valid value. */
570 consume_count_with_underscores (mangled
)
571 const char **mangled
;
575 if (**mangled
== '_')
578 if (!ISDIGIT ((unsigned char)**mangled
))
581 idx
= consume_count (mangled
);
582 if (**mangled
!= '_')
583 /* The trailing underscore was missing. */
590 if (**mangled
< '0' || **mangled
> '9')
593 idx
= **mangled
- '0';
600 /* C is the code for a type-qualifier. Return the TYPE_QUAL
601 corresponding to this qualifier. */
604 code_for_qualifier (c
)
610 return TYPE_QUAL_CONST
;
613 return TYPE_QUAL_VOLATILE
;
616 return TYPE_QUAL_RESTRICT
;
622 /* C was an invalid qualifier. */
626 /* Return the string corresponding to the qualifiers given by
630 qualifier_string (type_quals
)
635 case TYPE_UNQUALIFIED
:
638 case TYPE_QUAL_CONST
:
641 case TYPE_QUAL_VOLATILE
:
644 case TYPE_QUAL_RESTRICT
:
647 case TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
:
648 return "const volatile";
650 case TYPE_QUAL_CONST
| TYPE_QUAL_RESTRICT
:
651 return "const __restrict";
653 case TYPE_QUAL_VOLATILE
| TYPE_QUAL_RESTRICT
:
654 return "volatile __restrict";
656 case TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
| TYPE_QUAL_RESTRICT
:
657 return "const volatile __restrict";
663 /* TYPE_QUALS was an invalid qualifier set. */
667 /* C is the code for a type-qualifier. Return the string
668 corresponding to this qualifier. This function should only be
669 called with a valid qualifier code. */
672 demangle_qualifier (c
)
675 return qualifier_string (code_for_qualifier (c
));
679 cplus_demangle_opname (opname
, result
, options
)
686 struct work_stuff work
[1];
689 len
= strlen(opname
);
692 memset ((char *) work
, 0, sizeof (work
));
693 work
->options
= options
;
695 if (opname
[0] == '_' && opname
[1] == '_'
696 && opname
[2] == 'o' && opname
[3] == 'p')
699 /* type conversion operator. */
701 if (do_type (work
, &tem
, &type
))
703 strcat (result
, "operator ");
704 strncat (result
, type
.b
, type
.p
- type
.b
);
705 string_delete (&type
);
709 else if (opname
[0] == '_' && opname
[1] == '_'
710 && ISLOWER((unsigned char)opname
[2])
711 && ISLOWER((unsigned char)opname
[3]))
713 if (opname
[4] == '\0')
717 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
719 if (strlen (optable
[i
].in
) == 2
720 && memcmp (optable
[i
].in
, opname
+ 2, 2) == 0)
722 strcat (result
, "operator");
723 strcat (result
, optable
[i
].out
);
731 if (opname
[2] == 'a' && opname
[5] == '\0')
735 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
737 if (strlen (optable
[i
].in
) == 3
738 && memcmp (optable
[i
].in
, opname
+ 2, 3) == 0)
740 strcat (result
, "operator");
741 strcat (result
, optable
[i
].out
);
752 && strchr (cplus_markers
, opname
[2]) != NULL
)
754 /* see if it's an assignment expression */
755 if (len
>= 10 /* op$assign_ */
756 && memcmp (opname
+ 3, "assign_", 7) == 0)
759 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
762 if ((int) strlen (optable
[i
].in
) == len1
763 && memcmp (optable
[i
].in
, opname
+ 10, len1
) == 0)
765 strcat (result
, "operator");
766 strcat (result
, optable
[i
].out
);
767 strcat (result
, "=");
776 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
779 if ((int) strlen (optable
[i
].in
) == len1
780 && memcmp (optable
[i
].in
, opname
+ 3, len1
) == 0)
782 strcat (result
, "operator");
783 strcat (result
, optable
[i
].out
);
790 else if (len
>= 5 && memcmp (opname
, "type", 4) == 0
791 && strchr (cplus_markers
, opname
[4]) != NULL
)
793 /* type conversion operator */
795 if (do_type (work
, &tem
, &type
))
797 strcat (result
, "operator ");
798 strncat (result
, type
.b
, type
.p
- type
.b
);
799 string_delete (&type
);
803 squangle_mop_up (work
);
808 /* Takes operator name as e.g. "++" and returns mangled
809 operator name (e.g. "postincrement_expr"), or NULL if not found.
811 If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
812 if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
815 cplus_mangle_opname (opname
, options
)
822 len
= strlen (opname
);
823 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
825 if ((int) strlen (optable
[i
].out
) == len
826 && (options
& DMGL_ANSI
) == (optable
[i
].flags
& DMGL_ANSI
)
827 && memcmp (optable
[i
].out
, opname
, len
) == 0)
828 return optable
[i
].in
;
833 /* Add a routine to set the demangling style to be sure it is valid and
834 allow for any demangler initialization that maybe necessary. */
836 enum demangling_styles
837 cplus_demangle_set_style (style
)
838 enum demangling_styles style
;
840 const struct demangler_engine
*demangler
= libiberty_demanglers
;
842 for (; demangler
->demangling_style
!= unknown_demangling
; ++demangler
)
843 if (style
== demangler
->demangling_style
)
845 current_demangling_style
= style
;
846 return current_demangling_style
;
849 return unknown_demangling
;
852 /* Do string name to style translation */
854 enum demangling_styles
855 cplus_demangle_name_to_style (name
)
858 const struct demangler_engine
*demangler
= libiberty_demanglers
;
860 for (; demangler
->demangling_style
!= unknown_demangling
; ++demangler
)
861 if (strcmp (name
, demangler
->demangling_style_name
) == 0)
862 return demangler
->demangling_style
;
864 return unknown_demangling
;
867 /* char *cplus_demangle (const char *mangled, int options)
869 If MANGLED is a mangled function name produced by GNU C++, then
870 a pointer to a @code{malloc}ed string giving a C++ representation
871 of the name will be returned; otherwise NULL will be returned.
872 It is the caller's responsibility to free the string which
875 The OPTIONS arg may contain one or more of the following bits:
877 DMGL_ANSI ANSI qualifiers such as `const' and `void' are
879 DMGL_PARAMS Function parameters are included.
883 cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
884 cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
885 cplus_demangle ("foo__1Ai", 0) => "A::foo"
887 cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
888 cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
889 cplus_demangle ("foo__1Afe", 0) => "A::foo"
891 Note that any leading underscores, or other such characters prepended by
892 the compilation system, are presumed to have already been stripped from
896 cplus_demangle (mangled
, options
)
901 struct work_stuff work
[1];
903 if (current_demangling_style
== no_demangling
)
904 return xstrdup (mangled
);
906 memset ((char *) work
, 0, sizeof (work
));
907 work
->options
= options
;
908 if ((work
->options
& DMGL_STYLE_MASK
) == 0)
909 work
->options
|= (int) current_demangling_style
& DMGL_STYLE_MASK
;
911 /* The V3 ABI demangling is implemented elsewhere. */
912 if (GNU_V3_DEMANGLING
|| AUTO_DEMANGLING
)
914 ret
= cplus_demangle_v3 (mangled
, work
->options
);
915 if (ret
|| GNU_V3_DEMANGLING
)
921 ret
= java_demangle_v3 (mangled
);
927 return ada_demangle(mangled
,options
);
929 ret
= internal_cplus_demangle (work
, mangled
);
930 squangle_mop_up (work
);
935 /* Assuming *OLD_VECT points to an array of *SIZE objects of size
936 ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
937 updating *OLD_VECT and *SIZE as necessary. */
940 grow_vect (old_vect
, size
, min_size
, element_size
)
946 if (*size
< min_size
)
949 if (*size
< min_size
)
951 *old_vect
= xrealloc (*old_vect
, *size
* element_size
);
955 /* Demangle ada names:
956 1. Discard final __{DIGIT}+ or ${DIGIT}+
957 2. Convert other instances of embedded "__" to `.'.
958 3. Discard leading _ada_.
959 4. Remove everything after first ___ if it is followed by 'X'.
960 5. Put symbols that should be suppressed in <...> brackets.
961 The resulting string is valid until the next call of ada_demangle. */
964 ada_demangle (mangled
, option
)
966 int option ATTRIBUTE_UNUSED
;
971 char *demangled
= NULL
;
974 char *demangling_buffer
= NULL
;
975 size_t demangling_buffer_size
= 0;
979 if (strncmp (mangled
, "_ada_", 5) == 0)
985 if (mangled
[0] == '_' || mangled
[0] == '<')
988 p
= strstr (mangled
, "___");
990 len0
= strlen (mangled
);
1002 /* Make demangled big enough for possible expansion by operator name. */
1003 grow_vect ((void **) &(demangling_buffer
),
1004 &demangling_buffer_size
, 2 * len0
+ 1,
1006 demangled
= demangling_buffer
;
1008 if (ISDIGIT ((unsigned char) mangled
[len0
- 1])) {
1009 for (i
= len0
- 2; i
>= 0 && ISDIGIT ((unsigned char) mangled
[i
]); i
-= 1)
1011 if (i
> 1 && mangled
[i
] == '_' && mangled
[i
- 1] == '_')
1016 else if (mangled
[i
] == '$')
1023 for (i
= 0, j
= 0; i
< len0
&& ! ISALPHA ((unsigned char)mangled
[i
]);
1025 demangled
[j
] = mangled
[i
];
1032 if (i
< len0
- 2 && mangled
[i
] == '_' && mangled
[i
+ 1] == '_')
1035 changed
= at_start_name
= 1;
1040 demangled
[j
] = mangled
[i
];
1044 demangled
[j
] = '\000';
1046 for (i
= 0; demangled
[i
] != '\0'; i
+= 1)
1047 if (ISUPPER ((unsigned char)demangled
[i
]) || demangled
[i
] == ' ')
1056 grow_vect ((void **) &(demangling_buffer
),
1057 &demangling_buffer_size
, strlen (mangled
) + 3,
1059 demangled
= demangling_buffer
;
1060 if (mangled
[0] == '<')
1061 strcpy (demangled
, mangled
);
1063 sprintf (demangled
, "<%s>", mangled
);
1068 /* This function performs most of what cplus_demangle use to do, but
1069 to be able to demangle a name with a B, K or n code, we need to
1070 have a longer term memory of what types have been seen. The original
1071 now intializes and cleans up the squangle code info, while internal
1072 calls go directly to this routine to avoid resetting that info. */
1075 internal_cplus_demangle (work
, mangled
)
1076 struct work_stuff
*work
;
1077 const char *mangled
;
1082 char *demangled
= NULL
;
1084 s1
= work
->constructor
;
1085 s2
= work
->destructor
;
1086 s3
= work
->static_type
;
1087 s4
= work
->type_quals
;
1088 work
->constructor
= work
->destructor
= 0;
1089 work
->type_quals
= TYPE_UNQUALIFIED
;
1090 work
->dllimported
= 0;
1092 if ((mangled
!= NULL
) && (*mangled
!= '\0'))
1094 string_init (&decl
);
1096 /* First check to see if gnu style demangling is active and if the
1097 string to be demangled contains a CPLUS_MARKER. If so, attempt to
1098 recognize one of the gnu special forms rather than looking for a
1099 standard prefix. In particular, don't worry about whether there
1100 is a "__" string in the mangled string. Consider "_$_5__foo" for
1103 if ((AUTO_DEMANGLING
|| GNU_DEMANGLING
))
1105 success
= gnu_special (work
, &mangled
, &decl
);
1109 success
= demangle_prefix (work
, &mangled
, &decl
);
1111 if (success
&& (*mangled
!= '\0'))
1113 success
= demangle_signature (work
, &mangled
, &decl
);
1115 if (work
->constructor
== 2)
1117 string_prepend (&decl
, "global constructors keyed to ");
1118 work
->constructor
= 0;
1120 else if (work
->destructor
== 2)
1122 string_prepend (&decl
, "global destructors keyed to ");
1123 work
->destructor
= 0;
1125 else if (work
->dllimported
== 1)
1127 string_prepend (&decl
, "import stub for ");
1128 work
->dllimported
= 0;
1130 demangled
= mop_up (work
, &decl
, success
);
1132 work
->constructor
= s1
;
1133 work
->destructor
= s2
;
1134 work
->static_type
= s3
;
1135 work
->type_quals
= s4
;
1140 /* Clear out and squangling related storage */
1142 squangle_mop_up (work
)
1143 struct work_stuff
*work
;
1145 /* clean up the B and K type mangling types. */
1146 forget_B_and_K_types (work
);
1147 if (work
-> btypevec
!= NULL
)
1149 free ((char *) work
-> btypevec
);
1151 if (work
-> ktypevec
!= NULL
)
1153 free ((char *) work
-> ktypevec
);
1158 /* Copy the work state and storage. */
1161 work_stuff_copy_to_from (to
, from
)
1162 struct work_stuff
*to
;
1163 struct work_stuff
*from
;
1167 delete_work_stuff (to
);
1169 /* Shallow-copy scalars. */
1170 memcpy (to
, from
, sizeof (*to
));
1172 /* Deep-copy dynamic storage. */
1173 if (from
->typevec_size
)
1175 = (char **) xmalloc (from
->typevec_size
* sizeof (to
->typevec
[0]));
1177 for (i
= 0; i
< from
->ntypes
; i
++)
1179 int len
= strlen (from
->typevec
[i
]) + 1;
1181 to
->typevec
[i
] = xmalloc (len
);
1182 memcpy (to
->typevec
[i
], from
->typevec
[i
], len
);
1187 = (char **) xmalloc (from
->ksize
* sizeof (to
->ktypevec
[0]));
1189 for (i
= 0; i
< from
->numk
; i
++)
1191 int len
= strlen (from
->ktypevec
[i
]) + 1;
1193 to
->ktypevec
[i
] = xmalloc (len
);
1194 memcpy (to
->ktypevec
[i
], from
->ktypevec
[i
], len
);
1199 = (char **) xmalloc (from
->bsize
* sizeof (to
->btypevec
[0]));
1201 for (i
= 0; i
< from
->numb
; i
++)
1203 int len
= strlen (from
->btypevec
[i
]) + 1;
1205 to
->btypevec
[i
] = xmalloc (len
);
1206 memcpy (to
->btypevec
[i
], from
->btypevec
[i
], len
);
1209 if (from
->ntmpl_args
)
1211 = xmalloc (from
->ntmpl_args
* sizeof (to
->tmpl_argvec
[0]));
1213 for (i
= 0; i
< from
->ntmpl_args
; i
++)
1215 int len
= strlen (from
->tmpl_argvec
[i
]) + 1;
1217 to
->tmpl_argvec
[i
] = xmalloc (len
);
1218 memcpy (to
->tmpl_argvec
[i
], from
->tmpl_argvec
[i
], len
);
1221 if (from
->previous_argument
)
1223 to
->previous_argument
= (string
*) xmalloc (sizeof (string
));
1224 string_init (to
->previous_argument
);
1225 string_appends (to
->previous_argument
, from
->previous_argument
);
1230 /* Delete dynamic stuff in work_stuff that is not to be re-used. */
1233 delete_non_B_K_work_stuff (work
)
1234 struct work_stuff
*work
;
1236 /* Discard the remembered types, if any. */
1238 forget_types (work
);
1239 if (work
-> typevec
!= NULL
)
1241 free ((char *) work
-> typevec
);
1242 work
-> typevec
= NULL
;
1243 work
-> typevec_size
= 0;
1245 if (work
->tmpl_argvec
)
1249 for (i
= 0; i
< work
->ntmpl_args
; i
++)
1250 if (work
->tmpl_argvec
[i
])
1251 free ((char*) work
->tmpl_argvec
[i
]);
1253 free ((char*) work
->tmpl_argvec
);
1254 work
->tmpl_argvec
= NULL
;
1256 if (work
->previous_argument
)
1258 string_delete (work
->previous_argument
);
1259 free ((char*) work
->previous_argument
);
1260 work
->previous_argument
= NULL
;
1265 /* Delete all dynamic storage in work_stuff. */
1267 delete_work_stuff (work
)
1268 struct work_stuff
*work
;
1270 delete_non_B_K_work_stuff (work
);
1271 squangle_mop_up (work
);
1275 /* Clear out any mangled storage */
1278 mop_up (work
, declp
, success
)
1279 struct work_stuff
*work
;
1283 char *demangled
= NULL
;
1285 delete_non_B_K_work_stuff (work
);
1287 /* If demangling was successful, ensure that the demangled string is null
1288 terminated and return it. Otherwise, free the demangling decl. */
1292 string_delete (declp
);
1296 string_appendn (declp
, "", 1);
1297 demangled
= declp
->b
;
1306 demangle_signature -- demangle the signature part of a mangled name
1311 demangle_signature (struct work_stuff *work, const char **mangled,
1316 Consume and demangle the signature portion of the mangled name.
1318 DECLP is the string where demangled output is being built. At
1319 entry it contains the demangled root name from the mangled name
1320 prefix. I.E. either a demangled operator name or the root function
1321 name. In some special cases, it may contain nothing.
1323 *MANGLED points to the current unconsumed location in the mangled
1324 name. As tokens are consumed and demangling is performed, the
1325 pointer is updated to continuously point at the next token to
1328 Demangling GNU style mangled names is nasty because there is no
1329 explicit token that marks the start of the outermost function
1333 demangle_signature (work
, mangled
, declp
)
1334 struct work_stuff
*work
;
1335 const char **mangled
;
1340 int expect_func
= 0;
1341 int expect_return_type
= 0;
1342 const char *oldmangled
= NULL
;
1346 while (success
&& (**mangled
!= '\0'))
1351 oldmangled
= *mangled
;
1352 success
= demangle_qualified (work
, mangled
, declp
, 1, 0);
1354 remember_type (work
, oldmangled
, *mangled
- oldmangled
);
1355 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1361 oldmangled
= *mangled
;
1362 success
= demangle_qualified (work
, mangled
, declp
, 1, 0);
1363 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1371 /* Static member function */
1372 if (oldmangled
== NULL
)
1374 oldmangled
= *mangled
;
1377 work
-> static_type
= 1;
1383 work
->type_quals
|= code_for_qualifier (**mangled
);
1385 /* a qualified member function */
1386 if (oldmangled
== NULL
)
1387 oldmangled
= *mangled
;
1392 /* Local class name follows after "Lnnn_" */
1395 while (**mangled
&& (**mangled
!= '_'))
1406 case '0': case '1': case '2': case '3': case '4':
1407 case '5': case '6': case '7': case '8': case '9':
1408 if (oldmangled
== NULL
)
1410 oldmangled
= *mangled
;
1412 work
->temp_start
= -1; /* uppermost call to demangle_class */
1413 success
= demangle_class (work
, mangled
, declp
);
1416 remember_type (work
, oldmangled
, *mangled
- oldmangled
);
1418 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
|| EDG_DEMANGLING
)
1420 /* EDG and others will have the "F", so we let the loop cycle
1421 if we are looking at one. */
1422 if (**mangled
!= 'F')
1431 success
= do_type (work
, mangled
, &s
);
1434 string_append (&s
, SCOPE_STRING (work
));
1435 string_prepends (declp
, &s
);
1444 /* ARM/HP style demangling includes a specific 'F' character after
1445 the class name. For GNU style, it is just implied. So we can
1446 safely just consume any 'F' at this point and be compatible
1447 with either style. */
1453 /* For lucid/ARM/HP style we have to forget any types we might
1454 have remembered up to this point, since they were not argument
1455 types. GNU style considers all types seen as available for
1456 back references. See comment in demangle_args() */
1458 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
1460 forget_types (work
);
1462 success
= demangle_args (work
, mangled
, declp
);
1463 /* After picking off the function args, we expect to either
1464 find the function return type (preceded by an '_') or the
1465 end of the string. */
1466 if (success
&& (AUTO_DEMANGLING
|| EDG_DEMANGLING
) && **mangled
== '_')
1469 /* At this level, we do not care about the return type. */
1470 success
= do_type (work
, mangled
, &tname
);
1471 string_delete (&tname
);
1478 string_init(&trawname
);
1479 string_init(&tname
);
1480 if (oldmangled
== NULL
)
1482 oldmangled
= *mangled
;
1484 success
= demangle_template (work
, mangled
, &tname
,
1488 remember_type (work
, oldmangled
, *mangled
- oldmangled
);
1490 string_append (&tname
, SCOPE_STRING (work
));
1492 string_prepends(declp
, &tname
);
1493 if (work
-> destructor
& 1)
1495 string_prepend (&trawname
, "~");
1496 string_appends (declp
, &trawname
);
1497 work
->destructor
-= 1;
1499 if ((work
->constructor
& 1) || (work
->destructor
& 1))
1501 string_appends (declp
, &trawname
);
1502 work
->constructor
-= 1;
1504 string_delete(&trawname
);
1505 string_delete(&tname
);
1511 if ((AUTO_DEMANGLING
|| GNU_DEMANGLING
) && expect_return_type
)
1513 /* Read the return type. */
1515 string_init (&return_type
);
1518 success
= do_type (work
, mangled
, &return_type
);
1519 APPEND_BLANK (&return_type
);
1521 string_prepends (declp
, &return_type
);
1522 string_delete (&return_type
);
1526 /* At the outermost level, we cannot have a return type specified,
1527 so if we run into another '_' at this point we are dealing with
1528 a mangled name that is either bogus, or has been mangled by
1529 some algorithm we don't know how to deal with. So just
1530 reject the entire demangling. */
1531 /* However, "_nnn" is an expected suffix for alternate entry point
1532 numbered nnn for a function, with HP aCC, so skip over that
1533 without reporting failure. pai/1997-09-04 */
1537 while (**mangled
&& ISDIGIT ((unsigned char)**mangled
))
1545 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1547 /* A G++ template function. Read the template arguments. */
1548 success
= demangle_template (work
, mangled
, declp
, 0, 0,
1550 if (!(work
->constructor
& 1))
1551 expect_return_type
= 1;
1560 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1562 /* Assume we have stumbled onto the first outermost function
1563 argument token, and start processing args. */
1565 success
= demangle_args (work
, mangled
, declp
);
1569 /* Non-GNU demanglers use a specific token to mark the start
1570 of the outermost function argument tokens. Typically 'F',
1571 for ARM/HP-demangling, for example. So if we find something
1572 we are not prepared for, it must be an error. */
1578 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1581 if (success
&& expect_func
)
1584 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| EDG_DEMANGLING
)
1586 forget_types (work
);
1588 success
= demangle_args (work
, mangled
, declp
);
1589 /* Since template include the mangling of their return types,
1590 we must set expect_func to 0 so that we don't try do
1591 demangle more arguments the next time we get here. */
1596 if (success
&& !func_done
)
1598 if (AUTO_DEMANGLING
|| GNU_DEMANGLING
)
1600 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1601 bar__3fooi is 'foo::bar(int)'. We get here when we find the
1602 first case, and need to ensure that the '(void)' gets added to
1603 the current declp. Note that with ARM/HP, the first case
1604 represents the name of a static data member 'foo::bar',
1605 which is in the current declp, so we leave it alone. */
1606 success
= demangle_args (work
, mangled
, declp
);
1609 if (success
&& PRINT_ARG_TYPES
)
1611 if (work
->static_type
)
1612 string_append (declp
, " static");
1613 if (work
->type_quals
!= TYPE_UNQUALIFIED
)
1615 APPEND_BLANK (declp
);
1616 string_append (declp
, qualifier_string (work
->type_quals
));
1626 demangle_method_args (work
, mangled
, declp
)
1627 struct work_stuff
*work
;
1628 const char **mangled
;
1633 if (work
-> static_type
)
1635 string_append (declp
, *mangled
+ 1);
1636 *mangled
+= strlen (*mangled
);
1641 success
= demangle_args (work
, mangled
, declp
);
1649 demangle_template_template_parm (work
, mangled
, tname
)
1650 struct work_stuff
*work
;
1651 const char **mangled
;
1660 string_append (tname
, "template <");
1661 /* get size of template parameter list */
1662 if (get_count (mangled
, &r
))
1664 for (i
= 0; i
< r
; i
++)
1668 string_append (tname
, ", ");
1671 /* Z for type parameters */
1672 if (**mangled
== 'Z')
1675 string_append (tname
, "class");
1677 /* z for template parameters */
1678 else if (**mangled
== 'z')
1682 demangle_template_template_parm (work
, mangled
, tname
);
1690 /* temp is initialized in do_type */
1691 success
= do_type (work
, mangled
, &temp
);
1694 string_appends (tname
, &temp
);
1696 string_delete(&temp
);
1706 if (tname
->p
[-1] == '>')
1707 string_append (tname
, " ");
1708 string_append (tname
, "> class");
1713 demangle_expression (work
, mangled
, s
, tk
)
1714 struct work_stuff
*work
;
1715 const char** mangled
;
1719 int need_operator
= 0;
1723 string_appendn (s
, "(", 1);
1725 while (success
&& **mangled
!= 'W' && **mangled
!= '\0')
1734 len
= strlen (*mangled
);
1736 for (i
= 0; i
< ARRAY_SIZE (optable
); ++i
)
1738 size_t l
= strlen (optable
[i
].in
);
1741 && memcmp (optable
[i
].in
, *mangled
, l
) == 0)
1743 string_appendn (s
, " ", 1);
1744 string_append (s
, optable
[i
].out
);
1745 string_appendn (s
, " ", 1);
1758 success
= demangle_template_value_parm (work
, mangled
, s
, tk
);
1761 if (**mangled
!= 'W')
1765 string_appendn (s
, ")", 1);
1773 demangle_integral_value (work
, mangled
, s
)
1774 struct work_stuff
*work
;
1775 const char** mangled
;
1780 if (**mangled
== 'E')
1781 success
= demangle_expression (work
, mangled
, s
, tk_integral
);
1782 else if (**mangled
== 'Q' || **mangled
== 'K')
1783 success
= demangle_qualified (work
, mangled
, s
, 0, 1);
1788 /* By default, we let the number decide whether we shall consume an
1790 int consume_following_underscore
= 0;
1791 int leave_following_underscore
= 0;
1795 /* Negative numbers are indicated with a leading `m'. */
1796 if (**mangled
== 'm')
1798 string_appendn (s
, "-", 1);
1801 else if (mangled
[0][0] == '_' && mangled
[0][1] == 'm')
1803 /* Since consume_count_with_underscores does not handle the
1804 `m'-prefix we must do it here, using consume_count and
1805 adjusting underscores: we have to consume the underscore
1806 matching the prepended one. */
1807 consume_following_underscore
= 1;
1808 string_appendn (s
, "-", 1);
1811 else if (**mangled
== '_')
1813 /* Do not consume a following underscore;
1814 consume_following_underscore will consume what should be
1816 leave_following_underscore
= 1;
1819 /* We must call consume_count if we expect to remove a trailing
1820 underscore, since consume_count_with_underscores expects
1821 the leading underscore (that we consumed) if it is to handle
1822 multi-digit numbers. */
1823 if (consume_following_underscore
)
1824 value
= consume_count (mangled
);
1826 value
= consume_count_with_underscores (mangled
);
1830 char buf
[INTBUF_SIZE
];
1831 sprintf (buf
, "%d", value
);
1832 string_append (s
, buf
);
1834 /* Numbers not otherwise delimited, might have an underscore
1835 appended as a delimeter, which we should skip.
1837 ??? This used to always remove a following underscore, which
1838 is wrong. If other (arbitrary) cases are followed by an
1839 underscore, we need to do something more radical. */
1841 if ((value
> 9 || consume_following_underscore
)
1842 && ! leave_following_underscore
1843 && **mangled
== '_')
1854 /* Demangle the real value in MANGLED. */
1857 demangle_real_value (work
, mangled
, s
)
1858 struct work_stuff
*work
;
1859 const char **mangled
;
1862 if (**mangled
== 'E')
1863 return demangle_expression (work
, mangled
, s
, tk_real
);
1865 if (**mangled
== 'm')
1867 string_appendn (s
, "-", 1);
1870 while (ISDIGIT ((unsigned char)**mangled
))
1872 string_appendn (s
, *mangled
, 1);
1875 if (**mangled
== '.') /* fraction */
1877 string_appendn (s
, ".", 1);
1879 while (ISDIGIT ((unsigned char)**mangled
))
1881 string_appendn (s
, *mangled
, 1);
1885 if (**mangled
== 'e') /* exponent */
1887 string_appendn (s
, "e", 1);
1889 while (ISDIGIT ((unsigned char)**mangled
))
1891 string_appendn (s
, *mangled
, 1);
1900 demangle_template_value_parm (work
, mangled
, s
, tk
)
1901 struct work_stuff
*work
;
1902 const char **mangled
;
1908 if (**mangled
== 'Y')
1910 /* The next argument is a template parameter. */
1914 idx
= consume_count_with_underscores (mangled
);
1916 || (work
->tmpl_argvec
&& idx
>= work
->ntmpl_args
)
1917 || consume_count_with_underscores (mangled
) == -1)
1919 if (work
->tmpl_argvec
)
1920 string_append (s
, work
->tmpl_argvec
[idx
]);
1922 string_append_template_idx (s
, idx
);
1924 else if (tk
== tk_integral
)
1925 success
= demangle_integral_value (work
, mangled
, s
);
1926 else if (tk
== tk_char
)
1930 if (**mangled
== 'm')
1932 string_appendn (s
, "-", 1);
1935 string_appendn (s
, "'", 1);
1936 val
= consume_count(mangled
);
1943 string_appendn (s
, &tmp
[0], 1);
1944 string_appendn (s
, "'", 1);
1947 else if (tk
== tk_bool
)
1949 int val
= consume_count (mangled
);
1951 string_appendn (s
, "false", 5);
1953 string_appendn (s
, "true", 4);
1957 else if (tk
== tk_real
)
1958 success
= demangle_real_value (work
, mangled
, s
);
1959 else if (tk
== tk_pointer
|| tk
== tk_reference
)
1961 if (**mangled
== 'Q')
1962 success
= demangle_qualified (work
, mangled
, s
,
1967 int symbol_len
= consume_count (mangled
);
1968 if (symbol_len
== -1)
1970 if (symbol_len
== 0)
1971 string_appendn (s
, "0", 1);
1974 char *p
= xmalloc (symbol_len
+ 1), *q
;
1975 strncpy (p
, *mangled
, symbol_len
);
1976 p
[symbol_len
] = '\0';
1977 /* We use cplus_demangle here, rather than
1978 internal_cplus_demangle, because the name of the entity
1979 mangled here does not make use of any of the squangling
1980 or type-code information we have built up thus far; it is
1981 mangled independently. */
1982 q
= cplus_demangle (p
, work
->options
);
1983 if (tk
== tk_pointer
)
1984 string_appendn (s
, "&", 1);
1985 /* FIXME: Pointer-to-member constants should get a
1986 qualifying class name here. */
1989 string_append (s
, q
);
1993 string_append (s
, p
);
1996 *mangled
+= symbol_len
;
2003 /* Demangle the template name in MANGLED. The full name of the
2004 template (e.g., S<int>) is placed in TNAME. The name without the
2005 template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2006 non-NULL. If IS_TYPE is nonzero, this template is a type template,
2007 not a function template. If both IS_TYPE and REMEMBER are nonzero,
2008 the template is remembered in the list of back-referenceable
2012 demangle_template (work
, mangled
, tname
, trawname
, is_type
, remember
)
2013 struct work_stuff
*work
;
2014 const char **mangled
;
2025 int is_java_array
= 0;
2033 bindex
= register_Btype (work
);
2035 /* get template name */
2036 if (**mangled
== 'z')
2042 idx
= consume_count_with_underscores (mangled
);
2044 || (work
->tmpl_argvec
&& idx
>= work
->ntmpl_args
)
2045 || consume_count_with_underscores (mangled
) == -1)
2048 if (work
->tmpl_argvec
)
2050 string_append (tname
, work
->tmpl_argvec
[idx
]);
2052 string_append (trawname
, work
->tmpl_argvec
[idx
]);
2056 string_append_template_idx (tname
, idx
);
2058 string_append_template_idx (trawname
, idx
);
2063 if ((r
= consume_count (mangled
)) <= 0
2064 || (int) strlen (*mangled
) < r
)
2068 is_java_array
= (work
-> options
& DMGL_JAVA
)
2069 && strncmp (*mangled
, "JArray1Z", 8) == 0;
2070 if (! is_java_array
)
2072 string_appendn (tname
, *mangled
, r
);
2075 string_appendn (trawname
, *mangled
, r
);
2080 string_append (tname
, "<");
2081 /* get size of template parameter list */
2082 if (!get_count (mangled
, &r
))
2088 /* Create an array for saving the template argument values. */
2089 work
->tmpl_argvec
= (char**) xmalloc (r
* sizeof (char *));
2090 work
->ntmpl_args
= r
;
2091 for (i
= 0; i
< r
; i
++)
2092 work
->tmpl_argvec
[i
] = 0;
2094 for (i
= 0; i
< r
; i
++)
2098 string_append (tname
, ", ");
2100 /* Z for type parameters */
2101 if (**mangled
== 'Z')
2104 /* temp is initialized in do_type */
2105 success
= do_type (work
, mangled
, &temp
);
2108 string_appends (tname
, &temp
);
2112 /* Save the template argument. */
2113 int len
= temp
.p
- temp
.b
;
2114 work
->tmpl_argvec
[i
] = xmalloc (len
+ 1);
2115 memcpy (work
->tmpl_argvec
[i
], temp
.b
, len
);
2116 work
->tmpl_argvec
[i
][len
] = '\0';
2119 string_delete(&temp
);
2125 /* z for template parameters */
2126 else if (**mangled
== 'z')
2130 success
= demangle_template_template_parm (work
, mangled
, tname
);
2133 && (r2
= consume_count (mangled
)) > 0
2134 && (int) strlen (*mangled
) >= r2
)
2136 string_append (tname
, " ");
2137 string_appendn (tname
, *mangled
, r2
);
2140 /* Save the template argument. */
2142 work
->tmpl_argvec
[i
] = xmalloc (len
+ 1);
2143 memcpy (work
->tmpl_argvec
[i
], *mangled
, len
);
2144 work
->tmpl_argvec
[i
][len
] = '\0';
2158 /* otherwise, value parameter */
2160 /* temp is initialized in do_type */
2161 success
= do_type (work
, mangled
, &temp
);
2162 string_delete(&temp
);
2174 success
= demangle_template_value_parm (work
, mangled
, s
,
2175 (type_kind_t
) success
);
2187 int len
= s
->p
- s
->b
;
2188 work
->tmpl_argvec
[i
] = xmalloc (len
+ 1);
2189 memcpy (work
->tmpl_argvec
[i
], s
->b
, len
);
2190 work
->tmpl_argvec
[i
][len
] = '\0';
2192 string_appends (tname
, s
);
2200 string_append (tname
, "[]");
2204 if (tname
->p
[-1] == '>')
2205 string_append (tname
, " ");
2206 string_append (tname
, ">");
2209 if (is_type
&& remember
)
2210 remember_Btype (work
, tname
->b
, LEN_STRING (tname
), bindex
);
2213 if (work -> static_type)
2215 string_append (declp, *mangled + 1);
2216 *mangled += strlen (*mangled);
2221 success = demangle_args (work, mangled, declp);
2229 arm_pt (work
, mangled
, n
, anchor
, args
)
2230 struct work_stuff
*work
;
2231 const char *mangled
;
2233 const char **anchor
, **args
;
2235 /* Check if ARM template with "__pt__" in it ("parameterized type") */
2236 /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2237 if ((ARM_DEMANGLING
|| HP_DEMANGLING
) && (*anchor
= strstr (mangled
, "__pt__")))
2240 *args
= *anchor
+ 6;
2241 len
= consume_count (args
);
2244 if (*args
+ len
== mangled
+ n
&& **args
== '_')
2250 if (AUTO_DEMANGLING
|| EDG_DEMANGLING
)
2252 if ((*anchor
= strstr (mangled
, "__tm__"))
2253 || (*anchor
= strstr (mangled
, "__ps__"))
2254 || (*anchor
= strstr (mangled
, "__pt__")))
2257 *args
= *anchor
+ 6;
2258 len
= consume_count (args
);
2261 if (*args
+ len
== mangled
+ n
&& **args
== '_')
2267 else if ((*anchor
= strstr (mangled
, "__S")))
2270 *args
= *anchor
+ 3;
2271 len
= consume_count (args
);
2274 if (*args
+ len
== mangled
+ n
&& **args
== '_')
2286 demangle_arm_hp_template (work
, mangled
, n
, declp
)
2287 struct work_stuff
*work
;
2288 const char **mangled
;
2294 const char *e
= *mangled
+ n
;
2297 /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2299 if (HP_DEMANGLING
&& ((*mangled
)[n
] == 'X'))
2301 char *start_spec_args
= NULL
;
2303 /* First check for and omit template specialization pseudo-arguments,
2304 such as in "Spec<#1,#1.*>" */
2305 start_spec_args
= strchr (*mangled
, '<');
2306 if (start_spec_args
&& (start_spec_args
- *mangled
< n
))
2307 string_appendn (declp
, *mangled
, start_spec_args
- *mangled
);
2309 string_appendn (declp
, *mangled
, n
);
2310 (*mangled
) += n
+ 1;
2312 if (work
->temp_start
== -1) /* non-recursive call */
2313 work
->temp_start
= declp
->p
- declp
->b
;
2314 string_append (declp
, "<");
2317 string_clear (&arg
);
2321 /* 'T' signals a type parameter */
2323 if (!do_type (work
, mangled
, &arg
))
2324 goto hpacc_template_args_done
;
2329 /* 'U' or 'S' signals an integral value */
2330 if (!do_hpacc_template_const_value (work
, mangled
, &arg
))
2331 goto hpacc_template_args_done
;
2335 /* 'A' signals a named constant expression (literal) */
2336 if (!do_hpacc_template_literal (work
, mangled
, &arg
))
2337 goto hpacc_template_args_done
;
2341 /* Today, 1997-09-03, we have only the above types
2342 of template parameters */
2343 /* FIXME: maybe this should fail and return null */
2344 goto hpacc_template_args_done
;
2346 string_appends (declp
, &arg
);
2347 /* Check if we're at the end of template args.
2348 0 if at end of static member of template class,
2349 _ if done with template args for a function */
2350 if ((**mangled
== '\000') || (**mangled
== '_'))
2353 string_append (declp
, ",");
2355 hpacc_template_args_done
:
2356 string_append (declp
, ">");
2357 string_delete (&arg
);
2358 if (**mangled
== '_')
2362 /* ARM template? (Also handles HP cfront extensions) */
2363 else if (arm_pt (work
, *mangled
, n
, &p
, &args
))
2368 string_appendn (declp
, *mangled
, p
- *mangled
);
2369 if (work
->temp_start
== -1) /* non-recursive call */
2370 work
->temp_start
= declp
->p
- declp
->b
;
2371 string_append (declp
, "<");
2372 /* should do error checking here */
2374 string_clear (&arg
);
2376 /* Check for type or literal here */
2379 /* HP cfront extensions to ARM for template args */
2380 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2381 /* FIXME: We handle only numeric literals for HP cfront */
2383 /* A typed constant value follows */
2385 if (!do_type (work
, &args
, &type_str
))
2386 goto cfront_template_args_done
;
2387 string_append (&arg
, "(");
2388 string_appends (&arg
, &type_str
);
2389 string_append (&arg
, ")");
2391 goto cfront_template_args_done
;
2393 /* Now snarf a literal value following 'L' */
2394 if (!snarf_numeric_literal (&args
, &arg
))
2395 goto cfront_template_args_done
;
2399 /* Snarf a literal following 'L' */
2401 if (!snarf_numeric_literal (&args
, &arg
))
2402 goto cfront_template_args_done
;
2405 /* Not handling other HP cfront stuff */
2406 if (!do_type (work
, &args
, &arg
))
2407 goto cfront_template_args_done
;
2409 string_appends (declp
, &arg
);
2410 string_append (declp
, ",");
2412 cfront_template_args_done
:
2413 string_delete (&arg
);
2415 --declp
->p
; /* remove extra comma */
2416 string_append (declp
, ">");
2418 else if (n
>10 && strncmp (*mangled
, "_GLOBAL_", 8) == 0
2419 && (*mangled
)[9] == 'N'
2420 && (*mangled
)[8] == (*mangled
)[10]
2421 && strchr (cplus_markers
, (*mangled
)[8]))
2423 /* A member of the anonymous namespace. */
2424 string_append (declp
, "{anonymous}");
2428 if (work
->temp_start
== -1) /* non-recursive call only */
2429 work
->temp_start
= 0; /* disable in recursive calls */
2430 string_appendn (declp
, *mangled
, n
);
2435 /* Extract a class name, possibly a template with arguments, from the
2436 mangled string; qualifiers, local class indicators, etc. have
2437 already been dealt with */
2440 demangle_class_name (work
, mangled
, declp
)
2441 struct work_stuff
*work
;
2442 const char **mangled
;
2448 n
= consume_count (mangled
);
2451 if ((int) strlen (*mangled
) >= n
)
2453 demangle_arm_hp_template (work
, mangled
, n
, declp
);
2464 demangle_class -- demangle a mangled class sequence
2469 demangle_class (struct work_stuff *work, const char **mangled,
2474 DECLP points to the buffer into which demangling is being done.
2476 *MANGLED points to the current token to be demangled. On input,
2477 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2478 On exit, it points to the next token after the mangled class on
2479 success, or the first unconsumed token on failure.
2481 If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2482 we are demangling a constructor or destructor. In this case
2483 we prepend "class::class" or "class::~class" to DECLP.
2485 Otherwise, we prepend "class::" to the current DECLP.
2487 Reset the constructor/destructor flags once they have been
2488 "consumed". This allows demangle_class to be called later during
2489 the same demangling, to do normal class demangling.
2491 Returns 1 if demangling is successful, 0 otherwise.
2496 demangle_class (work
, mangled
, declp
)
2497 struct work_stuff
*work
;
2498 const char **mangled
;
2504 char *save_class_name_end
= 0;
2506 string_init (&class_name
);
2507 btype
= register_Btype (work
);
2508 if (demangle_class_name (work
, mangled
, &class_name
))
2510 save_class_name_end
= class_name
.p
;
2511 if ((work
->constructor
& 1) || (work
->destructor
& 1))
2513 /* adjust so we don't include template args */
2514 if (work
->temp_start
&& (work
->temp_start
!= -1))
2516 class_name
.p
= class_name
.b
+ work
->temp_start
;
2518 string_prepends (declp
, &class_name
);
2519 if (work
-> destructor
& 1)
2521 string_prepend (declp
, "~");
2522 work
-> destructor
-= 1;
2526 work
-> constructor
-= 1;
2529 class_name
.p
= save_class_name_end
;
2530 remember_Ktype (work
, class_name
.b
, LEN_STRING(&class_name
));
2531 remember_Btype (work
, class_name
.b
, LEN_STRING(&class_name
), btype
);
2532 string_prepend (declp
, SCOPE_STRING (work
));
2533 string_prepends (declp
, &class_name
);
2536 string_delete (&class_name
);
2541 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2542 the rightmost guess.
2544 Find the correct "__"-sequence where the function name ends and the
2545 signature starts, which is ambiguous with GNU mangling.
2546 Call demangle_signature here, so we can make sure we found the right
2547 one; *mangled will be consumed so caller will not make further calls to
2548 demangle_signature. */
2551 iterate_demangle_function (work
, mangled
, declp
, scan
)
2552 struct work_stuff
*work
;
2553 const char **mangled
;
2557 const char *mangle_init
= *mangled
;
2560 struct work_stuff work_init
;
2562 if (*(scan
+ 2) == '\0')
2565 /* Do not iterate for some demangling modes, or if there's only one
2566 "__"-sequence. This is the normal case. */
2567 if (ARM_DEMANGLING
|| LUCID_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
2568 || strstr (scan
+ 2, "__") == NULL
)
2570 demangle_function_name (work
, mangled
, declp
, scan
);
2574 /* Save state so we can restart if the guess at the correct "__" was
2576 string_init (&decl_init
);
2577 string_appends (&decl_init
, declp
);
2578 memset (&work_init
, 0, sizeof work_init
);
2579 work_stuff_copy_to_from (&work_init
, work
);
2581 /* Iterate over occurrences of __, allowing names and types to have a
2582 "__" sequence in them. We must start with the first (not the last)
2583 occurrence, since "__" most often occur between independent mangled
2584 parts, hence starting at the last occurence inside a signature
2585 might get us a "successful" demangling of the signature. */
2589 demangle_function_name (work
, mangled
, declp
, scan
);
2590 success
= demangle_signature (work
, mangled
, declp
);
2594 /* Reset demangle state for the next round. */
2595 *mangled
= mangle_init
;
2596 string_clear (declp
);
2597 string_appends (declp
, &decl_init
);
2598 work_stuff_copy_to_from (work
, &work_init
);
2600 /* Leave this underscore-sequence. */
2603 /* Scan for the next "__" sequence. */
2604 while (*scan
&& (scan
[0] != '_' || scan
[1] != '_'))
2607 /* Move to last "__" in this sequence. */
2608 while (*scan
&& *scan
== '_')
2613 /* Delete saved state. */
2614 delete_work_stuff (&work_init
);
2615 string_delete (&decl_init
);
2624 demangle_prefix -- consume the mangled name prefix and find signature
2629 demangle_prefix (struct work_stuff *work, const char **mangled,
2634 Consume and demangle the prefix of the mangled name.
2635 While processing the function name root, arrange to call
2636 demangle_signature if the root is ambiguous.
2638 DECLP points to the string buffer into which demangled output is
2639 placed. On entry, the buffer is empty. On exit it contains
2640 the root function name, the demangled operator name, or in some
2641 special cases either nothing or the completely demangled result.
2643 MANGLED points to the current pointer into the mangled name. As each
2644 token of the mangled name is consumed, it is updated. Upon entry
2645 the current mangled name pointer points to the first character of
2646 the mangled name. Upon exit, it should point to the first character
2647 of the signature if demangling was successful, or to the first
2648 unconsumed character if demangling of the prefix was unsuccessful.
2650 Returns 1 on success, 0 otherwise.
2654 demangle_prefix (work
, mangled
, declp
)
2655 struct work_stuff
*work
;
2656 const char **mangled
;
2663 if (strlen(*mangled
) > 6
2664 && (strncmp(*mangled
, "_imp__", 6) == 0
2665 || strncmp(*mangled
, "__imp_", 6) == 0))
2667 /* it's a symbol imported from a PE dynamic library. Check for both
2668 new style prefix _imp__ and legacy __imp_ used by older versions
2671 work
->dllimported
= 1;
2673 else if (strlen(*mangled
) >= 11 && strncmp(*mangled
, "_GLOBAL_", 8) == 0)
2675 char *marker
= strchr (cplus_markers
, (*mangled
)[8]);
2676 if (marker
!= NULL
&& *marker
== (*mangled
)[10])
2678 if ((*mangled
)[9] == 'D')
2680 /* it's a GNU global destructor to be executed at program exit */
2682 work
->destructor
= 2;
2683 if (gnu_special (work
, mangled
, declp
))
2686 else if ((*mangled
)[9] == 'I')
2688 /* it's a GNU global constructor to be executed at program init */
2690 work
->constructor
= 2;
2691 if (gnu_special (work
, mangled
, declp
))
2696 else if ((ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
) && strncmp(*mangled
, "__std__", 7) == 0)
2698 /* it's a ARM global destructor to be executed at program exit */
2700 work
->destructor
= 2;
2702 else if ((ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
) && strncmp(*mangled
, "__sti__", 7) == 0)
2704 /* it's a ARM global constructor to be executed at program initial */
2706 work
->constructor
= 2;
2709 /* This block of code is a reduction in strength time optimization
2711 scan = strstr (*mangled, "__"); */
2717 scan
= strchr (scan
, '_');
2718 } while (scan
!= NULL
&& *++scan
!= '_');
2720 if (scan
!= NULL
) --scan
;
2725 /* We found a sequence of two or more '_', ensure that we start at
2726 the last pair in the sequence. */
2727 i
= strspn (scan
, "_");
2738 else if (work
-> static_type
)
2740 if (!ISDIGIT ((unsigned char)scan
[0]) && (scan
[0] != 't'))
2745 else if ((scan
== *mangled
)
2746 && (ISDIGIT ((unsigned char)scan
[2]) || (scan
[2] == 'Q')
2747 || (scan
[2] == 't') || (scan
[2] == 'K') || (scan
[2] == 'H')))
2749 /* The ARM says nothing about the mangling of local variables.
2750 But cfront mangles local variables by prepending __<nesting_level>
2751 to them. As an extension to ARM demangling we handle this case. */
2752 if ((LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
)
2753 && ISDIGIT ((unsigned char)scan
[2]))
2755 *mangled
= scan
+ 2;
2756 consume_count (mangled
);
2757 string_append (declp
, *mangled
);
2758 *mangled
+= strlen (*mangled
);
2763 /* A GNU style constructor starts with __[0-9Qt]. But cfront uses
2764 names like __Q2_3foo3bar for nested type names. So don't accept
2765 this style of constructor for cfront demangling. A GNU
2766 style member-template constructor starts with 'H'. */
2767 if (!(LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
))
2768 work
-> constructor
+= 1;
2769 *mangled
= scan
+ 2;
2772 else if (ARM_DEMANGLING
&& scan
[2] == 'p' && scan
[3] == 't')
2774 /* Cfront-style parameterized type. Handled later as a signature. */
2778 demangle_arm_hp_template (work
, mangled
, strlen (*mangled
), declp
);
2780 else if (EDG_DEMANGLING
&& ((scan
[2] == 't' && scan
[3] == 'm')
2781 || (scan
[2] == 'p' && scan
[3] == 's')
2782 || (scan
[2] == 'p' && scan
[3] == 't')))
2784 /* EDG-style parameterized type. Handled later as a signature. */
2788 demangle_arm_hp_template (work
, mangled
, strlen (*mangled
), declp
);
2790 else if ((scan
== *mangled
) && !ISDIGIT ((unsigned char)scan
[2])
2791 && (scan
[2] != 't'))
2793 /* Mangled name starts with "__". Skip over any leading '_' characters,
2794 then find the next "__" that separates the prefix from the signature.
2796 if (!(ARM_DEMANGLING
|| LUCID_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
2797 || (arm_special (mangled
, declp
) == 0))
2799 while (*scan
== '_')
2803 if ((scan
= strstr (scan
, "__")) == NULL
|| (*(scan
+ 2) == '\0'))
2805 /* No separator (I.E. "__not_mangled"), or empty signature
2806 (I.E. "__not_mangled_either__") */
2810 return iterate_demangle_function (work
, mangled
, declp
, scan
);
2813 else if (*(scan
+ 2) != '\0')
2815 /* Mangled name does not start with "__" but does have one somewhere
2816 in there with non empty stuff after it. Looks like a global
2817 function name. Iterate over all "__":s until the right
2819 return iterate_demangle_function (work
, mangled
, declp
, scan
);
2823 /* Doesn't look like a mangled name */
2827 if (!success
&& (work
->constructor
== 2 || work
->destructor
== 2))
2829 string_append (declp
, *mangled
);
2830 *mangled
+= strlen (*mangled
);
2840 gnu_special -- special handling of gnu mangled strings
2845 gnu_special (struct work_stuff *work, const char **mangled,
2851 Process some special GNU style mangling forms that don't fit
2852 the normal pattern. For example:
2854 _$_3foo (destructor for class foo)
2855 _vt$foo (foo virtual table)
2856 _vt$foo$bar (foo::bar virtual table)
2857 __vt_foo (foo virtual table, new style with thunks)
2858 _3foo$varname (static data member)
2859 _Q22rs2tu$vw (static data member)
2860 __t6vector1Zii (constructor with template)
2861 __thunk_4__$_7ostream (virtual function thunk)
2865 gnu_special (work
, mangled
, declp
)
2866 struct work_stuff
*work
;
2867 const char **mangled
;
2874 if ((*mangled
)[0] == '_'
2875 && strchr (cplus_markers
, (*mangled
)[1]) != NULL
2876 && (*mangled
)[2] == '_')
2878 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2880 work
-> destructor
+= 1;
2882 else if ((*mangled
)[0] == '_'
2883 && (((*mangled
)[1] == '_'
2884 && (*mangled
)[2] == 'v'
2885 && (*mangled
)[3] == 't'
2886 && (*mangled
)[4] == '_')
2887 || ((*mangled
)[1] == 'v'
2888 && (*mangled
)[2] == 't'
2889 && strchr (cplus_markers
, (*mangled
)[3]) != NULL
)))
2891 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2892 and create the decl. Note that we consume the entire mangled
2893 input string, which means that demangle_signature has no work
2895 if ((*mangled
)[2] == 'v')
2896 (*mangled
) += 5; /* New style, with thunks: "__vt_" */
2898 (*mangled
) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2899 while (**mangled
!= '\0')
2905 success
= demangle_qualified (work
, mangled
, declp
, 0, 1);
2908 success
= demangle_template (work
, mangled
, declp
, 0, 1,
2912 if (ISDIGIT((unsigned char)*mangled
[0]))
2914 n
= consume_count(mangled
);
2915 /* We may be seeing a too-large size, or else a
2916 ".<digits>" indicating a static local symbol. In
2917 any case, declare victory and move on; *don't* try
2918 to use n to allocate. */
2919 if (n
> (int) strlen (*mangled
))
2927 n
= strcspn (*mangled
, cplus_markers
);
2929 string_appendn (declp
, *mangled
, n
);
2933 p
= strpbrk (*mangled
, cplus_markers
);
2934 if (success
&& ((p
== NULL
) || (p
== *mangled
)))
2938 string_append (declp
, SCOPE_STRING (work
));
2949 string_append (declp
, " virtual table");
2951 else if ((*mangled
)[0] == '_'
2952 && (strchr("0123456789Qt", (*mangled
)[1]) != NULL
)
2953 && (p
= strpbrk (*mangled
, cplus_markers
)) != NULL
)
2955 /* static data member, "_3foo$varname" for example */
2961 success
= demangle_qualified (work
, mangled
, declp
, 0, 1);
2964 success
= demangle_template (work
, mangled
, declp
, 0, 1, 1);
2967 n
= consume_count (mangled
);
2968 if (n
< 0 || n
> (long) strlen (*mangled
))
2974 if (n
> 10 && strncmp (*mangled
, "_GLOBAL_", 8) == 0
2975 && (*mangled
)[9] == 'N'
2976 && (*mangled
)[8] == (*mangled
)[10]
2977 && strchr (cplus_markers
, (*mangled
)[8]))
2979 /* A member of the anonymous namespace. There's information
2980 about what identifier or filename it was keyed to, but
2981 it's just there to make the mangled name unique; we just
2983 string_append (declp
, "{anonymous}");
2986 /* Now p points to the marker before the N, so we need to
2987 update it to the first marker after what we consumed. */
2988 p
= strpbrk (*mangled
, cplus_markers
);
2992 string_appendn (declp
, *mangled
, n
);
2995 if (success
&& (p
== *mangled
))
2997 /* Consumed everything up to the cplus_marker, append the
3000 string_append (declp
, SCOPE_STRING (work
));
3001 n
= strlen (*mangled
);
3002 string_appendn (declp
, *mangled
, n
);
3010 else if (strncmp (*mangled
, "__thunk_", 8) == 0)
3015 delta
= consume_count (mangled
);
3020 char *method
= internal_cplus_demangle (work
, ++*mangled
);
3025 sprintf (buf
, "virtual function thunk (delta:%d) for ", -delta
);
3026 string_append (declp
, buf
);
3027 string_append (declp
, method
);
3029 n
= strlen (*mangled
);
3038 else if (strncmp (*mangled
, "__t", 3) == 0
3039 && ((*mangled
)[3] == 'i' || (*mangled
)[3] == 'f'))
3041 p
= (*mangled
)[3] == 'i' ? " type_info node" : " type_info function";
3047 success
= demangle_qualified (work
, mangled
, declp
, 0, 1);
3050 success
= demangle_template (work
, mangled
, declp
, 0, 1, 1);
3053 success
= do_type (work
, mangled
, declp
);
3056 if (success
&& **mangled
!= '\0')
3059 string_append (declp
, p
);
3069 recursively_demangle(work
, mangled
, result
, namelength
)
3070 struct work_stuff
*work
;
3071 const char **mangled
;
3075 char * recurse
= (char *)NULL
;
3076 char * recurse_dem
= (char *)NULL
;
3078 recurse
= (char *) xmalloc (namelength
+ 1);
3079 memcpy (recurse
, *mangled
, namelength
);
3080 recurse
[namelength
] = '\000';
3082 recurse_dem
= cplus_demangle (recurse
, work
->options
);
3086 string_append (result
, recurse_dem
);
3091 string_appendn (result
, *mangled
, namelength
);
3094 *mangled
+= namelength
;
3101 arm_special -- special handling of ARM/lucid mangled strings
3106 arm_special (const char **mangled,
3112 Process some special ARM style mangling forms that don't fit
3113 the normal pattern. For example:
3115 __vtbl__3foo (foo virtual table)
3116 __vtbl__3foo__3bar (bar::foo virtual table)
3121 arm_special (mangled
, declp
)
3122 const char **mangled
;
3129 if (strncmp (*mangled
, ARM_VTABLE_STRING
, ARM_VTABLE_STRLEN
) == 0)
3131 /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3132 and create the decl. Note that we consume the entire mangled
3133 input string, which means that demangle_signature has no work
3135 scan
= *mangled
+ ARM_VTABLE_STRLEN
;
3136 while (*scan
!= '\0') /* first check it can be demangled */
3138 n
= consume_count (&scan
);
3141 return (0); /* no good */
3144 if (scan
[0] == '_' && scan
[1] == '_')
3149 (*mangled
) += ARM_VTABLE_STRLEN
;
3150 while (**mangled
!= '\0')
3152 n
= consume_count (mangled
);
3154 || n
> (long) strlen (*mangled
))
3156 string_prependn (declp
, *mangled
, n
);
3158 if ((*mangled
)[0] == '_' && (*mangled
)[1] == '_')
3160 string_prepend (declp
, "::");
3164 string_append (declp
, " virtual table");
3177 demangle_qualified -- demangle 'Q' qualified name strings
3182 demangle_qualified (struct work_stuff *, const char *mangled,
3183 string *result, int isfuncname, int append);
3187 Demangle a qualified name, such as "Q25Outer5Inner" which is
3188 the mangled form of "Outer::Inner". The demangled output is
3189 prepended or appended to the result string according to the
3190 state of the append flag.
3192 If isfuncname is nonzero, then the qualified name we are building
3193 is going to be used as a member function name, so if it is a
3194 constructor or destructor function, append an appropriate
3195 constructor or destructor name. I.E. for the above example,
3196 the result for use as a constructor is "Outer::Inner::Inner"
3197 and the result for use as a destructor is "Outer::Inner::~Inner".
3201 Numeric conversion is ASCII dependent (FIXME).
3206 demangle_qualified (work
, mangled
, result
, isfuncname
, append
)
3207 struct work_stuff
*work
;
3208 const char **mangled
;
3218 int bindex
= register_Btype (work
);
3220 /* We only make use of ISFUNCNAME if the entity is a constructor or
3222 isfuncname
= (isfuncname
3223 && ((work
->constructor
& 1) || (work
->destructor
& 1)));
3225 string_init (&temp
);
3226 string_init (&last_name
);
3228 if ((*mangled
)[0] == 'K')
3230 /* Squangling qualified name reuse */
3233 idx
= consume_count_with_underscores (mangled
);
3234 if (idx
== -1 || idx
>= work
-> numk
)
3237 string_append (&temp
, work
-> ktypevec
[idx
]);
3240 switch ((*mangled
)[1])
3243 /* GNU mangled name with more than 9 classes. The count is preceded
3244 by an underscore (to distinguish it from the <= 9 case) and followed
3245 by an underscore. */
3247 qualifiers
= consume_count_with_underscores (mangled
);
3248 if (qualifiers
== -1)
3261 /* The count is in a single digit. */
3262 num
[0] = (*mangled
)[1];
3264 qualifiers
= atoi (num
);
3266 /* If there is an underscore after the digit, skip it. This is
3267 said to be for ARM-qualified names, but the ARM makes no
3268 mention of such an underscore. Perhaps cfront uses one. */
3269 if ((*mangled
)[2] == '_')
3284 /* Pick off the names and collect them in the temp buffer in the order
3285 in which they are found, separated by '::'. */
3287 while (qualifiers
-- > 0)
3290 string_clear (&last_name
);
3292 if (*mangled
[0] == '_')
3295 if (*mangled
[0] == 't')
3297 /* Here we always append to TEMP since we will want to use
3298 the template name without the template parameters as a
3299 constructor or destructor name. The appropriate
3300 (parameter-less) value is returned by demangle_template
3301 in LAST_NAME. We do not remember the template type here,
3302 in order to match the G++ mangling algorithm. */
3303 success
= demangle_template(work
, mangled
, &temp
,
3308 else if (*mangled
[0] == 'K')
3312 idx
= consume_count_with_underscores (mangled
);
3313 if (idx
== -1 || idx
>= work
->numk
)
3316 string_append (&temp
, work
->ktypevec
[idx
]);
3319 if (!success
) break;
3326 /* Now recursively demangle the qualifier
3327 * This is necessary to deal with templates in
3328 * mangling styles like EDG */
3329 namelength
= consume_count (mangled
);
3330 if (namelength
== -1)
3335 recursively_demangle(work
, mangled
, &temp
, namelength
);
3339 success
= do_type (work
, mangled
, &last_name
);
3342 string_appends (&temp
, &last_name
);
3347 remember_Ktype (work
, temp
.b
, LEN_STRING (&temp
));
3350 string_append (&temp
, SCOPE_STRING (work
));
3353 remember_Btype (work
, temp
.b
, LEN_STRING (&temp
), bindex
);
3355 /* If we are using the result as a function name, we need to append
3356 the appropriate '::' separated constructor or destructor name.
3357 We do this here because this is the most convenient place, where
3358 we already have a pointer to the name and the length of the name. */
3362 string_append (&temp
, SCOPE_STRING (work
));
3363 if (work
-> destructor
& 1)
3364 string_append (&temp
, "~");
3365 string_appends (&temp
, &last_name
);
3368 /* Now either prepend the temp buffer to the result, or append it,
3369 depending upon the state of the append flag. */
3372 string_appends (result
, &temp
);
3375 if (!STRING_EMPTY (result
))
3376 string_append (&temp
, SCOPE_STRING (work
));
3377 string_prepends (result
, &temp
);
3380 string_delete (&last_name
);
3381 string_delete (&temp
);
3389 get_count -- convert an ascii count to integer, consuming tokens
3394 get_count (const char **type, int *count)
3398 Assume that *type points at a count in a mangled name; set
3399 *count to its value, and set *type to the next character after
3400 the count. There are some weird rules in effect here.
3402 If *type does not point at a string of digits, return zero.
3404 If *type points at a string of digits followed by an
3405 underscore, set *count to their value as an integer, advance
3406 *type to point *after the underscore, and return 1.
3408 If *type points at a string of digits not followed by an
3409 underscore, consume only the first digit. Set *count to its
3410 value as an integer, leave *type pointing after that digit,
3413 The excuse for this odd behavior: in the ARM and HP demangling
3414 styles, a type can be followed by a repeat count of the form
3417 `x' is a single digit specifying how many additional copies
3418 of the type to append to the argument list, and
3420 `y' is one or more digits, specifying the zero-based index of
3421 the first repeated argument in the list. Yes, as you're
3422 unmangling the name you can figure this out yourself, but
3425 So, for example, in `bar__3fooFPiN51', the first argument is a
3426 pointer to an integer (`Pi'), and then the next five arguments
3427 are the same (`N5'), and the first repeat is the function's
3428 second argument (`1').
3432 get_count (type
, count
)
3439 if (!ISDIGIT ((unsigned char)**type
))
3443 *count
= **type
- '0';
3445 if (ISDIGIT ((unsigned char)**type
))
3455 while (ISDIGIT ((unsigned char)*p
));
3466 /* RESULT will be initialised here; it will be freed on failure. The
3467 value returned is really a type_kind_t. */
3470 do_type (work
, mangled
, result
)
3471 struct work_stuff
*work
;
3472 const char **mangled
;
3479 const char *remembered_type
;
3482 type_kind_t tk
= tk_none
;
3484 string_init (&btype
);
3485 string_init (&decl
);
3486 string_init (result
);
3490 while (success
&& !done
)
3496 /* A pointer type */
3500 if (! (work
-> options
& DMGL_JAVA
))
3501 string_prepend (&decl
, "*");
3506 /* A reference type */
3509 string_prepend (&decl
, "&");
3518 if (!STRING_EMPTY (&decl
)
3519 && (decl
.b
[0] == '*' || decl
.b
[0] == '&'))
3521 string_prepend (&decl
, "(");
3522 string_append (&decl
, ")");
3524 string_append (&decl
, "[");
3525 if (**mangled
!= '_')
3526 success
= demangle_template_value_parm (work
, mangled
, &decl
,
3528 if (**mangled
== '_')
3530 string_append (&decl
, "]");
3534 /* A back reference to a previously seen type */
3537 if (!get_count (mangled
, &n
) || n
>= work
-> ntypes
)
3543 remembered_type
= work
-> typevec
[n
];
3544 mangled
= &remembered_type
;
3551 if (!STRING_EMPTY (&decl
)
3552 && (decl
.b
[0] == '*' || decl
.b
[0] == '&'))
3554 string_prepend (&decl
, "(");
3555 string_append (&decl
, ")");
3557 /* After picking off the function args, we expect to either find the
3558 function return type (preceded by an '_') or the end of the
3560 if (!demangle_nested_args (work
, mangled
, &decl
)
3561 || (**mangled
!= '_' && **mangled
!= '\0'))
3566 if (success
&& (**mangled
== '_'))
3573 type_quals
= TYPE_UNQUALIFIED
;
3575 member
= **mangled
== 'M';
3578 string_append (&decl
, ")");
3580 /* We don't need to prepend `::' for a qualified name;
3581 demangle_qualified will do that for us. */
3582 if (**mangled
!= 'Q')
3583 string_prepend (&decl
, SCOPE_STRING (work
));
3585 if (ISDIGIT ((unsigned char)**mangled
))
3587 n
= consume_count (mangled
);
3589 || (int) strlen (*mangled
) < n
)
3594 string_prependn (&decl
, *mangled
, n
);
3597 else if (**mangled
== 'X' || **mangled
== 'Y')
3600 do_type (work
, mangled
, &temp
);
3601 string_prepends (&decl
, &temp
);
3603 else if (**mangled
== 't')
3606 string_init (&temp
);
3607 success
= demangle_template (work
, mangled
, &temp
,
3611 string_prependn (&decl
, temp
.b
, temp
.p
- temp
.b
);
3612 string_clear (&temp
);
3617 else if (**mangled
== 'Q')
3619 success
= demangle_qualified (work
, mangled
, &decl
,
3631 string_prepend (&decl
, "(");
3639 type_quals
|= code_for_qualifier (**mangled
);
3647 if (*(*mangled
)++ != 'F')
3653 if ((member
&& !demangle_nested_args (work
, mangled
, &decl
))
3654 || **mangled
!= '_')
3660 if (! PRINT_ANSI_QUALIFIERS
)
3664 if (type_quals
!= TYPE_UNQUALIFIED
)
3666 APPEND_BLANK (&decl
);
3667 string_append (&decl
, qualifier_string (type_quals
));
3678 if (PRINT_ANSI_QUALIFIERS
)
3680 if (!STRING_EMPTY (&decl
))
3681 string_prepend (&decl
, " ");
3683 string_prepend (&decl
, demangle_qualifier (**mangled
));
3698 if (success
) switch (**mangled
)
3700 /* A qualified name, such as "Outer::Inner". */
3704 success
= demangle_qualified (work
, mangled
, result
, 0, 1);
3708 /* A back reference to a previously seen squangled type */
3711 if (!get_count (mangled
, &n
) || n
>= work
-> numb
)
3714 string_append (result
, work
->btypevec
[n
]);
3719 /* A template parm. We substitute the corresponding argument. */
3724 idx
= consume_count_with_underscores (mangled
);
3727 || (work
->tmpl_argvec
&& idx
>= work
->ntmpl_args
)
3728 || consume_count_with_underscores (mangled
) == -1)
3734 if (work
->tmpl_argvec
)
3735 string_append (result
, work
->tmpl_argvec
[idx
]);
3737 string_append_template_idx (result
, idx
);
3744 success
= demangle_fund_type (work
, mangled
, result
);
3746 tk
= (type_kind_t
) success
;
3752 if (!STRING_EMPTY (&decl
))
3754 string_append (result
, " ");
3755 string_appends (result
, &decl
);
3759 string_delete (result
);
3760 string_delete (&decl
);
3763 /* Assume an integral type, if we're not sure. */
3764 return (int) ((tk
== tk_none
) ? tk_integral
: tk
);
3769 /* Given a pointer to a type string that represents a fundamental type
3770 argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3771 string in which the demangled output is being built in RESULT, and
3772 the WORK structure, decode the types and add them to the result.
3777 "Sl" => "signed long"
3778 "CUs" => "const unsigned short"
3780 The value returned is really a type_kind_t. */
3783 demangle_fund_type (work
, mangled
, result
)
3784 struct work_stuff
*work
;
3785 const char **mangled
;
3791 unsigned int dec
= 0;
3793 type_kind_t tk
= tk_integral
;
3795 string_init (&btype
);
3797 /* First pick off any type qualifiers. There can be more than one. */
3806 if (PRINT_ANSI_QUALIFIERS
)
3808 if (!STRING_EMPTY (result
))
3809 string_prepend (result
, " ");
3810 string_prepend (result
, demangle_qualifier (**mangled
));
3816 APPEND_BLANK (result
);
3817 string_append (result
, "unsigned");
3819 case 'S': /* signed char only */
3821 APPEND_BLANK (result
);
3822 string_append (result
, "signed");
3826 APPEND_BLANK (result
);
3827 string_append (result
, "__complex");
3835 /* Now pick off the fundamental type. There can be only one. */
3844 APPEND_BLANK (result
);
3845 string_append (result
, "void");
3849 APPEND_BLANK (result
);
3850 string_append (result
, "long long");
3854 APPEND_BLANK (result
);
3855 string_append (result
, "long");
3859 APPEND_BLANK (result
);
3860 string_append (result
, "int");
3864 APPEND_BLANK (result
);
3865 string_append (result
, "short");
3869 APPEND_BLANK (result
);
3870 string_append (result
, "bool");
3875 APPEND_BLANK (result
);
3876 string_append (result
, "char");
3881 APPEND_BLANK (result
);
3882 string_append (result
, "wchar_t");
3887 APPEND_BLANK (result
);
3888 string_append (result
, "long double");
3893 APPEND_BLANK (result
);
3894 string_append (result
, "double");
3899 APPEND_BLANK (result
);
3900 string_append (result
, "float");
3905 if (!ISDIGIT ((unsigned char)**mangled
))
3912 if (**mangled
== '_')
3917 i
< (long) sizeof (buf
) - 1 && **mangled
&& **mangled
!= '_';
3920 if (**mangled
!= '_')
3930 strncpy (buf
, *mangled
, 2);
3932 *mangled
+= min (strlen (*mangled
), 2);
3934 sscanf (buf
, "%x", &dec
);
3935 sprintf (buf
, "int%u_t", dec
);
3936 APPEND_BLANK (result
);
3937 string_append (result
, buf
);
3941 /* An explicit type, such as "6mytype" or "7integer" */
3953 int bindex
= register_Btype (work
);
3955 string_init (&btype
);
3956 if (demangle_class_name (work
, mangled
, &btype
)) {
3957 remember_Btype (work
, btype
.b
, LEN_STRING (&btype
), bindex
);
3958 APPEND_BLANK (result
);
3959 string_appends (result
, &btype
);
3963 string_delete (&btype
);
3968 success
= demangle_template (work
, mangled
, &btype
, 0, 1, 1);
3969 string_appends (result
, &btype
);
3977 return success
? ((int) tk
) : 0;
3981 /* Handle a template's value parameter for HP aCC (extension from ARM)
3982 **mangled points to 'S' or 'U' */
3985 do_hpacc_template_const_value (work
, mangled
, result
)
3986 struct work_stuff
*work ATTRIBUTE_UNUSED
;
3987 const char **mangled
;
3992 if (**mangled
!= 'U' && **mangled
!= 'S')
3995 unsigned_const
= (**mangled
== 'U');
4002 string_append (result
, "-");
4008 /* special case for -2^31 */
4009 string_append (result
, "-2147483648");
4016 /* We have to be looking at an integer now */
4017 if (!(ISDIGIT ((unsigned char)**mangled
)))
4020 /* We only deal with integral values for template
4021 parameters -- so it's OK to look only for digits */
4022 while (ISDIGIT ((unsigned char)**mangled
))
4024 char_str
[0] = **mangled
;
4025 string_append (result
, char_str
);
4030 string_append (result
, "U");
4032 /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4033 with L or LL suffixes. pai/1997-09-03 */
4035 return 1; /* success */
4038 /* Handle a template's literal parameter for HP aCC (extension from ARM)
4039 **mangled is pointing to the 'A' */
4042 do_hpacc_template_literal (work
, mangled
, result
)
4043 struct work_stuff
*work
;
4044 const char **mangled
;
4047 int literal_len
= 0;
4051 if (**mangled
!= 'A')
4056 literal_len
= consume_count (mangled
);
4058 if (literal_len
<= 0)
4061 /* Literal parameters are names of arrays, functions, etc. and the
4062 canonical representation uses the address operator */
4063 string_append (result
, "&");
4065 /* Now recursively demangle the literal name */
4066 recurse
= (char *) xmalloc (literal_len
+ 1);
4067 memcpy (recurse
, *mangled
, literal_len
);
4068 recurse
[literal_len
] = '\000';
4070 recurse_dem
= cplus_demangle (recurse
, work
->options
);
4074 string_append (result
, recurse_dem
);
4079 string_appendn (result
, *mangled
, literal_len
);
4081 (*mangled
) += literal_len
;
4088 snarf_numeric_literal (args
, arg
)
4095 string_append (arg
, char_str
);
4098 else if (**args
== '+')
4101 if (!ISDIGIT ((unsigned char)**args
))
4104 while (ISDIGIT ((unsigned char)**args
))
4106 char_str
[0] = **args
;
4107 string_append (arg
, char_str
);
4114 /* Demangle the next argument, given by MANGLED into RESULT, which
4115 *should be an uninitialized* string. It will be initialized here,
4116 and free'd should anything go wrong. */
4119 do_arg (work
, mangled
, result
)
4120 struct work_stuff
*work
;
4121 const char **mangled
;
4124 /* Remember where we started so that we can record the type, for
4125 non-squangling type remembering. */
4126 const char *start
= *mangled
;
4128 string_init (result
);
4130 if (work
->nrepeats
> 0)
4134 if (work
->previous_argument
== 0)
4137 /* We want to reissue the previous type in this argument list. */
4138 string_appends (result
, work
->previous_argument
);
4142 if (**mangled
== 'n')
4144 /* A squangling-style repeat. */
4146 work
->nrepeats
= consume_count(mangled
);
4148 if (work
->nrepeats
<= 0)
4149 /* This was not a repeat count after all. */
4152 if (work
->nrepeats
> 9)
4154 if (**mangled
!= '_')
4155 /* The repeat count should be followed by an '_' in this
4162 /* Now, the repeat is all set up. */
4163 return do_arg (work
, mangled
, result
);
4166 /* Save the result in WORK->previous_argument so that we can find it
4167 if it's repeated. Note that saving START is not good enough: we
4168 do not want to add additional types to the back-referenceable
4169 type vector when processing a repeated type. */
4170 if (work
->previous_argument
)
4171 string_clear (work
->previous_argument
);
4174 work
->previous_argument
= (string
*) xmalloc (sizeof (string
));
4175 string_init (work
->previous_argument
);
4178 if (!do_type (work
, mangled
, work
->previous_argument
))
4181 string_appends (result
, work
->previous_argument
);
4183 remember_type (work
, start
, *mangled
- start
);
4188 remember_type (work
, start
, len
)
4189 struct work_stuff
*work
;
4195 if (work
->forgetting_types
)
4198 if (work
-> ntypes
>= work
-> typevec_size
)
4200 if (work
-> typevec_size
== 0)
4202 work
-> typevec_size
= 3;
4204 = (char **) xmalloc (sizeof (char *) * work
-> typevec_size
);
4208 work
-> typevec_size
*= 2;
4210 = (char **) xrealloc ((char *)work
-> typevec
,
4211 sizeof (char *) * work
-> typevec_size
);
4214 tem
= xmalloc (len
+ 1);
4215 memcpy (tem
, start
, len
);
4217 work
-> typevec
[work
-> ntypes
++] = tem
;
4221 /* Remember a K type class qualifier. */
4223 remember_Ktype (work
, start
, len
)
4224 struct work_stuff
*work
;
4230 if (work
-> numk
>= work
-> ksize
)
4232 if (work
-> ksize
== 0)
4236 = (char **) xmalloc (sizeof (char *) * work
-> ksize
);
4242 = (char **) xrealloc ((char *)work
-> ktypevec
,
4243 sizeof (char *) * work
-> ksize
);
4246 tem
= xmalloc (len
+ 1);
4247 memcpy (tem
, start
, len
);
4249 work
-> ktypevec
[work
-> numk
++] = tem
;
4252 /* Register a B code, and get an index for it. B codes are registered
4253 as they are seen, rather than as they are completed, so map<temp<char> >
4254 registers map<temp<char> > as B0, and temp<char> as B1 */
4257 register_Btype (work
)
4258 struct work_stuff
*work
;
4262 if (work
-> numb
>= work
-> bsize
)
4264 if (work
-> bsize
== 0)
4268 = (char **) xmalloc (sizeof (char *) * work
-> bsize
);
4274 = (char **) xrealloc ((char *)work
-> btypevec
,
4275 sizeof (char *) * work
-> bsize
);
4278 ret
= work
-> numb
++;
4279 work
-> btypevec
[ret
] = NULL
;
4283 /* Store a value into a previously registered B code type. */
4286 remember_Btype (work
, start
, len
, index
)
4287 struct work_stuff
*work
;
4293 tem
= xmalloc (len
+ 1);
4294 memcpy (tem
, start
, len
);
4296 work
-> btypevec
[index
] = tem
;
4299 /* Lose all the info related to B and K type codes. */
4301 forget_B_and_K_types (work
)
4302 struct work_stuff
*work
;
4306 while (work
-> numk
> 0)
4308 i
= --(work
-> numk
);
4309 if (work
-> ktypevec
[i
] != NULL
)
4311 free (work
-> ktypevec
[i
]);
4312 work
-> ktypevec
[i
] = NULL
;
4316 while (work
-> numb
> 0)
4318 i
= --(work
-> numb
);
4319 if (work
-> btypevec
[i
] != NULL
)
4321 free (work
-> btypevec
[i
]);
4322 work
-> btypevec
[i
] = NULL
;
4326 /* Forget the remembered types, but not the type vector itself. */
4330 struct work_stuff
*work
;
4334 while (work
-> ntypes
> 0)
4336 i
= --(work
-> ntypes
);
4337 if (work
-> typevec
[i
] != NULL
)
4339 free (work
-> typevec
[i
]);
4340 work
-> typevec
[i
] = NULL
;
4345 /* Process the argument list part of the signature, after any class spec
4346 has been consumed, as well as the first 'F' character (if any). For
4349 "__als__3fooRT0" => process "RT0"
4350 "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
4352 DECLP must be already initialised, usually non-empty. It won't be freed
4355 Note that g++ differs significantly from ARM and lucid style mangling
4356 with regards to references to previously seen types. For example, given
4357 the source fragment:
4361 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4364 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4365 void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4367 g++ produces the names:
4372 while lcc (and presumably other ARM style compilers as well) produces:
4374 foo__FiR3fooT1T2T1T2
4375 __ct__3fooFiR3fooT1T2T1T2
4377 Note that g++ bases its type numbers starting at zero and counts all
4378 previously seen types, while lucid/ARM bases its type numbers starting
4379 at one and only considers types after it has seen the 'F' character
4380 indicating the start of the function args. For lucid/ARM style, we
4381 account for this difference by discarding any previously seen types when
4382 we see the 'F' character, and subtracting one from the type number
4388 demangle_args (work
, mangled
, declp
)
4389 struct work_stuff
*work
;
4390 const char **mangled
;
4400 if (PRINT_ARG_TYPES
)
4402 string_append (declp
, "(");
4403 if (**mangled
== '\0')
4405 string_append (declp
, "void");
4409 while ((**mangled
!= '_' && **mangled
!= '\0' && **mangled
!= 'e')
4410 || work
->nrepeats
> 0)
4412 if ((**mangled
== 'N') || (**mangled
== 'T'))
4414 temptype
= *(*mangled
)++;
4416 if (temptype
== 'N')
4418 if (!get_count (mangled
, &r
))
4427 if ((HP_DEMANGLING
|| ARM_DEMANGLING
|| EDG_DEMANGLING
) && work
-> ntypes
>= 10)
4429 /* If we have 10 or more types we might have more than a 1 digit
4430 index so we'll have to consume the whole count here. This
4431 will lose if the next thing is a type name preceded by a
4432 count but it's impossible to demangle that case properly
4433 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4434 Pc, ...)" or "(..., type12, char *, ...)" */
4435 if ((t
= consume_count(mangled
)) <= 0)
4442 if (!get_count (mangled
, &t
))
4447 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
4451 /* Validate the type index. Protect against illegal indices from
4452 malformed type strings. */
4453 if ((t
< 0) || (t
>= work
-> ntypes
))
4457 while (work
->nrepeats
> 0 || --r
>= 0)
4459 tem
= work
-> typevec
[t
];
4460 if (need_comma
&& PRINT_ARG_TYPES
)
4462 string_append (declp
, ", ");
4464 if (!do_arg (work
, &tem
, &arg
))
4468 if (PRINT_ARG_TYPES
)
4470 string_appends (declp
, &arg
);
4472 string_delete (&arg
);
4478 if (need_comma
&& PRINT_ARG_TYPES
)
4479 string_append (declp
, ", ");
4480 if (!do_arg (work
, mangled
, &arg
))
4482 if (PRINT_ARG_TYPES
)
4483 string_appends (declp
, &arg
);
4484 string_delete (&arg
);
4489 if (**mangled
== 'e')
4492 if (PRINT_ARG_TYPES
)
4496 string_append (declp
, ",");
4498 string_append (declp
, "...");
4502 if (PRINT_ARG_TYPES
)
4504 string_append (declp
, ")");
4509 /* Like demangle_args, but for demangling the argument lists of function
4510 and method pointers or references, not top-level declarations. */
4513 demangle_nested_args (work
, mangled
, declp
)
4514 struct work_stuff
*work
;
4515 const char **mangled
;
4518 string
* saved_previous_argument
;
4522 /* The G++ name-mangling algorithm does not remember types on nested
4523 argument lists, unless -fsquangling is used, and in that case the
4524 type vector updated by remember_type is not used. So, we turn
4525 off remembering of types here. */
4526 ++work
->forgetting_types
;
4528 /* For the repeat codes used with -fsquangling, we must keep track of
4529 the last argument. */
4530 saved_previous_argument
= work
->previous_argument
;
4531 saved_nrepeats
= work
->nrepeats
;
4532 work
->previous_argument
= 0;
4535 /* Actually demangle the arguments. */
4536 result
= demangle_args (work
, mangled
, declp
);
4538 /* Restore the previous_argument field. */
4539 if (work
->previous_argument
)
4540 string_delete (work
->previous_argument
);
4541 work
->previous_argument
= saved_previous_argument
;
4542 --work
->forgetting_types
;
4543 work
->nrepeats
= saved_nrepeats
;
4549 demangle_function_name (work
, mangled
, declp
, scan
)
4550 struct work_stuff
*work
;
4551 const char **mangled
;
4559 string_appendn (declp
, (*mangled
), scan
- (*mangled
));
4560 string_need (declp
, 1);
4561 *(declp
-> p
) = '\0';
4563 /* Consume the function name, including the "__" separating the name
4564 from the signature. We are guaranteed that SCAN points to the
4567 (*mangled
) = scan
+ 2;
4568 /* We may be looking at an instantiation of a template function:
4569 foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4570 following _F marks the start of the function arguments. Handle
4571 the template arguments first. */
4573 if (HP_DEMANGLING
&& (**mangled
== 'X'))
4575 demangle_arm_hp_template (work
, mangled
, 0, declp
);
4576 /* This leaves MANGLED pointing to the 'F' marking func args */
4579 if (LUCID_DEMANGLING
|| ARM_DEMANGLING
|| HP_DEMANGLING
|| EDG_DEMANGLING
)
4582 /* See if we have an ARM style constructor or destructor operator.
4583 If so, then just record it, clear the decl, and return.
4584 We can't build the actual constructor/destructor decl until later,
4585 when we recover the class name from the signature. */
4587 if (strcmp (declp
-> b
, "__ct") == 0)
4589 work
-> constructor
+= 1;
4590 string_clear (declp
);
4593 else if (strcmp (declp
-> b
, "__dt") == 0)
4595 work
-> destructor
+= 1;
4596 string_clear (declp
);
4601 if (declp
->p
- declp
->b
>= 3
4602 && declp
->b
[0] == 'o'
4603 && declp
->b
[1] == 'p'
4604 && strchr (cplus_markers
, declp
->b
[2]) != NULL
)
4606 /* see if it's an assignment expression */
4607 if (declp
->p
- declp
->b
>= 10 /* op$assign_ */
4608 && memcmp (declp
->b
+ 3, "assign_", 7) == 0)
4610 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4612 int len
= declp
->p
- declp
->b
- 10;
4613 if ((int) strlen (optable
[i
].in
) == len
4614 && memcmp (optable
[i
].in
, declp
->b
+ 10, len
) == 0)
4616 string_clear (declp
);
4617 string_append (declp
, "operator");
4618 string_append (declp
, optable
[i
].out
);
4619 string_append (declp
, "=");
4626 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4628 int len
= declp
->p
- declp
->b
- 3;
4629 if ((int) strlen (optable
[i
].in
) == len
4630 && memcmp (optable
[i
].in
, declp
->b
+ 3, len
) == 0)
4632 string_clear (declp
);
4633 string_append (declp
, "operator");
4634 string_append (declp
, optable
[i
].out
);
4640 else if (declp
->p
- declp
->b
>= 5 && memcmp (declp
->b
, "type", 4) == 0
4641 && strchr (cplus_markers
, declp
->b
[4]) != NULL
)
4643 /* type conversion operator */
4645 if (do_type (work
, &tem
, &type
))
4647 string_clear (declp
);
4648 string_append (declp
, "operator ");
4649 string_appends (declp
, &type
);
4650 string_delete (&type
);
4653 else if (declp
->b
[0] == '_' && declp
->b
[1] == '_'
4654 && declp
->b
[2] == 'o' && declp
->b
[3] == 'p')
4657 /* type conversion operator. */
4659 if (do_type (work
, &tem
, &type
))
4661 string_clear (declp
);
4662 string_append (declp
, "operator ");
4663 string_appends (declp
, &type
);
4664 string_delete (&type
);
4667 else if (declp
->b
[0] == '_' && declp
->b
[1] == '_'
4668 && ISLOWER((unsigned char)declp
->b
[2])
4669 && ISLOWER((unsigned char)declp
->b
[3]))
4671 if (declp
->b
[4] == '\0')
4674 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4676 if (strlen (optable
[i
].in
) == 2
4677 && memcmp (optable
[i
].in
, declp
->b
+ 2, 2) == 0)
4679 string_clear (declp
);
4680 string_append (declp
, "operator");
4681 string_append (declp
, optable
[i
].out
);
4688 if (declp
->b
[2] == 'a' && declp
->b
[5] == '\0')
4691 for (i
= 0; i
< ARRAY_SIZE (optable
); i
++)
4693 if (strlen (optable
[i
].in
) == 3
4694 && memcmp (optable
[i
].in
, declp
->b
+ 2, 3) == 0)
4696 string_clear (declp
);
4697 string_append (declp
, "operator");
4698 string_append (declp
, optable
[i
].out
);
4707 /* a mini string-handling package */
4722 s
->p
= s
->b
= xmalloc (n
);
4725 else if (s
->e
- s
->p
< n
)
4730 s
->b
= xrealloc (s
->b
, n
);
4743 s
->b
= s
->e
= s
->p
= NULL
;
4751 s
->b
= s
->p
= s
->e
= NULL
;
4767 return (s
->b
== s
->p
);
4773 string_append (p
, s
)
4778 if (s
== NULL
|| *s
== '\0')
4782 memcpy (p
->p
, s
, n
);
4787 string_appends (p
, s
)
4796 memcpy (p
->p
, s
->b
, n
);
4802 string_appendn (p
, s
, n
)
4810 memcpy (p
->p
, s
, n
);
4816 string_prepend (p
, s
)
4820 if (s
!= NULL
&& *s
!= '\0')
4822 string_prependn (p
, s
, strlen (s
));
4827 string_prepends (p
, s
)
4832 string_prependn (p
, s
->b
, s
->p
- s
->b
);
4837 string_prependn (p
, s
, n
)
4847 for (q
= p
->p
- 1; q
>= p
->b
; q
--)
4851 memcpy (p
->b
, s
, n
);
4857 string_append_template_idx (s
, idx
)
4861 char buf
[INTBUF_SIZE
+ 1 /* 'T' */];
4862 sprintf(buf
, "T%d", idx
);
4863 string_append (s
, buf
);
4866 /* To generate a standalone demangler program for testing purposes,
4867 just compile and link this file with -DMAIN and libiberty.a. When
4868 run, it demangles each command line arg, or each stdin string, and
4869 prints the result on stdout. */
4875 static const char *program_name
;
4876 static const char *program_version
= VERSION
;
4877 static int flags
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_VERBOSE
;
4879 static void demangle_it
PARAMS ((char *));
4880 static void usage
PARAMS ((FILE *, int)) ATTRIBUTE_NORETURN
;
4881 static void fatal
PARAMS ((const char *)) ATTRIBUTE_NORETURN
;
4882 static void print_demangler_list
PARAMS ((FILE *));
4885 demangle_it (mangled_name
)
4890 /* For command line args, also try to demangle type encodings. */
4891 result
= cplus_demangle (mangled_name
, flags
| DMGL_TYPES
);
4894 printf ("%s\n", mangled_name
);
4898 printf ("%s\n", result
);
4904 print_demangler_list (stream
)
4907 const struct demangler_engine
*demangler
;
4909 fprintf (stream
, "{%s", libiberty_demanglers
->demangling_style_name
);
4911 for (demangler
= libiberty_demanglers
+ 1;
4912 demangler
->demangling_style
!= unknown_demangling
;
4914 fprintf (stream
, ",%s", demangler
->demangling_style_name
);
4916 fprintf (stream
, "}");
4920 usage (stream
, status
)
4925 Usage: %s [-_] [-n] [--strip-underscores] [--no-strip-underscores] \n",
4930 print_demangler_list (stream
);
4931 fprintf (stream
, "]\n");
4935 print_demangler_list (stream
);
4936 fprintf (stream
, "]\n");
4939 [--help] [--version] [arg...]\n");
4943 #define MBUF_SIZE 32767
4944 char mbuffer
[MBUF_SIZE
];
4946 /* Defined in the automatically-generated underscore.c. */
4947 extern int prepends_underscore
;
4949 int strip_underscore
= 0;
4951 static const struct option long_options
[] = {
4952 {"strip-underscores", no_argument
, 0, '_'},
4953 {"format", required_argument
, 0, 's'},
4954 {"help", no_argument
, 0, 'h'},
4955 {"no-strip-underscores", no_argument
, 0, 'n'},
4956 {"version", no_argument
, 0, 'v'},
4957 {0, no_argument
, 0, 0}
4960 /* More 'friendly' abort that prints the line and file.
4961 config.h can #define abort fancy_abort if you like that sort of thing. */
4966 fatal ("Internal gcc abort.");
4971 standard_symbol_characters
PARAMS ((void));
4974 hp_symbol_characters
PARAMS ((void));
4977 gnu_v3_symbol_characters
PARAMS ((void));
4979 /* Return the string of non-alnum characters that may occur
4980 as a valid symbol component, in the standard assembler symbol
4984 standard_symbol_characters ()
4990 /* Return the string of non-alnum characters that may occur
4991 as a valid symbol name component in an HP object file.
4993 Note that, since HP's compiler generates object code straight from
4994 C++ source, without going through an assembler, its mangled
4995 identifiers can use all sorts of characters that no assembler would
4996 tolerate, so the alphabet this function creates is a little odd.
4997 Here are some sample mangled identifiers offered by HP:
4999 typeid*__XT24AddressIndExpClassMember_
5000 [Vftptr]key:__dt__32OrdinaryCompareIndExpClassMemberFv
5001 __ct__Q2_9Elf64_Dyn18{unnamed.union.#1}Fv
5003 This still seems really weird to me, since nowhere else in this
5004 file is there anything to recognize curly brackets, parens, etc.
5005 I've talked with Srikanth <srikanth@cup.hp.com>, and he assures me
5006 this is right, but I still strongly suspect that there's a
5007 misunderstanding here.
5009 If we decide it's better for c++filt to use HP's assembler syntax
5010 to scrape identifiers out of its input, here's the definition of
5011 the symbol name syntax from the HP assembler manual:
5013 Symbols are composed of uppercase and lowercase letters, decimal
5014 digits, dollar symbol, period (.), ampersand (&), pound sign(#) and
5015 underscore (_). A symbol can begin with a letter, digit underscore or
5016 dollar sign. If a symbol begins with a digit, it must contain a
5017 non-digit character.
5021 hp_symbol_characters ()
5023 return "_$.<>#,*&[]:(){}";
5027 /* Return the string of non-alnum characters that may occur
5028 as a valid symbol component in the GNU C++ V3 ABI mangling
5032 gnu_v3_symbol_characters ()
5038 extern int main
PARAMS ((int, char **));
5047 const char *valid_symbols
;
5048 enum demangling_styles style
= auto_demangling
;
5050 program_name
= argv
[0];
5052 strip_underscore
= prepends_underscore
;
5054 while ((c
= getopt_long (argc
, argv
, "_ns:", long_options
, (int *) 0)) != EOF
)
5064 strip_underscore
= 0;
5067 printf ("GNU %s (C++ demangler), version %s\n", program_name
, program_version
);
5070 strip_underscore
= 1;
5074 style
= cplus_demangle_name_to_style (optarg
);
5075 if (style
== unknown_demangling
)
5077 fprintf (stderr
, "%s: unknown demangling style `%s'\n",
5078 program_name
, optarg
);
5082 cplus_demangle_set_style (style
);
5090 for ( ; optind
< argc
; optind
++)
5092 demangle_it (argv
[optind
]);
5097 switch (current_demangling_style
)
5099 case gnu_demangling
:
5100 case lucid_demangling
:
5101 case arm_demangling
:
5102 case java_demangling
:
5103 case edg_demangling
:
5104 case gnat_demangling
:
5105 case auto_demangling
:
5106 valid_symbols
= standard_symbol_characters ();
5109 valid_symbols
= hp_symbol_characters ();
5111 case gnu_v3_demangling
:
5112 valid_symbols
= gnu_v3_symbol_characters ();
5115 /* Folks should explicitly indicate the appropriate alphabet for
5116 each demangling. Providing a default would allow the
5117 question to go unconsidered. */
5125 /* Try to read a label. */
5126 while (c
!= EOF
&& (ISALNUM (c
) || strchr (valid_symbols
, c
)))
5128 if (i
>= MBUF_SIZE
-1)
5137 if (mbuffer
[0] == '.' || mbuffer
[0] == '$')
5139 if (strip_underscore
&& mbuffer
[skip_first
] == '_')
5146 flags
|= (int) style
;
5147 result
= cplus_demangle (mbuffer
+ skip_first
, flags
);
5150 if (mbuffer
[0] == '.')
5152 fputs (result
, stdout
);
5156 fputs (mbuffer
, stdout
);
5174 fprintf (stderr
, "%s: %s\n", program_name
, str
);
5182 register PTR value
= (PTR
) malloc (size
);
5184 fatal ("virtual memory exhausted");
5189 xrealloc (ptr
, size
)
5193 register PTR value
= (PTR
) realloc (ptr
, size
);
5195 fatal ("virtual memory exhausted");