WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/libiberty/cplus-dem.c

Rev	Author	Line No.	Line
5191	serge	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
		7
		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.
		13
		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
		21	combined executable.)
		22
		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.
		27
		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. */
		32
		33	/* This file exports two functions; cplus_mangle_opname and cplus_demangle.
		34
		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
		37	available memory. */
		38
		39	/* This file lives in both GCC and libiberty. When making changes, please
		40	try not to break either. */
		41
		42	#ifdef HAVE_CONFIG_H
		43	#include "config.h"
		44	#endif
		45
		46	#include "safe-ctype.h"
		47
		48	#include
		49	#include
		50	#include
		51
		52	#ifdef HAVE_STDLIB_H
		53	#include
		54	#else
		55	void * malloc ();
		56	void * realloc ();
		57	#endif
		58
		59	#include
		60	#undef CURRENT_DEMANGLING_STYLE
		61	#define CURRENT_DEMANGLING_STYLE work->options
		62
		63	#include "libiberty.h"
		64
		65	#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
		66
		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
		70
		71	extern void fancy_abort (void) ATTRIBUTE_NORETURN;
		72
		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 '$'.
		83
		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_compiled
		87	marker symbol (FIXME). */
		88
		89	#if !defined (CPLUS_MARKER)
		90	#define CPLUS_MARKER '$'
		91	#endif
		92
		93	enum demangling_styles current_demangling_style = auto_demangling;
		94
		95	static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
		96
		97	static char char_str[2] = { '\000', '\000' };
		98
		99	void
		100	set_cplus_marker_for_demangling (int ch)
		101	{
		102	cplus_markers[0] = ch;
		103	}
		104
		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 */
		110	} string;
		111
		112	/* Stuff that is shared between sub-routines.
		113	Using a shared structure allows cplus_demangle to be reentrant. */
		114
		115	struct work_stuff
		116	{
		117	int options;
		118	char **typevec;
		119	char **ktypevec;
		120	char **btypevec;
		121	int numk;
		122	int numb;
		123	int ksize;
		124	int bsize;
		125	int ntypes;
		126	int typevec_size;
		127	int constructor;
		128	int destructor;
		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
		136	we see. */
		137	string* previous_argument; /* The last function argument demangled. */
		138	int nrepeats; /* The number of times to repeat the previous
		139	argument. */
		140	};
		141
		142	#define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
		143	#define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
		144
		145	static const struct optable
		146	{
		147	const char *const in;
		148	const char *const out;
		149	const int flags;
		150	} optable[] = {
		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", "
		226	{"mn", "
		227	{"nop", "", 0}, /* old (for operator=) */
		228	{"rm", "->", DMGL_ANSI}, / ansi */
		229	{"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */
		230	};
		231
		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'
		234	values. */
		235	typedef enum type_kind_t
		236	{
		237	tk_none,
		238	tk_pointer,
		239	tk_reference,
		240	tk_integral,
		241	tk_bool,
		242	tk_char,
		243	tk_real
		244	} type_kind_t;
		245
		246	const struct demangler_engine libiberty_demanglers[] =
		247	{
		248	{
		249	NO_DEMANGLING_STYLE_STRING,
		250	no_demangling,
		251	"Demangling disabled"
		252	}
		253	,
		254	{
		255	AUTO_DEMANGLING_STYLE_STRING,
		256	auto_demangling,
		257	"Automatic selection based on executable"
		258	}
		259	,
		260	{
		261	GNU_DEMANGLING_STYLE_STRING,
		262	gnu_demangling,
		263	"GNU (g++) style demangling"
		264	}
		265	,
		266	{
		267	LUCID_DEMANGLING_STYLE_STRING,
		268	lucid_demangling,
		269	"Lucid (lcc) style demangling"
		270	}
		271	,
		272	{
		273	ARM_DEMANGLING_STYLE_STRING,
		274	arm_demangling,
		275	"ARM style demangling"
		276	}
		277	,
		278	{
		279	HP_DEMANGLING_STYLE_STRING,
		280	hp_demangling,
		281	"HP (aCC) style demangling"
		282	}
		283	,
		284	{
		285	EDG_DEMANGLING_STYLE_STRING,
		286	edg_demangling,
		287	"EDG style demangling"
		288	}
		289	,
		290	{
		291	GNU_V3_DEMANGLING_STYLE_STRING,
		292	gnu_v3_demangling,
		293	"GNU (g++) V3 ABI-style demangling"
		294	}
		295	,
		296	{
		297	JAVA_DEMANGLING_STYLE_STRING,
		298	java_demangling,
		299	"Java style demangling"
		300	}
		301	,
		302	{
		303	GNAT_DEMANGLING_STYLE_STRING,
		304	gnat_demangling,
		305	"GNAT style demangling"
		306	}
		307	,
		308	{
6324	serge	309	DLANG_DEMANGLING_STYLE_STRING,
		310	dlang_demangling,
		311	"DLANG style demangling"
		312	}
		313	,
		314	{
5191	serge	315	NULL, unknown_demangling, NULL
		316	}
		317	};
		318
		319	#define STRING_EMPTY(str) ((str) -> b == (str) -> p)
		320	#define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
		321	string_append(str, " ");}
		322	#define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
		323
		324	/* The scope separator appropriate for the language being demangled. */
		325
		326	#define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
		327
		328	#define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
		329	#define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
		330
		331	/* Prototypes for local functions */
		332
		333	static void delete_work_stuff (struct work_stuff *);
		334
		335	static void delete_non_B_K_work_stuff (struct work_stuff *);
		336
		337	static char mop_up (struct work_stuff , string *, int);
		338
		339	static void squangle_mop_up (struct work_stuff *);
		340
		341	static void work_stuff_copy_to_from (struct work_stuff , struct work_stuff );
		342
		343	#if 0
		344	static int
		345	demangle_method_args (struct work_stuff , const char , string );
		346	#endif
		347
		348	static char *
		349	internal_cplus_demangle (struct work_stuff , const char );
		350
		351	static int
		352	demangle_template_template_parm (struct work_stuff *work,
		353	const char *, string );
		354
		355	static int
		356	demangle_template (struct work_stuff work, const char , string ,
		357	string *, int, int);
		358
		359	static int
		360	arm_pt (struct work_stuff , const char , int, const char **,
		361	const char **);
		362
		363	static int
		364	demangle_class_name (struct work_stuff , const char , string );
		365
		366	static int
		367	demangle_qualified (struct work_stuff , const char , string ,
		368	int, int);
		369
		370	static int demangle_class (struct work_stuff , const char , string );
		371
		372	static int demangle_fund_type (struct work_stuff , const char , string );
		373
		374	static int demangle_signature (struct work_stuff , const char , string );
		375
		376	static int demangle_prefix (struct work_stuff , const char , string );
		377
		378	static int gnu_special (struct work_stuff , const char , string );
		379
		380	static int arm_special (const char *, string );
		381
		382	static void string_need (string *, int);
		383
		384	static void string_delete (string *);
		385
		386	static void
		387	string_init (string *);
		388
		389	static void string_clear (string *);
		390
		391	#if 0
		392	static int string_empty (string *);
		393	#endif
		394
		395	static void string_append (string , const char );
		396
		397	static void string_appends (string , string );
		398
		399	static void string_appendn (string , const char , int);
		400
		401	static void string_prepend (string , const char );
		402
		403	static void string_prependn (string , const char , int);
		404
		405	static void string_append_template_idx (string *, int);
		406
		407	static int get_count (const char *, int );
		408
		409	static int consume_count (const char **);
		410
		411	static int consume_count_with_underscores (const char**);
		412
		413	static int demangle_args (struct work_stuff , const char , string );
		414
		415	static int demangle_nested_args (struct work_stuff, const char, string);
		416
		417	static int do_type (struct work_stuff , const char , string );
		418
		419	static int do_arg (struct work_stuff , const char , string );
		420
		421	static int
		422	demangle_function_name (struct work_stuff , const char , string ,
		423	const char *);
		424
		425	static int
		426	iterate_demangle_function (struct work_stuff *,
		427	const char *, string , const char *);
		428
		429	static void remember_type (struct work_stuff , const char , int);
		430
		431	static void remember_Btype (struct work_stuff , const char , int, int);
		432
		433	static int register_Btype (struct work_stuff *);
		434
		435	static void remember_Ktype (struct work_stuff , const char , int);
		436
		437	static void forget_types (struct work_stuff *);
		438
		439	static void forget_B_and_K_types (struct work_stuff *);
		440
		441	static void string_prepends (string , string );
		442
		443	static int
		444	demangle_template_value_parm (struct work_stuff, const char*,
		445	string*, type_kind_t);
		446
		447	static int
		448	do_hpacc_template_const_value (struct work_stuff , const char , string );
		449
		450	static int
		451	do_hpacc_template_literal (struct work_stuff , const char , string );
		452
		453	static int snarf_numeric_literal (const char *, string );
		454
		455	/* There is a TYPE_QUAL value for each type qualifier. They can be
		456	combined by bitwise-or to form the complete set of qualifiers for a
		457	type. */
		458
		459	#define TYPE_UNQUALIFIED 0x0
		460	#define TYPE_QUAL_CONST 0x1
		461	#define TYPE_QUAL_VOLATILE 0x2
		462	#define TYPE_QUAL_RESTRICT 0x4
		463
		464	static int code_for_qualifier (int);
		465
		466	static const char* qualifier_string (int);
		467
		468	static const char* demangle_qualifier (int);
		469
		470	static int demangle_expression (struct work_stuff , const char , string ,
		471	type_kind_t);
		472
		473	static int
		474	demangle_integral_value (struct work_stuff , const char , string );
		475
		476	static int
		477	demangle_real_value (struct work_stuff , const char , string );
		478
		479	static void
		480	demangle_arm_hp_template (struct work_stuff , const char , int, string );
		481
		482	static void
		483	recursively_demangle (struct work_stuff , const char , string , int);
		484
		485	/* Translate count to integer, consuming tokens in the process.
		486	Conversion terminates on the first non-digit character.
		487
		488	Trying to consume something that isn't a count results in no
		489	consumption of input and a return of -1.
		490
		491	Overflow consumes the rest of the digits, and returns -1. */
		492
		493	static int
		494	consume_count (const char **type)
		495	{
		496	int count = 0;
		497
		498	if (! ISDIGIT ((unsigned char)**type))
		499	return -1;
		500
		501	while (ISDIGIT ((unsigned char)**type))
		502	{
		503	count *= 10;
		504
		505	/* Check for overflow.
		506	We assume that count is represented using two's-complement;
		507	no power of two is divisible by ten, so if an overflow occurs
		508	when multiplying by ten, the result will not be a multiple of
		509	ten. */
		510	if ((count % 10) != 0)
		511	{
		512	while (ISDIGIT ((unsigned char) **type))
		513	(*type)++;
		514	return -1;
		515	}
		516
		517	count += **type - '0';
		518	(*type)++;
		519	}
		520
		521	if (count < 0)
		522	count = -1;
		523
		524	return (count);
		525	}
		526
		527
		528	/* Like consume_count, but for counts that are preceded and followed
		529	by '_' if they are greater than 10. Also, -1 is returned for
		530	failure, since 0 can be a valid value. */
		531
		532	static int
		533	consume_count_with_underscores (const char **mangled)
		534	{
		535	int idx;
		536
		537	if (**mangled == '_')
		538	{
		539	(*mangled)++;
		540	if (!ISDIGIT ((unsigned char)**mangled))
		541	return -1;
		542
		543	idx = consume_count (mangled);
		544	if (**mangled != '_')
		545	/* The trailing underscore was missing. */
		546	return -1;
		547
		548	(*mangled)++;
		549	}
		550	else
		551	{
		552	if (mangled < '0' \|\| mangled > '9')
		553	return -1;
		554
		555	idx = **mangled - '0';
		556	(*mangled)++;
		557	}
		558
		559	return idx;
		560	}
		561
		562	/* C is the code for a type-qualifier. Return the TYPE_QUAL
		563	corresponding to this qualifier. */
		564
		565	static int
		566	code_for_qualifier (int c)
		567	{
		568	switch (c)
		569	{
		570	case 'C':
		571	return TYPE_QUAL_CONST;
		572
		573	case 'V':
		574	return TYPE_QUAL_VOLATILE;
		575
		576	case 'u':
		577	return TYPE_QUAL_RESTRICT;
		578
		579	default:
		580	break;
		581	}
		582
		583	/* C was an invalid qualifier. */
		584	abort ();
		585	}
		586
		587	/* Return the string corresponding to the qualifiers given by
		588	TYPE_QUALS. */
		589
		590	static const char*
		591	qualifier_string (int type_quals)
		592	{
		593	switch (type_quals)
		594	{
		595	case TYPE_UNQUALIFIED:
		596	return "";
		597
		598	case TYPE_QUAL_CONST:
		599	return "const";
		600
		601	case TYPE_QUAL_VOLATILE:
		602	return "volatile";
		603
		604	case TYPE_QUAL_RESTRICT:
		605	return "__restrict";
		606
		607	case TYPE_QUAL_CONST \| TYPE_QUAL_VOLATILE:
		608	return "const volatile";
		609
		610	case TYPE_QUAL_CONST \| TYPE_QUAL_RESTRICT:
		611	return "const __restrict";
		612
		613	case TYPE_QUAL_VOLATILE \| TYPE_QUAL_RESTRICT:
		614	return "volatile __restrict";
		615
		616	case TYPE_QUAL_CONST \| TYPE_QUAL_VOLATILE \| TYPE_QUAL_RESTRICT:
		617	return "const volatile __restrict";
		618
		619	default:
		620	break;
		621	}
		622
		623	/* TYPE_QUALS was an invalid qualifier set. */
		624	abort ();
		625	}
		626
		627	/* C is the code for a type-qualifier. Return the string
		628	corresponding to this qualifier. This function should only be
		629	called with a valid qualifier code. */
		630
		631	static const char*
		632	demangle_qualifier (int c)
		633	{
		634	return qualifier_string (code_for_qualifier (c));
		635	}
		636
		637	int
		638	cplus_demangle_opname (const char opname, char result, int options)
		639	{
		640	int len, len1, ret;
		641	string type;
		642	struct work_stuff work[1];
		643	const char *tem;
		644
		645	len = strlen(opname);
		646	result[0] = '\0';
		647	ret = 0;
		648	memset ((char *) work, 0, sizeof (work));
		649	work->options = options;
		650
		651	if (opname[0] == '_' && opname[1] == '_'
		652	&& opname[2] == 'o' && opname[3] == 'p')
		653	{
		654	/* ANSI. */
		655	/* type conversion operator. */
		656	tem = opname + 4;
		657	if (do_type (work, &tem, &type))
		658	{
		659	strcat (result, "operator ");
		660	strncat (result, type.b, type.p - type.b);
		661	string_delete (&type);
		662	ret = 1;
		663	}
		664	}
		665	else if (opname[0] == '_' && opname[1] == '_'
		666	&& ISLOWER((unsigned char)opname[2])
		667	&& ISLOWER((unsigned char)opname[3]))
		668	{
		669	if (opname[4] == '\0')
		670	{
		671	/* Operator. */
		672	size_t i;
		673	for (i = 0; i < ARRAY_SIZE (optable); i++)
		674	{
		675	if (strlen (optable[i].in) == 2
		676	&& memcmp (optable[i].in, opname + 2, 2) == 0)
		677	{
		678	strcat (result, "operator");
		679	strcat (result, optable[i].out);
		680	ret = 1;
		681	break;
		682	}
		683	}
		684	}
		685	else
		686	{
		687	if (opname[2] == 'a' && opname[5] == '\0')
		688	{
		689	/* Assignment. */
		690	size_t i;
		691	for (i = 0; i < ARRAY_SIZE (optable); i++)
		692	{
		693	if (strlen (optable[i].in) == 3
		694	&& memcmp (optable[i].in, opname + 2, 3) == 0)
		695	{
		696	strcat (result, "operator");
		697	strcat (result, optable[i].out);
		698	ret = 1;
		699	break;
		700	}
		701	}
		702	}
		703	}
		704	}
		705	else if (len >= 3
		706	&& opname[0] == 'o'
		707	&& opname[1] == 'p'
		708	&& strchr (cplus_markers, opname[2]) != NULL)
		709	{
		710	/* see if it's an assignment expression */
		711	if (len >= 10 /* op$assign_ */
		712	&& memcmp (opname + 3, "assign_", 7) == 0)
		713	{
		714	size_t i;
		715	for (i = 0; i < ARRAY_SIZE (optable); i++)
		716	{
		717	len1 = len - 10;
		718	if ((int) strlen (optable[i].in) == len1
		719	&& memcmp (optable[i].in, opname + 10, len1) == 0)
		720	{
		721	strcat (result, "operator");
		722	strcat (result, optable[i].out);
		723	strcat (result, "=");
		724	ret = 1;
		725	break;
		726	}
		727	}
		728	}
		729	else
		730	{
		731	size_t i;
		732	for (i = 0; i < ARRAY_SIZE (optable); i++)
		733	{
		734	len1 = len - 3;
		735	if ((int) strlen (optable[i].in) == len1
		736	&& memcmp (optable[i].in, opname + 3, len1) == 0)
		737	{
		738	strcat (result, "operator");
		739	strcat (result, optable[i].out);
		740	ret = 1;
		741	break;
		742	}
		743	}
		744	}
		745	}
		746	else if (len >= 5 && memcmp (opname, "type", 4) == 0
		747	&& strchr (cplus_markers, opname[4]) != NULL)
		748	{
		749	/* type conversion operator */
		750	tem = opname + 5;
		751	if (do_type (work, &tem, &type))
		752	{
		753	strcat (result, "operator ");
		754	strncat (result, type.b, type.p - type.b);
		755	string_delete (&type);
		756	ret = 1;
		757	}
		758	}
		759	squangle_mop_up (work);
		760	return ret;
		761
		762	}
		763
		764	/* Takes operator name as e.g. "++" and returns mangled
		765	operator name (e.g. "postincrement_expr"), or NULL if not found.
		766
		767	If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
		768	if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
		769
		770	const char *
		771	cplus_mangle_opname (const char *opname, int options)
		772	{
		773	size_t i;
		774	int len;
		775
		776	len = strlen (opname);
		777	for (i = 0; i < ARRAY_SIZE (optable); i++)
		778	{
		779	if ((int) strlen (optable[i].out) == len
		780	&& (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
		781	&& memcmp (optable[i].out, opname, len) == 0)
		782	return optable[i].in;
		783	}
		784	return (0);
		785	}
		786
		787	/* Add a routine to set the demangling style to be sure it is valid and
		788	allow for any demangler initialization that maybe necessary. */
		789
		790	enum demangling_styles
		791	cplus_demangle_set_style (enum demangling_styles style)
		792	{
		793	const struct demangler_engine *demangler = libiberty_demanglers;
		794
		795	for (; demangler->demangling_style != unknown_demangling; ++demangler)
		796	if (style == demangler->demangling_style)
		797	{
		798	current_demangling_style = style;
		799	return current_demangling_style;
		800	}
		801
		802	return unknown_demangling;
		803	}
		804
		805	/* Do string name to style translation */
		806
		807	enum demangling_styles
		808	cplus_demangle_name_to_style (const char *name)
		809	{
		810	const struct demangler_engine *demangler = libiberty_demanglers;
		811
		812	for (; demangler->demangling_style != unknown_demangling; ++demangler)
		813	if (strcmp (name, demangler->demangling_style_name) == 0)
		814	return demangler->demangling_style;
		815
		816	return unknown_demangling;
		817	}
		818
		819	/* char cplus_demangle (const char mangled, int options)
		820
		821	If MANGLED is a mangled function name produced by GNU C++, then
		822	a pointer to a @code{malloc}ed string giving a C++ representation
		823	of the name will be returned; otherwise NULL will be returned.
		824	It is the caller's responsibility to free the string which
		825	is returned.
		826
		827	The OPTIONS arg may contain one or more of the following bits:
		828
		829	DMGL_ANSI ANSI qualifiers such as `const' and `void' are
		830	included.
		831	DMGL_PARAMS Function parameters are included.
		832
		833	For example,
		834
		835	cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
		836	cplus_demangle ("foo__1Ai", DMGL_PARAMS \| DMGL_ANSI) => "A::foo(int)"
		837	cplus_demangle ("foo__1Ai", 0) => "A::foo"
		838
		839	cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
		840	cplus_demangle ("foo__1Afe", DMGL_PARAMS \| DMGL_ANSI)=> "A::foo(float,...)"
		841	cplus_demangle ("foo__1Afe", 0) => "A::foo"
		842
		843	Note that any leading underscores, or other such characters prepended by
		844	the compilation system, are presumed to have already been stripped from
		845	MANGLED. */
		846
		847	char *
		848	cplus_demangle (const char *mangled, int options)
		849	{
		850	char *ret;
		851	struct work_stuff work[1];
		852
		853	if (current_demangling_style == no_demangling)
		854	return xstrdup (mangled);
		855
		856	memset ((char *) work, 0, sizeof (work));
		857	work->options = options;
		858	if ((work->options & DMGL_STYLE_MASK) == 0)
		859	work->options \|= (int) current_demangling_style & DMGL_STYLE_MASK;
		860
		861	/* The V3 ABI demangling is implemented elsewhere. */
		862	if (GNU_V3_DEMANGLING \|\| AUTO_DEMANGLING)
		863	{
		864	ret = cplus_demangle_v3 (mangled, work->options);
		865	if (ret \|\| GNU_V3_DEMANGLING)
		866	return ret;
		867	}
		868
		869	if (JAVA_DEMANGLING)
		870	{
		871	ret = java_demangle_v3 (mangled);
		872	if (ret)
		873	return ret;
		874	}
		875
		876	if (GNAT_DEMANGLING)
		877	return ada_demangle (mangled, options);
		878
6324	serge	879	if (DLANG_DEMANGLING)
		880	{
		881	ret = dlang_demangle (mangled, options);
		882	if (ret)
		883	return ret;
		884	}
		885
5191	serge	886	ret = internal_cplus_demangle (work, mangled);
		887	squangle_mop_up (work);
		888	return (ret);
		889	}
		890
		891	/* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */
		892
		893	char *
		894	ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
		895	{
		896	int len0;
		897	const char* p;
		898	char *d;
		899	char *demangled;
		900
		901	/* Discard leading _ada_, which is used for library level subprograms. */
		902	if (strncmp (mangled, "_ada_", 5) == 0)
		903	mangled += 5;
		904
		905	/* All ada unit names are lower-case. */
		906	if (!ISLOWER (mangled[0]))
		907	goto unknown;
		908
		909	/* Most of the demangling will trivially remove chars. Operator names
		910	may add one char but because they are always preceeded by '__' which is
		911	replaced by '.', they eventually never expand the size.
		912	A few special names such as '___elabs' add a few chars (at most 7), but
		913	they occur only once. */
		914	len0 = strlen (mangled) + 7 + 1;
		915	demangled = XNEWVEC (char, len0);
		916
		917	d = demangled;
		918	p = mangled;
		919	while (1)
		920	{
		921	/* An entity names is expected. */
		922	if (ISLOWER (*p))
		923	{
		924	/* An identifier, which is always lower case. */
		925	do
		926	d++ = p++;
		927	while (ISLOWER(p) \|\| ISDIGIT (p)
		928	\|\| (p[0] == '_' && (ISLOWER (p[1]) \|\| ISDIGIT (p[1]))));
		929	}
		930	else if (p[0] == 'O')
		931	{
		932	/* An operator name. */
		933	static const char * const operators[][2] =
		934	{{"Oabs", "abs"}, {"Oand", "and"}, {"Omod", "mod"},
		935	{"Onot", "not"}, {"Oor", "or"}, {"Orem", "rem"},
		936	{"Oxor", "xor"}, {"Oeq", "="}, {"One", "/="},
		937	{"Olt", "<"}, {"Ole", "<="}, {"Ogt", ">"},
		938	{"Oge", ">="}, {"Oadd", "+"}, {"Osubtract", "-"},
		939	{"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
		940	{"Oexpon", "**"}, {NULL, NULL}};
		941	int k;
		942
		943	for (k = 0; operators[k][0] != NULL; k++)
		944	{
		945	size_t slen = strlen (operators[k][0]);
		946	if (strncmp (p, operators[k][0], slen) == 0)
		947	{
		948	p += slen;
		949	slen = strlen (operators[k][1]);
		950	*d++ = '"';
		951	memcpy (d, operators[k][1], slen);
		952	d += slen;
		953	*d++ = '"';
		954	break;
		955	}
		956	}
		957	/* Operator not found. */
		958	if (operators[k][0] == NULL)
		959	goto unknown;
		960	}
		961	else
		962	{
		963	/* Not a GNAT encoding. */
		964	goto unknown;
		965	}
		966
		967	/* The name can be directly followed by some uppercase letters. */
		968	if (p[0] == 'T' && p[1] == 'K')
		969	{
		970	/* Task stuff. */
		971	if (p[2] == 'B' && p[3] == 0)
		972	{
		973	/* Subprogram for task body. */
		974	break;
		975	}
		976	else if (p[2] == '_' && p[3] == '_')
		977	{
		978	/* Inner declarations in a task. */
		979	p += 4;
		980	*d++ = '.';
		981	continue;
		982	}
		983	else
		984	goto unknown;
		985	}
		986	if (p[0] == 'E' && p[1] == 0)
		987	{
		988	/* Exception name. */
		989	goto unknown;
		990	}
		991	if ((p[0] == 'P' \|\| p[0] == 'N') && p[1] == 0)
		992	{
		993	/* Protected type subprogram. */
		994	break;
		995	}
		996	if ((p == 'N' \|\| p == 'S') && p[1] == 0)
		997	{
		998	/* Enumerated type name table. */
		999	goto unknown;
		1000	}
		1001	if (p[0] == 'X')
		1002	{
		1003	/* Body nested. */
		1004	p++;
		1005	while (p[0] == 'n' \|\| p[0] == 'b')
		1006	p++;
		1007	}
		1008	if (p[0] == 'S' && p[1] != 0 && (p[2] == '_' \|\| p[2] == 0))
		1009	{
		1010	/* Stream operations. */
		1011	const char *name;
		1012	switch (p[1])
		1013	{
		1014	case 'R':
		1015	name = "'Read";
		1016	break;
		1017	case 'W':
		1018	name = "'Write";
		1019	break;
		1020	case 'I':
		1021	name = "'Input";
		1022	break;
		1023	case 'O':
		1024	name = "'Output";
		1025	break;
		1026	default:
		1027	goto unknown;
		1028	}
		1029	p += 2;
		1030	strcpy (d, name);
		1031	d += strlen (name);
		1032	}
		1033	else if (p[0] == 'D')
		1034	{
		1035	/* Controlled type operation. */
		1036	const char *name;
		1037	switch (p[1])
		1038	{
		1039	case 'F':
		1040	name = ".Finalize";
		1041	break;
		1042	case 'A':
		1043	name = ".Adjust";
		1044	break;
		1045	default:
		1046	goto unknown;
		1047	}
		1048	strcpy (d, name);
		1049	d += strlen (name);
		1050	break;
		1051	}
		1052
		1053	if (p[0] == '_')
		1054	{
		1055	/* Separator. */
		1056	if (p[1] == '_')
		1057	{
		1058	/* Standard separator. Handled first. */
		1059	p += 2;
		1060
		1061	if (ISDIGIT (*p))
		1062	{
		1063	/* Overloading number. */
		1064	do
		1065	p++;
		1066	while (ISDIGIT (*p) \|\| (p[0] == '_' && ISDIGIT (p[1])));
		1067	if (*p == 'X')
		1068	{
		1069	p++;
		1070	while (p[0] == 'n' \|\| p[0] == 'b')
		1071	p++;
		1072	}
		1073	}
		1074	else if (p[0] == '_' && p[1] != '_')
		1075	{
		1076	/* Special names. */
		1077	static const char * const special[][2] = {
		1078	{ "_elabb", "'Elab_Body" },
		1079	{ "_elabs", "'Elab_Spec" },
		1080	{ "_size", "'Size" },
		1081	{ "_alignment", "'Alignment" },
		1082	{ "_assign", ".\":=\"" },
		1083	{ NULL, NULL }
		1084	};
		1085	int k;
		1086
		1087	for (k = 0; special[k][0] != NULL; k++)
		1088	{
		1089	size_t slen = strlen (special[k][0]);
		1090	if (strncmp (p, special[k][0], slen) == 0)
		1091	{
		1092	p += slen;
		1093	slen = strlen (special[k][1]);
		1094	memcpy (d, special[k][1], slen);
		1095	d += slen;
		1096	break;
		1097	}
		1098	}
		1099	if (special[k][0] != NULL)
		1100	break;
		1101	else
		1102	goto unknown;
		1103	}
		1104	else
		1105	{
		1106	*d++ = '.';
		1107	continue;
		1108	}
		1109	}
		1110	else if (p[1] == 'B' \|\| p[1] == 'E')
		1111	{
		1112	/* Entry Body or barrier Evaluation. */
		1113	p += 2;
		1114	while (ISDIGIT (*p))
		1115	p++;
		1116	if (p[0] == 's' && p[1] == 0)
		1117	break;
		1118	else
		1119	goto unknown;
		1120	}
		1121	else
		1122	goto unknown;
		1123	}
		1124
		1125	if (p[0] == '.' && ISDIGIT (p[1]))
		1126	{
		1127	/* Nested subprogram. */
		1128	p += 2;
		1129	while (ISDIGIT (*p))
		1130	p++;
		1131	}
		1132	if (*p == 0)
		1133	{
		1134	/* End of mangled name. */
		1135	break;
		1136	}
		1137	else
		1138	goto unknown;
		1139	}
		1140	*d = 0;
		1141	return demangled;
		1142
		1143	unknown:
		1144	len0 = strlen (mangled);
		1145	demangled = XNEWVEC (char, len0 + 3);
		1146
		1147	if (mangled[0] == '<')
		1148	strcpy (demangled, mangled);
		1149	else
		1150	sprintf (demangled, "<%s>", mangled);
		1151
		1152	return demangled;
		1153	}
		1154
		1155	/* This function performs most of what cplus_demangle use to do, but
		1156	to be able to demangle a name with a B, K or n code, we need to
		1157	have a longer term memory of what types have been seen. The original
		1158	now initializes and cleans up the squangle code info, while internal
		1159	calls go directly to this routine to avoid resetting that info. */
		1160
		1161	static char *
		1162	internal_cplus_demangle (struct work_stuff work, const char mangled)
		1163	{
		1164
		1165	string decl;
		1166	int success = 0;
		1167	char *demangled = NULL;
		1168	int s1, s2, s3, s4;
		1169	s1 = work->constructor;
		1170	s2 = work->destructor;
		1171	s3 = work->static_type;
		1172	s4 = work->type_quals;
		1173	work->constructor = work->destructor = 0;
		1174	work->type_quals = TYPE_UNQUALIFIED;
		1175	work->dllimported = 0;
		1176
		1177	if ((mangled != NULL) && (*mangled != '\0'))
		1178	{
		1179	string_init (&decl);
		1180
		1181	/* First check to see if gnu style demangling is active and if the
		1182	string to be demangled contains a CPLUS_MARKER. If so, attempt to
		1183	recognize one of the gnu special forms rather than looking for a
		1184	standard prefix. In particular, don't worry about whether there
		1185	is a "__" string in the mangled string. Consider "_$_5__foo" for
		1186	example. */
		1187
		1188	if ((AUTO_DEMANGLING \|\| GNU_DEMANGLING))
		1189	{
		1190	success = gnu_special (work, &mangled, &decl);
6324	serge	1191	if (!success)
		1192	{
		1193	delete_work_stuff (work);
		1194	string_delete (&decl);
		1195	}
5191	serge	1196	}
		1197	if (!success)
		1198	{
		1199	success = demangle_prefix (work, &mangled, &decl);
		1200	}
		1201	if (success && (*mangled != '\0'))
		1202	{
		1203	success = demangle_signature (work, &mangled, &decl);
		1204	}
		1205	if (work->constructor == 2)
		1206	{
		1207	string_prepend (&decl, "global constructors keyed to ");
		1208	work->constructor = 0;
		1209	}
		1210	else if (work->destructor == 2)
		1211	{
		1212	string_prepend (&decl, "global destructors keyed to ");
		1213	work->destructor = 0;
		1214	}
		1215	else if (work->dllimported == 1)
		1216	{
		1217	string_prepend (&decl, "import stub for ");
		1218	work->dllimported = 0;
		1219	}
		1220	demangled = mop_up (work, &decl, success);
		1221	}
		1222	work->constructor = s1;
		1223	work->destructor = s2;
		1224	work->static_type = s3;
		1225	work->type_quals = s4;
		1226	return demangled;
		1227	}
		1228
		1229
		1230	/* Clear out and squangling related storage */
		1231	static void
		1232	squangle_mop_up (struct work_stuff *work)
		1233	{
		1234	/* clean up the B and K type mangling types. */
		1235	forget_B_and_K_types (work);
		1236	if (work -> btypevec != NULL)
		1237	{
		1238	free ((char *) work -> btypevec);
6324	serge	1239	work->btypevec = NULL;
5191	serge	1240	}
		1241	if (work -> ktypevec != NULL)
		1242	{
		1243	free ((char *) work -> ktypevec);
6324	serge	1244	work->ktypevec = NULL;
5191	serge	1245	}
		1246	}
		1247
		1248
		1249	/* Copy the work state and storage. */
		1250
		1251	static void
		1252	work_stuff_copy_to_from (struct work_stuff to, struct work_stuff from)
		1253	{
		1254	int i;
		1255
		1256	delete_work_stuff (to);
		1257
		1258	/* Shallow-copy scalars. */
		1259	memcpy (to, from, sizeof (*to));
		1260
		1261	/* Deep-copy dynamic storage. */
		1262	if (from->typevec_size)
		1263	to->typevec = XNEWVEC (char *, from->typevec_size);
		1264
		1265	for (i = 0; i < from->ntypes; i++)
		1266	{
		1267	int len = strlen (from->typevec[i]) + 1;
		1268
		1269	to->typevec[i] = XNEWVEC (char, len);
		1270	memcpy (to->typevec[i], from->typevec[i], len);
		1271	}
		1272
		1273	if (from->ksize)
		1274	to->ktypevec = XNEWVEC (char *, from->ksize);
		1275
		1276	for (i = 0; i < from->numk; i++)
		1277	{
		1278	int len = strlen (from->ktypevec[i]) + 1;
		1279
		1280	to->ktypevec[i] = XNEWVEC (char, len);
		1281	memcpy (to->ktypevec[i], from->ktypevec[i], len);
		1282	}
		1283
		1284	if (from->bsize)
		1285	to->btypevec = XNEWVEC (char *, from->bsize);
		1286
		1287	for (i = 0; i < from->numb; i++)
		1288	{
		1289	int len = strlen (from->btypevec[i]) + 1;
		1290
		1291	to->btypevec[i] = XNEWVEC (char , len);
		1292	memcpy (to->btypevec[i], from->btypevec[i], len);
		1293	}
		1294
		1295	if (from->ntmpl_args)
		1296	to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
		1297
		1298	for (i = 0; i < from->ntmpl_args; i++)
		1299	{
		1300	int len = strlen (from->tmpl_argvec[i]) + 1;
		1301
		1302	to->tmpl_argvec[i] = XNEWVEC (char, len);
		1303	memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
		1304	}
		1305
		1306	if (from->previous_argument)
		1307	{
		1308	to->previous_argument = XNEW (string);
		1309	string_init (to->previous_argument);
		1310	string_appends (to->previous_argument, from->previous_argument);
		1311	}
		1312	}
		1313
		1314
		1315	/* Delete dynamic stuff in work_stuff that is not to be re-used. */
		1316
		1317	static void
		1318	delete_non_B_K_work_stuff (struct work_stuff *work)
		1319	{
		1320	/* Discard the remembered types, if any. */
		1321
		1322	forget_types (work);
		1323	if (work -> typevec != NULL)
		1324	{
		1325	free ((char *) work -> typevec);
		1326	work -> typevec = NULL;
		1327	work -> typevec_size = 0;
		1328	}
		1329	if (work->tmpl_argvec)
		1330	{
		1331	int i;
		1332
		1333	for (i = 0; i < work->ntmpl_args; i++)
		1334	free ((char*) work->tmpl_argvec[i]);
		1335
		1336	free ((char*) work->tmpl_argvec);
		1337	work->tmpl_argvec = NULL;
		1338	}
		1339	if (work->previous_argument)
		1340	{
		1341	string_delete (work->previous_argument);
		1342	free ((char*) work->previous_argument);
		1343	work->previous_argument = NULL;
		1344	}
		1345	}
		1346
		1347
		1348	/* Delete all dynamic storage in work_stuff. */
		1349	static void
		1350	delete_work_stuff (struct work_stuff *work)
		1351	{
		1352	delete_non_B_K_work_stuff (work);
		1353	squangle_mop_up (work);
		1354	}
		1355
		1356
		1357	/* Clear out any mangled storage */
		1358
		1359	static char *
		1360	mop_up (struct work_stuff work, string declp, int success)
		1361	{
		1362	char *demangled = NULL;
		1363
		1364	delete_non_B_K_work_stuff (work);
		1365
		1366	/* If demangling was successful, ensure that the demangled string is null
		1367	terminated and return it. Otherwise, free the demangling decl. */
		1368
		1369	if (!success)
		1370	{
		1371	string_delete (declp);
		1372	}
		1373	else
		1374	{
		1375	string_appendn (declp, "", 1);
		1376	demangled = declp->b;
		1377	}
		1378	return (demangled);
		1379	}
		1380
		1381	/*
		1382
		1383	LOCAL FUNCTION
		1384
		1385	demangle_signature -- demangle the signature part of a mangled name
		1386
		1387	SYNOPSIS
		1388
		1389	static int
		1390	demangle_signature (struct work_stuff work, const char *mangled,
		1391	string *declp);
		1392
		1393	DESCRIPTION
		1394
		1395	Consume and demangle the signature portion of the mangled name.
		1396
		1397	DECLP is the string where demangled output is being built. At
		1398	entry it contains the demangled root name from the mangled name
		1399	prefix. I.E. either a demangled operator name or the root function
		1400	name. In some special cases, it may contain nothing.
		1401
		1402	*MANGLED points to the current unconsumed location in the mangled
		1403	name. As tokens are consumed and demangling is performed, the
		1404	pointer is updated to continuously point at the next token to
		1405	be consumed.
		1406
		1407	Demangling GNU style mangled names is nasty because there is no
		1408	explicit token that marks the start of the outermost function
		1409	argument list. */
		1410
		1411	static int
		1412	demangle_signature (struct work_stuff *work,
		1413	const char *mangled, string declp)
		1414	{
		1415	int success = 1;
		1416	int func_done = 0;
		1417	int expect_func = 0;
		1418	int expect_return_type = 0;
		1419	const char *oldmangled = NULL;
		1420	string trawname;
		1421	string tname;
		1422
		1423	while (success && (**mangled != '\0'))
		1424	{
		1425	switch (**mangled)
		1426	{
		1427	case 'Q':
		1428	oldmangled = *mangled;
		1429	success = demangle_qualified (work, mangled, declp, 1, 0);
		1430	if (success)
		1431	remember_type (work, oldmangled, *mangled - oldmangled);
		1432	if (AUTO_DEMANGLING \|\| GNU_DEMANGLING)
		1433	expect_func = 1;
		1434	oldmangled = NULL;
		1435	break;
		1436
		1437	case 'K':
		1438	oldmangled = *mangled;
		1439	success = demangle_qualified (work, mangled, declp, 1, 0);
		1440	if (AUTO_DEMANGLING \|\| GNU_DEMANGLING)
		1441	{
		1442	expect_func = 1;
		1443	}
		1444	oldmangled = NULL;
		1445	break;
		1446
		1447	case 'S':
		1448	/* Static member function */
		1449	if (oldmangled == NULL)
		1450	{
		1451	oldmangled = *mangled;
		1452	}
		1453	(*mangled)++;
		1454	work -> static_type = 1;
		1455	break;
		1456
		1457	case 'C':
		1458	case 'V':
		1459	case 'u':
		1460	work->type_quals \|= code_for_qualifier (**mangled);
		1461
		1462	/* a qualified member function */
		1463	if (oldmangled == NULL)
		1464	oldmangled = *mangled;
		1465	(*mangled)++;
		1466	break;
		1467
		1468	case 'L':
		1469	/* Local class name follows after "Lnnn_" */
		1470	if (HP_DEMANGLING)
		1471	{
		1472	while (mangled && (mangled != '_'))
		1473	(*mangled)++;
		1474	if (!**mangled)
		1475	success = 0;
		1476	else
		1477	(*mangled)++;
		1478	}
		1479	else
		1480	success = 0;
		1481	break;
		1482
		1483	case '0': case '1': case '2': case '3': case '4':
		1484	case '5': case '6': case '7': case '8': case '9':
		1485	if (oldmangled == NULL)
		1486	{
		1487	oldmangled = *mangled;
		1488	}
		1489	work->temp_start = -1; /* uppermost call to demangle_class */
		1490	success = demangle_class (work, mangled, declp);
		1491	if (success)
		1492	{
		1493	remember_type (work, oldmangled, *mangled - oldmangled);
		1494	}
		1495	if (AUTO_DEMANGLING \|\| GNU_DEMANGLING \|\| EDG_DEMANGLING)
		1496	{
		1497	/* EDG and others will have the "F", so we let the loop cycle
		1498	if we are looking at one. */
		1499	if (**mangled != 'F')
		1500	expect_func = 1;
		1501	}
		1502	oldmangled = NULL;
		1503	break;
		1504
		1505	case 'B':
		1506	{
		1507	string s;
		1508	success = do_type (work, mangled, &s);
		1509	if (success)
		1510	{
		1511	string_append (&s, SCOPE_STRING (work));
		1512	string_prepends (declp, &s);
		1513	string_delete (&s);
		1514	}
		1515	oldmangled = NULL;
		1516	expect_func = 1;
		1517	}
		1518	break;
		1519
		1520	case 'F':
		1521	/* Function */
		1522	/* ARM/HP style demangling includes a specific 'F' character after
		1523	the class name. For GNU style, it is just implied. So we can
		1524	safely just consume any 'F' at this point and be compatible
		1525	with either style. */
		1526
		1527	oldmangled = NULL;
		1528	func_done = 1;
		1529	(*mangled)++;
		1530
		1531	/* For lucid/ARM/HP style we have to forget any types we might
		1532	have remembered up to this point, since they were not argument
		1533	types. GNU style considers all types seen as available for
		1534	back references. See comment in demangle_args() */
		1535
		1536	if (LUCID_DEMANGLING \|\| ARM_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING)
		1537	{
		1538	forget_types (work);
		1539	}
		1540	success = demangle_args (work, mangled, declp);
		1541	/* After picking off the function args, we expect to either
		1542	find the function return type (preceded by an '_') or the
		1543	end of the string. */
		1544	if (success && (AUTO_DEMANGLING \|\| EDG_DEMANGLING) && **mangled == '_')
		1545	{
		1546	++(*mangled);
		1547	/* At this level, we do not care about the return type. */
		1548	success = do_type (work, mangled, &tname);
		1549	string_delete (&tname);
		1550	}
		1551
		1552	break;
		1553
		1554	case 't':
		1555	/* G++ Template */
		1556	string_init(&trawname);
		1557	string_init(&tname);
		1558	if (oldmangled == NULL)
		1559	{
		1560	oldmangled = *mangled;
		1561	}
		1562	success = demangle_template (work, mangled, &tname,
		1563	&trawname, 1, 1);
		1564	if (success)
		1565	{
		1566	remember_type (work, oldmangled, *mangled - oldmangled);
		1567	}
		1568	string_append (&tname, SCOPE_STRING (work));
		1569
		1570	string_prepends(declp, &tname);
		1571	if (work -> destructor & 1)
		1572	{
		1573	string_prepend (&trawname, "~");
		1574	string_appends (declp, &trawname);
		1575	work->destructor -= 1;
		1576	}
		1577	if ((work->constructor & 1) \|\| (work->destructor & 1))
		1578	{
		1579	string_appends (declp, &trawname);
		1580	work->constructor -= 1;
		1581	}
		1582	string_delete(&trawname);
		1583	string_delete(&tname);
		1584	oldmangled = NULL;
		1585	expect_func = 1;
		1586	break;
		1587
		1588	case '_':
		1589	if ((AUTO_DEMANGLING \|\| GNU_DEMANGLING) && expect_return_type)
		1590	{
		1591	/* Read the return type. */
		1592	string return_type;
		1593
		1594	(*mangled)++;
		1595	success = do_type (work, mangled, &return_type);
		1596	APPEND_BLANK (&return_type);
		1597
		1598	string_prepends (declp, &return_type);
		1599	string_delete (&return_type);
		1600	break;
		1601	}
		1602	else
		1603	/* At the outermost level, we cannot have a return type specified,
		1604	so if we run into another '_' at this point we are dealing with
		1605	a mangled name that is either bogus, or has been mangled by
		1606	some algorithm we don't know how to deal with. So just
		1607	reject the entire demangling. */
		1608	/* However, "_nnn" is an expected suffix for alternate entry point
		1609	numbered nnn for a function, with HP aCC, so skip over that
		1610	without reporting failure. pai/1997-09-04 */
		1611	if (HP_DEMANGLING)
		1612	{
		1613	(*mangled)++;
		1614	while (mangled && ISDIGIT ((unsigned char)mangled))
		1615	(*mangled)++;
		1616	}
		1617	else
		1618	success = 0;
		1619	break;
		1620
		1621	case 'H':
		1622	if (AUTO_DEMANGLING \|\| GNU_DEMANGLING)
		1623	{
		1624	/* A G++ template function. Read the template arguments. */
		1625	success = demangle_template (work, mangled, declp, 0, 0,
		1626	0);
		1627	if (!(work->constructor & 1))
		1628	expect_return_type = 1;
		1629	(*mangled)++;
		1630	break;
		1631	}
		1632	else
		1633	/* fall through */
		1634	{;}
		1635
		1636	default:
		1637	if (AUTO_DEMANGLING \|\| GNU_DEMANGLING)
		1638	{
		1639	/* Assume we have stumbled onto the first outermost function
		1640	argument token, and start processing args. */
		1641	func_done = 1;
		1642	success = demangle_args (work, mangled, declp);
		1643	}
		1644	else
		1645	{
		1646	/* Non-GNU demanglers use a specific token to mark the start
		1647	of the outermost function argument tokens. Typically 'F',
		1648	for ARM/HP-demangling, for example. So if we find something
		1649	we are not prepared for, it must be an error. */
		1650	success = 0;
		1651	}
		1652	break;
		1653	}
		1654	/*
		1655	if (AUTO_DEMANGLING \|\| GNU_DEMANGLING)
		1656	*/
		1657	{
		1658	if (success && expect_func)
		1659	{
		1660	func_done = 1;
		1661	if (LUCID_DEMANGLING \|\| ARM_DEMANGLING \|\| EDG_DEMANGLING)
		1662	{
		1663	forget_types (work);
		1664	}
		1665	success = demangle_args (work, mangled, declp);
		1666	/* Since template include the mangling of their return types,
		1667	we must set expect_func to 0 so that we don't try do
		1668	demangle more arguments the next time we get here. */
		1669	expect_func = 0;
		1670	}
		1671	}
		1672	}
		1673	if (success && !func_done)
		1674	{
		1675	if (AUTO_DEMANGLING \|\| GNU_DEMANGLING)
		1676	{
		1677	/* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
		1678	bar__3fooi is 'foo::bar(int)'. We get here when we find the
		1679	first case, and need to ensure that the '(void)' gets added to
		1680	the current declp. Note that with ARM/HP, the first case
		1681	represents the name of a static data member 'foo::bar',
		1682	which is in the current declp, so we leave it alone. */
		1683	success = demangle_args (work, mangled, declp);
		1684	}
		1685	}
		1686	if (success && PRINT_ARG_TYPES)
		1687	{
		1688	if (work->static_type)
		1689	string_append (declp, " static");
		1690	if (work->type_quals != TYPE_UNQUALIFIED)
		1691	{
		1692	APPEND_BLANK (declp);
		1693	string_append (declp, qualifier_string (work->type_quals));
		1694	}
		1695	}
		1696
		1697	return (success);
		1698	}
		1699
		1700	#if 0
		1701
		1702	static int
		1703	demangle_method_args (struct work_stuff work, const char *mangled,
		1704	string *declp)
		1705	{
		1706	int success = 0;
		1707
		1708	if (work -> static_type)
		1709	{
		1710	string_append (declp, *mangled + 1);
		1711	mangled += strlen (mangled);
		1712	success = 1;
		1713	}
		1714	else
		1715	{
		1716	success = demangle_args (work, mangled, declp);
		1717	}
		1718	return (success);
		1719	}
		1720
		1721	#endif
		1722
		1723	static int
		1724	demangle_template_template_parm (struct work_stuff *work,
		1725	const char *mangled, string tname)
		1726	{
		1727	int i;
		1728	int r;
		1729	int need_comma = 0;
		1730	int success = 1;
		1731	string temp;
		1732
		1733	string_append (tname, "template <");
		1734	/* get size of template parameter list */
		1735	if (get_count (mangled, &r))
		1736	{
		1737	for (i = 0; i < r; i++)
		1738	{
		1739	if (need_comma)
		1740	{
		1741	string_append (tname, ", ");
		1742	}
		1743
		1744	/* Z for type parameters */
		1745	if (**mangled == 'Z')
		1746	{
		1747	(*mangled)++;
		1748	string_append (tname, "class");
		1749	}
		1750	/* z for template parameters */
		1751	else if (**mangled == 'z')
		1752	{
		1753	(*mangled)++;
		1754	success =
		1755	demangle_template_template_parm (work, mangled, tname);
		1756	if (!success)
		1757	{
		1758	break;
		1759	}
		1760	}
		1761	else
		1762	{
		1763	/* temp is initialized in do_type */
		1764	success = do_type (work, mangled, &temp);
		1765	if (success)
		1766	{
		1767	string_appends (tname, &temp);
		1768	}
		1769	string_delete(&temp);
		1770	if (!success)
		1771	{
		1772	break;
		1773	}
		1774	}
		1775	need_comma = 1;
		1776	}
		1777
		1778	}
		1779	if (tname->p[-1] == '>')
		1780	string_append (tname, " ");
		1781	string_append (tname, "> class");
		1782	return (success);
		1783	}
		1784
		1785	static int
		1786	demangle_expression (struct work_stuff work, const char *mangled,
		1787	string *s, type_kind_t tk)
		1788	{
		1789	int need_operator = 0;
		1790	int success;
		1791
		1792	success = 1;
		1793	string_appendn (s, "(", 1);
		1794	(*mangled)++;
		1795	while (success && mangled != 'W' && mangled != '\0')
		1796	{
		1797	if (need_operator)
		1798	{
		1799	size_t i;
		1800	size_t len;
		1801
		1802	success = 0;
		1803
		1804	len = strlen (*mangled);
		1805
		1806	for (i = 0; i < ARRAY_SIZE (optable); ++i)
		1807	{
		1808	size_t l = strlen (optable[i].in);
		1809
		1810	if (l <= len
		1811	&& memcmp (optable[i].in, *mangled, l) == 0)
		1812	{
		1813	string_appendn (s, " ", 1);
		1814	string_append (s, optable[i].out);
		1815	string_appendn (s, " ", 1);
		1816	success = 1;
		1817	(*mangled) += l;
		1818	break;
		1819	}
		1820	}
		1821
		1822	if (!success)
		1823	break;
		1824	}
		1825	else
		1826	need_operator = 1;
		1827
		1828	success = demangle_template_value_parm (work, mangled, s, tk);
		1829	}
		1830
		1831	if (**mangled != 'W')
		1832	success = 0;
		1833	else
		1834	{
		1835	string_appendn (s, ")", 1);
		1836	(*mangled)++;
		1837	}
		1838
		1839	return success;
		1840	}
		1841
		1842	static int
		1843	demangle_integral_value (struct work_stuff *work,
		1844	const char *mangled, string s)
		1845	{
		1846	int success;
		1847
		1848	if (**mangled == 'E')
		1849	success = demangle_expression (work, mangled, s, tk_integral);
		1850	else if (mangled == 'Q' \|\| mangled == 'K')
		1851	success = demangle_qualified (work, mangled, s, 0, 1);
		1852	else
		1853	{
		1854	int value;
		1855
		1856	/* By default, we let the number decide whether we shall consume an
		1857	underscore. */
		1858	int multidigit_without_leading_underscore = 0;
		1859	int leave_following_underscore = 0;
		1860
		1861	success = 0;
		1862
		1863	if (**mangled == '_')
		1864	{
		1865	if (mangled[0][1] == 'm')
		1866	{
		1867	/* Since consume_count_with_underscores does not handle the
		1868	`m'-prefix we must do it here, using consume_count and
		1869	adjusting underscores: we have to consume the underscore
		1870	matching the prepended one. */
		1871	multidigit_without_leading_underscore = 1;
		1872	string_appendn (s, "-", 1);
		1873	(*mangled) += 2;
		1874	}
		1875	else
		1876	{
		1877	/* Do not consume a following underscore;
		1878	consume_count_with_underscores will consume what
		1879	should be consumed. */
		1880	leave_following_underscore = 1;
		1881	}
		1882	}
		1883	else
		1884	{
		1885	/* Negative numbers are indicated with a leading `m'. */
		1886	if (**mangled == 'm')
		1887	{
		1888	string_appendn (s, "-", 1);
		1889	(*mangled)++;
		1890	}
		1891	/* Since consume_count_with_underscores does not handle
		1892	multi-digit numbers that do not start with an underscore,
		1893	and this number can be an integer template parameter,
		1894	we have to call consume_count. */
		1895	multidigit_without_leading_underscore = 1;
		1896	/* These multi-digit numbers never end on an underscore,
		1897	so if there is one then don't eat it. */
		1898	leave_following_underscore = 1;
		1899	}
		1900
		1901	/* We must call consume_count if we expect to remove a trailing
		1902	underscore, since consume_count_with_underscores expects
		1903	the leading underscore (that we consumed) if it is to handle
		1904	multi-digit numbers. */
		1905	if (multidigit_without_leading_underscore)
		1906	value = consume_count (mangled);
		1907	else
		1908	value = consume_count_with_underscores (mangled);
		1909
		1910	if (value != -1)
		1911	{
		1912	char buf[INTBUF_SIZE];
		1913	sprintf (buf, "%d", value);
		1914	string_append (s, buf);
		1915
		1916	/* Numbers not otherwise delimited, might have an underscore
		1917	appended as a delimeter, which we should skip.
		1918
		1919	??? This used to always remove a following underscore, which
		1920	is wrong. If other (arbitrary) cases are followed by an
		1921	underscore, we need to do something more radical. */
		1922
		1923	if ((value > 9 \|\| multidigit_without_leading_underscore)
		1924	&& ! leave_following_underscore
		1925	&& **mangled == '_')
		1926	(*mangled)++;
		1927
		1928	/* All is well. */
		1929	success = 1;
		1930	}
		1931	}
		1932
		1933	return success;
		1934	}
		1935
		1936	/* Demangle the real value in MANGLED. */
		1937
		1938	static int
		1939	demangle_real_value (struct work_stuff *work,
		1940	const char *mangled, string s)
		1941	{
		1942	if (**mangled == 'E')
		1943	return demangle_expression (work, mangled, s, tk_real);
		1944
		1945	if (**mangled == 'm')
		1946	{
		1947	string_appendn (s, "-", 1);
		1948	(*mangled)++;
		1949	}
		1950	while (ISDIGIT ((unsigned char)**mangled))
		1951	{
		1952	string_appendn (s, *mangled, 1);
		1953	(*mangled)++;
		1954	}
		1955	if (*mangled == '.') / fraction */
		1956	{
		1957	string_appendn (s, ".", 1);
		1958	(*mangled)++;
		1959	while (ISDIGIT ((unsigned char)**mangled))
		1960	{
		1961	string_appendn (s, *mangled, 1);
		1962	(*mangled)++;
		1963	}
		1964	}
		1965	if (*mangled == 'e') / exponent */
		1966	{
		1967	string_appendn (s, "e", 1);
		1968	(*mangled)++;
		1969	while (ISDIGIT ((unsigned char)**mangled))
		1970	{
		1971	string_appendn (s, *mangled, 1);
		1972	(*mangled)++;
		1973	}
		1974	}
		1975
		1976	return 1;
		1977	}
		1978
		1979	static int
		1980	demangle_template_value_parm (struct work_stuff work, const char *mangled,
		1981	string *s, type_kind_t tk)
		1982	{
		1983	int success = 1;
		1984
		1985	if (**mangled == 'Y')
		1986	{
		1987	/* The next argument is a template parameter. */
		1988	int idx;
		1989
		1990	(*mangled)++;
		1991	idx = consume_count_with_underscores (mangled);
		1992	if (idx == -1
		1993	\|\| (work->tmpl_argvec && idx >= work->ntmpl_args)
		1994	\|\| consume_count_with_underscores (mangled) == -1)
		1995	return -1;
		1996	if (work->tmpl_argvec)
		1997	string_append (s, work->tmpl_argvec[idx]);
		1998	else
		1999	string_append_template_idx (s, idx);
		2000	}
		2001	else if (tk == tk_integral)
		2002	success = demangle_integral_value (work, mangled, s);
		2003	else if (tk == tk_char)
		2004	{
		2005	char tmp[2];
		2006	int val;
		2007	if (**mangled == 'm')
		2008	{
		2009	string_appendn (s, "-", 1);
		2010	(*mangled)++;
		2011	}
		2012	string_appendn (s, "'", 1);
		2013	val = consume_count(mangled);
		2014	if (val <= 0)
		2015	success = 0;
		2016	else
		2017	{
		2018	tmp[0] = (char)val;
		2019	tmp[1] = '\0';
		2020	string_appendn (s, &tmp[0], 1);
		2021	string_appendn (s, "'", 1);
		2022	}
		2023	}
		2024	else if (tk == tk_bool)
		2025	{
		2026	int val = consume_count (mangled);
		2027	if (val == 0)
		2028	string_appendn (s, "false", 5);
		2029	else if (val == 1)
		2030	string_appendn (s, "true", 4);
		2031	else
		2032	success = 0;
		2033	}
		2034	else if (tk == tk_real)
		2035	success = demangle_real_value (work, mangled, s);
		2036	else if (tk == tk_pointer \|\| tk == tk_reference)
		2037	{
		2038	if (**mangled == 'Q')
		2039	success = demangle_qualified (work, mangled, s,
		2040	/isfuncname=/0,
		2041	/append=/1);
		2042	else
		2043	{
		2044	int symbol_len = consume_count (mangled);
		2045	if (symbol_len == -1)
		2046	return -1;
		2047	if (symbol_len == 0)
		2048	string_appendn (s, "0", 1);
		2049	else
		2050	{
		2051	char p = XNEWVEC (char, symbol_len + 1), q;
		2052	strncpy (p, *mangled, symbol_len);
		2053	p [symbol_len] = '\0';
		2054	/* We use cplus_demangle here, rather than
		2055	internal_cplus_demangle, because the name of the entity
		2056	mangled here does not make use of any of the squangling
		2057	or type-code information we have built up thus far; it is
		2058	mangled independently. */
		2059	q = cplus_demangle (p, work->options);
		2060	if (tk == tk_pointer)
		2061	string_appendn (s, "&", 1);
		2062	/* FIXME: Pointer-to-member constants should get a
		2063	qualifying class name here. */
		2064	if (q)
		2065	{
		2066	string_append (s, q);
		2067	free (q);
		2068	}
		2069	else
		2070	string_append (s, p);
		2071	free (p);
		2072	}
		2073	*mangled += symbol_len;
		2074	}
		2075	}
		2076
		2077	return success;
		2078	}
		2079
		2080	/* Demangle the template name in MANGLED. The full name of the
		2081	template (e.g., S) is placed in TNAME. The name without the
		2082	template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
		2083	non-NULL. If IS_TYPE is nonzero, this template is a type template,
		2084	not a function template. If both IS_TYPE and REMEMBER are nonzero,
		2085	the template is remembered in the list of back-referenceable
		2086	types. */
		2087
		2088	static int
		2089	demangle_template (struct work_stuff work, const char *mangled,
		2090	string tname, string trawname,
		2091	int is_type, int remember)
		2092	{
		2093	int i;
		2094	int r;
		2095	int need_comma = 0;
		2096	int success = 0;
		2097	int is_java_array = 0;
		2098	string temp;
		2099
		2100	(*mangled)++;
		2101	if (is_type)
		2102	{
		2103	/* get template name */
		2104	if (**mangled == 'z')
		2105	{
		2106	int idx;
		2107	(*mangled)++;
		2108	(*mangled)++;
		2109
		2110	idx = consume_count_with_underscores (mangled);
		2111	if (idx == -1
		2112	\|\| (work->tmpl_argvec && idx >= work->ntmpl_args)
		2113	\|\| consume_count_with_underscores (mangled) == -1)
		2114	return (0);
		2115
		2116	if (work->tmpl_argvec)
		2117	{
		2118	string_append (tname, work->tmpl_argvec[idx]);
		2119	if (trawname)
		2120	string_append (trawname, work->tmpl_argvec[idx]);
		2121	}
		2122	else
		2123	{
		2124	string_append_template_idx (tname, idx);
		2125	if (trawname)
		2126	string_append_template_idx (trawname, idx);
		2127	}
		2128	}
		2129	else
		2130	{
		2131	if ((r = consume_count (mangled)) <= 0
		2132	\|\| (int) strlen (*mangled) < r)
		2133	{
		2134	return (0);
		2135	}
		2136	is_java_array = (work -> options & DMGL_JAVA)
		2137	&& strncmp (*mangled, "JArray1Z", 8) == 0;
		2138	if (! is_java_array)
		2139	{
		2140	string_appendn (tname, *mangled, r);
		2141	}
		2142	if (trawname)
		2143	string_appendn (trawname, *mangled, r);
		2144	*mangled += r;
		2145	}
		2146	}
		2147	if (!is_java_array)
		2148	string_append (tname, "<");
		2149	/* get size of template parameter list */
		2150	if (!get_count (mangled, &r))
		2151	{
		2152	return (0);
		2153	}
		2154	if (!is_type)
		2155	{
		2156	/* Create an array for saving the template argument values. */
		2157	work->tmpl_argvec = XNEWVEC (char *, r);
		2158	work->ntmpl_args = r;
		2159	for (i = 0; i < r; i++)
		2160	work->tmpl_argvec[i] = 0;
		2161	}
		2162	for (i = 0; i < r; i++)
		2163	{
		2164	if (need_comma)
		2165	{
		2166	string_append (tname, ", ");
		2167	}
		2168	/* Z for type parameters */
		2169	if (**mangled == 'Z')
		2170	{
		2171	(*mangled)++;
		2172	/* temp is initialized in do_type */
		2173	success = do_type (work, mangled, &temp);
		2174	if (success)
		2175	{
		2176	string_appends (tname, &temp);
		2177
		2178	if (!is_type)
		2179	{
		2180	/* Save the template argument. */
		2181	int len = temp.p - temp.b;
		2182	work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
		2183	memcpy (work->tmpl_argvec[i], temp.b, len);
		2184	work->tmpl_argvec[i][len] = '\0';
		2185	}
		2186	}
		2187	string_delete(&temp);
		2188	if (!success)
		2189	{
		2190	break;
		2191	}
		2192	}
		2193	/* z for template parameters */
		2194	else if (**mangled == 'z')
		2195	{
		2196	int r2;
		2197	(*mangled)++;
		2198	success = demangle_template_template_parm (work, mangled, tname);
		2199
		2200	if (success
		2201	&& (r2 = consume_count (mangled)) > 0
		2202	&& (int) strlen (*mangled) >= r2)
		2203	{
		2204	string_append (tname, " ");
		2205	string_appendn (tname, *mangled, r2);
		2206	if (!is_type)
		2207	{
		2208	/* Save the template argument. */
		2209	int len = r2;
		2210	work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
		2211	memcpy (work->tmpl_argvec[i], *mangled, len);
		2212	work->tmpl_argvec[i][len] = '\0';
		2213	}
		2214	*mangled += r2;
		2215	}
		2216	if (!success)
		2217	{
		2218	break;
		2219	}
		2220	}
		2221	else
		2222	{
		2223	string param;
		2224	string* s;
		2225
		2226	/* otherwise, value parameter */
		2227
		2228	/* temp is initialized in do_type */
		2229	success = do_type (work, mangled, &temp);
		2230	string_delete(&temp);
		2231	if (!success)
		2232	break;
		2233
		2234	if (!is_type)
		2235	{
		2236	s = ¶m;
		2237	string_init (s);
		2238	}
		2239	else
		2240	s = tname;
		2241
		2242	success = demangle_template_value_parm (work, mangled, s,
		2243	(type_kind_t) success);
		2244
		2245	if (!success)
		2246	{
		2247	if (!is_type)
		2248	string_delete (s);
		2249	success = 0;
		2250	break;
		2251	}
		2252
		2253	if (!is_type)
		2254	{
		2255	int len = s->p - s->b;
		2256	work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
		2257	memcpy (work->tmpl_argvec[i], s->b, len);
		2258	work->tmpl_argvec[i][len] = '\0';
		2259
		2260	string_appends (tname, s);
		2261	string_delete (s);
		2262	}
		2263	}
		2264	need_comma = 1;
		2265	}
		2266	if (is_java_array)
		2267	{
		2268	string_append (tname, "[]");
		2269	}
		2270	else
		2271	{
		2272	if (tname->p[-1] == '>')
		2273	string_append (tname, " ");
		2274	string_append (tname, ">");
		2275	}
		2276
		2277	if (is_type && remember)
		2278	{
		2279	const int bindex = register_Btype (work);
		2280	remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
		2281	}
		2282
		2283	/*
		2284	if (work -> static_type)
		2285	{
		2286	string_append (declp, *mangled + 1);
		2287	mangled += strlen (mangled);
		2288	success = 1;
		2289	}
		2290	else
		2291	{
		2292	success = demangle_args (work, mangled, declp);
		2293	}
		2294	}
		2295	*/
		2296	return (success);
		2297	}
		2298
		2299	static int
		2300	arm_pt (struct work_stuff work, const char mangled,
		2301	int n, const char anchor, const char args)
		2302	{
		2303	/* Check if ARM template with "__pt__" in it ("parameterized type") */
		2304	/* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
		2305	if ((ARM_DEMANGLING \|\| HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
		2306	{
		2307	int len;
		2308	args = anchor + 6;
		2309	len = consume_count (args);
		2310	if (len == -1)
		2311	return 0;
		2312	if (args + len == mangled + n && *args == '_')
		2313	{
		2314	++*args;
		2315	return 1;
		2316	}
		2317	}
		2318	if (AUTO_DEMANGLING \|\| EDG_DEMANGLING)
		2319	{
		2320	if ((*anchor = strstr (mangled, "__tm__"))
		2321	\|\| (*anchor = strstr (mangled, "__ps__"))
		2322	\|\| (*anchor = strstr (mangled, "__pt__")))
		2323	{
		2324	int len;
		2325	args = anchor + 6;
		2326	len = consume_count (args);
		2327	if (len == -1)
		2328	return 0;
		2329	if (args + len == mangled + n && *args == '_')
		2330	{
		2331	++*args;
		2332	return 1;
		2333	}
		2334	}
		2335	else if ((*anchor = strstr (mangled, "__S")))
		2336	{
		2337	int len;
		2338	args = anchor + 3;
		2339	len = consume_count (args);
		2340	if (len == -1)
		2341	return 0;
		2342	if (args + len == mangled + n && *args == '_')
		2343	{
		2344	++*args;
		2345	return 1;
		2346	}
		2347	}
		2348	}
		2349
		2350	return 0;
		2351	}
		2352
		2353	static void
		2354	demangle_arm_hp_template (struct work_stuff work, const char *mangled,
		2355	int n, string *declp)
		2356	{
		2357	const char *p;
		2358	const char *args;
		2359	const char e = mangled + n;
		2360	string arg;
		2361
		2362	/* Check for HP aCC template spec: classXt1t2 where t1, t2 are
		2363	template args */
		2364	if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
		2365	{
		2366	char *start_spec_args = NULL;
		2367	int hold_options;
		2368
		2369	/* First check for and omit template specialization pseudo-arguments,
		2370	such as in "Spec<#1,#1.>" /
		2371	start_spec_args = strchr (*mangled, '<');
		2372	if (start_spec_args && (start_spec_args - *mangled < n))
		2373	string_appendn (declp, mangled, start_spec_args - mangled);
		2374	else
		2375	string_appendn (declp, *mangled, n);
		2376	(*mangled) += n + 1;
		2377	string_init (&arg);
		2378	if (work->temp_start == -1) /* non-recursive call */
		2379	work->temp_start = declp->p - declp->b;
		2380
		2381	/* We want to unconditionally demangle parameter types in
		2382	template parameters. */
		2383	hold_options = work->options;
		2384	work->options \|= DMGL_PARAMS;
		2385
		2386	string_append (declp, "<");
		2387	while (1)
		2388	{
		2389	string_delete (&arg);
		2390	switch (**mangled)
		2391	{
		2392	case 'T':
		2393	/* 'T' signals a type parameter */
		2394	(*mangled)++;
		2395	if (!do_type (work, mangled, &arg))
		2396	goto hpacc_template_args_done;
		2397	break;
		2398
		2399	case 'U':
		2400	case 'S':
		2401	/* 'U' or 'S' signals an integral value */
		2402	if (!do_hpacc_template_const_value (work, mangled, &arg))
		2403	goto hpacc_template_args_done;
		2404	break;
		2405
		2406	case 'A':
		2407	/* 'A' signals a named constant expression (literal) */
		2408	if (!do_hpacc_template_literal (work, mangled, &arg))
		2409	goto hpacc_template_args_done;
		2410	break;
		2411
		2412	default:
		2413	/* Today, 1997-09-03, we have only the above types
		2414	of template parameters */
		2415	/* FIXME: maybe this should fail and return null */
		2416	goto hpacc_template_args_done;
		2417	}
		2418	string_appends (declp, &arg);
		2419	/* Check if we're at the end of template args.
		2420
		2421	_ if done with template args for a function */
		2422	if ((mangled == '\000') \|\| (mangled == '_'))
		2423	break;
		2424	else
		2425	string_append (declp, ",");
		2426	}
		2427	hpacc_template_args_done:
		2428	string_append (declp, ">");
		2429	string_delete (&arg);
		2430	if (**mangled == '_')
		2431	(*mangled)++;
		2432	work->options = hold_options;
		2433	return;
		2434	}
		2435	/* ARM template? (Also handles HP cfront extensions) */
		2436	else if (arm_pt (work, *mangled, n, &p, &args))
		2437	{
		2438	int hold_options;
		2439	string type_str;
		2440
		2441	string_init (&arg);
		2442	string_appendn (declp, mangled, p - mangled);
		2443	if (work->temp_start == -1) /* non-recursive call */
		2444	work->temp_start = declp->p - declp->b;
		2445
		2446	/* We want to unconditionally demangle parameter types in
		2447	template parameters. */
		2448	hold_options = work->options;
		2449	work->options \|= DMGL_PARAMS;
		2450
		2451	string_append (declp, "<");
		2452	/* should do error checking here */
		2453	while (args < e) {
		2454	string_delete (&arg);
		2455
		2456	/* Check for type or literal here */
		2457	switch (*args)
		2458	{
		2459	/* HP cfront extensions to ARM for template args */
		2460	/* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
		2461	/* FIXME: We handle only numeric literals for HP cfront */
		2462	case 'X':
		2463	/* A typed constant value follows */
		2464	args++;
		2465	if (!do_type (work, &args, &type_str))
		2466	goto cfront_template_args_done;
		2467	string_append (&arg, "(");
		2468	string_appends (&arg, &type_str);
		2469	string_delete (&type_str);
		2470	string_append (&arg, ")");
		2471	if (*args != 'L')
		2472	goto cfront_template_args_done;
		2473	args++;
		2474	/* Now snarf a literal value following 'L' */
		2475	if (!snarf_numeric_literal (&args, &arg))
		2476	goto cfront_template_args_done;
		2477	break;
		2478
		2479	case 'L':
		2480	/* Snarf a literal following 'L' */
		2481	args++;
		2482	if (!snarf_numeric_literal (&args, &arg))
		2483	goto cfront_template_args_done;
		2484	break;
		2485	default:
		2486	/* Not handling other HP cfront stuff */
		2487	{
		2488	const char* old_args = args;
		2489	if (!do_type (work, &args, &arg))
		2490	goto cfront_template_args_done;
		2491
		2492	/* Fail if we didn't make any progress: prevent infinite loop. */
		2493	if (args == old_args)
		2494	{
		2495	work->options = hold_options;
		2496	return;
		2497	}
		2498	}
		2499	}
		2500	string_appends (declp, &arg);
		2501	string_append (declp, ",");
		2502	}
		2503	cfront_template_args_done:
		2504	string_delete (&arg);
		2505	if (args >= e)
		2506	--declp->p; /* remove extra comma */
		2507	string_append (declp, ">");
		2508	work->options = hold_options;
		2509	}
		2510	else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
		2511	&& (*mangled)[9] == 'N'
		2512	&& (mangled)[8] == (mangled)[10]
		2513	&& strchr (cplus_markers, (*mangled)[8]))
		2514	{
		2515	/* A member of the anonymous namespace. */
		2516	string_append (declp, "{anonymous}");
		2517	}
		2518	else
		2519	{
		2520	if (work->temp_start == -1) /* non-recursive call only */
		2521	work->temp_start = 0; /* disable in recursive calls */
		2522	string_appendn (declp, *mangled, n);
		2523	}
		2524	*mangled += n;
		2525	}
		2526
		2527	/* Extract a class name, possibly a template with arguments, from the
		2528	mangled string; qualifiers, local class indicators, etc. have
		2529	already been dealt with */
		2530
		2531	static int
		2532	demangle_class_name (struct work_stuff work, const char *mangled,
		2533	string *declp)
		2534	{
		2535	int n;
		2536	int success = 0;
		2537
		2538	n = consume_count (mangled);
		2539	if (n == -1)
		2540	return 0;
		2541	if ((int) strlen (*mangled) >= n)
		2542	{
		2543	demangle_arm_hp_template (work, mangled, n, declp);
		2544	success = 1;
		2545	}
		2546
		2547	return (success);
		2548	}
		2549
		2550	/*
		2551
		2552	LOCAL FUNCTION
		2553
		2554	demangle_class -- demangle a mangled class sequence
		2555
		2556	SYNOPSIS
		2557
		2558	static int
		2559	demangle_class (struct work_stuff work, const char *mangled,
		2560	strint *declp)
		2561
		2562	DESCRIPTION
		2563
		2564	DECLP points to the buffer into which demangling is being done.
		2565
		2566	*MANGLED points to the current token to be demangled. On input,
		2567	it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
		2568	On exit, it points to the next token after the mangled class on
		2569	success, or the first unconsumed token on failure.
		2570
		2571	If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
		2572	we are demangling a constructor or destructor. In this case
		2573	we prepend "class::class" or "class::~class" to DECLP.
		2574
		2575	Otherwise, we prepend "class::" to the current DECLP.
		2576
		2577	Reset the constructor/destructor flags once they have been
		2578	"consumed". This allows demangle_class to be called later during
		2579	the same demangling, to do normal class demangling.
		2580
		2581	Returns 1 if demangling is successful, 0 otherwise.
		2582
		2583	*/
		2584
		2585	static int
		2586	demangle_class (struct work_stuff work, const char mangled, string declp)
		2587	{
		2588	int success = 0;
		2589	int btype;
		2590	string class_name;
		2591	char *save_class_name_end = 0;
		2592
		2593	string_init (&class_name);
		2594	btype = register_Btype (work);
		2595	if (demangle_class_name (work, mangled, &class_name))
		2596	{
		2597	save_class_name_end = class_name.p;
		2598	if ((work->constructor & 1) \|\| (work->destructor & 1))
		2599	{
		2600	/* adjust so we don't include template args */
		2601	if (work->temp_start && (work->temp_start != -1))
		2602	{
		2603	class_name.p = class_name.b + work->temp_start;
		2604	}
		2605	string_prepends (declp, &class_name);
		2606	if (work -> destructor & 1)
		2607	{
		2608	string_prepend (declp, "~");
		2609	work -> destructor -= 1;
		2610	}
		2611	else
		2612	{
		2613	work -> constructor -= 1;
		2614	}
		2615	}
		2616	class_name.p = save_class_name_end;
		2617	remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
		2618	remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
		2619	string_prepend (declp, SCOPE_STRING (work));
		2620	string_prepends (declp, &class_name);
		2621	success = 1;
		2622	}
		2623	string_delete (&class_name);
		2624	return (success);
		2625	}
		2626
		2627
		2628	/* Called when there's a "__" in the mangled name, with `scan' pointing to
		2629	the rightmost guess.
		2630
		2631	Find the correct "__"-sequence where the function name ends and the
		2632	signature starts, which is ambiguous with GNU mangling.
		2633	Call demangle_signature here, so we can make sure we found the right
		2634	one; *mangled will be consumed so caller will not make further calls to
		2635	demangle_signature. */
		2636
		2637	static int
		2638	iterate_demangle_function (struct work_stuff work, const char *mangled,
		2639	string declp, const char scan)
		2640	{
		2641	const char mangle_init = mangled;
		2642	int success = 0;
		2643	string decl_init;
		2644	struct work_stuff work_init;
		2645
		2646	if (*(scan + 2) == '\0')
		2647	return 0;
		2648
		2649	/* Do not iterate for some demangling modes, or if there's only one
		2650	"__"-sequence. This is the normal case. */
		2651	if (ARM_DEMANGLING \|\| LUCID_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING
		2652	\|\| strstr (scan + 2, "__") == NULL)
		2653	return demangle_function_name (work, mangled, declp, scan);
		2654
		2655	/* Save state so we can restart if the guess at the correct "__" was
		2656	wrong. */
		2657	string_init (&decl_init);
		2658	string_appends (&decl_init, declp);
		2659	memset (&work_init, 0, sizeof work_init);
		2660	work_stuff_copy_to_from (&work_init, work);
		2661
		2662	/* Iterate over occurrences of __, allowing names and types to have a
		2663	"__" sequence in them. We must start with the first (not the last)
		2664	occurrence, since "__" most often occur between independent mangled
		2665	parts, hence starting at the last occurence inside a signature
		2666	might get us a "successful" demangling of the signature. */
		2667
		2668	while (scan[2])
		2669	{
		2670	if (demangle_function_name (work, mangled, declp, scan))
		2671	{
		2672	success = demangle_signature (work, mangled, declp);
		2673	if (success)
		2674	break;
		2675	}
		2676
		2677	/* Reset demangle state for the next round. */
		2678	*mangled = mangle_init;
		2679	string_clear (declp);
		2680	string_appends (declp, &decl_init);
		2681	work_stuff_copy_to_from (work, &work_init);
		2682
		2683	/* Leave this underscore-sequence. */
		2684	scan += 2;
		2685
		2686	/* Scan for the next "__" sequence. */
		2687	while (*scan && (scan[0] != '_' \|\| scan[1] != '_'))
		2688	scan++;
		2689
		2690	/* Move to last "__" in this sequence. */
		2691	while (scan && scan == '_')
		2692	scan++;
		2693	scan -= 2;
		2694	}
		2695
		2696	/* Delete saved state. */
		2697	delete_work_stuff (&work_init);
		2698	string_delete (&decl_init);
		2699
		2700	return success;
		2701	}
		2702
		2703	/*
		2704
		2705	LOCAL FUNCTION
		2706
		2707	demangle_prefix -- consume the mangled name prefix and find signature
		2708
		2709	SYNOPSIS
		2710
		2711	static int
		2712	demangle_prefix (struct work_stuff work, const char *mangled,
		2713	string *declp);
		2714
		2715	DESCRIPTION
		2716
		2717	Consume and demangle the prefix of the mangled name.
		2718	While processing the function name root, arrange to call
		2719	demangle_signature if the root is ambiguous.
		2720
		2721	DECLP points to the string buffer into which demangled output is
		2722	placed. On entry, the buffer is empty. On exit it contains
		2723	the root function name, the demangled operator name, or in some
		2724	special cases either nothing or the completely demangled result.
		2725
		2726	MANGLED points to the current pointer into the mangled name. As each
		2727	token of the mangled name is consumed, it is updated. Upon entry
		2728	the current mangled name pointer points to the first character of
		2729	the mangled name. Upon exit, it should point to the first character
		2730	of the signature if demangling was successful, or to the first
		2731	unconsumed character if demangling of the prefix was unsuccessful.
		2732
		2733	Returns 1 on success, 0 otherwise.
		2734	*/
		2735
		2736	static int
		2737	demangle_prefix (struct work_stuff work, const char *mangled,
		2738	string *declp)
		2739	{
		2740	int success = 1;
		2741	const char *scan;
		2742	int i;
		2743
		2744	if (strlen(*mangled) > 6
		2745	&& (strncmp(*mangled, "_imp__", 6) == 0
		2746	\|\| strncmp(*mangled, "__imp_", 6) == 0))
		2747	{
		2748	/* it's a symbol imported from a PE dynamic library. Check for both
		2749	new style prefix _imp__ and legacy __imp_ used by older versions
		2750	of dlltool. */
		2751	(*mangled) += 6;
		2752	work->dllimported = 1;
		2753	}
		2754	else if (strlen(mangled) >= 11 && strncmp(mangled, "_GLOBAL_", 8) == 0)
		2755	{
		2756	char marker = strchr (cplus_markers, (mangled)[8]);
		2757	if (marker != NULL && marker == (mangled)[10])
		2758	{
		2759	if ((*mangled)[9] == 'D')
		2760	{
		2761	/* it's a GNU global destructor to be executed at program exit */
		2762	(*mangled) += 11;
		2763	work->destructor = 2;
		2764	if (gnu_special (work, mangled, declp))
		2765	return success;
		2766	}
		2767	else if ((*mangled)[9] == 'I')
		2768	{
		2769	/* it's a GNU global constructor to be executed at program init */
		2770	(*mangled) += 11;
		2771	work->constructor = 2;
		2772	if (gnu_special (work, mangled, declp))
		2773	return success;
		2774	}
		2775	}
		2776	}
		2777	else if ((ARM_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
		2778	{
		2779	/* it's a ARM global destructor to be executed at program exit */
		2780	(*mangled) += 7;
		2781	work->destructor = 2;
		2782	}
		2783	else if ((ARM_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
		2784	{
		2785	/* it's a ARM global constructor to be executed at program initial */
		2786	(*mangled) += 7;
		2787	work->constructor = 2;
		2788	}
		2789
		2790	/* This block of code is a reduction in strength time optimization
		2791	of:
		2792	scan = strstr (mangled, "__"); /
		2793
		2794	{
		2795	scan = *mangled;
		2796
		2797	do {
		2798	scan = strchr (scan, '_');
		2799	} while (scan != NULL && *++scan != '_');
		2800
		2801	if (scan != NULL) --scan;
		2802	}
		2803
		2804	if (scan != NULL)
		2805	{
		2806	/* We found a sequence of two or more '_', ensure that we start at
		2807	the last pair in the sequence. */
		2808	i = strspn (scan, "_");
		2809	if (i > 2)
		2810	{
		2811	scan += (i - 2);
		2812	}
		2813	}
		2814
		2815	if (scan == NULL)
		2816	{
		2817	success = 0;
		2818	}
		2819	else if (work -> static_type)
		2820	{
		2821	if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
		2822	{
		2823	success = 0;
		2824	}
		2825	}
		2826	else if ((scan == *mangled)
		2827	&& (ISDIGIT ((unsigned char)scan[2]) \|\| (scan[2] == 'Q')
		2828	\|\| (scan[2] == 't') \|\| (scan[2] == 'K') \|\| (scan[2] == 'H')))
		2829	{
		2830	/* The ARM says nothing about the mangling of local variables.
		2831	But cfront mangles local variables by prepending __
		2832	to them. As an extension to ARM demangling we handle this case. */
		2833	if ((LUCID_DEMANGLING \|\| ARM_DEMANGLING \|\| HP_DEMANGLING)
		2834	&& ISDIGIT ((unsigned char)scan[2]))
		2835	{
		2836	*mangled = scan + 2;
		2837	consume_count (mangled);
		2838	string_append (declp, *mangled);
		2839	mangled += strlen (mangled);
		2840	success = 1;
		2841	}
		2842	else
		2843	{
		2844	/* A GNU style constructor starts with __[0-9Qt]. But cfront uses
		2845	names like __Q2_3foo3bar for nested type names. So don't accept
		2846	this style of constructor for cfront demangling. A GNU
		2847	style member-template constructor starts with 'H'. */
		2848	if (!(LUCID_DEMANGLING \|\| ARM_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING))
		2849	work -> constructor += 1;
		2850	*mangled = scan + 2;
		2851	}
		2852	}
		2853	else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
		2854	{
		2855	/* Cfront-style parameterized type. Handled later as a signature. */
		2856	success = 1;
		2857
		2858	/* ARM template? */
		2859	demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
		2860	}
		2861	else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
		2862	\|\| (scan[2] == 'p' && scan[3] == 's')
		2863	\|\| (scan[2] == 'p' && scan[3] == 't')))
		2864	{
		2865	/* EDG-style parameterized type. Handled later as a signature. */
		2866	success = 1;
		2867
		2868	/* EDG template? */
		2869	demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
		2870	}
		2871	else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
		2872	&& (scan[2] != 't'))
		2873	{
		2874	/* Mangled name starts with "__". Skip over any leading '_' characters,
		2875	then find the next "__" that separates the prefix from the signature.
		2876	*/
		2877	if (!(ARM_DEMANGLING \|\| LUCID_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING)
		2878	\|\| (arm_special (mangled, declp) == 0))
		2879	{
		2880	while (*scan == '_')
		2881	{
		2882	scan++;
		2883	}
		2884	if ((scan = strstr (scan, "__")) == NULL \|\| (*(scan + 2) == '\0'))
		2885	{
		2886	/* No separator (I.E. "__not_mangled"), or empty signature
		2887	(I.E. "__not_mangled_either__") */
		2888	success = 0;
		2889	}
		2890	else
		2891	return iterate_demangle_function (work, mangled, declp, scan);
		2892	}
		2893	}
		2894	else if (*(scan + 2) != '\0')
		2895	{
		2896	/* Mangled name does not start with "__" but does have one somewhere
		2897	in there with non empty stuff after it. Looks like a global
		2898	function name. Iterate over all "__":s until the right
		2899	one is found. */
		2900	return iterate_demangle_function (work, mangled, declp, scan);
		2901	}
		2902	else
		2903	{
		2904	/* Doesn't look like a mangled name */
		2905	success = 0;
		2906	}
		2907
		2908	if (!success && (work->constructor == 2 \|\| work->destructor == 2))
		2909	{
		2910	string_append (declp, *mangled);
		2911	mangled += strlen (mangled);
		2912	success = 1;
		2913	}
		2914	return (success);
		2915	}
		2916
		2917	/*
		2918
		2919	LOCAL FUNCTION
		2920
		2921	gnu_special -- special handling of gnu mangled strings
		2922
		2923	SYNOPSIS
		2924
		2925	static int
		2926	gnu_special (struct work_stuff work, const char *mangled,
		2927	string *declp);
		2928
		2929
		2930	DESCRIPTION
		2931
		2932	Process some special GNU style mangling forms that don't fit
		2933	the normal pattern. For example:
		2934
		2935	_$_3foo (destructor for class foo)
		2936	_vt$foo (foo virtual table)
		2937	_vt$foo$bar (foo::bar virtual table)
		2938	__vt_foo (foo virtual table, new style with thunks)
		2939	_3foo$varname (static data member)
		2940	_Q22rs2tu$vw (static data member)
		2941	__t6vector1Zii (constructor with template)
		2942	__thunk_4__$_7ostream (virtual function thunk)
		2943	*/
		2944
		2945	static int
		2946	gnu_special (struct work_stuff work, const char mangled, string declp)
		2947	{
		2948	int n;
		2949	int success = 1;
		2950	const char *p;
		2951
		2952	if ((*mangled)[0] == '_'
		2953	&& strchr (cplus_markers, (*mangled)[1]) != NULL
		2954	&& (*mangled)[2] == '_')
		2955	{
		2956	/* Found a GNU style destructor, get past "__" */
		2957	(*mangled) += 3;
		2958	work -> destructor += 1;
		2959	}
		2960	else if ((*mangled)[0] == '_'
		2961	&& (((*mangled)[1] == '_'
		2962	&& (*mangled)[2] == 'v'
		2963	&& (*mangled)[3] == 't'
		2964	&& (*mangled)[4] == '_')
		2965	\|\| ((*mangled)[1] == 'v'
		2966	&& (*mangled)[2] == 't'
		2967	&& strchr (cplus_markers, (*mangled)[3]) != NULL)))
		2968	{
		2969	/* Found a GNU style virtual table, get past "_vt"
		2970	and create the decl. Note that we consume the entire mangled
		2971	input string, which means that demangle_signature has no work
		2972	to do. */
		2973	if ((*mangled)[2] == 'v')
		2974	(mangled) += 5; / New style, with thunks: "__vt_" */
		2975	else
		2976	(mangled) += 4; / Old style, no thunks: "_vt" */
		2977	while (**mangled != '\0')
		2978	{
		2979	switch (**mangled)
		2980	{
		2981	case 'Q':
		2982	case 'K':
		2983	success = demangle_qualified (work, mangled, declp, 0, 1);
		2984	break;
		2985	case 't':
		2986	success = demangle_template (work, mangled, declp, 0, 1,
		2987	1);
		2988	break;
		2989	default:
		2990	if (ISDIGIT((unsigned char)*mangled[0]))
		2991	{
		2992	n = consume_count(mangled);
		2993	/* We may be seeing a too-large size, or else a
		2994	"." indicating a static local symbol. In
		2995	any case, declare victory and move on; don't try
		2996	to use n to allocate. */
		2997	if (n > (int) strlen (*mangled))
		2998	{
		2999	success = 1;
		3000	break;
		3001	}
		3002	}
		3003	else
		3004	{
		3005	n = strcspn (*mangled, cplus_markers);
		3006	}
		3007	string_appendn (declp, *mangled, n);
		3008	(*mangled) += n;
		3009	}
		3010
		3011	p = strpbrk (*mangled, cplus_markers);
		3012	if (success && ((p == NULL) \|\| (p == *mangled)))
		3013	{
		3014	if (p != NULL)
		3015	{
		3016	string_append (declp, SCOPE_STRING (work));
		3017	(*mangled)++;
		3018	}
		3019	}
		3020	else
		3021	{
		3022	success = 0;
		3023	break;
		3024	}
		3025	}
		3026	if (success)
		3027	string_append (declp, " virtual table");
		3028	}
		3029	else if ((*mangled)[0] == '_'
		3030	&& (strchr("0123456789Qt", (*mangled)[1]) != NULL)
		3031	&& (p = strpbrk (*mangled, cplus_markers)) != NULL)
		3032	{
		3033	/* static data member, "_3foo$varname" for example */
		3034	(*mangled)++;
		3035	switch (**mangled)
		3036	{
		3037	case 'Q':
		3038	case 'K':
		3039	success = demangle_qualified (work, mangled, declp, 0, 1);
		3040	break;
		3041	case 't':
		3042	success = demangle_template (work, mangled, declp, 0, 1, 1);
		3043	break;
		3044	default:
		3045	n = consume_count (mangled);
		3046	if (n < 0 \|\| n > (long) strlen (*mangled))
		3047	{
		3048	success = 0;
		3049	break;
		3050	}
		3051
		3052	if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
		3053	&& (*mangled)[9] == 'N'
		3054	&& (mangled)[8] == (mangled)[10]
		3055	&& strchr (cplus_markers, (*mangled)[8]))
		3056	{
		3057	/* A member of the anonymous namespace. There's information
		3058	about what identifier or filename it was keyed to, but
		3059	it's just there to make the mangled name unique; we just
		3060	step over it. */
		3061	string_append (declp, "{anonymous}");
		3062	(*mangled) += n;
		3063
		3064	/* Now p points to the marker before the N, so we need to
		3065	update it to the first marker after what we consumed. */
		3066	p = strpbrk (*mangled, cplus_markers);
		3067	break;
		3068	}
		3069
		3070	string_appendn (declp, *mangled, n);
		3071	(*mangled) += n;
		3072	}
		3073	if (success && (p == *mangled))
		3074	{
		3075	/* Consumed everything up to the cplus_marker, append the
		3076	variable name. */
		3077	(*mangled)++;
		3078	string_append (declp, SCOPE_STRING (work));
		3079	n = strlen (*mangled);
		3080	string_appendn (declp, *mangled, n);
		3081	(*mangled) += n;
		3082	}
		3083	else
		3084	{
		3085	success = 0;
		3086	}
		3087	}
		3088	else if (strncmp (*mangled, "__thunk_", 8) == 0)
		3089	{
		3090	int delta;
		3091
		3092	(*mangled) += 8;
		3093	delta = consume_count (mangled);
		3094	if (delta == -1)
		3095	success = 0;
		3096	else
		3097	{
		3098	char method = internal_cplus_demangle (work, ++mangled);
		3099
		3100	if (method)
		3101	{
		3102	char buf[50];
		3103	sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
		3104	string_append (declp, buf);
		3105	string_append (declp, method);
		3106	free (method);
		3107	n = strlen (*mangled);
		3108	(*mangled) += n;
		3109	}
		3110	else
		3111	{
		3112	success = 0;
		3113	}
		3114	}
		3115	}
		3116	else if (strncmp (*mangled, "__t", 3) == 0
		3117	&& ((mangled)[3] == 'i' \|\| (mangled)[3] == 'f'))
		3118	{
		3119	p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
		3120	(*mangled) += 4;
		3121	switch (**mangled)
		3122	{
		3123	case 'Q':
		3124	case 'K':
		3125	success = demangle_qualified (work, mangled, declp, 0, 1);
		3126	break;
		3127	case 't':
		3128	success = demangle_template (work, mangled, declp, 0, 1, 1);
		3129	break;
		3130	default:
		3131	success = do_type (work, mangled, declp);
		3132	break;
		3133	}
		3134	if (success && **mangled != '\0')
		3135	success = 0;
		3136	if (success)
		3137	string_append (declp, p);
		3138	}
		3139	else
		3140	{
		3141	success = 0;
		3142	}
		3143	return (success);
		3144	}
		3145
		3146	static void
		3147	recursively_demangle(struct work_stuff work, const char *mangled,
		3148	string *result, int namelength)
		3149	{
		3150	char * recurse = (char *)NULL;
		3151	char * recurse_dem = (char *)NULL;
		3152
		3153	recurse = XNEWVEC (char, namelength + 1);
		3154	memcpy (recurse, *mangled, namelength);
		3155	recurse[namelength] = '\000';
		3156
		3157	recurse_dem = cplus_demangle (recurse, work->options);
		3158
		3159	if (recurse_dem)
		3160	{
		3161	string_append (result, recurse_dem);
		3162	free (recurse_dem);
		3163	}
		3164	else
		3165	{
		3166	string_appendn (result, *mangled, namelength);
		3167	}
		3168	free (recurse);
		3169	*mangled += namelength;
		3170	}
		3171
		3172	/*
		3173
		3174	LOCAL FUNCTION
		3175
		3176	arm_special -- special handling of ARM/lucid mangled strings
		3177
		3178	SYNOPSIS
		3179
		3180	static int
		3181	arm_special (const char **mangled,
		3182	string *declp);
		3183
		3184
		3185	DESCRIPTION
		3186
		3187	Process some special ARM style mangling forms that don't fit
		3188	the normal pattern. For example:
		3189
		3190	__vtbl__3foo (foo virtual table)
		3191	__vtbl__3foo__3bar (bar::foo virtual table)
		3192
		3193	*/
		3194
		3195	static int
		3196	arm_special (const char *mangled, string declp)
		3197	{
		3198	int n;
		3199	int success = 1;
		3200	const char *scan;
		3201
		3202	if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
		3203	{
		3204	/* Found a ARM style virtual table, get past ARM_VTABLE_STRING
		3205	and create the decl. Note that we consume the entire mangled
		3206	input string, which means that demangle_signature has no work
		3207	to do. */
		3208	scan = *mangled + ARM_VTABLE_STRLEN;
		3209	while (scan != '\0') / first check it can be demangled */
		3210	{
		3211	n = consume_count (&scan);
		3212	if (n == -1)
		3213	{
		3214	return (0); /* no good */
		3215	}
		3216	scan += n;
		3217	if (scan[0] == '_' && scan[1] == '_')
		3218	{
		3219	scan += 2;
		3220	}
		3221	}
		3222	(*mangled) += ARM_VTABLE_STRLEN;
		3223	while (**mangled != '\0')
		3224	{
		3225	n = consume_count (mangled);
		3226	if (n == -1
		3227	\|\| n > (long) strlen (*mangled))
		3228	return 0;
		3229	string_prependn (declp, *mangled, n);
		3230	(*mangled) += n;
		3231	if ((mangled)[0] == '_' && (mangled)[1] == '_')
		3232	{
		3233	string_prepend (declp, "::");
		3234	(*mangled) += 2;
		3235	}
		3236	}
		3237	string_append (declp, " virtual table");
		3238	}
		3239	else
		3240	{
		3241	success = 0;
		3242	}
		3243	return (success);
		3244	}
		3245
		3246	/*
		3247
		3248	LOCAL FUNCTION
		3249
		3250	demangle_qualified -- demangle 'Q' qualified name strings
		3251
		3252	SYNOPSIS
		3253
		3254	static int
		3255	demangle_qualified (struct work_stuff , const char mangled,
		3256	string *result, int isfuncname, int append);
		3257
		3258	DESCRIPTION
		3259
		3260	Demangle a qualified name, such as "Q25Outer5Inner" which is
		3261	the mangled form of "Outer::Inner". The demangled output is
		3262	prepended or appended to the result string according to the
		3263	state of the append flag.
		3264
		3265	If isfuncname is nonzero, then the qualified name we are building
		3266	is going to be used as a member function name, so if it is a
		3267	constructor or destructor function, append an appropriate
		3268	constructor or destructor name. I.E. for the above example,
		3269	the result for use as a constructor is "Outer::Inner::Inner"
		3270	and the result for use as a destructor is "Outer::Inner::~Inner".
		3271
		3272	BUGS
		3273
		3274	Numeric conversion is ASCII dependent (FIXME).
		3275
		3276	*/
		3277
		3278	static int
		3279	demangle_qualified (struct work_stuff work, const char *mangled,
		3280	string *result, int isfuncname, int append)
		3281	{
		3282	int qualifiers = 0;
		3283	int success = 1;
		3284	char num[2];
		3285	string temp;
		3286	string last_name;
		3287	int bindex = register_Btype (work);
		3288
		3289	/* We only make use of ISFUNCNAME if the entity is a constructor or
		3290	destructor. */
		3291	isfuncname = (isfuncname
		3292	&& ((work->constructor & 1) \|\| (work->destructor & 1)));
		3293
		3294	string_init (&temp);
		3295	string_init (&last_name);
		3296
		3297	if ((*mangled)[0] == 'K')
		3298	{
		3299	/* Squangling qualified name reuse */
		3300	int idx;
		3301	(*mangled)++;
		3302	idx = consume_count_with_underscores (mangled);
		3303	if (idx == -1 \|\| idx >= work -> numk)
		3304	success = 0;
		3305	else
		3306	string_append (&temp, work -> ktypevec[idx]);
		3307	}
		3308	else
		3309	switch ((*mangled)[1])
		3310	{
		3311	case '_':
		3312	/* GNU mangled name with more than 9 classes. The count is preceded
		3313	by an underscore (to distinguish it from the <= 9 case) and followed
		3314	by an underscore. */
		3315	(*mangled)++;
		3316	qualifiers = consume_count_with_underscores (mangled);
		3317	if (qualifiers == -1)
		3318	success = 0;
		3319	break;
		3320
		3321	case '1':
		3322	case '2':
		3323	case '3':
		3324	case '4':
		3325	case '5':
		3326	case '6':
		3327	case '7':
		3328	case '8':
		3329	case '9':
		3330	/* The count is in a single digit. */
		3331	num[0] = (*mangled)[1];
		3332	num[1] = '\0';
		3333	qualifiers = atoi (num);
		3334
		3335	/* If there is an underscore after the digit, skip it. This is
		3336	said to be for ARM-qualified names, but the ARM makes no
		3337	mention of such an underscore. Perhaps cfront uses one. */
		3338	if ((*mangled)[2] == '_')
		3339	{
		3340	(*mangled)++;
		3341	}
		3342	(*mangled) += 2;
		3343	break;
		3344
		3345	case '0':
		3346	default:
		3347	success = 0;
		3348	}
		3349
		3350	if (!success)
		3351	return success;
		3352
		3353	/* Pick off the names and collect them in the temp buffer in the order
		3354	in which they are found, separated by '::'. */
		3355
		3356	while (qualifiers-- > 0)
		3357	{
		3358	int remember_K = 1;
		3359	string_clear (&last_name);
		3360
		3361	if (*mangled[0] == '_')
		3362	(*mangled)++;
		3363
		3364	if (*mangled[0] == 't')
		3365	{
		3366	/* Here we always append to TEMP since we will want to use
		3367	the template name without the template parameters as a
		3368	constructor or destructor name. The appropriate
		3369	(parameter-less) value is returned by demangle_template
		3370	in LAST_NAME. We do not remember the template type here,
		3371	in order to match the G++ mangling algorithm. */
		3372	success = demangle_template(work, mangled, &temp,
		3373	&last_name, 1, 0);
		3374	if (!success)
		3375	break;
		3376	}
		3377	else if (*mangled[0] == 'K')
		3378	{
		3379	int idx;
		3380	(*mangled)++;
		3381	idx = consume_count_with_underscores (mangled);
		3382	if (idx == -1 \|\| idx >= work->numk)
		3383	success = 0;
		3384	else
		3385	string_append (&temp, work->ktypevec[idx]);
		3386	remember_K = 0;
		3387
		3388	if (!success) break;
		3389	}
		3390	else
		3391	{
		3392	if (EDG_DEMANGLING)
		3393	{
		3394	int namelength;
		3395	/* Now recursively demangle the qualifier
		3396	* This is necessary to deal with templates in
		3397	* mangling styles like EDG */
		3398	namelength = consume_count (mangled);
		3399	if (namelength == -1)
		3400	{
		3401	success = 0;
		3402	break;
		3403	}
		3404	recursively_demangle(work, mangled, &temp, namelength);
		3405	}
		3406	else
		3407	{
		3408	string_delete (&last_name);
		3409	success = do_type (work, mangled, &last_name);
		3410	if (!success)
		3411	break;
		3412	string_appends (&temp, &last_name);
		3413	}
		3414	}
		3415
		3416	if (remember_K)
		3417	remember_Ktype (work, temp.b, LEN_STRING (&temp));
		3418
		3419	if (qualifiers > 0)
		3420	string_append (&temp, SCOPE_STRING (work));
		3421	}
		3422
		3423	remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
		3424
		3425	/* If we are using the result as a function name, we need to append
		3426	the appropriate '::' separated constructor or destructor name.
		3427	We do this here because this is the most convenient place, where
		3428	we already have a pointer to the name and the length of the name. */
		3429
		3430	if (isfuncname)
		3431	{
		3432	string_append (&temp, SCOPE_STRING (work));
		3433	if (work -> destructor & 1)
		3434	string_append (&temp, "~");
		3435	string_appends (&temp, &last_name);
		3436	}
		3437
		3438	/* Now either prepend the temp buffer to the result, or append it,
		3439	depending upon the state of the append flag. */
		3440
		3441	if (append)
		3442	string_appends (result, &temp);
		3443	else
		3444	{
		3445	if (!STRING_EMPTY (result))
		3446	string_append (&temp, SCOPE_STRING (work));
		3447	string_prepends (result, &temp);
		3448	}
		3449
		3450	string_delete (&last_name);
		3451	string_delete (&temp);
		3452	return (success);
		3453	}
		3454
		3455	/*
		3456
		3457	LOCAL FUNCTION
		3458
		3459	get_count -- convert an ascii count to integer, consuming tokens
		3460
		3461	SYNOPSIS
		3462
		3463	static int
		3464	get_count (const char *type, int count)
		3465
		3466	DESCRIPTION
		3467
		3468	Assume that *type points at a count in a mangled name; set
		3469	count to its value, and set type to the next character after
		3470	the count. There are some weird rules in effect here.
		3471
		3472	If *type does not point at a string of digits, return zero.
		3473
		3474	If *type points at a string of digits followed by an
		3475	underscore, set *count to their value as an integer, advance
		3476	type to point after the underscore, and return 1.
		3477
		3478	If *type points at a string of digits not followed by an
		3479	underscore, consume only the first digit. Set *count to its
		3480	value as an integer, leave *type pointing after that digit,
		3481	and return 1.
		3482
		3483	The excuse for this odd behavior: in the ARM and HP demangling
		3484	styles, a type can be followed by a repeat count of the form
		3485	`Nxy', where:
		3486
		3487	`x' is a single digit specifying how many additional copies
		3488	of the type to append to the argument list, and
		3489
		3490	`y' is one or more digits, specifying the zero-based index of
		3491	the first repeated argument in the list. Yes, as you're
		3492	unmangling the name you can figure this out yourself, but
		3493	it's there anyway.
		3494
		3495	So, for example, in `bar__3fooFPiN51', the first argument is a
		3496	pointer to an integer (`Pi'), and then the next five arguments
		3497	are the same (`N5'), and the first repeat is the function's
		3498	second argument (`1').
		3499	*/
		3500
		3501	static int
		3502	get_count (const char *type, int count)
		3503	{
		3504	const char *p;
		3505	int n;
		3506
		3507	if (!ISDIGIT ((unsigned char)**type))
		3508	return (0);
		3509	else
		3510	{
		3511	count = *type - '0';
		3512	(*type)++;
		3513	if (ISDIGIT ((unsigned char)**type))
		3514	{
		3515	p = *type;
		3516	n = *count;
		3517	do
		3518	{
		3519	n *= 10;
		3520	n += *p - '0';
		3521	p++;
		3522	}
		3523	while (ISDIGIT ((unsigned char)*p));
		3524	if (*p == '_')
		3525	{
		3526	*type = p + 1;
		3527	*count = n;
		3528	}
		3529	}
		3530	}
		3531	return (1);
		3532	}
		3533
		3534	/* RESULT will be initialised here; it will be freed on failure. The
		3535	value returned is really a type_kind_t. */
		3536
		3537	static int
		3538	do_type (struct work_stuff work, const char mangled, string result)
		3539	{
		3540	int n;
		3541	int done;
		3542	int success;
		3543	string decl;
		3544	const char *remembered_type;
		3545	int type_quals;
		3546	type_kind_t tk = tk_none;
		3547
		3548	string_init (&decl);
		3549	string_init (result);
		3550
		3551	done = 0;
		3552	success = 1;
		3553	while (success && !done)
		3554	{
		3555	int member;
		3556	switch (**mangled)
		3557	{
		3558
		3559	/* A pointer type */
		3560	case 'P':
		3561	case 'p':
		3562	(*mangled)++;
		3563	if (! (work -> options & DMGL_JAVA))
		3564	string_prepend (&decl, "*");
		3565	if (tk == tk_none)
		3566	tk = tk_pointer;
		3567	break;
		3568
		3569	/* A reference type */
		3570	case 'R':
		3571	(*mangled)++;
		3572	string_prepend (&decl, "&");
		3573	if (tk == tk_none)
		3574	tk = tk_reference;
		3575	break;
		3576
		3577	/* An array */
		3578	case 'A':
		3579	{
		3580	++(*mangled);
		3581	if (!STRING_EMPTY (&decl)
		3582	&& (decl.b[0] == '*' \|\| decl.b[0] == '&'))
		3583	{
		3584	string_prepend (&decl, "(");
		3585	string_append (&decl, ")");
		3586	}
		3587	string_append (&decl, "[");
		3588	if (**mangled != '_')
		3589	success = demangle_template_value_parm (work, mangled, &decl,
		3590	tk_integral);
		3591	if (**mangled == '_')
		3592	++(*mangled);
		3593	string_append (&decl, "]");
		3594	break;
		3595	}
		3596
		3597	/* A back reference to a previously seen type */
		3598	case 'T':
		3599	(*mangled)++;
		3600	if (!get_count (mangled, &n) \|\| n >= work -> ntypes)
		3601	{
		3602	success = 0;
		3603	}
		3604	else
		3605	{
		3606	remembered_type = work -> typevec[n];
		3607	mangled = &remembered_type;
		3608	}
		3609	break;
		3610
		3611	/* A function */
		3612	case 'F':
		3613	(*mangled)++;
		3614	if (!STRING_EMPTY (&decl)
		3615	&& (decl.b[0] == '*' \|\| decl.b[0] == '&'))
		3616	{
		3617	string_prepend (&decl, "(");
		3618	string_append (&decl, ")");
		3619	}
		3620	/* After picking off the function args, we expect to either find the
		3621	function return type (preceded by an '_') or the end of the
		3622	string. */
		3623	if (!demangle_nested_args (work, mangled, &decl)
		3624	\|\| (mangled != '_' && mangled != '\0'))
		3625	{
		3626	success = 0;
		3627	break;
		3628	}
		3629	if (success && (**mangled == '_'))
		3630	(*mangled)++;
		3631	break;
		3632
		3633	case 'M':
		3634	case 'O':
		3635	{
		3636	type_quals = TYPE_UNQUALIFIED;
		3637
		3638	member = **mangled == 'M';
		3639	(*mangled)++;
		3640
		3641	string_append (&decl, ")");
		3642
		3643	/* We don't need to prepend `::' for a qualified name;
		3644	demangle_qualified will do that for us. */
		3645	if (**mangled != 'Q')
		3646	string_prepend (&decl, SCOPE_STRING (work));
		3647
		3648	if (ISDIGIT ((unsigned char)**mangled))
		3649	{
		3650	n = consume_count (mangled);
		3651	if (n == -1
		3652	\|\| (int) strlen (*mangled) < n)
		3653	{
		3654	success = 0;
		3655	break;
		3656	}
		3657	string_prependn (&decl, *mangled, n);
		3658	*mangled += n;
		3659	}
		3660	else if (mangled == 'X' \|\| mangled == 'Y')
		3661	{
		3662	string temp;
		3663	do_type (work, mangled, &temp);
		3664	string_prepends (&decl, &temp);
		3665	string_delete (&temp);
		3666	}
		3667	else if (**mangled == 't')
		3668	{
		3669	string temp;
		3670	string_init (&temp);
		3671	success = demangle_template (work, mangled, &temp,
		3672	NULL, 1, 1);
		3673	if (success)
		3674	{
		3675	string_prependn (&decl, temp.b, temp.p - temp.b);
		3676	string_delete (&temp);
		3677	}
		3678	else
6324	serge	3679	{
		3680	string_delete (&temp);
5191	serge	3681	break;
6324	serge	3682	}
5191	serge	3683	}
		3684	else if (**mangled == 'Q')
		3685	{
		3686	success = demangle_qualified (work, mangled, &decl,
		3687	/isfuncnam=/0,
		3688	/append=/0);
		3689	if (!success)
		3690	break;
		3691	}
		3692	else
		3693	{
		3694	success = 0;
		3695	break;
		3696	}
		3697
		3698	string_prepend (&decl, "(");
		3699	if (member)
		3700	{
		3701	switch (**mangled)
		3702	{
		3703	case 'C':
		3704	case 'V':
		3705	case 'u':
		3706	type_quals \|= code_for_qualifier (**mangled);
		3707	(*mangled)++;
		3708	break;
		3709
		3710	default:
		3711	break;
		3712	}
		3713
		3714	if ((mangled)++ != 'F')
		3715	{
		3716	success = 0;
		3717	break;
		3718	}
		3719	}
		3720	if ((member && !demangle_nested_args (work, mangled, &decl))
		3721	\|\| **mangled != '_')
		3722	{
		3723	success = 0;
		3724	break;
		3725	}
		3726	(*mangled)++;
		3727	if (! PRINT_ANSI_QUALIFIERS)
		3728	{
		3729	break;
		3730	}
		3731	if (type_quals != TYPE_UNQUALIFIED)
		3732	{
		3733	APPEND_BLANK (&decl);
		3734	string_append (&decl, qualifier_string (type_quals));
		3735	}
		3736	break;
		3737	}
		3738	case 'G':
		3739	(*mangled)++;
		3740	break;
		3741
		3742	case 'C':
		3743	case 'V':
		3744	case 'u':
		3745	if (PRINT_ANSI_QUALIFIERS)
		3746	{
		3747	if (!STRING_EMPTY (&decl))
		3748	string_prepend (&decl, " ");
		3749
		3750	string_prepend (&decl, demangle_qualifier (**mangled));
		3751	}
		3752	(*mangled)++;
		3753	break;
		3754	/*
		3755	}
		3756	*/
		3757
		3758	/* fall through */
		3759	default:
		3760	done = 1;
		3761	break;
		3762	}
		3763	}
		3764
		3765	if (success) switch (**mangled)
		3766	{
		3767	/* A qualified name, such as "Outer::Inner". */
		3768	case 'Q':
		3769	case 'K':
		3770	{
		3771	success = demangle_qualified (work, mangled, result, 0, 1);
		3772	break;
		3773	}
		3774
		3775	/* A back reference to a previously seen squangled type */
		3776	case 'B':
		3777	(*mangled)++;
		3778	if (!get_count (mangled, &n) \|\| n >= work -> numb)
		3779	success = 0;
		3780	else
		3781	string_append (result, work->btypevec[n]);
		3782	break;
		3783
		3784	case 'X':
		3785	case 'Y':
		3786	/* A template parm. We substitute the corresponding argument. */
		3787	{
		3788	int idx;
		3789
		3790	(*mangled)++;
		3791	idx = consume_count_with_underscores (mangled);
		3792
		3793	if (idx == -1
		3794	\|\| (work->tmpl_argvec && idx >= work->ntmpl_args)
		3795	\|\| consume_count_with_underscores (mangled) == -1)
		3796	{
		3797	success = 0;
		3798	break;
		3799	}
		3800
		3801	if (work->tmpl_argvec)
		3802	string_append (result, work->tmpl_argvec[idx]);
		3803	else
		3804	string_append_template_idx (result, idx);
		3805
		3806	success = 1;
		3807	}
		3808	break;
		3809
		3810	default:
		3811	success = demangle_fund_type (work, mangled, result);
		3812	if (tk == tk_none)
		3813	tk = (type_kind_t) success;
		3814	break;
		3815	}
		3816
		3817	if (success)
		3818	{
		3819	if (!STRING_EMPTY (&decl))
		3820	{
		3821	string_append (result, " ");
		3822	string_appends (result, &decl);
		3823	}
		3824	}
		3825	else
		3826	string_delete (result);
		3827	string_delete (&decl);
		3828
		3829	if (success)
		3830	/* Assume an integral type, if we're not sure. */
		3831	return (int) ((tk == tk_none) ? tk_integral : tk);
		3832	else
		3833	return 0;
		3834	}
		3835
		3836	/* Given a pointer to a type string that represents a fundamental type
		3837	argument (int, long, unsigned int, etc) in TYPE, a pointer to the
		3838	string in which the demangled output is being built in RESULT, and
		3839	the WORK structure, decode the types and add them to the result.
		3840
		3841	For example:
		3842
		3843	"Ci" => "const int"
		3844	"Sl" => "signed long"
		3845	"CUs" => "const unsigned short"
		3846
		3847	The value returned is really a type_kind_t. */
		3848
		3849	static int
		3850	demangle_fund_type (struct work_stuff *work,
		3851	const char *mangled, string result)
		3852	{
		3853	int done = 0;
		3854	int success = 1;
		3855	char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
		3856	unsigned int dec = 0;
		3857	type_kind_t tk = tk_integral;
		3858
		3859	/* First pick off any type qualifiers. There can be more than one. */
		3860
		3861	while (!done)
		3862	{
		3863	switch (**mangled)
		3864	{
		3865	case 'C':
		3866	case 'V':
		3867	case 'u':
		3868	if (PRINT_ANSI_QUALIFIERS)
		3869	{
		3870	if (!STRING_EMPTY (result))
		3871	string_prepend (result, " ");
		3872	string_prepend (result, demangle_qualifier (**mangled));
		3873	}
		3874	(*mangled)++;
		3875	break;
		3876	case 'U':
		3877	(*mangled)++;
		3878	APPEND_BLANK (result);
		3879	string_append (result, "unsigned");
		3880	break;
		3881	case 'S': /* signed char only */
		3882	(*mangled)++;
		3883	APPEND_BLANK (result);
		3884	string_append (result, "signed");
		3885	break;
		3886	case 'J':
		3887	(*mangled)++;
		3888	APPEND_BLANK (result);
		3889	string_append (result, "__complex");
		3890	break;
		3891	default:
		3892	done = 1;
		3893	break;
		3894	}
		3895	}
		3896
		3897	/* Now pick off the fundamental type. There can be only one. */
		3898
		3899	switch (**mangled)
		3900	{
		3901	case '\0':
		3902	case '_':
		3903	break;
		3904	case 'v':
		3905	(*mangled)++;
		3906	APPEND_BLANK (result);
		3907	string_append (result, "void");
		3908	break;
		3909	case 'x':
		3910	(*mangled)++;
		3911	APPEND_BLANK (result);
		3912	string_append (result, "long long");
		3913	break;
		3914	case 'l':
		3915	(*mangled)++;
		3916	APPEND_BLANK (result);
		3917	string_append (result, "long");
		3918	break;
		3919	case 'i':
		3920	(*mangled)++;
		3921	APPEND_BLANK (result);
		3922	string_append (result, "int");
		3923	break;
		3924	case 's':
		3925	(*mangled)++;
		3926	APPEND_BLANK (result);
		3927	string_append (result, "short");
		3928	break;
		3929	case 'b':
		3930	(*mangled)++;
		3931	APPEND_BLANK (result);
		3932	string_append (result, "bool");
		3933	tk = tk_bool;
		3934	break;
		3935	case 'c':
		3936	(*mangled)++;
		3937	APPEND_BLANK (result);
		3938	string_append (result, "char");
		3939	tk = tk_char;
		3940	break;
		3941	case 'w':
		3942	(*mangled)++;
		3943	APPEND_BLANK (result);
		3944	string_append (result, "wchar_t");
		3945	tk = tk_char;
		3946	break;
		3947	case 'r':
		3948	(*mangled)++;
		3949	APPEND_BLANK (result);
		3950	string_append (result, "long double");
		3951	tk = tk_real;
		3952	break;
		3953	case 'd':
		3954	(*mangled)++;
		3955	APPEND_BLANK (result);
		3956	string_append (result, "double");
		3957	tk = tk_real;
		3958	break;
		3959	case 'f':
		3960	(*mangled)++;
		3961	APPEND_BLANK (result);
		3962	string_append (result, "float");
		3963	tk = tk_real;
		3964	break;
		3965	case 'G':
		3966	(*mangled)++;
		3967	if (!ISDIGIT ((unsigned char)**mangled))
		3968	{
		3969	success = 0;
		3970	break;
		3971	}
		3972	case 'I':
		3973	(*mangled)++;
		3974	if (**mangled == '_')
		3975	{
		3976	int i;
		3977	(*mangled)++;
		3978	for (i = 0;
		3979	i < (long) sizeof (buf) - 1 && mangled && mangled != '_';
		3980	(*mangled)++, i++)
		3981	buf[i] = **mangled;
		3982	if (**mangled != '_')
		3983	{
		3984	success = 0;
		3985	break;
		3986	}
		3987	buf[i] = '\0';
		3988	(*mangled)++;
		3989	}
		3990	else
		3991	{
		3992	strncpy (buf, *mangled, 2);
		3993	buf[2] = '\0';
		3994	mangled += min (strlen (mangled), 2);
		3995	}
		3996	sscanf (buf, "%x", &dec);
		3997	sprintf (buf, "int%u_t", dec);
		3998	APPEND_BLANK (result);
		3999	string_append (result, buf);
		4000	break;
		4001
		4002	/* fall through */
		4003	/* An explicit type, such as "6mytype" or "7integer" */
		4004	case '0':
		4005	case '1':
		4006	case '2':
		4007	case '3':
		4008	case '4':
		4009	case '5':
		4010	case '6':
		4011	case '7':
		4012	case '8':
		4013	case '9':
		4014	{
		4015	int bindex = register_Btype (work);
		4016	string btype;
		4017	string_init (&btype);
		4018	if (demangle_class_name (work, mangled, &btype)) {
		4019	remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
		4020	APPEND_BLANK (result);
		4021	string_appends (result, &btype);
		4022	}
		4023	else
		4024	success = 0;
		4025	string_delete (&btype);
		4026	break;
		4027	}
		4028	case 't':
		4029	{
		4030	string btype;
		4031	string_init (&btype);
		4032	success = demangle_template (work, mangled, &btype, 0, 1, 1);
		4033	string_appends (result, &btype);
		4034	string_delete (&btype);
		4035	break;
		4036	}
		4037	default:
		4038	success = 0;
		4039	break;
		4040	}
		4041
		4042	return success ? ((int) tk) : 0;
		4043	}
		4044
		4045
		4046	/* Handle a template's value parameter for HP aCC (extension from ARM)
		4047	*mangled points to 'S' or 'U' /
		4048
		4049	static int
		4050	do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
		4051	const char *mangled, string result)
		4052	{
		4053	int unsigned_const;
		4054
		4055	if (mangled != 'U' && mangled != 'S')
		4056	return 0;
		4057
		4058	unsigned_const = (**mangled == 'U');
		4059
		4060	(*mangled)++;
		4061
		4062	switch (**mangled)
		4063	{
		4064	case 'N':
		4065	string_append (result, "-");
		4066	/* fall through */
		4067	case 'P':
		4068	(*mangled)++;
		4069	break;
		4070	case 'M':
		4071	/* special case for -2^31 */
		4072	string_append (result, "-2147483648");
		4073	(*mangled)++;
		4074	return 1;
		4075	default:
		4076	return 0;
		4077	}
		4078
		4079	/* We have to be looking at an integer now */
		4080	if (!(ISDIGIT ((unsigned char)**mangled)))
		4081	return 0;
		4082
		4083	/* We only deal with integral values for template
		4084	parameters -- so it's OK to look only for digits */
		4085	while (ISDIGIT ((unsigned char)**mangled))
		4086	{
		4087	char_str[0] = **mangled;
		4088	string_append (result, char_str);
		4089	(*mangled)++;
		4090	}
		4091
		4092	if (unsigned_const)
		4093	string_append (result, "U");
		4094
		4095	/* FIXME? Some day we may have 64-bit (or larger :-) ) constants
		4096	with L or LL suffixes. pai/1997-09-03 */
		4097
		4098	return 1; /* success */
		4099	}
		4100
		4101	/* Handle a template's literal parameter for HP aCC (extension from ARM)
		4102	*mangled is pointing to the 'A' /
		4103
		4104	static int
		4105	do_hpacc_template_literal (struct work_stuff work, const char *mangled,
		4106	string *result)
		4107	{
		4108	int literal_len = 0;
		4109	char * recurse;
		4110	char * recurse_dem;
		4111
		4112	if (**mangled != 'A')
		4113	return 0;
		4114
		4115	(*mangled)++;
		4116
		4117	literal_len = consume_count (mangled);
		4118
		4119	if (literal_len <= 0)
		4120	return 0;
		4121
		4122	/* Literal parameters are names of arrays, functions, etc. and the
		4123	canonical representation uses the address operator */
		4124	string_append (result, "&");
		4125
		4126	/* Now recursively demangle the literal name */
		4127	recurse = XNEWVEC (char, literal_len + 1);
		4128	memcpy (recurse, *mangled, literal_len);
		4129	recurse[literal_len] = '\000';
		4130
		4131	recurse_dem = cplus_demangle (recurse, work->options);
		4132
		4133	if (recurse_dem)
		4134	{
		4135	string_append (result, recurse_dem);
		4136	free (recurse_dem);
		4137	}
		4138	else
		4139	{
		4140	string_appendn (result, *mangled, literal_len);
		4141	}
		4142	(*mangled) += literal_len;
		4143	free (recurse);
		4144
		4145	return 1;
		4146	}
		4147
		4148	static int
		4149	snarf_numeric_literal (const char *args, string arg)
		4150	{
		4151	if (**args == '-')
		4152	{
		4153	char_str[0] = '-';
		4154	string_append (arg, char_str);
		4155	(*args)++;
		4156	}
		4157	else if (**args == '+')
		4158	(*args)++;
		4159
		4160	if (!ISDIGIT ((unsigned char)**args))
		4161	return 0;
		4162
		4163	while (ISDIGIT ((unsigned char)**args))
		4164	{
		4165	char_str[0] = **args;
		4166	string_append (arg, char_str);
		4167	(*args)++;
		4168	}
		4169
		4170	return 1;
		4171	}
		4172
		4173	/* Demangle the next argument, given by MANGLED into RESULT, which
		4174	should be an uninitialized string. It will be initialized here,
		4175	and free'd should anything go wrong. */
		4176
		4177	static int
		4178	do_arg (struct work_stuff work, const char mangled, string result)
		4179	{
		4180	/* Remember where we started so that we can record the type, for
		4181	non-squangling type remembering. */
		4182	const char start = mangled;
		4183
		4184	string_init (result);
		4185
		4186	if (work->nrepeats > 0)
		4187	{
		4188	--work->nrepeats;
		4189
		4190	if (work->previous_argument == 0)
		4191	return 0;
		4192
		4193	/* We want to reissue the previous type in this argument list. */
		4194	string_appends (result, work->previous_argument);
		4195	return 1;
		4196	}
		4197
		4198	if (**mangled == 'n')
		4199	{
		4200	/* A squangling-style repeat. */
		4201	(*mangled)++;
		4202	work->nrepeats = consume_count(mangled);
		4203
		4204	if (work->nrepeats <= 0)
		4205	/* This was not a repeat count after all. */
		4206	return 0;
		4207
		4208	if (work->nrepeats > 9)
		4209	{
		4210	if (**mangled != '_')
		4211	/* The repeat count should be followed by an '_' in this
		4212	case. */
		4213	return 0;
		4214	else
		4215	(*mangled)++;
		4216	}
		4217
		4218	/* Now, the repeat is all set up. */
		4219	return do_arg (work, mangled, result);
		4220	}
		4221
		4222	/* Save the result in WORK->previous_argument so that we can find it
		4223	if it's repeated. Note that saving START is not good enough: we
		4224	do not want to add additional types to the back-referenceable
		4225	type vector when processing a repeated type. */
		4226	if (work->previous_argument)
		4227	string_delete (work->previous_argument);
		4228	else
		4229	work->previous_argument = XNEW (string);
		4230
		4231	if (!do_type (work, mangled, work->previous_argument))
		4232	return 0;
		4233
		4234	string_appends (result, work->previous_argument);
		4235
		4236	remember_type (work, start, *mangled - start);
		4237	return 1;
		4238	}
		4239
		4240	static void
		4241	remember_type (struct work_stuff work, const char start, int len)
		4242	{
		4243	char *tem;
		4244
		4245	if (work->forgetting_types)
		4246	return;
		4247
		4248	if (work -> ntypes >= work -> typevec_size)
		4249	{
		4250	if (work -> typevec_size == 0)
		4251	{
		4252	work -> typevec_size = 3;
		4253	work -> typevec = XNEWVEC (char *, work->typevec_size);
		4254	}
		4255	else
		4256	{
		4257	work -> typevec_size *= 2;
		4258	work -> typevec
		4259	= XRESIZEVEC (char *, work->typevec, work->typevec_size);
		4260	}
		4261	}
		4262	tem = XNEWVEC (char, len + 1);
		4263	memcpy (tem, start, len);
		4264	tem[len] = '\0';
		4265	work -> typevec[work -> ntypes++] = tem;
		4266	}
		4267
		4268
		4269	/* Remember a K type class qualifier. */
		4270	static void
		4271	remember_Ktype (struct work_stuff work, const char start, int len)
		4272	{
		4273	char *tem;
		4274
		4275	if (work -> numk >= work -> ksize)
		4276	{
		4277	if (work -> ksize == 0)
		4278	{
		4279	work -> ksize = 5;
		4280	work -> ktypevec = XNEWVEC (char *, work->ksize);
		4281	}
		4282	else
		4283	{
		4284	work -> ksize *= 2;
		4285	work -> ktypevec
		4286	= XRESIZEVEC (char *, work->ktypevec, work->ksize);
		4287	}
		4288	}
		4289	tem = XNEWVEC (char, len + 1);
		4290	memcpy (tem, start, len);
		4291	tem[len] = '\0';
		4292	work -> ktypevec[work -> numk++] = tem;
		4293	}
		4294
		4295	/* Register a B code, and get an index for it. B codes are registered
		4296	as they are seen, rather than as they are completed, so map >
		4297	registers map > as B0, and temp as B1 */
		4298
		4299	static int
		4300	register_Btype (struct work_stuff *work)
		4301	{
		4302	int ret;
		4303
		4304	if (work -> numb >= work -> bsize)
		4305	{
		4306	if (work -> bsize == 0)
		4307	{
		4308	work -> bsize = 5;
		4309	work -> btypevec = XNEWVEC (char *, work->bsize);
		4310	}
		4311	else
		4312	{
		4313	work -> bsize *= 2;
		4314	work -> btypevec
		4315	= XRESIZEVEC (char *, work->btypevec, work->bsize);
		4316	}
		4317	}
		4318	ret = work -> numb++;
		4319	work -> btypevec[ret] = NULL;
		4320	return(ret);
		4321	}
		4322
		4323	/* Store a value into a previously registered B code type. */
		4324
		4325	static void
		4326	remember_Btype (struct work_stuff work, const char start,
		4327	int len, int index)
		4328	{
		4329	char *tem;
		4330
		4331	tem = XNEWVEC (char, len + 1);
		4332	memcpy (tem, start, len);
		4333	tem[len] = '\0';
		4334	work -> btypevec[index] = tem;
		4335	}
		4336
		4337	/* Lose all the info related to B and K type codes. */
		4338	static void
		4339	forget_B_and_K_types (struct work_stuff *work)
		4340	{
		4341	int i;
		4342
		4343	while (work -> numk > 0)
		4344	{
		4345	i = --(work -> numk);
		4346	if (work -> ktypevec[i] != NULL)
		4347	{
		4348	free (work -> ktypevec[i]);
		4349	work -> ktypevec[i] = NULL;
		4350	}
		4351	}
		4352
		4353	while (work -> numb > 0)
		4354	{
		4355	i = --(work -> numb);
		4356	if (work -> btypevec[i] != NULL)
		4357	{
		4358	free (work -> btypevec[i]);
		4359	work -> btypevec[i] = NULL;
		4360	}
		4361	}
		4362	}
		4363	/* Forget the remembered types, but not the type vector itself. */
		4364
		4365	static void
		4366	forget_types (struct work_stuff *work)
		4367	{
		4368	int i;
		4369
		4370	while (work -> ntypes > 0)
		4371	{
		4372	i = --(work -> ntypes);
		4373	if (work -> typevec[i] != NULL)
		4374	{
		4375	free (work -> typevec[i]);
		4376	work -> typevec[i] = NULL;
		4377	}
		4378	}
		4379	}
		4380
		4381	/* Process the argument list part of the signature, after any class spec
		4382	has been consumed, as well as the first 'F' character (if any). For
		4383	example:
		4384
		4385	"__als__3fooRT0" => process "RT0"
		4386	"complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
		4387
		4388	DECLP must be already initialised, usually non-empty. It won't be freed
		4389	on failure.
		4390
		4391	Note that g++ differs significantly from ARM and lucid style mangling
		4392	with regards to references to previously seen types. For example, given
		4393	the source fragment:
		4394
		4395	class foo {
		4396	public:
		4397	foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
		4398	};
		4399
		4400	foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
		4401	void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
		4402
		4403	g++ produces the names:
		4404
		4405	__3fooiRT0iT2iT2
		4406	foo__FiR3fooiT1iT1
		4407
		4408	while lcc (and presumably other ARM style compilers as well) produces:
		4409
		4410	foo__FiR3fooT1T2T1T2
		4411	__ct__3fooFiR3fooT1T2T1T2
		4412
		4413	Note that g++ bases its type numbers starting at zero and counts all
		4414	previously seen types, while lucid/ARM bases its type numbers starting
		4415	at one and only considers types after it has seen the 'F' character
		4416	indicating the start of the function args. For lucid/ARM style, we
		4417	account for this difference by discarding any previously seen types when
		4418	we see the 'F' character, and subtracting one from the type number
		4419	reference.
		4420
		4421	*/
		4422
		4423	static int
		4424	demangle_args (struct work_stuff work, const char *mangled,
		4425	string *declp)
		4426	{
		4427	string arg;
		4428	int need_comma = 0;
		4429	int r;
		4430	int t;
		4431	const char *tem;
		4432	char temptype;
		4433
		4434	if (PRINT_ARG_TYPES)
		4435	{
		4436	string_append (declp, "(");
		4437	if (**mangled == '\0')
		4438	{
		4439	string_append (declp, "void");
		4440	}
		4441	}
		4442
		4443	while ((mangled != '_' && mangled != '\0' && **mangled != 'e')
		4444	\|\| work->nrepeats > 0)
		4445	{
		4446	if ((mangled == 'N') \|\| (mangled == 'T'))
		4447	{
		4448	temptype = (mangled)++;
		4449
		4450	if (temptype == 'N')
		4451	{
		4452	if (!get_count (mangled, &r))
		4453	{
		4454	return (0);
		4455	}
		4456	}
		4457	else
		4458	{
		4459	r = 1;
		4460	}
		4461	if ((HP_DEMANGLING \|\| ARM_DEMANGLING \|\| EDG_DEMANGLING) && work -> ntypes >= 10)
		4462	{
		4463	/* If we have 10 or more types we might have more than a 1 digit
		4464	index so we'll have to consume the whole count here. This
		4465	will lose if the next thing is a type name preceded by a
		4466	count but it's impossible to demangle that case properly
		4467	anyway. Eg if we already have 12 types is T12Pc "(..., type1,
		4468	Pc, ...)" or "(..., type12, char , ...)" /
		4469	if ((t = consume_count(mangled)) <= 0)
		4470	{
		4471	return (0);
		4472	}
		4473	}
		4474	else
		4475	{
		4476	if (!get_count (mangled, &t))
		4477	{
		4478	return (0);
		4479	}
		4480	}
		4481	if (LUCID_DEMANGLING \|\| ARM_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING)
		4482	{
		4483	t--;
		4484	}
		4485	/* Validate the type index. Protect against illegal indices from
		4486	malformed type strings. */
		4487	if ((t < 0) \|\| (t >= work -> ntypes))
		4488	{
		4489	return (0);
		4490	}
		4491	while (work->nrepeats > 0 \|\| --r >= 0)
		4492	{
		4493	tem = work -> typevec[t];
		4494	if (need_comma && PRINT_ARG_TYPES)
		4495	{
		4496	string_append (declp, ", ");
		4497	}
		4498	if (!do_arg (work, &tem, &arg))
		4499	{
		4500	return (0);
		4501	}
		4502	if (PRINT_ARG_TYPES)
		4503	{
		4504	string_appends (declp, &arg);
		4505	}
		4506	string_delete (&arg);
		4507	need_comma = 1;
		4508	}
		4509	}
		4510	else
		4511	{
		4512	if (need_comma && PRINT_ARG_TYPES)
		4513	string_append (declp, ", ");
		4514	if (!do_arg (work, mangled, &arg))
		4515	return (0);
		4516	if (PRINT_ARG_TYPES)
		4517	string_appends (declp, &arg);
		4518	string_delete (&arg);
		4519	need_comma = 1;
		4520	}
		4521	}
		4522
		4523	if (**mangled == 'e')
		4524	{
		4525	(*mangled)++;
		4526	if (PRINT_ARG_TYPES)
		4527	{
		4528	if (need_comma)
		4529	{
		4530	string_append (declp, ",");
		4531	}
		4532	string_append (declp, "...");
		4533	}
		4534	}
		4535
		4536	if (PRINT_ARG_TYPES)
		4537	{
		4538	string_append (declp, ")");
		4539	}
		4540	return (1);
		4541	}
		4542
		4543	/* Like demangle_args, but for demangling the argument lists of function
		4544	and method pointers or references, not top-level declarations. */
		4545
		4546	static int
		4547	demangle_nested_args (struct work_stuff work, const char *mangled,
		4548	string *declp)
		4549	{
		4550	string* saved_previous_argument;
		4551	int result;
		4552	int saved_nrepeats;
		4553
		4554	/* The G++ name-mangling algorithm does not remember types on nested
		4555	argument lists, unless -fsquangling is used, and in that case the
		4556	type vector updated by remember_type is not used. So, we turn
		4557	off remembering of types here. */
		4558	++work->forgetting_types;
		4559
		4560	/* For the repeat codes used with -fsquangling, we must keep track of
		4561	the last argument. */
		4562	saved_previous_argument = work->previous_argument;
		4563	saved_nrepeats = work->nrepeats;
		4564	work->previous_argument = 0;
		4565	work->nrepeats = 0;
		4566
		4567	/* Actually demangle the arguments. */
		4568	result = demangle_args (work, mangled, declp);
		4569
		4570	/* Restore the previous_argument field. */
		4571	if (work->previous_argument)
		4572	{
		4573	string_delete (work->previous_argument);
		4574	free ((char *) work->previous_argument);
		4575	}
		4576	work->previous_argument = saved_previous_argument;
		4577	--work->forgetting_types;
		4578	work->nrepeats = saved_nrepeats;
		4579
		4580	return result;
		4581	}
		4582
		4583	/* Returns 1 if a valid function name was found or 0 otherwise. */
		4584
		4585	static int
		4586	demangle_function_name (struct work_stuff work, const char *mangled,
		4587	string declp, const char scan)
		4588	{
		4589	size_t i;
		4590	string type;
		4591	const char *tem;
		4592
		4593	string_appendn (declp, (mangled), scan - (mangled));
		4594	string_need (declp, 1);
		4595	*(declp -> p) = '\0';
		4596
		4597	/* Consume the function name, including the "__" separating the name
		4598	from the signature. We are guaranteed that SCAN points to the
		4599	separator. */
		4600
		4601	(*mangled) = scan + 2;
		4602	/* We may be looking at an instantiation of a template function:
		4603	foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
		4604	following _F marks the start of the function arguments. Handle
		4605	the template arguments first. */
		4606
		4607	if (HP_DEMANGLING && (**mangled == 'X'))
		4608	{
		4609	demangle_arm_hp_template (work, mangled, 0, declp);
		4610	/* This leaves MANGLED pointing to the 'F' marking func args */
		4611	}
		4612
		4613	if (LUCID_DEMANGLING \|\| ARM_DEMANGLING \|\| HP_DEMANGLING \|\| EDG_DEMANGLING)
		4614	{
		4615
		4616	/* See if we have an ARM style constructor or destructor operator.
		4617	If so, then just record it, clear the decl, and return.
		4618	We can't build the actual constructor/destructor decl until later,
		4619	when we recover the class name from the signature. */
		4620
		4621	if (strcmp (declp -> b, "__ct") == 0)
		4622	{
		4623	work -> constructor += 1;
		4624	string_clear (declp);
		4625	return 1;
		4626	}
		4627	else if (strcmp (declp -> b, "__dt") == 0)
		4628	{
		4629	work -> destructor += 1;
		4630	string_clear (declp);
		4631	return 1;
		4632	}
		4633	}
		4634
		4635	if (declp->p - declp->b >= 3
		4636	&& declp->b[0] == 'o'
		4637	&& declp->b[1] == 'p'
		4638	&& strchr (cplus_markers, declp->b[2]) != NULL)
		4639	{
		4640	/* see if it's an assignment expression */
		4641	if (declp->p - declp->b >= 10 /* op$assign_ */
		4642	&& memcmp (declp->b + 3, "assign_", 7) == 0)
		4643	{
		4644	for (i = 0; i < ARRAY_SIZE (optable); i++)
		4645	{
		4646	int len = declp->p - declp->b - 10;
		4647	if ((int) strlen (optable[i].in) == len
		4648	&& memcmp (optable[i].in, declp->b + 10, len) == 0)
		4649	{
		4650	string_clear (declp);
		4651	string_append (declp, "operator");
		4652	string_append (declp, optable[i].out);
		4653	string_append (declp, "=");
		4654	break;
		4655	}
		4656	}
		4657	}
		4658	else
		4659	{
		4660	for (i = 0; i < ARRAY_SIZE (optable); i++)
		4661	{
		4662	int len = declp->p - declp->b - 3;
		4663	if ((int) strlen (optable[i].in) == len
		4664	&& memcmp (optable[i].in, declp->b + 3, len) == 0)
		4665	{
		4666	string_clear (declp);
		4667	string_append (declp, "operator");
		4668	string_append (declp, optable[i].out);
		4669	break;
		4670	}
		4671	}
		4672	}
		4673	}
		4674	else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
		4675	&& strchr (cplus_markers, declp->b[4]) != NULL)
		4676	{
		4677	/* type conversion operator */
		4678	tem = declp->b + 5;
		4679	if (do_type (work, &tem, &type))
		4680	{
		4681	string_clear (declp);
		4682	string_append (declp, "operator ");
		4683	string_appends (declp, &type);
		4684	string_delete (&type);
		4685	}
		4686	}
		4687	else if (declp->b[0] == '_' && declp->b[1] == '_'
		4688	&& declp->b[2] == 'o' && declp->b[3] == 'p')
		4689	{
		4690	/* ANSI. */
		4691	/* type conversion operator. */
		4692	tem = declp->b + 4;
		4693	if (do_type (work, &tem, &type))
		4694	{
		4695	string_clear (declp);
		4696	string_append (declp, "operator ");
		4697	string_appends (declp, &type);
		4698	string_delete (&type);
		4699	}
		4700	}
		4701	else if (declp->b[0] == '_' && declp->b[1] == '_'
		4702	&& ISLOWER((unsigned char)declp->b[2])
		4703	&& ISLOWER((unsigned char)declp->b[3]))
		4704	{
		4705	if (declp->b[4] == '\0')
		4706	{
		4707	/* Operator. */
		4708	for (i = 0; i < ARRAY_SIZE (optable); i++)
		4709	{
		4710	if (strlen (optable[i].in) == 2
		4711	&& memcmp (optable[i].in, declp->b + 2, 2) == 0)
		4712	{
		4713	string_clear (declp);
		4714	string_append (declp, "operator");
		4715	string_append (declp, optable[i].out);
		4716	break;
		4717	}
		4718	}
		4719	}
		4720	else
		4721	{
		4722	if (declp->b[2] == 'a' && declp->b[5] == '\0')
		4723	{
		4724	/* Assignment. */
		4725	for (i = 0; i < ARRAY_SIZE (optable); i++)
		4726	{
		4727	if (strlen (optable[i].in) == 3
		4728	&& memcmp (optable[i].in, declp->b + 2, 3) == 0)
		4729	{
		4730	string_clear (declp);
		4731	string_append (declp, "operator");
		4732	string_append (declp, optable[i].out);
		4733	break;
		4734	}
		4735	}
		4736	}
		4737	}
		4738	}
		4739
		4740	/* If a function name was obtained but it's not valid, we were not
		4741	successful. */
		4742	if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
		4743	return 0;
		4744	else
		4745	return 1;
		4746	}
		4747
		4748	/* a mini string-handling package */
		4749
		4750	static void
		4751	string_need (string *s, int n)
		4752	{
		4753	int tem;
		4754
		4755	if (s->b == NULL)
		4756	{
		4757	if (n < 32)
		4758	{
		4759	n = 32;
		4760	}
		4761	s->p = s->b = XNEWVEC (char, n);
		4762	s->e = s->b + n;
		4763	}
		4764	else if (s->e - s->p < n)
		4765	{
		4766	tem = s->p - s->b;
		4767	n += tem;
		4768	n *= 2;
		4769	s->b = XRESIZEVEC (char, s->b, n);
		4770	s->p = s->b + tem;
		4771	s->e = s->b + n;
		4772	}
		4773	}
		4774
		4775	static void
		4776	string_delete (string *s)
		4777	{
		4778	if (s->b != NULL)
		4779	{
		4780	free (s->b);
		4781	s->b = s->e = s->p = NULL;
		4782	}
		4783	}
		4784
		4785	static void
		4786	string_init (string *s)
		4787	{
		4788	s->b = s->p = s->e = NULL;
		4789	}
		4790
		4791	static void
		4792	string_clear (string *s)
		4793	{
		4794	s->p = s->b;
		4795	}
		4796
		4797	#if 0
		4798
		4799	static int
		4800	string_empty (string *s)
		4801	{
		4802	return (s->b == s->p);
		4803	}
		4804
		4805	#endif
		4806
		4807	static void
		4808	string_append (string p, const char s)
		4809	{
		4810	int n;
		4811	if (s == NULL \|\| *s == '\0')
		4812	return;
		4813	n = strlen (s);
		4814	string_need (p, n);
		4815	memcpy (p->p, s, n);
		4816	p->p += n;
		4817	}
		4818
		4819	static void
		4820	string_appends (string p, string s)
		4821	{
		4822	int n;
		4823
		4824	if (s->b != s->p)
		4825	{
		4826	n = s->p - s->b;
		4827	string_need (p, n);
		4828	memcpy (p->p, s->b, n);
		4829	p->p += n;
		4830	}
		4831	}
		4832
		4833	static void
		4834	string_appendn (string p, const char s, int n)
		4835	{
		4836	if (n != 0)
		4837	{
		4838	string_need (p, n);
		4839	memcpy (p->p, s, n);
		4840	p->p += n;
		4841	}
		4842	}
		4843
		4844	static void
		4845	string_prepend (string p, const char s)
		4846	{
		4847	if (s != NULL && *s != '\0')
		4848	{
		4849	string_prependn (p, s, strlen (s));
		4850	}
		4851	}
		4852
		4853	static void
		4854	string_prepends (string p, string s)
		4855	{
		4856	if (s->b != s->p)
		4857	{
		4858	string_prependn (p, s->b, s->p - s->b);
		4859	}
		4860	}
		4861
		4862	static void
		4863	string_prependn (string p, const char s, int n)
		4864	{
		4865	char *q;
		4866
		4867	if (n != 0)
		4868	{
		4869	string_need (p, n);
		4870	for (q = p->p - 1; q >= p->b; q--)
		4871	{
		4872	q[n] = q[0];
		4873	}
		4874	memcpy (p->b, s, n);
		4875	p->p += n;
		4876	}
		4877	}
		4878
		4879	static void
		4880	string_append_template_idx (string *s, int idx)
		4881	{
		4882	char buf[INTBUF_SIZE + 1 /* 'T' */];
		4883	sprintf(buf, "T%d", idx);
		4884	string_append (s, buf);
		4885	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/libiberty/cplus-dem.c – Rev 6324