1
/* Demangler for GNU C++
2
Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
3
2000, 2001, 2002, 2003, 2004, 2010 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
In addition to the permissions in the GNU Library General Public
15
License, the Free Software Foundation gives you unlimited permission
16
to link the compiled version of this file into combinations with other
17
programs, and to distribute those combinations without any restriction
18
coming from the use of this file. (The Library Public License
19
restrictions do apply in other respects; for example, they cover
20
modification of the file, and distribution when not linked into a
23
Libiberty is distributed in the hope that it will be useful,
24
but WITHOUT ANY WARRANTY; without even the implied warranty of
25
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26
Library General Public License for more details.
28
You should have received a copy of the GNU Library General Public
29
License along with libiberty; see the file COPYING.LIB. If
30
not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
31
Boston, MA 02110-1301, USA. */
33
/* This file exports two functions; cplus_mangle_opname and cplus_demangle.
35
This file imports xmalloc and xrealloc, which are like malloc and
36
realloc except that they generate a fatal error if there is no
39
/* This file lives in both GCC and libiberty. When making changes, please
40
try not to break either. */
46
#include "safe-ctype.h"
48
#include <sys/types.h>
60
#undef CURRENT_DEMANGLING_STYLE
61
#define CURRENT_DEMANGLING_STYLE work->options
63
#include "libiberty.h"
65
#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
67
/* A value at least one greater than the maximum number of characters
68
that will be output when using the `%d' format with `printf'. */
69
#define INTBUF_SIZE 32
71
extern void fancy_abort (void) ATTRIBUTE_NORETURN;
73
/* In order to allow a single demangler executable to demangle strings
74
using various common values of CPLUS_MARKER, as well as any specific
75
one set at compile time, we maintain a string containing all the
76
commonly used ones, and check to see if the marker we are looking for
77
is in that string. CPLUS_MARKER is usually '$' on systems where the
78
assembler can deal with that. Where the assembler can't, it's usually
79
'.' (but on many systems '.' is used for other things). We put the
80
current defined CPLUS_MARKER first (which defaults to '$'), followed
81
by the next most common value, followed by an explicit '$' in case
82
the value of CPLUS_MARKER is not '$'.
84
We could avoid this if we could just get g++ to tell us what the actual
85
cplus marker character is as part of the debug information, perhaps by
86
ensuring that it is the character that terminates the gcc<n>_compiled
87
marker symbol (FIXME). */
89
#if !defined (CPLUS_MARKER)
90
#define CPLUS_MARKER '$'
93
enum demangling_styles current_demangling_style = auto_demangling;
95
static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
97
static char char_str[2] = { '\000', '\000' };
100
set_cplus_marker_for_demangling (int ch)
102
cplus_markers[0] = ch;
105
typedef struct string /* Beware: these aren't required to be */
106
{ /* '\0' terminated. */
107
char *b; /* pointer to start of string */
108
char *p; /* pointer after last character */
109
char *e; /* pointer after end of allocated space */
112
/* Stuff that is shared between sub-routines.
113
Using a shared structure allows cplus_demangle to be reentrant. */
129
int static_type; /* A static member function */
130
int temp_start; /* index in demangled to start of template args */
131
int type_quals; /* The type qualifiers. */
132
int dllimported; /* Symbol imported from a PE DLL */
133
char **tmpl_argvec; /* Template function arguments. */
134
int ntmpl_args; /* The number of template function arguments. */
135
int forgetting_types; /* Nonzero if we are not remembering the types
137
string* previous_argument; /* The last function argument demangled. */
138
int nrepeats; /* The number of times to repeat the previous
142
#define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
143
#define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
145
static const struct optable
147
const char *const in;
148
const char *const out;
151
{"nw", " new", DMGL_ANSI}, /* new (1.92, ansi) */
152
{"dl", " delete", DMGL_ANSI}, /* new (1.92, ansi) */
153
{"new", " new", 0}, /* old (1.91, and 1.x) */
154
{"delete", " delete", 0}, /* old (1.91, and 1.x) */
155
{"vn", " new []", DMGL_ANSI}, /* GNU, pending ansi */
156
{"vd", " delete []", DMGL_ANSI}, /* GNU, pending ansi */
157
{"as", "=", DMGL_ANSI}, /* ansi */
158
{"ne", "!=", DMGL_ANSI}, /* old, ansi */
159
{"eq", "==", DMGL_ANSI}, /* old, ansi */
160
{"ge", ">=", DMGL_ANSI}, /* old, ansi */
161
{"gt", ">", DMGL_ANSI}, /* old, ansi */
162
{"le", "<=", DMGL_ANSI}, /* old, ansi */
163
{"lt", "<", DMGL_ANSI}, /* old, ansi */
164
{"plus", "+", 0}, /* old */
165
{"pl", "+", DMGL_ANSI}, /* ansi */
166
{"apl", "+=", DMGL_ANSI}, /* ansi */
167
{"minus", "-", 0}, /* old */
168
{"mi", "-", DMGL_ANSI}, /* ansi */
169
{"ami", "-=", DMGL_ANSI}, /* ansi */
170
{"mult", "*", 0}, /* old */
171
{"ml", "*", DMGL_ANSI}, /* ansi */
172
{"amu", "*=", DMGL_ANSI}, /* ansi (ARM/Lucid) */
173
{"aml", "*=", DMGL_ANSI}, /* ansi (GNU/g++) */
174
{"convert", "+", 0}, /* old (unary +) */
175
{"negate", "-", 0}, /* old (unary -) */
176
{"trunc_mod", "%", 0}, /* old */
177
{"md", "%", DMGL_ANSI}, /* ansi */
178
{"amd", "%=", DMGL_ANSI}, /* ansi */
179
{"trunc_div", "/", 0}, /* old */
180
{"dv", "/", DMGL_ANSI}, /* ansi */
181
{"adv", "/=", DMGL_ANSI}, /* ansi */
182
{"truth_andif", "&&", 0}, /* old */
183
{"aa", "&&", DMGL_ANSI}, /* ansi */
184
{"truth_orif", "||", 0}, /* old */
185
{"oo", "||", DMGL_ANSI}, /* ansi */
186
{"truth_not", "!", 0}, /* old */
187
{"nt", "!", DMGL_ANSI}, /* ansi */
188
{"postincrement","++", 0}, /* old */
189
{"pp", "++", DMGL_ANSI}, /* ansi */
190
{"postdecrement","--", 0}, /* old */
191
{"mm", "--", DMGL_ANSI}, /* ansi */
192
{"bit_ior", "|", 0}, /* old */
193
{"or", "|", DMGL_ANSI}, /* ansi */
194
{"aor", "|=", DMGL_ANSI}, /* ansi */
195
{"bit_xor", "^", 0}, /* old */
196
{"er", "^", DMGL_ANSI}, /* ansi */
197
{"aer", "^=", DMGL_ANSI}, /* ansi */
198
{"bit_and", "&", 0}, /* old */
199
{"ad", "&", DMGL_ANSI}, /* ansi */
200
{"aad", "&=", DMGL_ANSI}, /* ansi */
201
{"bit_not", "~", 0}, /* old */
202
{"co", "~", DMGL_ANSI}, /* ansi */
203
{"call", "()", 0}, /* old */
204
{"cl", "()", DMGL_ANSI}, /* ansi */
205
{"alshift", "<<", 0}, /* old */
206
{"ls", "<<", DMGL_ANSI}, /* ansi */
207
{"als", "<<=", DMGL_ANSI}, /* ansi */
208
{"arshift", ">>", 0}, /* old */
209
{"rs", ">>", DMGL_ANSI}, /* ansi */
210
{"ars", ">>=", DMGL_ANSI}, /* ansi */
211
{"component", "->", 0}, /* old */
212
{"pt", "->", DMGL_ANSI}, /* ansi; Lucid C++ form */
213
{"rf", "->", DMGL_ANSI}, /* ansi; ARM/GNU form */
214
{"indirect", "*", 0}, /* old */
215
{"method_call", "->()", 0}, /* old */
216
{"addr", "&", 0}, /* old (unary &) */
217
{"array", "[]", 0}, /* old */
218
{"vc", "[]", DMGL_ANSI}, /* ansi */
219
{"compound", ", ", 0}, /* old */
220
{"cm", ", ", DMGL_ANSI}, /* ansi */
221
{"cond", "?:", 0}, /* old */
222
{"cn", "?:", DMGL_ANSI}, /* pseudo-ansi */
223
{"max", ">?", 0}, /* old */
224
{"mx", ">?", DMGL_ANSI}, /* pseudo-ansi */
225
{"min", "<?", 0}, /* old */
226
{"mn", "<?", DMGL_ANSI}, /* pseudo-ansi */
227
{"nop", "", 0}, /* old (for operator=) */
228
{"rm", "->*", DMGL_ANSI}, /* ansi */
229
{"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */
232
/* These values are used to indicate the various type varieties.
233
They are all non-zero so that they can be used as `success'
235
typedef enum type_kind_t
246
const struct demangler_engine libiberty_demanglers[] =
249
NO_DEMANGLING_STYLE_STRING,
251
"Demangling disabled"
255
AUTO_DEMANGLING_STYLE_STRING,
257
"Automatic selection based on executable"
261
GNU_DEMANGLING_STYLE_STRING,
263
"GNU (g++) style demangling"
267
LUCID_DEMANGLING_STYLE_STRING,
269
"Lucid (lcc) style demangling"
273
ARM_DEMANGLING_STYLE_STRING,
275
"ARM style demangling"
279
HP_DEMANGLING_STYLE_STRING,
281
"HP (aCC) style demangling"
285
EDG_DEMANGLING_STYLE_STRING,
287
"EDG style demangling"
291
GNU_V3_DEMANGLING_STYLE_STRING,
293
"GNU (g++) V3 ABI-style demangling"
297
JAVA_DEMANGLING_STYLE_STRING,
299
"Java style demangling"
303
GNAT_DEMANGLING_STYLE_STRING,
305
"GNAT style demangling"
309
NULL, unknown_demangling, NULL
313
#define STRING_EMPTY(str) ((str) -> b == (str) -> p)
314
#define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
315
string_append(str, " ");}
316
#define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
318
/* The scope separator appropriate for the language being demangled. */
320
#define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
322
#define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
323
#define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
325
/* Prototypes for local functions */
327
static void delete_work_stuff (struct work_stuff *);
329
static void delete_non_B_K_work_stuff (struct work_stuff *);
331
static char *mop_up (struct work_stuff *, string *, int);
333
static void squangle_mop_up (struct work_stuff *);
335
static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
339
demangle_method_args (struct work_stuff *, const char **, string *);
343
internal_cplus_demangle (struct work_stuff *, const char *);
346
demangle_template_template_parm (struct work_stuff *work,
347
const char **, string *);
350
demangle_template (struct work_stuff *work, const char **, string *,
354
arm_pt (struct work_stuff *, const char *, int, const char **,
358
demangle_class_name (struct work_stuff *, const char **, string *);
361
demangle_qualified (struct work_stuff *, const char **, string *,
364
static int demangle_class (struct work_stuff *, const char **, string *);
366
static int demangle_fund_type (struct work_stuff *, const char **, string *);
368
static int demangle_signature (struct work_stuff *, const char **, string *);
370
static int demangle_prefix (struct work_stuff *, const char **, string *);
372
static int gnu_special (struct work_stuff *, const char **, string *);
374
static int arm_special (const char **, string *);
376
static void string_need (string *, int);
378
static void string_delete (string *);
381
string_init (string *);
383
static void string_clear (string *);
386
static int string_empty (string *);
389
static void string_append (string *, const char *);
391
static void string_appends (string *, string *);
393
static void string_appendn (string *, const char *, int);
395
static void string_prepend (string *, const char *);
397
static void string_prependn (string *, const char *, int);
399
static void string_append_template_idx (string *, int);
401
static int get_count (const char **, int *);
403
static int consume_count (const char **);
405
static int consume_count_with_underscores (const char**);
407
static int demangle_args (struct work_stuff *, const char **, string *);
409
static int demangle_nested_args (struct work_stuff*, const char**, string*);
411
static int do_type (struct work_stuff *, const char **, string *);
413
static int do_arg (struct work_stuff *, const char **, string *);
416
demangle_function_name (struct work_stuff *, const char **, string *,
420
iterate_demangle_function (struct work_stuff *,
421
const char **, string *, const char *);
423
static void remember_type (struct work_stuff *, const char *, int);
425
static void remember_Btype (struct work_stuff *, const char *, int, int);
427
static int register_Btype (struct work_stuff *);
429
static void remember_Ktype (struct work_stuff *, const char *, int);
431
static void forget_types (struct work_stuff *);
433
static void forget_B_and_K_types (struct work_stuff *);
435
static void string_prepends (string *, string *);
438
demangle_template_value_parm (struct work_stuff*, const char**,
439
string*, type_kind_t);
442
do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
445
do_hpacc_template_literal (struct work_stuff *, const char **, string *);
447
static int snarf_numeric_literal (const char **, string *);
449
/* There is a TYPE_QUAL value for each type qualifier. They can be
450
combined by bitwise-or to form the complete set of qualifiers for a
453
#define TYPE_UNQUALIFIED 0x0
454
#define TYPE_QUAL_CONST 0x1
455
#define TYPE_QUAL_VOLATILE 0x2
456
#define TYPE_QUAL_RESTRICT 0x4
458
static int code_for_qualifier (int);
460
static const char* qualifier_string (int);
462
static const char* demangle_qualifier (int);
464
static int demangle_expression (struct work_stuff *, const char **, string *,
468
demangle_integral_value (struct work_stuff *, const char **, string *);
471
demangle_real_value (struct work_stuff *, const char **, string *);
474
demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
477
recursively_demangle (struct work_stuff *, const char **, string *, int);
479
/* Translate count to integer, consuming tokens in the process.
480
Conversion terminates on the first non-digit character.
482
Trying to consume something that isn't a count results in no
483
consumption of input and a return of -1.
485
Overflow consumes the rest of the digits, and returns -1. */
488
consume_count (const char **type)
492
if (! ISDIGIT ((unsigned char)**type))
495
while (ISDIGIT ((unsigned char)**type))
499
/* Check for overflow.
500
We assume that count is represented using two's-complement;
501
no power of two is divisible by ten, so if an overflow occurs
502
when multiplying by ten, the result will not be a multiple of
504
if ((count % 10) != 0)
506
while (ISDIGIT ((unsigned char) **type))
511
count += **type - '0';
522
/* Like consume_count, but for counts that are preceded and followed
523
by '_' if they are greater than 10. Also, -1 is returned for
524
failure, since 0 can be a valid value. */
527
consume_count_with_underscores (const char **mangled)
531
if (**mangled == '_')
534
if (!ISDIGIT ((unsigned char)**mangled))
537
idx = consume_count (mangled);
538
if (**mangled != '_')
539
/* The trailing underscore was missing. */
546
if (**mangled < '0' || **mangled > '9')
549
idx = **mangled - '0';
556
/* C is the code for a type-qualifier. Return the TYPE_QUAL
557
corresponding to this qualifier. */
560
code_for_qualifier (int c)
565
return TYPE_QUAL_CONST;
568
return TYPE_QUAL_VOLATILE;
571
return TYPE_QUAL_RESTRICT;
577
/* C was an invalid qualifier. */
581
/* Return the string corresponding to the qualifiers given by
585
qualifier_string (int type_quals)
589
case TYPE_UNQUALIFIED:
592
case TYPE_QUAL_CONST:
595
case TYPE_QUAL_VOLATILE:
598
case TYPE_QUAL_RESTRICT:
601
case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
602
return "const volatile";
604
case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
605
return "const __restrict";
607
case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
608
return "volatile __restrict";
610
case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
611
return "const volatile __restrict";
617
/* TYPE_QUALS was an invalid qualifier set. */
621
/* C is the code for a type-qualifier. Return the string
622
corresponding to this qualifier. This function should only be
623
called with a valid qualifier code. */
626
demangle_qualifier (int c)
628
return qualifier_string (code_for_qualifier (c));
632
cplus_demangle_opname (const char *opname, char *result, int options)
636
struct work_stuff work[1];
639
len = strlen(opname);
642
memset ((char *) work, 0, sizeof (work));
643
work->options = options;
645
if (opname[0] == '_' && opname[1] == '_'
646
&& opname[2] == 'o' && opname[3] == 'p')
649
/* type conversion operator. */
651
if (do_type (work, &tem, &type))
653
strcat (result, "operator ");
654
strncat (result, type.b, type.p - type.b);
655
string_delete (&type);
659
else if (opname[0] == '_' && opname[1] == '_'
660
&& ISLOWER((unsigned char)opname[2])
661
&& ISLOWER((unsigned char)opname[3]))
663
if (opname[4] == '\0')
667
for (i = 0; i < ARRAY_SIZE (optable); i++)
669
if (strlen (optable[i].in) == 2
670
&& memcmp (optable[i].in, opname + 2, 2) == 0)
672
strcat (result, "operator");
673
strcat (result, optable[i].out);
681
if (opname[2] == 'a' && opname[5] == '\0')
685
for (i = 0; i < ARRAY_SIZE (optable); i++)
687
if (strlen (optable[i].in) == 3
688
&& memcmp (optable[i].in, opname + 2, 3) == 0)
690
strcat (result, "operator");
691
strcat (result, optable[i].out);
702
&& strchr (cplus_markers, opname[2]) != NULL)
704
/* see if it's an assignment expression */
705
if (len >= 10 /* op$assign_ */
706
&& memcmp (opname + 3, "assign_", 7) == 0)
709
for (i = 0; i < ARRAY_SIZE (optable); i++)
712
if ((int) strlen (optable[i].in) == len1
713
&& memcmp (optable[i].in, opname + 10, len1) == 0)
715
strcat (result, "operator");
716
strcat (result, optable[i].out);
717
strcat (result, "=");
726
for (i = 0; i < ARRAY_SIZE (optable); i++)
729
if ((int) strlen (optable[i].in) == len1
730
&& memcmp (optable[i].in, opname + 3, len1) == 0)
732
strcat (result, "operator");
733
strcat (result, optable[i].out);
740
else if (len >= 5 && memcmp (opname, "type", 4) == 0
741
&& strchr (cplus_markers, opname[4]) != NULL)
743
/* type conversion operator */
745
if (do_type (work, &tem, &type))
747
strcat (result, "operator ");
748
strncat (result, type.b, type.p - type.b);
749
string_delete (&type);
753
squangle_mop_up (work);
758
/* Takes operator name as e.g. "++" and returns mangled
759
operator name (e.g. "postincrement_expr"), or NULL if not found.
761
If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
762
if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
765
cplus_mangle_opname (const char *opname, int options)
770
len = strlen (opname);
771
for (i = 0; i < ARRAY_SIZE (optable); i++)
773
if ((int) strlen (optable[i].out) == len
774
&& (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
775
&& memcmp (optable[i].out, opname, len) == 0)
776
return optable[i].in;
781
/* Add a routine to set the demangling style to be sure it is valid and
782
allow for any demangler initialization that maybe necessary. */
784
enum demangling_styles
785
cplus_demangle_set_style (enum demangling_styles style)
787
const struct demangler_engine *demangler = libiberty_demanglers;
789
for (; demangler->demangling_style != unknown_demangling; ++demangler)
790
if (style == demangler->demangling_style)
792
current_demangling_style = style;
793
return current_demangling_style;
796
return unknown_demangling;
799
/* Do string name to style translation */
801
enum demangling_styles
802
cplus_demangle_name_to_style (const char *name)
804
const struct demangler_engine *demangler = libiberty_demanglers;
806
for (; demangler->demangling_style != unknown_demangling; ++demangler)
807
if (strcmp (name, demangler->demangling_style_name) == 0)
808
return demangler->demangling_style;
810
return unknown_demangling;
813
/* char *cplus_demangle (const char *mangled, int options)
815
If MANGLED is a mangled function name produced by GNU C++, then
816
a pointer to a @code{malloc}ed string giving a C++ representation
817
of the name will be returned; otherwise NULL will be returned.
818
It is the caller's responsibility to free the string which
821
The OPTIONS arg may contain one or more of the following bits:
823
DMGL_ANSI ANSI qualifiers such as `const' and `void' are
825
DMGL_PARAMS Function parameters are included.
829
cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
830
cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
831
cplus_demangle ("foo__1Ai", 0) => "A::foo"
833
cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
834
cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
835
cplus_demangle ("foo__1Afe", 0) => "A::foo"
837
Note that any leading underscores, or other such characters prepended by
838
the compilation system, are presumed to have already been stripped from
842
cplus_demangle (const char *mangled, int options)
845
struct work_stuff work[1];
847
if (current_demangling_style == no_demangling)
848
return xstrdup (mangled);
850
memset ((char *) work, 0, sizeof (work));
851
work->options = options;
852
if ((work->options & DMGL_STYLE_MASK) == 0)
853
work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
855
/* The V3 ABI demangling is implemented elsewhere. */
856
if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
858
ret = cplus_demangle_v3 (mangled, work->options);
859
if (ret || GNU_V3_DEMANGLING)
865
ret = java_demangle_v3 (mangled);
871
return ada_demangle (mangled, options);
873
ret = internal_cplus_demangle (work, mangled);
874
squangle_mop_up (work);
878
/* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */
881
ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
888
/* Discard leading _ada_, which is used for library level subprograms. */
889
if (strncmp (mangled, "_ada_", 5) == 0)
892
/* All ada unit names are lower-case. */
893
if (!ISLOWER (mangled[0]))
896
/* Most of the demangling will trivially remove chars. Operator names
897
may add one char but because they are always preceeded by '__' which is
898
replaced by '.', they eventually never expand the size.
899
A few special names such as '___elabs' add a few chars (at most 7), but
900
they occur only once. */
901
len0 = strlen (mangled) + 7 + 1;
902
demangled = XNEWVEC (char, len0);
908
/* An entity names is expected. */
911
/* An identifier, which is always lower case. */
914
while (ISLOWER(*p) || ISDIGIT (*p)
915
|| (p[0] == '_' && (ISLOWER (p[1]) || ISDIGIT (p[1]))));
917
else if (p[0] == 'O')
919
/* An operator name. */
920
static const char * const operators[][2] =
921
{{"Oabs", "abs"}, {"Oand", "and"}, {"Omod", "mod"},
922
{"Onot", "not"}, {"Oor", "or"}, {"Orem", "rem"},
923
{"Oxor", "xor"}, {"Oeq", "="}, {"One", "/="},
924
{"Olt", "<"}, {"Ole", "<="}, {"Ogt", ">"},
925
{"Oge", ">="}, {"Oadd", "+"}, {"Osubtract", "-"},
926
{"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
927
{"Oexpon", "**"}, {NULL, NULL}};
930
for (k = 0; operators[k][0] != NULL; k++)
932
size_t slen = strlen (operators[k][0]);
933
if (strncmp (p, operators[k][0], slen) == 0)
936
slen = strlen (operators[k][1]);
938
memcpy (d, operators[k][1], slen);
944
/* Operator not found. */
945
if (operators[k][0] == NULL)
950
/* Not a GNAT encoding. */
954
/* The name can be directly followed by some uppercase letters. */
955
if (p[0] == 'T' && p[1] == 'K')
958
if (p[2] == 'B' && p[3] == 0)
960
/* Subprogram for task body. */
963
else if (p[2] == '_' && p[3] == '_')
965
/* Inner declarations in a task. */
973
if (p[0] == 'E' && p[1] == 0)
975
/* Exception name. */
978
if ((p[0] == 'P' || p[0] == 'N') && p[1] == 0)
980
/* Protected type subprogram. */
983
if ((*p == 'N' || *p == 'S') && p[1] == 0)
985
/* Enumerated type name table. */
992
while (p[0] == 'n' || p[0] == 'b')
995
if (p[0] == 'S' && p[1] != 0 && (p[2] == '_' || p[2] == 0))
997
/* Stream operations. */
1020
else if (p[0] == 'D')
1022
/* Controlled type operation. */
1045
/* Standard separator. Handled first. */
1050
/* Overloading number. */
1053
while (ISDIGIT (*p) || (p[0] == '_' && ISDIGIT (p[1])));
1057
while (p[0] == 'n' || p[0] == 'b')
1061
else if (p[0] == '_' && p[1] != '_')
1063
/* Special names. */
1064
static const char * const special[][2] = {
1065
{ "_elabb", "'Elab_Body" },
1066
{ "_elabs", "'Elab_Spec" },
1067
{ "_size", "'Size" },
1068
{ "_alignment", "'Alignment" },
1069
{ "_assign", ".\":=\"" },
1074
for (k = 0; special[k][0] != NULL; k++)
1076
size_t slen = strlen (special[k][0]);
1077
if (strncmp (p, special[k][0], slen) == 0)
1080
slen = strlen (special[k][1]);
1081
memcpy (d, special[k][1], slen);
1086
if (special[k][0] != NULL)
1097
else if (p[1] == 'B' || p[1] == 'E')
1099
/* Entry Body or barrier Evaluation. */
1101
while (ISDIGIT (*p))
1103
if (p[0] == 's' && p[1] == 0)
1112
if (p[0] == '.' && ISDIGIT (p[1]))
1114
/* Nested subprogram. */
1116
while (ISDIGIT (*p))
1121
/* End of mangled name. */
1131
len0 = strlen (mangled);
1132
demangled = XNEWVEC (char, len0 + 3);
1134
if (mangled[0] == '<')
1135
strcpy (demangled, mangled);
1137
sprintf (demangled, "<%s>", mangled);
1142
/* This function performs most of what cplus_demangle use to do, but
1143
to be able to demangle a name with a B, K or n code, we need to
1144
have a longer term memory of what types have been seen. The original
1145
now initializes and cleans up the squangle code info, while internal
1146
calls go directly to this routine to avoid resetting that info. */
1149
internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1154
char *demangled = NULL;
1156
s1 = work->constructor;
1157
s2 = work->destructor;
1158
s3 = work->static_type;
1159
s4 = work->type_quals;
1160
work->constructor = work->destructor = 0;
1161
work->type_quals = TYPE_UNQUALIFIED;
1162
work->dllimported = 0;
1164
if ((mangled != NULL) && (*mangled != '\0'))
1166
string_init (&decl);
1168
/* First check to see if gnu style demangling is active and if the
1169
string to be demangled contains a CPLUS_MARKER. If so, attempt to
1170
recognize one of the gnu special forms rather than looking for a
1171
standard prefix. In particular, don't worry about whether there
1172
is a "__" string in the mangled string. Consider "_$_5__foo" for
1175
if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1177
success = gnu_special (work, &mangled, &decl);
1181
success = demangle_prefix (work, &mangled, &decl);
1183
if (success && (*mangled != '\0'))
1185
success = demangle_signature (work, &mangled, &decl);
1187
if (work->constructor == 2)
1189
string_prepend (&decl, "global constructors keyed to ");
1190
work->constructor = 0;
1192
else if (work->destructor == 2)
1194
string_prepend (&decl, "global destructors keyed to ");
1195
work->destructor = 0;
1197
else if (work->dllimported == 1)
1199
string_prepend (&decl, "import stub for ");
1200
work->dllimported = 0;
1202
demangled = mop_up (work, &decl, success);
1204
work->constructor = s1;
1205
work->destructor = s2;
1206
work->static_type = s3;
1207
work->type_quals = s4;
1212
/* Clear out and squangling related storage */
1214
squangle_mop_up (struct work_stuff *work)
1216
/* clean up the B and K type mangling types. */
1217
forget_B_and_K_types (work);
1218
if (work -> btypevec != NULL)
1220
free ((char *) work -> btypevec);
1222
if (work -> ktypevec != NULL)
1224
free ((char *) work -> ktypevec);
1229
/* Copy the work state and storage. */
1232
work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
1236
delete_work_stuff (to);
1238
/* Shallow-copy scalars. */
1239
memcpy (to, from, sizeof (*to));
1241
/* Deep-copy dynamic storage. */
1242
if (from->typevec_size)
1243
to->typevec = XNEWVEC (char *, from->typevec_size);
1245
for (i = 0; i < from->ntypes; i++)
1247
int len = strlen (from->typevec[i]) + 1;
1249
to->typevec[i] = XNEWVEC (char, len);
1250
memcpy (to->typevec[i], from->typevec[i], len);
1254
to->ktypevec = XNEWVEC (char *, from->ksize);
1256
for (i = 0; i < from->numk; i++)
1258
int len = strlen (from->ktypevec[i]) + 1;
1260
to->ktypevec[i] = XNEWVEC (char, len);
1261
memcpy (to->ktypevec[i], from->ktypevec[i], len);
1265
to->btypevec = XNEWVEC (char *, from->bsize);
1267
for (i = 0; i < from->numb; i++)
1269
int len = strlen (from->btypevec[i]) + 1;
1271
to->btypevec[i] = XNEWVEC (char , len);
1272
memcpy (to->btypevec[i], from->btypevec[i], len);
1275
if (from->ntmpl_args)
1276
to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
1278
for (i = 0; i < from->ntmpl_args; i++)
1280
int len = strlen (from->tmpl_argvec[i]) + 1;
1282
to->tmpl_argvec[i] = XNEWVEC (char, len);
1283
memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1286
if (from->previous_argument)
1288
to->previous_argument = XNEW (string);
1289
string_init (to->previous_argument);
1290
string_appends (to->previous_argument, from->previous_argument);
1295
/* Delete dynamic stuff in work_stuff that is not to be re-used. */
1298
delete_non_B_K_work_stuff (struct work_stuff *work)
1300
/* Discard the remembered types, if any. */
1302
forget_types (work);
1303
if (work -> typevec != NULL)
1305
free ((char *) work -> typevec);
1306
work -> typevec = NULL;
1307
work -> typevec_size = 0;
1309
if (work->tmpl_argvec)
1313
for (i = 0; i < work->ntmpl_args; i++)
1314
free ((char*) work->tmpl_argvec[i]);
1316
free ((char*) work->tmpl_argvec);
1317
work->tmpl_argvec = NULL;
1319
if (work->previous_argument)
1321
string_delete (work->previous_argument);
1322
free ((char*) work->previous_argument);
1323
work->previous_argument = NULL;
1328
/* Delete all dynamic storage in work_stuff. */
1330
delete_work_stuff (struct work_stuff *work)
1332
delete_non_B_K_work_stuff (work);
1333
squangle_mop_up (work);
1337
/* Clear out any mangled storage */
1340
mop_up (struct work_stuff *work, string *declp, int success)
1342
char *demangled = NULL;
1344
delete_non_B_K_work_stuff (work);
1346
/* If demangling was successful, ensure that the demangled string is null
1347
terminated and return it. Otherwise, free the demangling decl. */
1351
string_delete (declp);
1355
string_appendn (declp, "", 1);
1356
demangled = declp->b;
1365
demangle_signature -- demangle the signature part of a mangled name
1370
demangle_signature (struct work_stuff *work, const char **mangled,
1375
Consume and demangle the signature portion of the mangled name.
1377
DECLP is the string where demangled output is being built. At
1378
entry it contains the demangled root name from the mangled name
1379
prefix. I.E. either a demangled operator name or the root function
1380
name. In some special cases, it may contain nothing.
1382
*MANGLED points to the current unconsumed location in the mangled
1383
name. As tokens are consumed and demangling is performed, the
1384
pointer is updated to continuously point at the next token to
1387
Demangling GNU style mangled names is nasty because there is no
1388
explicit token that marks the start of the outermost function
1392
demangle_signature (struct work_stuff *work,
1393
const char **mangled, string *declp)
1397
int expect_func = 0;
1398
int expect_return_type = 0;
1399
const char *oldmangled = NULL;
1403
while (success && (**mangled != '\0'))
1408
oldmangled = *mangled;
1409
success = demangle_qualified (work, mangled, declp, 1, 0);
1411
remember_type (work, oldmangled, *mangled - oldmangled);
1412
if (AUTO_DEMANGLING || GNU_DEMANGLING)
1418
oldmangled = *mangled;
1419
success = demangle_qualified (work, mangled, declp, 1, 0);
1420
if (AUTO_DEMANGLING || GNU_DEMANGLING)
1428
/* Static member function */
1429
if (oldmangled == NULL)
1431
oldmangled = *mangled;
1434
work -> static_type = 1;
1440
work->type_quals |= code_for_qualifier (**mangled);
1442
/* a qualified member function */
1443
if (oldmangled == NULL)
1444
oldmangled = *mangled;
1449
/* Local class name follows after "Lnnn_" */
1452
while (**mangled && (**mangled != '_'))
1463
case '0': case '1': case '2': case '3': case '4':
1464
case '5': case '6': case '7': case '8': case '9':
1465
if (oldmangled == NULL)
1467
oldmangled = *mangled;
1469
work->temp_start = -1; /* uppermost call to demangle_class */
1470
success = demangle_class (work, mangled, declp);
1473
remember_type (work, oldmangled, *mangled - oldmangled);
1475
if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1477
/* EDG and others will have the "F", so we let the loop cycle
1478
if we are looking at one. */
1479
if (**mangled != 'F')
1488
success = do_type (work, mangled, &s);
1491
string_append (&s, SCOPE_STRING (work));
1492
string_prepends (declp, &s);
1502
/* ARM/HP style demangling includes a specific 'F' character after
1503
the class name. For GNU style, it is just implied. So we can
1504
safely just consume any 'F' at this point and be compatible
1505
with either style. */
1511
/* For lucid/ARM/HP style we have to forget any types we might
1512
have remembered up to this point, since they were not argument
1513
types. GNU style considers all types seen as available for
1514
back references. See comment in demangle_args() */
1516
if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1518
forget_types (work);
1520
success = demangle_args (work, mangled, declp);
1521
/* After picking off the function args, we expect to either
1522
find the function return type (preceded by an '_') or the
1523
end of the string. */
1524
if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1527
/* At this level, we do not care about the return type. */
1528
success = do_type (work, mangled, &tname);
1529
string_delete (&tname);
1536
string_init(&trawname);
1537
string_init(&tname);
1538
if (oldmangled == NULL)
1540
oldmangled = *mangled;
1542
success = demangle_template (work, mangled, &tname,
1546
remember_type (work, oldmangled, *mangled - oldmangled);
1548
string_append (&tname, SCOPE_STRING (work));
1550
string_prepends(declp, &tname);
1551
if (work -> destructor & 1)
1553
string_prepend (&trawname, "~");
1554
string_appends (declp, &trawname);
1555
work->destructor -= 1;
1557
if ((work->constructor & 1) || (work->destructor & 1))
1559
string_appends (declp, &trawname);
1560
work->constructor -= 1;
1562
string_delete(&trawname);
1563
string_delete(&tname);
1569
if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1571
/* Read the return type. */
1575
success = do_type (work, mangled, &return_type);
1576
APPEND_BLANK (&return_type);
1578
string_prepends (declp, &return_type);
1579
string_delete (&return_type);
1583
/* At the outermost level, we cannot have a return type specified,
1584
so if we run into another '_' at this point we are dealing with
1585
a mangled name that is either bogus, or has been mangled by
1586
some algorithm we don't know how to deal with. So just
1587
reject the entire demangling. */
1588
/* However, "_nnn" is an expected suffix for alternate entry point
1589
numbered nnn for a function, with HP aCC, so skip over that
1590
without reporting failure. pai/1997-09-04 */
1594
while (**mangled && ISDIGIT ((unsigned char)**mangled))
1602
if (AUTO_DEMANGLING || GNU_DEMANGLING)
1604
/* A G++ template function. Read the template arguments. */
1605
success = demangle_template (work, mangled, declp, 0, 0,
1607
if (!(work->constructor & 1))
1608
expect_return_type = 1;
1617
if (AUTO_DEMANGLING || GNU_DEMANGLING)
1619
/* Assume we have stumbled onto the first outermost function
1620
argument token, and start processing args. */
1622
success = demangle_args (work, mangled, declp);
1626
/* Non-GNU demanglers use a specific token to mark the start
1627
of the outermost function argument tokens. Typically 'F',
1628
for ARM/HP-demangling, for example. So if we find something
1629
we are not prepared for, it must be an error. */
1635
if (AUTO_DEMANGLING || GNU_DEMANGLING)
1638
if (success && expect_func)
1641
if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1643
forget_types (work);
1645
success = demangle_args (work, mangled, declp);
1646
/* Since template include the mangling of their return types,
1647
we must set expect_func to 0 so that we don't try do
1648
demangle more arguments the next time we get here. */
1653
if (success && !func_done)
1655
if (AUTO_DEMANGLING || GNU_DEMANGLING)
1657
/* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1658
bar__3fooi is 'foo::bar(int)'. We get here when we find the
1659
first case, and need to ensure that the '(void)' gets added to
1660
the current declp. Note that with ARM/HP, the first case
1661
represents the name of a static data member 'foo::bar',
1662
which is in the current declp, so we leave it alone. */
1663
success = demangle_args (work, mangled, declp);
1666
if (success && PRINT_ARG_TYPES)
1668
if (work->static_type)
1669
string_append (declp, " static");
1670
if (work->type_quals != TYPE_UNQUALIFIED)
1672
APPEND_BLANK (declp);
1673
string_append (declp, qualifier_string (work->type_quals));
1683
demangle_method_args (struct work_stuff *work, const char **mangled,
1688
if (work -> static_type)
1690
string_append (declp, *mangled + 1);
1691
*mangled += strlen (*mangled);
1696
success = demangle_args (work, mangled, declp);
1704
demangle_template_template_parm (struct work_stuff *work,
1705
const char **mangled, string *tname)
1713
string_append (tname, "template <");
1714
/* get size of template parameter list */
1715
if (get_count (mangled, &r))
1717
for (i = 0; i < r; i++)
1721
string_append (tname, ", ");
1724
/* Z for type parameters */
1725
if (**mangled == 'Z')
1728
string_append (tname, "class");
1730
/* z for template parameters */
1731
else if (**mangled == 'z')
1735
demangle_template_template_parm (work, mangled, tname);
1743
/* temp is initialized in do_type */
1744
success = do_type (work, mangled, &temp);
1747
string_appends (tname, &temp);
1749
string_delete(&temp);
1759
if (tname->p[-1] == '>')
1760
string_append (tname, " ");
1761
string_append (tname, "> class");
1766
demangle_expression (struct work_stuff *work, const char **mangled,
1767
string *s, type_kind_t tk)
1769
int need_operator = 0;
1773
string_appendn (s, "(", 1);
1775
while (success && **mangled != 'W' && **mangled != '\0')
1784
len = strlen (*mangled);
1786
for (i = 0; i < ARRAY_SIZE (optable); ++i)
1788
size_t l = strlen (optable[i].in);
1791
&& memcmp (optable[i].in, *mangled, l) == 0)
1793
string_appendn (s, " ", 1);
1794
string_append (s, optable[i].out);
1795
string_appendn (s, " ", 1);
1808
success = demangle_template_value_parm (work, mangled, s, tk);
1811
if (**mangled != 'W')
1815
string_appendn (s, ")", 1);
1823
demangle_integral_value (struct work_stuff *work,
1824
const char **mangled, string *s)
1828
if (**mangled == 'E')
1829
success = demangle_expression (work, mangled, s, tk_integral);
1830
else if (**mangled == 'Q' || **mangled == 'K')
1831
success = demangle_qualified (work, mangled, s, 0, 1);
1836
/* By default, we let the number decide whether we shall consume an
1838
int multidigit_without_leading_underscore = 0;
1839
int leave_following_underscore = 0;
1843
if (**mangled == '_')
1845
if (mangled[0][1] == 'm')
1847
/* Since consume_count_with_underscores does not handle the
1848
`m'-prefix we must do it here, using consume_count and
1849
adjusting underscores: we have to consume the underscore
1850
matching the prepended one. */
1851
multidigit_without_leading_underscore = 1;
1852
string_appendn (s, "-", 1);
1857
/* Do not consume a following underscore;
1858
consume_count_with_underscores will consume what
1859
should be consumed. */
1860
leave_following_underscore = 1;
1865
/* Negative numbers are indicated with a leading `m'. */
1866
if (**mangled == 'm')
1868
string_appendn (s, "-", 1);
1871
/* Since consume_count_with_underscores does not handle
1872
multi-digit numbers that do not start with an underscore,
1873
and this number can be an integer template parameter,
1874
we have to call consume_count. */
1875
multidigit_without_leading_underscore = 1;
1876
/* These multi-digit numbers never end on an underscore,
1877
so if there is one then don't eat it. */
1878
leave_following_underscore = 1;
1881
/* We must call consume_count if we expect to remove a trailing
1882
underscore, since consume_count_with_underscores expects
1883
the leading underscore (that we consumed) if it is to handle
1884
multi-digit numbers. */
1885
if (multidigit_without_leading_underscore)
1886
value = consume_count (mangled);
1888
value = consume_count_with_underscores (mangled);
1892
char buf[INTBUF_SIZE];
1893
sprintf (buf, "%d", value);
1894
string_append (s, buf);
1896
/* Numbers not otherwise delimited, might have an underscore
1897
appended as a delimeter, which we should skip.
1899
??? This used to always remove a following underscore, which
1900
is wrong. If other (arbitrary) cases are followed by an
1901
underscore, we need to do something more radical. */
1903
if ((value > 9 || multidigit_without_leading_underscore)
1904
&& ! leave_following_underscore
1905
&& **mangled == '_')
1916
/* Demangle the real value in MANGLED. */
1919
demangle_real_value (struct work_stuff *work,
1920
const char **mangled, string *s)
1922
if (**mangled == 'E')
1923
return demangle_expression (work, mangled, s, tk_real);
1925
if (**mangled == 'm')
1927
string_appendn (s, "-", 1);
1930
while (ISDIGIT ((unsigned char)**mangled))
1932
string_appendn (s, *mangled, 1);
1935
if (**mangled == '.') /* fraction */
1937
string_appendn (s, ".", 1);
1939
while (ISDIGIT ((unsigned char)**mangled))
1941
string_appendn (s, *mangled, 1);
1945
if (**mangled == 'e') /* exponent */
1947
string_appendn (s, "e", 1);
1949
while (ISDIGIT ((unsigned char)**mangled))
1951
string_appendn (s, *mangled, 1);
1960
demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1961
string *s, type_kind_t tk)
1965
if (**mangled == 'Y')
1967
/* The next argument is a template parameter. */
1971
idx = consume_count_with_underscores (mangled);
1973
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
1974
|| consume_count_with_underscores (mangled) == -1)
1976
if (work->tmpl_argvec)
1977
string_append (s, work->tmpl_argvec[idx]);
1979
string_append_template_idx (s, idx);
1981
else if (tk == tk_integral)
1982
success = demangle_integral_value (work, mangled, s);
1983
else if (tk == tk_char)
1987
if (**mangled == 'm')
1989
string_appendn (s, "-", 1);
1992
string_appendn (s, "'", 1);
1993
val = consume_count(mangled);
2000
string_appendn (s, &tmp[0], 1);
2001
string_appendn (s, "'", 1);
2004
else if (tk == tk_bool)
2006
int val = consume_count (mangled);
2008
string_appendn (s, "false", 5);
2010
string_appendn (s, "true", 4);
2014
else if (tk == tk_real)
2015
success = demangle_real_value (work, mangled, s);
2016
else if (tk == tk_pointer || tk == tk_reference)
2018
if (**mangled == 'Q')
2019
success = demangle_qualified (work, mangled, s,
2024
int symbol_len = consume_count (mangled);
2025
if (symbol_len == -1)
2027
if (symbol_len == 0)
2028
string_appendn (s, "0", 1);
2031
char *p = XNEWVEC (char, symbol_len + 1), *q;
2032
strncpy (p, *mangled, symbol_len);
2033
p [symbol_len] = '\0';
2034
/* We use cplus_demangle here, rather than
2035
internal_cplus_demangle, because the name of the entity
2036
mangled here does not make use of any of the squangling
2037
or type-code information we have built up thus far; it is
2038
mangled independently. */
2039
q = cplus_demangle (p, work->options);
2040
if (tk == tk_pointer)
2041
string_appendn (s, "&", 1);
2042
/* FIXME: Pointer-to-member constants should get a
2043
qualifying class name here. */
2046
string_append (s, q);
2050
string_append (s, p);
2053
*mangled += symbol_len;
2060
/* Demangle the template name in MANGLED. The full name of the
2061
template (e.g., S<int>) is placed in TNAME. The name without the
2062
template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2063
non-NULL. If IS_TYPE is nonzero, this template is a type template,
2064
not a function template. If both IS_TYPE and REMEMBER are nonzero,
2065
the template is remembered in the list of back-referenceable
2069
demangle_template (struct work_stuff *work, const char **mangled,
2070
string *tname, string *trawname,
2071
int is_type, int remember)
2077
int is_java_array = 0;
2083
/* get template name */
2084
if (**mangled == 'z')
2090
idx = consume_count_with_underscores (mangled);
2092
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
2093
|| consume_count_with_underscores (mangled) == -1)
2096
if (work->tmpl_argvec)
2098
string_append (tname, work->tmpl_argvec[idx]);
2100
string_append (trawname, work->tmpl_argvec[idx]);
2104
string_append_template_idx (tname, idx);
2106
string_append_template_idx (trawname, idx);
2111
if ((r = consume_count (mangled)) <= 0
2112
|| (int) strlen (*mangled) < r)
2116
is_java_array = (work -> options & DMGL_JAVA)
2117
&& strncmp (*mangled, "JArray1Z", 8) == 0;
2118
if (! is_java_array)
2120
string_appendn (tname, *mangled, r);
2123
string_appendn (trawname, *mangled, r);
2128
string_append (tname, "<");
2129
/* get size of template parameter list */
2130
if (!get_count (mangled, &r))
2136
/* Create an array for saving the template argument values. */
2137
work->tmpl_argvec = XNEWVEC (char *, r);
2138
work->ntmpl_args = r;
2139
for (i = 0; i < r; i++)
2140
work->tmpl_argvec[i] = 0;
2142
for (i = 0; i < r; i++)
2146
string_append (tname, ", ");
2148
/* Z for type parameters */
2149
if (**mangled == 'Z')
2152
/* temp is initialized in do_type */
2153
success = do_type (work, mangled, &temp);
2156
string_appends (tname, &temp);
2160
/* Save the template argument. */
2161
int len = temp.p - temp.b;
2162
work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2163
memcpy (work->tmpl_argvec[i], temp.b, len);
2164
work->tmpl_argvec[i][len] = '\0';
2167
string_delete(&temp);
2173
/* z for template parameters */
2174
else if (**mangled == 'z')
2178
success = demangle_template_template_parm (work, mangled, tname);
2181
&& (r2 = consume_count (mangled)) > 0
2182
&& (int) strlen (*mangled) >= r2)
2184
string_append (tname, " ");
2185
string_appendn (tname, *mangled, r2);
2188
/* Save the template argument. */
2190
work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2191
memcpy (work->tmpl_argvec[i], *mangled, len);
2192
work->tmpl_argvec[i][len] = '\0';
2206
/* otherwise, value parameter */
2208
/* temp is initialized in do_type */
2209
success = do_type (work, mangled, &temp);
2210
string_delete(&temp);
2222
success = demangle_template_value_parm (work, mangled, s,
2223
(type_kind_t) success);
2235
int len = s->p - s->b;
2236
work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2237
memcpy (work->tmpl_argvec[i], s->b, len);
2238
work->tmpl_argvec[i][len] = '\0';
2240
string_appends (tname, s);
2248
string_append (tname, "[]");
2252
if (tname->p[-1] == '>')
2253
string_append (tname, " ");
2254
string_append (tname, ">");
2257
if (is_type && remember)
2259
const int bindex = register_Btype (work);
2260
remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2264
if (work -> static_type)
2266
string_append (declp, *mangled + 1);
2267
*mangled += strlen (*mangled);
2272
success = demangle_args (work, mangled, declp);
2280
arm_pt (struct work_stuff *work, const char *mangled,
2281
int n, const char **anchor, const char **args)
2283
/* Check if ARM template with "__pt__" in it ("parameterized type") */
2284
/* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2285
if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2288
*args = *anchor + 6;
2289
len = consume_count (args);
2292
if (*args + len == mangled + n && **args == '_')
2298
if (AUTO_DEMANGLING || EDG_DEMANGLING)
2300
if ((*anchor = strstr (mangled, "__tm__"))
2301
|| (*anchor = strstr (mangled, "__ps__"))
2302
|| (*anchor = strstr (mangled, "__pt__")))
2305
*args = *anchor + 6;
2306
len = consume_count (args);
2309
if (*args + len == mangled + n && **args == '_')
2315
else if ((*anchor = strstr (mangled, "__S")))
2318
*args = *anchor + 3;
2319
len = consume_count (args);
2322
if (*args + len == mangled + n && **args == '_')
2334
demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2335
int n, string *declp)
2339
const char *e = *mangled + n;
2342
/* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2344
if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2346
char *start_spec_args = NULL;
2349
/* First check for and omit template specialization pseudo-arguments,
2350
such as in "Spec<#1,#1.*>" */
2351
start_spec_args = strchr (*mangled, '<');
2352
if (start_spec_args && (start_spec_args - *mangled < n))
2353
string_appendn (declp, *mangled, start_spec_args - *mangled);
2355
string_appendn (declp, *mangled, n);
2356
(*mangled) += n + 1;
2358
if (work->temp_start == -1) /* non-recursive call */
2359
work->temp_start = declp->p - declp->b;
2361
/* We want to unconditionally demangle parameter types in
2362
template parameters. */
2363
hold_options = work->options;
2364
work->options |= DMGL_PARAMS;
2366
string_append (declp, "<");
2369
string_delete (&arg);
2373
/* 'T' signals a type parameter */
2375
if (!do_type (work, mangled, &arg))
2376
goto hpacc_template_args_done;
2381
/* 'U' or 'S' signals an integral value */
2382
if (!do_hpacc_template_const_value (work, mangled, &arg))
2383
goto hpacc_template_args_done;
2387
/* 'A' signals a named constant expression (literal) */
2388
if (!do_hpacc_template_literal (work, mangled, &arg))
2389
goto hpacc_template_args_done;
2393
/* Today, 1997-09-03, we have only the above types
2394
of template parameters */
2395
/* FIXME: maybe this should fail and return null */
2396
goto hpacc_template_args_done;
2398
string_appends (declp, &arg);
2399
/* Check if we're at the end of template args.
2400
0 if at end of static member of template class,
2401
_ if done with template args for a function */
2402
if ((**mangled == '\000') || (**mangled == '_'))
2405
string_append (declp, ",");
2407
hpacc_template_args_done:
2408
string_append (declp, ">");
2409
string_delete (&arg);
2410
if (**mangled == '_')
2412
work->options = hold_options;
2415
/* ARM template? (Also handles HP cfront extensions) */
2416
else if (arm_pt (work, *mangled, n, &p, &args))
2422
string_appendn (declp, *mangled, p - *mangled);
2423
if (work->temp_start == -1) /* non-recursive call */
2424
work->temp_start = declp->p - declp->b;
2426
/* We want to unconditionally demangle parameter types in
2427
template parameters. */
2428
hold_options = work->options;
2429
work->options |= DMGL_PARAMS;
2431
string_append (declp, "<");
2432
/* should do error checking here */
2434
string_delete (&arg);
2436
/* Check for type or literal here */
2439
/* HP cfront extensions to ARM for template args */
2440
/* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2441
/* FIXME: We handle only numeric literals for HP cfront */
2443
/* A typed constant value follows */
2445
if (!do_type (work, &args, &type_str))
2446
goto cfront_template_args_done;
2447
string_append (&arg, "(");
2448
string_appends (&arg, &type_str);
2449
string_delete (&type_str);
2450
string_append (&arg, ")");
2452
goto cfront_template_args_done;
2454
/* Now snarf a literal value following 'L' */
2455
if (!snarf_numeric_literal (&args, &arg))
2456
goto cfront_template_args_done;
2460
/* Snarf a literal following 'L' */
2462
if (!snarf_numeric_literal (&args, &arg))
2463
goto cfront_template_args_done;
2466
/* Not handling other HP cfront stuff */
2468
const char* old_args = args;
2469
if (!do_type (work, &args, &arg))
2470
goto cfront_template_args_done;
2472
/* Fail if we didn't make any progress: prevent infinite loop. */
2473
if (args == old_args)
2475
work->options = hold_options;
2480
string_appends (declp, &arg);
2481
string_append (declp, ",");
2483
cfront_template_args_done:
2484
string_delete (&arg);
2486
--declp->p; /* remove extra comma */
2487
string_append (declp, ">");
2488
work->options = hold_options;
2490
else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2491
&& (*mangled)[9] == 'N'
2492
&& (*mangled)[8] == (*mangled)[10]
2493
&& strchr (cplus_markers, (*mangled)[8]))
2495
/* A member of the anonymous namespace. */
2496
string_append (declp, "{anonymous}");
2500
if (work->temp_start == -1) /* non-recursive call only */
2501
work->temp_start = 0; /* disable in recursive calls */
2502
string_appendn (declp, *mangled, n);
2507
/* Extract a class name, possibly a template with arguments, from the
2508
mangled string; qualifiers, local class indicators, etc. have
2509
already been dealt with */
2512
demangle_class_name (struct work_stuff *work, const char **mangled,
2518
n = consume_count (mangled);
2521
if ((int) strlen (*mangled) >= n)
2523
demangle_arm_hp_template (work, mangled, n, declp);
2534
demangle_class -- demangle a mangled class sequence
2539
demangle_class (struct work_stuff *work, const char **mangled,
2544
DECLP points to the buffer into which demangling is being done.
2546
*MANGLED points to the current token to be demangled. On input,
2547
it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2548
On exit, it points to the next token after the mangled class on
2549
success, or the first unconsumed token on failure.
2551
If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2552
we are demangling a constructor or destructor. In this case
2553
we prepend "class::class" or "class::~class" to DECLP.
2555
Otherwise, we prepend "class::" to the current DECLP.
2557
Reset the constructor/destructor flags once they have been
2558
"consumed". This allows demangle_class to be called later during
2559
the same demangling, to do normal class demangling.
2561
Returns 1 if demangling is successful, 0 otherwise.
2566
demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2571
char *save_class_name_end = 0;
2573
string_init (&class_name);
2574
btype = register_Btype (work);
2575
if (demangle_class_name (work, mangled, &class_name))
2577
save_class_name_end = class_name.p;
2578
if ((work->constructor & 1) || (work->destructor & 1))
2580
/* adjust so we don't include template args */
2581
if (work->temp_start && (work->temp_start != -1))
2583
class_name.p = class_name.b + work->temp_start;
2585
string_prepends (declp, &class_name);
2586
if (work -> destructor & 1)
2588
string_prepend (declp, "~");
2589
work -> destructor -= 1;
2593
work -> constructor -= 1;
2596
class_name.p = save_class_name_end;
2597
remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2598
remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2599
string_prepend (declp, SCOPE_STRING (work));
2600
string_prepends (declp, &class_name);
2603
string_delete (&class_name);
2608
/* Called when there's a "__" in the mangled name, with `scan' pointing to
2609
the rightmost guess.
2611
Find the correct "__"-sequence where the function name ends and the
2612
signature starts, which is ambiguous with GNU mangling.
2613
Call demangle_signature here, so we can make sure we found the right
2614
one; *mangled will be consumed so caller will not make further calls to
2615
demangle_signature. */
2618
iterate_demangle_function (struct work_stuff *work, const char **mangled,
2619
string *declp, const char *scan)
2621
const char *mangle_init = *mangled;
2624
struct work_stuff work_init;
2626
if (*(scan + 2) == '\0')
2629
/* Do not iterate for some demangling modes, or if there's only one
2630
"__"-sequence. This is the normal case. */
2631
if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2632
|| strstr (scan + 2, "__") == NULL)
2633
return demangle_function_name (work, mangled, declp, scan);
2635
/* Save state so we can restart if the guess at the correct "__" was
2637
string_init (&decl_init);
2638
string_appends (&decl_init, declp);
2639
memset (&work_init, 0, sizeof work_init);
2640
work_stuff_copy_to_from (&work_init, work);
2642
/* Iterate over occurrences of __, allowing names and types to have a
2643
"__" sequence in them. We must start with the first (not the last)
2644
occurrence, since "__" most often occur between independent mangled
2645
parts, hence starting at the last occurence inside a signature
2646
might get us a "successful" demangling of the signature. */
2650
if (demangle_function_name (work, mangled, declp, scan))
2652
success = demangle_signature (work, mangled, declp);
2657
/* Reset demangle state for the next round. */
2658
*mangled = mangle_init;
2659
string_clear (declp);
2660
string_appends (declp, &decl_init);
2661
work_stuff_copy_to_from (work, &work_init);
2663
/* Leave this underscore-sequence. */
2666
/* Scan for the next "__" sequence. */
2667
while (*scan && (scan[0] != '_' || scan[1] != '_'))
2670
/* Move to last "__" in this sequence. */
2671
while (*scan && *scan == '_')
2676
/* Delete saved state. */
2677
delete_work_stuff (&work_init);
2678
string_delete (&decl_init);
2687
demangle_prefix -- consume the mangled name prefix and find signature
2692
demangle_prefix (struct work_stuff *work, const char **mangled,
2697
Consume and demangle the prefix of the mangled name.
2698
While processing the function name root, arrange to call
2699
demangle_signature if the root is ambiguous.
2701
DECLP points to the string buffer into which demangled output is
2702
placed. On entry, the buffer is empty. On exit it contains
2703
the root function name, the demangled operator name, or in some
2704
special cases either nothing or the completely demangled result.
2706
MANGLED points to the current pointer into the mangled name. As each
2707
token of the mangled name is consumed, it is updated. Upon entry
2708
the current mangled name pointer points to the first character of
2709
the mangled name. Upon exit, it should point to the first character
2710
of the signature if demangling was successful, or to the first
2711
unconsumed character if demangling of the prefix was unsuccessful.
2713
Returns 1 on success, 0 otherwise.
2717
demangle_prefix (struct work_stuff *work, const char **mangled,
2724
if (strlen(*mangled) > 6
2725
&& (strncmp(*mangled, "_imp__", 6) == 0
2726
|| strncmp(*mangled, "__imp_", 6) == 0))
2728
/* it's a symbol imported from a PE dynamic library. Check for both
2729
new style prefix _imp__ and legacy __imp_ used by older versions
2732
work->dllimported = 1;
2734
else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2736
char *marker = strchr (cplus_markers, (*mangled)[8]);
2737
if (marker != NULL && *marker == (*mangled)[10])
2739
if ((*mangled)[9] == 'D')
2741
/* it's a GNU global destructor to be executed at program exit */
2743
work->destructor = 2;
2744
if (gnu_special (work, mangled, declp))
2747
else if ((*mangled)[9] == 'I')
2749
/* it's a GNU global constructor to be executed at program init */
2751
work->constructor = 2;
2752
if (gnu_special (work, mangled, declp))
2757
else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2759
/* it's a ARM global destructor to be executed at program exit */
2761
work->destructor = 2;
2763
else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2765
/* it's a ARM global constructor to be executed at program initial */
2767
work->constructor = 2;
2770
/* This block of code is a reduction in strength time optimization
2772
scan = strstr (*mangled, "__"); */
2778
scan = strchr (scan, '_');
2779
} while (scan != NULL && *++scan != '_');
2781
if (scan != NULL) --scan;
2786
/* We found a sequence of two or more '_', ensure that we start at
2787
the last pair in the sequence. */
2788
i = strspn (scan, "_");
2799
else if (work -> static_type)
2801
if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2806
else if ((scan == *mangled)
2807
&& (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2808
|| (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2810
/* The ARM says nothing about the mangling of local variables.
2811
But cfront mangles local variables by prepending __<nesting_level>
2812
to them. As an extension to ARM demangling we handle this case. */
2813
if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2814
&& ISDIGIT ((unsigned char)scan[2]))
2816
*mangled = scan + 2;
2817
consume_count (mangled);
2818
string_append (declp, *mangled);
2819
*mangled += strlen (*mangled);
2824
/* A GNU style constructor starts with __[0-9Qt]. But cfront uses
2825
names like __Q2_3foo3bar for nested type names. So don't accept
2826
this style of constructor for cfront demangling. A GNU
2827
style member-template constructor starts with 'H'. */
2828
if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2829
work -> constructor += 1;
2830
*mangled = scan + 2;
2833
else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2835
/* Cfront-style parameterized type. Handled later as a signature. */
2839
demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2841
else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2842
|| (scan[2] == 'p' && scan[3] == 's')
2843
|| (scan[2] == 'p' && scan[3] == 't')))
2845
/* EDG-style parameterized type. Handled later as a signature. */
2849
demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2851
else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2852
&& (scan[2] != 't'))
2854
/* Mangled name starts with "__". Skip over any leading '_' characters,
2855
then find the next "__" that separates the prefix from the signature.
2857
if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2858
|| (arm_special (mangled, declp) == 0))
2860
while (*scan == '_')
2864
if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2866
/* No separator (I.E. "__not_mangled"), or empty signature
2867
(I.E. "__not_mangled_either__") */
2871
return iterate_demangle_function (work, mangled, declp, scan);
2874
else if (*(scan + 2) != '\0')
2876
/* Mangled name does not start with "__" but does have one somewhere
2877
in there with non empty stuff after it. Looks like a global
2878
function name. Iterate over all "__":s until the right
2880
return iterate_demangle_function (work, mangled, declp, scan);
2884
/* Doesn't look like a mangled name */
2888
if (!success && (work->constructor == 2 || work->destructor == 2))
2890
string_append (declp, *mangled);
2891
*mangled += strlen (*mangled);
2901
gnu_special -- special handling of gnu mangled strings
2906
gnu_special (struct work_stuff *work, const char **mangled,
2912
Process some special GNU style mangling forms that don't fit
2913
the normal pattern. For example:
2915
_$_3foo (destructor for class foo)
2916
_vt$foo (foo virtual table)
2917
_vt$foo$bar (foo::bar virtual table)
2918
__vt_foo (foo virtual table, new style with thunks)
2919
_3foo$varname (static data member)
2920
_Q22rs2tu$vw (static data member)
2921
__t6vector1Zii (constructor with template)
2922
__thunk_4__$_7ostream (virtual function thunk)
2926
gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2932
if ((*mangled)[0] == '_'
2933
&& strchr (cplus_markers, (*mangled)[1]) != NULL
2934
&& (*mangled)[2] == '_')
2936
/* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2938
work -> destructor += 1;
2940
else if ((*mangled)[0] == '_'
2941
&& (((*mangled)[1] == '_'
2942
&& (*mangled)[2] == 'v'
2943
&& (*mangled)[3] == 't'
2944
&& (*mangled)[4] == '_')
2945
|| ((*mangled)[1] == 'v'
2946
&& (*mangled)[2] == 't'
2947
&& strchr (cplus_markers, (*mangled)[3]) != NULL)))
2949
/* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2950
and create the decl. Note that we consume the entire mangled
2951
input string, which means that demangle_signature has no work
2953
if ((*mangled)[2] == 'v')
2954
(*mangled) += 5; /* New style, with thunks: "__vt_" */
2956
(*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2957
while (**mangled != '\0')
2963
success = demangle_qualified (work, mangled, declp, 0, 1);
2966
success = demangle_template (work, mangled, declp, 0, 1,
2970
if (ISDIGIT((unsigned char)*mangled[0]))
2972
n = consume_count(mangled);
2973
/* We may be seeing a too-large size, or else a
2974
".<digits>" indicating a static local symbol. In
2975
any case, declare victory and move on; *don't* try
2976
to use n to allocate. */
2977
if (n > (int) strlen (*mangled))
2985
n = strcspn (*mangled, cplus_markers);
2987
string_appendn (declp, *mangled, n);
2991
p = strpbrk (*mangled, cplus_markers);
2992
if (success && ((p == NULL) || (p == *mangled)))
2996
string_append (declp, SCOPE_STRING (work));
3007
string_append (declp, " virtual table");
3009
else if ((*mangled)[0] == '_'
3010
&& (strchr("0123456789Qt", (*mangled)[1]) != NULL)
3011
&& (p = strpbrk (*mangled, cplus_markers)) != NULL)
3013
/* static data member, "_3foo$varname" for example */
3019
success = demangle_qualified (work, mangled, declp, 0, 1);
3022
success = demangle_template (work, mangled, declp, 0, 1, 1);
3025
n = consume_count (mangled);
3026
if (n < 0 || n > (long) strlen (*mangled))
3032
if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
3033
&& (*mangled)[9] == 'N'
3034
&& (*mangled)[8] == (*mangled)[10]
3035
&& strchr (cplus_markers, (*mangled)[8]))
3037
/* A member of the anonymous namespace. There's information
3038
about what identifier or filename it was keyed to, but
3039
it's just there to make the mangled name unique; we just
3041
string_append (declp, "{anonymous}");
3044
/* Now p points to the marker before the N, so we need to
3045
update it to the first marker after what we consumed. */
3046
p = strpbrk (*mangled, cplus_markers);
3050
string_appendn (declp, *mangled, n);
3053
if (success && (p == *mangled))
3055
/* Consumed everything up to the cplus_marker, append the
3058
string_append (declp, SCOPE_STRING (work));
3059
n = strlen (*mangled);
3060
string_appendn (declp, *mangled, n);
3068
else if (strncmp (*mangled, "__thunk_", 8) == 0)
3073
delta = consume_count (mangled);
3078
char *method = internal_cplus_demangle (work, ++*mangled);
3083
sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
3084
string_append (declp, buf);
3085
string_append (declp, method);
3087
n = strlen (*mangled);
3096
else if (strncmp (*mangled, "__t", 3) == 0
3097
&& ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
3099
p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
3105
success = demangle_qualified (work, mangled, declp, 0, 1);
3108
success = demangle_template (work, mangled, declp, 0, 1, 1);
3111
success = do_type (work, mangled, declp);
3114
if (success && **mangled != '\0')
3117
string_append (declp, p);
3127
recursively_demangle(struct work_stuff *work, const char **mangled,
3128
string *result, int namelength)
3130
char * recurse = (char *)NULL;
3131
char * recurse_dem = (char *)NULL;
3133
recurse = XNEWVEC (char, namelength + 1);
3134
memcpy (recurse, *mangled, namelength);
3135
recurse[namelength] = '\000';
3137
recurse_dem = cplus_demangle (recurse, work->options);
3141
string_append (result, recurse_dem);
3146
string_appendn (result, *mangled, namelength);
3149
*mangled += namelength;
3156
arm_special -- special handling of ARM/lucid mangled strings
3161
arm_special (const char **mangled,
3167
Process some special ARM style mangling forms that don't fit
3168
the normal pattern. For example:
3170
__vtbl__3foo (foo virtual table)
3171
__vtbl__3foo__3bar (bar::foo virtual table)
3176
arm_special (const char **mangled, string *declp)
3182
if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3184
/* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3185
and create the decl. Note that we consume the entire mangled
3186
input string, which means that demangle_signature has no work
3188
scan = *mangled + ARM_VTABLE_STRLEN;
3189
while (*scan != '\0') /* first check it can be demangled */
3191
n = consume_count (&scan);
3194
return (0); /* no good */
3197
if (scan[0] == '_' && scan[1] == '_')
3202
(*mangled) += ARM_VTABLE_STRLEN;
3203
while (**mangled != '\0')
3205
n = consume_count (mangled);
3207
|| n > (long) strlen (*mangled))
3209
string_prependn (declp, *mangled, n);
3211
if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3213
string_prepend (declp, "::");
3217
string_append (declp, " virtual table");
3230
demangle_qualified -- demangle 'Q' qualified name strings
3235
demangle_qualified (struct work_stuff *, const char *mangled,
3236
string *result, int isfuncname, int append);
3240
Demangle a qualified name, such as "Q25Outer5Inner" which is
3241
the mangled form of "Outer::Inner". The demangled output is
3242
prepended or appended to the result string according to the
3243
state of the append flag.
3245
If isfuncname is nonzero, then the qualified name we are building
3246
is going to be used as a member function name, so if it is a
3247
constructor or destructor function, append an appropriate
3248
constructor or destructor name. I.E. for the above example,
3249
the result for use as a constructor is "Outer::Inner::Inner"
3250
and the result for use as a destructor is "Outer::Inner::~Inner".
3254
Numeric conversion is ASCII dependent (FIXME).
3259
demangle_qualified (struct work_stuff *work, const char **mangled,
3260
string *result, int isfuncname, int append)
3267
int bindex = register_Btype (work);
3269
/* We only make use of ISFUNCNAME if the entity is a constructor or
3271
isfuncname = (isfuncname
3272
&& ((work->constructor & 1) || (work->destructor & 1)));
3274
string_init (&temp);
3275
string_init (&last_name);
3277
if ((*mangled)[0] == 'K')
3279
/* Squangling qualified name reuse */
3282
idx = consume_count_with_underscores (mangled);
3283
if (idx == -1 || idx >= work -> numk)
3286
string_append (&temp, work -> ktypevec[idx]);
3289
switch ((*mangled)[1])
3292
/* GNU mangled name with more than 9 classes. The count is preceded
3293
by an underscore (to distinguish it from the <= 9 case) and followed
3294
by an underscore. */
3296
qualifiers = consume_count_with_underscores (mangled);
3297
if (qualifiers == -1)
3310
/* The count is in a single digit. */
3311
num[0] = (*mangled)[1];
3313
qualifiers = atoi (num);
3315
/* If there is an underscore after the digit, skip it. This is
3316
said to be for ARM-qualified names, but the ARM makes no
3317
mention of such an underscore. Perhaps cfront uses one. */
3318
if ((*mangled)[2] == '_')
3333
/* Pick off the names and collect them in the temp buffer in the order
3334
in which they are found, separated by '::'. */
3336
while (qualifiers-- > 0)
3339
string_clear (&last_name);
3341
if (*mangled[0] == '_')
3344
if (*mangled[0] == 't')
3346
/* Here we always append to TEMP since we will want to use
3347
the template name without the template parameters as a
3348
constructor or destructor name. The appropriate
3349
(parameter-less) value is returned by demangle_template
3350
in LAST_NAME. We do not remember the template type here,
3351
in order to match the G++ mangling algorithm. */
3352
success = demangle_template(work, mangled, &temp,
3357
else if (*mangled[0] == 'K')
3361
idx = consume_count_with_underscores (mangled);
3362
if (idx == -1 || idx >= work->numk)
3365
string_append (&temp, work->ktypevec[idx]);
3368
if (!success) break;
3375
/* Now recursively demangle the qualifier
3376
* This is necessary to deal with templates in
3377
* mangling styles like EDG */
3378
namelength = consume_count (mangled);
3379
if (namelength == -1)
3384
recursively_demangle(work, mangled, &temp, namelength);
3388
string_delete (&last_name);
3389
success = do_type (work, mangled, &last_name);
3392
string_appends (&temp, &last_name);
3397
remember_Ktype (work, temp.b, LEN_STRING (&temp));
3400
string_append (&temp, SCOPE_STRING (work));
3403
remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3405
/* If we are using the result as a function name, we need to append
3406
the appropriate '::' separated constructor or destructor name.
3407
We do this here because this is the most convenient place, where
3408
we already have a pointer to the name and the length of the name. */
3412
string_append (&temp, SCOPE_STRING (work));
3413
if (work -> destructor & 1)
3414
string_append (&temp, "~");
3415
string_appends (&temp, &last_name);
3418
/* Now either prepend the temp buffer to the result, or append it,
3419
depending upon the state of the append flag. */
3422
string_appends (result, &temp);
3425
if (!STRING_EMPTY (result))
3426
string_append (&temp, SCOPE_STRING (work));
3427
string_prepends (result, &temp);
3430
string_delete (&last_name);
3431
string_delete (&temp);
3439
get_count -- convert an ascii count to integer, consuming tokens
3444
get_count (const char **type, int *count)
3448
Assume that *type points at a count in a mangled name; set
3449
*count to its value, and set *type to the next character after
3450
the count. There are some weird rules in effect here.
3452
If *type does not point at a string of digits, return zero.
3454
If *type points at a string of digits followed by an
3455
underscore, set *count to their value as an integer, advance
3456
*type to point *after the underscore, and return 1.
3458
If *type points at a string of digits not followed by an
3459
underscore, consume only the first digit. Set *count to its
3460
value as an integer, leave *type pointing after that digit,
3463
The excuse for this odd behavior: in the ARM and HP demangling
3464
styles, a type can be followed by a repeat count of the form
3467
`x' is a single digit specifying how many additional copies
3468
of the type to append to the argument list, and
3470
`y' is one or more digits, specifying the zero-based index of
3471
the first repeated argument in the list. Yes, as you're
3472
unmangling the name you can figure this out yourself, but
3475
So, for example, in `bar__3fooFPiN51', the first argument is a
3476
pointer to an integer (`Pi'), and then the next five arguments
3477
are the same (`N5'), and the first repeat is the function's
3478
second argument (`1').
3482
get_count (const char **type, int *count)
3487
if (!ISDIGIT ((unsigned char)**type))
3491
*count = **type - '0';
3493
if (ISDIGIT ((unsigned char)**type))
3503
while (ISDIGIT ((unsigned char)*p));
3514
/* RESULT will be initialised here; it will be freed on failure. The
3515
value returned is really a type_kind_t. */
3518
do_type (struct work_stuff *work, const char **mangled, string *result)
3524
const char *remembered_type;
3526
type_kind_t tk = tk_none;
3528
string_init (&decl);
3529
string_init (result);
3533
while (success && !done)
3539
/* A pointer type */
3543
if (! (work -> options & DMGL_JAVA))
3544
string_prepend (&decl, "*");
3549
/* A reference type */
3552
string_prepend (&decl, "&");
3561
if (!STRING_EMPTY (&decl)
3562
&& (decl.b[0] == '*' || decl.b[0] == '&'))
3564
string_prepend (&decl, "(");
3565
string_append (&decl, ")");
3567
string_append (&decl, "[");
3568
if (**mangled != '_')
3569
success = demangle_template_value_parm (work, mangled, &decl,
3571
if (**mangled == '_')
3573
string_append (&decl, "]");
3577
/* A back reference to a previously seen type */
3580
if (!get_count (mangled, &n) || n >= work -> ntypes)
3586
remembered_type = work -> typevec[n];
3587
mangled = &remembered_type;
3594
if (!STRING_EMPTY (&decl)
3595
&& (decl.b[0] == '*' || decl.b[0] == '&'))
3597
string_prepend (&decl, "(");
3598
string_append (&decl, ")");
3600
/* After picking off the function args, we expect to either find the
3601
function return type (preceded by an '_') or the end of the
3603
if (!demangle_nested_args (work, mangled, &decl)
3604
|| (**mangled != '_' && **mangled != '\0'))
3609
if (success && (**mangled == '_'))
3616
type_quals = TYPE_UNQUALIFIED;
3618
member = **mangled == 'M';
3621
string_append (&decl, ")");
3623
/* We don't need to prepend `::' for a qualified name;
3624
demangle_qualified will do that for us. */
3625
if (**mangled != 'Q')
3626
string_prepend (&decl, SCOPE_STRING (work));
3628
if (ISDIGIT ((unsigned char)**mangled))
3630
n = consume_count (mangled);
3632
|| (int) strlen (*mangled) < n)
3637
string_prependn (&decl, *mangled, n);
3640
else if (**mangled == 'X' || **mangled == 'Y')
3643
do_type (work, mangled, &temp);
3644
string_prepends (&decl, &temp);
3645
string_delete (&temp);
3647
else if (**mangled == 't')
3650
string_init (&temp);
3651
success = demangle_template (work, mangled, &temp,
3655
string_prependn (&decl, temp.b, temp.p - temp.b);
3656
string_delete (&temp);
3661
else if (**mangled == 'Q')
3663
success = demangle_qualified (work, mangled, &decl,
3675
string_prepend (&decl, "(");
3683
type_quals |= code_for_qualifier (**mangled);
3691
if (*(*mangled)++ != 'F')
3697
if ((member && !demangle_nested_args (work, mangled, &decl))
3698
|| **mangled != '_')
3704
if (! PRINT_ANSI_QUALIFIERS)
3708
if (type_quals != TYPE_UNQUALIFIED)
3710
APPEND_BLANK (&decl);
3711
string_append (&decl, qualifier_string (type_quals));
3722
if (PRINT_ANSI_QUALIFIERS)
3724
if (!STRING_EMPTY (&decl))
3725
string_prepend (&decl, " ");
3727
string_prepend (&decl, demangle_qualifier (**mangled));
3742
if (success) switch (**mangled)
3744
/* A qualified name, such as "Outer::Inner". */
3748
success = demangle_qualified (work, mangled, result, 0, 1);
3752
/* A back reference to a previously seen squangled type */
3755
if (!get_count (mangled, &n) || n >= work -> numb)
3758
string_append (result, work->btypevec[n]);
3763
/* A template parm. We substitute the corresponding argument. */
3768
idx = consume_count_with_underscores (mangled);
3771
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
3772
|| consume_count_with_underscores (mangled) == -1)
3778
if (work->tmpl_argvec)
3779
string_append (result, work->tmpl_argvec[idx]);
3781
string_append_template_idx (result, idx);
3788
success = demangle_fund_type (work, mangled, result);
3790
tk = (type_kind_t) success;
3796
if (!STRING_EMPTY (&decl))
3798
string_append (result, " ");
3799
string_appends (result, &decl);
3803
string_delete (result);
3804
string_delete (&decl);
3807
/* Assume an integral type, if we're not sure. */
3808
return (int) ((tk == tk_none) ? tk_integral : tk);
3813
/* Given a pointer to a type string that represents a fundamental type
3814
argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3815
string in which the demangled output is being built in RESULT, and
3816
the WORK structure, decode the types and add them to the result.
3821
"Sl" => "signed long"
3822
"CUs" => "const unsigned short"
3824
The value returned is really a type_kind_t. */
3827
demangle_fund_type (struct work_stuff *work,
3828
const char **mangled, string *result)
3832
char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
3833
unsigned int dec = 0;
3834
type_kind_t tk = tk_integral;
3836
/* First pick off any type qualifiers. There can be more than one. */
3845
if (PRINT_ANSI_QUALIFIERS)
3847
if (!STRING_EMPTY (result))
3848
string_prepend (result, " ");
3849
string_prepend (result, demangle_qualifier (**mangled));
3855
APPEND_BLANK (result);
3856
string_append (result, "unsigned");
3858
case 'S': /* signed char only */
3860
APPEND_BLANK (result);
3861
string_append (result, "signed");
3865
APPEND_BLANK (result);
3866
string_append (result, "__complex");
3874
/* Now pick off the fundamental type. There can be only one. */
3883
APPEND_BLANK (result);
3884
string_append (result, "void");
3888
APPEND_BLANK (result);
3889
string_append (result, "long long");
3893
APPEND_BLANK (result);
3894
string_append (result, "long");
3898
APPEND_BLANK (result);
3899
string_append (result, "int");
3903
APPEND_BLANK (result);
3904
string_append (result, "short");
3908
APPEND_BLANK (result);
3909
string_append (result, "bool");
3914
APPEND_BLANK (result);
3915
string_append (result, "char");
3920
APPEND_BLANK (result);
3921
string_append (result, "wchar_t");
3926
APPEND_BLANK (result);
3927
string_append (result, "long double");
3932
APPEND_BLANK (result);
3933
string_append (result, "double");
3938
APPEND_BLANK (result);
3939
string_append (result, "float");
3944
if (!ISDIGIT ((unsigned char)**mangled))
3951
if (**mangled == '_')
3956
i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3959
if (**mangled != '_')
3969
strncpy (buf, *mangled, 2);
3971
*mangled += min (strlen (*mangled), 2);
3973
sscanf (buf, "%x", &dec);
3974
sprintf (buf, "int%u_t", dec);
3975
APPEND_BLANK (result);
3976
string_append (result, buf);
3980
/* An explicit type, such as "6mytype" or "7integer" */
3992
int bindex = register_Btype (work);
3994
string_init (&btype);
3995
if (demangle_class_name (work, mangled, &btype)) {
3996
remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3997
APPEND_BLANK (result);
3998
string_appends (result, &btype);
4002
string_delete (&btype);
4008
string_init (&btype);
4009
success = demangle_template (work, mangled, &btype, 0, 1, 1);
4010
string_appends (result, &btype);
4011
string_delete (&btype);
4019
return success ? ((int) tk) : 0;
4023
/* Handle a template's value parameter for HP aCC (extension from ARM)
4024
**mangled points to 'S' or 'U' */
4027
do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
4028
const char **mangled, string *result)
4032
if (**mangled != 'U' && **mangled != 'S')
4035
unsigned_const = (**mangled == 'U');
4042
string_append (result, "-");
4048
/* special case for -2^31 */
4049
string_append (result, "-2147483648");
4056
/* We have to be looking at an integer now */
4057
if (!(ISDIGIT ((unsigned char)**mangled)))
4060
/* We only deal with integral values for template
4061
parameters -- so it's OK to look only for digits */
4062
while (ISDIGIT ((unsigned char)**mangled))
4064
char_str[0] = **mangled;
4065
string_append (result, char_str);
4070
string_append (result, "U");
4072
/* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4073
with L or LL suffixes. pai/1997-09-03 */
4075
return 1; /* success */
4078
/* Handle a template's literal parameter for HP aCC (extension from ARM)
4079
**mangled is pointing to the 'A' */
4082
do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
4085
int literal_len = 0;
4089
if (**mangled != 'A')
4094
literal_len = consume_count (mangled);
4096
if (literal_len <= 0)
4099
/* Literal parameters are names of arrays, functions, etc. and the
4100
canonical representation uses the address operator */
4101
string_append (result, "&");
4103
/* Now recursively demangle the literal name */
4104
recurse = XNEWVEC (char, literal_len + 1);
4105
memcpy (recurse, *mangled, literal_len);
4106
recurse[literal_len] = '\000';
4108
recurse_dem = cplus_demangle (recurse, work->options);
4112
string_append (result, recurse_dem);
4117
string_appendn (result, *mangled, literal_len);
4119
(*mangled) += literal_len;
4126
snarf_numeric_literal (const char **args, string *arg)
4131
string_append (arg, char_str);
4134
else if (**args == '+')
4137
if (!ISDIGIT ((unsigned char)**args))
4140
while (ISDIGIT ((unsigned char)**args))
4142
char_str[0] = **args;
4143
string_append (arg, char_str);
4150
/* Demangle the next argument, given by MANGLED into RESULT, which
4151
*should be an uninitialized* string. It will be initialized here,
4152
and free'd should anything go wrong. */
4155
do_arg (struct work_stuff *work, const char **mangled, string *result)
4157
/* Remember where we started so that we can record the type, for
4158
non-squangling type remembering. */
4159
const char *start = *mangled;
4161
string_init (result);
4163
if (work->nrepeats > 0)
4167
if (work->previous_argument == 0)
4170
/* We want to reissue the previous type in this argument list. */
4171
string_appends (result, work->previous_argument);
4175
if (**mangled == 'n')
4177
/* A squangling-style repeat. */
4179
work->nrepeats = consume_count(mangled);
4181
if (work->nrepeats <= 0)
4182
/* This was not a repeat count after all. */
4185
if (work->nrepeats > 9)
4187
if (**mangled != '_')
4188
/* The repeat count should be followed by an '_' in this
4195
/* Now, the repeat is all set up. */
4196
return do_arg (work, mangled, result);
4199
/* Save the result in WORK->previous_argument so that we can find it
4200
if it's repeated. Note that saving START is not good enough: we
4201
do not want to add additional types to the back-referenceable
4202
type vector when processing a repeated type. */
4203
if (work->previous_argument)
4204
string_delete (work->previous_argument);
4206
work->previous_argument = XNEW (string);
4208
if (!do_type (work, mangled, work->previous_argument))
4211
string_appends (result, work->previous_argument);
4213
remember_type (work, start, *mangled - start);
4218
remember_type (struct work_stuff *work, const char *start, int len)
4222
if (work->forgetting_types)
4225
if (work -> ntypes >= work -> typevec_size)
4227
if (work -> typevec_size == 0)
4229
work -> typevec_size = 3;
4230
work -> typevec = XNEWVEC (char *, work->typevec_size);
4234
work -> typevec_size *= 2;
4236
= XRESIZEVEC (char *, work->typevec, work->typevec_size);
4239
tem = XNEWVEC (char, len + 1);
4240
memcpy (tem, start, len);
4242
work -> typevec[work -> ntypes++] = tem;
4246
/* Remember a K type class qualifier. */
4248
remember_Ktype (struct work_stuff *work, const char *start, int len)
4252
if (work -> numk >= work -> ksize)
4254
if (work -> ksize == 0)
4257
work -> ktypevec = XNEWVEC (char *, work->ksize);
4263
= XRESIZEVEC (char *, work->ktypevec, work->ksize);
4266
tem = XNEWVEC (char, len + 1);
4267
memcpy (tem, start, len);
4269
work -> ktypevec[work -> numk++] = tem;
4272
/* Register a B code, and get an index for it. B codes are registered
4273
as they are seen, rather than as they are completed, so map<temp<char> >
4274
registers map<temp<char> > as B0, and temp<char> as B1 */
4277
register_Btype (struct work_stuff *work)
4281
if (work -> numb >= work -> bsize)
4283
if (work -> bsize == 0)
4286
work -> btypevec = XNEWVEC (char *, work->bsize);
4292
= XRESIZEVEC (char *, work->btypevec, work->bsize);
4295
ret = work -> numb++;
4296
work -> btypevec[ret] = NULL;
4300
/* Store a value into a previously registered B code type. */
4303
remember_Btype (struct work_stuff *work, const char *start,
4308
tem = XNEWVEC (char, len + 1);
4309
memcpy (tem, start, len);
4311
work -> btypevec[index] = tem;
4314
/* Lose all the info related to B and K type codes. */
4316
forget_B_and_K_types (struct work_stuff *work)
4320
while (work -> numk > 0)
4322
i = --(work -> numk);
4323
if (work -> ktypevec[i] != NULL)
4325
free (work -> ktypevec[i]);
4326
work -> ktypevec[i] = NULL;
4330
while (work -> numb > 0)
4332
i = --(work -> numb);
4333
if (work -> btypevec[i] != NULL)
4335
free (work -> btypevec[i]);
4336
work -> btypevec[i] = NULL;
4340
/* Forget the remembered types, but not the type vector itself. */
4343
forget_types (struct work_stuff *work)
4347
while (work -> ntypes > 0)
4349
i = --(work -> ntypes);
4350
if (work -> typevec[i] != NULL)
4352
free (work -> typevec[i]);
4353
work -> typevec[i] = NULL;
4358
/* Process the argument list part of the signature, after any class spec
4359
has been consumed, as well as the first 'F' character (if any). For
4362
"__als__3fooRT0" => process "RT0"
4363
"complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
4365
DECLP must be already initialised, usually non-empty. It won't be freed
4368
Note that g++ differs significantly from ARM and lucid style mangling
4369
with regards to references to previously seen types. For example, given
4370
the source fragment:
4374
foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4377
foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4378
void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4380
g++ produces the names:
4385
while lcc (and presumably other ARM style compilers as well) produces:
4387
foo__FiR3fooT1T2T1T2
4388
__ct__3fooFiR3fooT1T2T1T2
4390
Note that g++ bases its type numbers starting at zero and counts all
4391
previously seen types, while lucid/ARM bases its type numbers starting
4392
at one and only considers types after it has seen the 'F' character
4393
indicating the start of the function args. For lucid/ARM style, we
4394
account for this difference by discarding any previously seen types when
4395
we see the 'F' character, and subtracting one from the type number
4401
demangle_args (struct work_stuff *work, const char **mangled,
4411
if (PRINT_ARG_TYPES)
4413
string_append (declp, "(");
4414
if (**mangled == '\0')
4416
string_append (declp, "void");
4420
while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4421
|| work->nrepeats > 0)
4423
if ((**mangled == 'N') || (**mangled == 'T'))
4425
temptype = *(*mangled)++;
4427
if (temptype == 'N')
4429
if (!get_count (mangled, &r))
4438
if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4440
/* If we have 10 or more types we might have more than a 1 digit
4441
index so we'll have to consume the whole count here. This
4442
will lose if the next thing is a type name preceded by a
4443
count but it's impossible to demangle that case properly
4444
anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4445
Pc, ...)" or "(..., type12, char *, ...)" */
4446
if ((t = consume_count(mangled)) <= 0)
4453
if (!get_count (mangled, &t))
4458
if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4462
/* Validate the type index. Protect against illegal indices from
4463
malformed type strings. */
4464
if ((t < 0) || (t >= work -> ntypes))
4468
while (work->nrepeats > 0 || --r >= 0)
4470
tem = work -> typevec[t];
4471
if (need_comma && PRINT_ARG_TYPES)
4473
string_append (declp, ", ");
4475
if (!do_arg (work, &tem, &arg))
4479
if (PRINT_ARG_TYPES)
4481
string_appends (declp, &arg);
4483
string_delete (&arg);
4489
if (need_comma && PRINT_ARG_TYPES)
4490
string_append (declp, ", ");
4491
if (!do_arg (work, mangled, &arg))
4493
if (PRINT_ARG_TYPES)
4494
string_appends (declp, &arg);
4495
string_delete (&arg);
4500
if (**mangled == 'e')
4503
if (PRINT_ARG_TYPES)
4507
string_append (declp, ",");
4509
string_append (declp, "...");
4513
if (PRINT_ARG_TYPES)
4515
string_append (declp, ")");
4520
/* Like demangle_args, but for demangling the argument lists of function
4521
and method pointers or references, not top-level declarations. */
4524
demangle_nested_args (struct work_stuff *work, const char **mangled,
4527
string* saved_previous_argument;
4531
/* The G++ name-mangling algorithm does not remember types on nested
4532
argument lists, unless -fsquangling is used, and in that case the
4533
type vector updated by remember_type is not used. So, we turn
4534
off remembering of types here. */
4535
++work->forgetting_types;
4537
/* For the repeat codes used with -fsquangling, we must keep track of
4538
the last argument. */
4539
saved_previous_argument = work->previous_argument;
4540
saved_nrepeats = work->nrepeats;
4541
work->previous_argument = 0;
4544
/* Actually demangle the arguments. */
4545
result = demangle_args (work, mangled, declp);
4547
/* Restore the previous_argument field. */
4548
if (work->previous_argument)
4550
string_delete (work->previous_argument);
4551
free ((char *) work->previous_argument);
4553
work->previous_argument = saved_previous_argument;
4554
--work->forgetting_types;
4555
work->nrepeats = saved_nrepeats;
4560
/* Returns 1 if a valid function name was found or 0 otherwise. */
4563
demangle_function_name (struct work_stuff *work, const char **mangled,
4564
string *declp, const char *scan)
4570
string_appendn (declp, (*mangled), scan - (*mangled));
4571
string_need (declp, 1);
4572
*(declp -> p) = '\0';
4574
/* Consume the function name, including the "__" separating the name
4575
from the signature. We are guaranteed that SCAN points to the
4578
(*mangled) = scan + 2;
4579
/* We may be looking at an instantiation of a template function:
4580
foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4581
following _F marks the start of the function arguments. Handle
4582
the template arguments first. */
4584
if (HP_DEMANGLING && (**mangled == 'X'))
4586
demangle_arm_hp_template (work, mangled, 0, declp);
4587
/* This leaves MANGLED pointing to the 'F' marking func args */
4590
if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4593
/* See if we have an ARM style constructor or destructor operator.
4594
If so, then just record it, clear the decl, and return.
4595
We can't build the actual constructor/destructor decl until later,
4596
when we recover the class name from the signature. */
4598
if (strcmp (declp -> b, "__ct") == 0)
4600
work -> constructor += 1;
4601
string_clear (declp);
4604
else if (strcmp (declp -> b, "__dt") == 0)
4606
work -> destructor += 1;
4607
string_clear (declp);
4612
if (declp->p - declp->b >= 3
4613
&& declp->b[0] == 'o'
4614
&& declp->b[1] == 'p'
4615
&& strchr (cplus_markers, declp->b[2]) != NULL)
4617
/* see if it's an assignment expression */
4618
if (declp->p - declp->b >= 10 /* op$assign_ */
4619
&& memcmp (declp->b + 3, "assign_", 7) == 0)
4621
for (i = 0; i < ARRAY_SIZE (optable); i++)
4623
int len = declp->p - declp->b - 10;
4624
if ((int) strlen (optable[i].in) == len
4625
&& memcmp (optable[i].in, declp->b + 10, len) == 0)
4627
string_clear (declp);
4628
string_append (declp, "operator");
4629
string_append (declp, optable[i].out);
4630
string_append (declp, "=");
4637
for (i = 0; i < ARRAY_SIZE (optable); i++)
4639
int len = declp->p - declp->b - 3;
4640
if ((int) strlen (optable[i].in) == len
4641
&& memcmp (optable[i].in, declp->b + 3, len) == 0)
4643
string_clear (declp);
4644
string_append (declp, "operator");
4645
string_append (declp, optable[i].out);
4651
else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4652
&& strchr (cplus_markers, declp->b[4]) != NULL)
4654
/* type conversion operator */
4656
if (do_type (work, &tem, &type))
4658
string_clear (declp);
4659
string_append (declp, "operator ");
4660
string_appends (declp, &type);
4661
string_delete (&type);
4664
else if (declp->b[0] == '_' && declp->b[1] == '_'
4665
&& declp->b[2] == 'o' && declp->b[3] == 'p')
4668
/* type conversion operator. */
4670
if (do_type (work, &tem, &type))
4672
string_clear (declp);
4673
string_append (declp, "operator ");
4674
string_appends (declp, &type);
4675
string_delete (&type);
4678
else if (declp->b[0] == '_' && declp->b[1] == '_'
4679
&& ISLOWER((unsigned char)declp->b[2])
4680
&& ISLOWER((unsigned char)declp->b[3]))
4682
if (declp->b[4] == '\0')
4685
for (i = 0; i < ARRAY_SIZE (optable); i++)
4687
if (strlen (optable[i].in) == 2
4688
&& memcmp (optable[i].in, declp->b + 2, 2) == 0)
4690
string_clear (declp);
4691
string_append (declp, "operator");
4692
string_append (declp, optable[i].out);
4699
if (declp->b[2] == 'a' && declp->b[5] == '\0')
4702
for (i = 0; i < ARRAY_SIZE (optable); i++)
4704
if (strlen (optable[i].in) == 3
4705
&& memcmp (optable[i].in, declp->b + 2, 3) == 0)
4707
string_clear (declp);
4708
string_append (declp, "operator");
4709
string_append (declp, optable[i].out);
4717
/* If a function name was obtained but it's not valid, we were not
4719
if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
4725
/* a mini string-handling package */
4728
string_need (string *s, int n)
4738
s->p = s->b = XNEWVEC (char, n);
4741
else if (s->e - s->p < n)
4746
s->b = XRESIZEVEC (char, s->b, n);
4753
string_delete (string *s)
4758
s->b = s->e = s->p = NULL;
4763
string_init (string *s)
4765
s->b = s->p = s->e = NULL;
4769
string_clear (string *s)
4777
string_empty (string *s)
4779
return (s->b == s->p);
4785
string_append (string *p, const char *s)
4788
if (s == NULL || *s == '\0')
4792
memcpy (p->p, s, n);
4797
string_appends (string *p, string *s)
4805
memcpy (p->p, s->b, n);
4811
string_appendn (string *p, const char *s, int n)
4816
memcpy (p->p, s, n);
4822
string_prepend (string *p, const char *s)
4824
if (s != NULL && *s != '\0')
4826
string_prependn (p, s, strlen (s));
4831
string_prepends (string *p, string *s)
4835
string_prependn (p, s->b, s->p - s->b);
4840
string_prependn (string *p, const char *s, int n)
4847
for (q = p->p - 1; q >= p->b; q--)
4851
memcpy (p->b, s, n);
4857
string_append_template_idx (string *s, int idx)
4859
char buf[INTBUF_SIZE + 1 /* 'T' */];
4860
sprintf(buf, "T%d", idx);
4861
string_append (s, buf);