Context Navigation

source: trunk/binutils/libiberty/cplus-dem.c@ 2630

Visit:

Last change on this file since 2630 was 953, checked in by bird, 22 years ago
put in some code which have been split out to gcc/cp/cxxfilt.c. Need to get GCC up to date soon!
Property cvs2svn:cvs-rev set to `1.2` Property svn:eol-style set to `native` Property svn:executable set to ``*
File size: 124.8 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: