Context Navigation

source: rtems-tools/rtemstoolkit/libiberty/cp-demangle.c @ 87e0e76

4.104.115

Last change on this file since 87e0e76 was 87e0e76, checked in by Chris Johns <chrisj@…>, on 09/13/14 at 02:09:16
Refactor code into the RTEMS Toolkit.
Property mode set to `100644`
File size: 129.0 KB

Line
1	/* Demangler for g++ V3 ABI.
2	Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
3	Free Software Foundation, Inc.
4	Written by Ian Lance Taylor <ian@wasabisystems.com>.
5
6	This file is part of the libiberty library, which is part of GCC.
7
8	This file is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 2 of the License, or
11	(at your option) any later version.
12
13	In addition to the permissions in the GNU General Public License, the
14	Free Software Foundation gives you unlimited permission to link the
15	compiled version of this file into combinations with other programs,
16	and to distribute those combinations without any restriction coming
17	from the use of this file. (The General Public License restrictions
18	do apply in other respects; for example, they cover modification of
19	the file, and distribution when not linked into a combined
20	executable.)
21
22	This program is distributed in the hope that it will be useful,
23	but WITHOUT ANY WARRANTY; without even the implied warranty of
24	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25	GNU General Public License for more details.
26
27	You should have received a copy of the GNU General Public License
28	along with this program; if not, write to the Free Software
29	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
30	*/
31
32	/* This code implements a demangler for the g++ V3 ABI. The ABI is
33	described on this web page:
34	http://www.codesourcery.com/cxx-abi/abi.html#mangling
35
36	This code was written while looking at the demangler written by
37	Alex Samuel <samuel@codesourcery.com>.
38
39	This code first pulls the mangled name apart into a list of
40	components, and then walks the list generating the demangled
41	name.
42
43	This file will normally define the following functions, q.v.:
44	char cplus_demangle_v3(const char mangled, int options)
45	char java_demangle_v3(const char mangled)
46	int cplus_demangle_v3_callback(const char *mangled, int options,
47	demangle_callbackref callback)
48	int java_demangle_v3_callback(const char *mangled,
49	demangle_callbackref callback)
50	enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
51	enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
52
53	Also, the interface to the component list is public, and defined in
54	demangle.h. The interface consists of these types, which are
55	defined in demangle.h:
56	enum demangle_component_type
57	struct demangle_component
58	demangle_callbackref
59	and these functions defined in this file:
60	cplus_demangle_fill_name
61	cplus_demangle_fill_extended_operator
62	cplus_demangle_fill_ctor
63	cplus_demangle_fill_dtor
64	cplus_demangle_print
65	cplus_demangle_print_callback
66	and other functions defined in the file cp-demint.c.
67
68	This file also defines some other functions and variables which are
69	only to be used by the file cp-demint.c.
70
71	Preprocessor macros you can define while compiling this file:
72
73	IN_LIBGCC2
74	If defined, this file defines the following functions, q.v.:
75	char __cxa_demangle (const char mangled, char buf, size_t len,
76	int *status)
77	int __gcclibcxx_demangle_callback (const char *,
78	void (*)
79	(const char , size_t, void ),
80	void *)
81	instead of cplus_demangle_v3[_callback]() and
82	java_demangle_v3[_callback]().
83
84	IN_GLIBCPP_V3
85	If defined, this file defines only __cxa_demangle() and
86	__gcclibcxx_demangle_callback(), and no other publically visible
87	functions or variables.
88
89	STANDALONE_DEMANGLER
90	If defined, this file defines a main() function which demangles
91	any arguments, or, if none, demangles stdin.
92
93	CP_DEMANGLE_DEBUG
94	If defined, turns on debugging mode, which prints information on
95	stdout about the mangled string. This is not generally useful.
96	*/
97
98	#if defined (_AIX) && !defined (__GNUC__)
99	#pragma alloca
100	#endif
101
102	#ifdef HAVE_CONFIG_H
103	#include "config.h"
104	#endif
105
106	#include <stdio.h>
107
108	#ifdef HAVE_STDLIB_H
109	#include <stdlib.h>
110	#endif
111	#ifdef HAVE_STRING_H
112	#include <string.h>
113	#endif
114
115	#ifdef HAVE_ALLOCA_H
116	# include <alloca.h>
117	#else
118	# ifndef alloca
119	# ifdef __GNUC__
120	# define alloca __builtin_alloca
121	# else
122	extern char *alloca ();
123	# endif /* __GNUC__ */
124	# endif /* alloca */
125	#endif /* HAVE_ALLOCA_H */
126
127	#include "ansidecl.h"
128	#include "libiberty.h"
129	#include "demangle.h"
130	#include "cp-demangle.h"
131
132	/* If IN_GLIBCPP_V3 is defined, some functions are made static. We
133	also rename them via #define to avoid compiler errors when the
134	static definition conflicts with the extern declaration in a header
135	file. */
136	#ifdef IN_GLIBCPP_V3
137
138	#define CP_STATIC_IF_GLIBCPP_V3 static
139
140	#define cplus_demangle_fill_name d_fill_name
141	static int d_fill_name (struct demangle_component , const char , int);
142
143	#define cplus_demangle_fill_extended_operator d_fill_extended_operator
144	static int
145	d_fill_extended_operator (struct demangle_component *, int,
146	struct demangle_component *);
147
148	#define cplus_demangle_fill_ctor d_fill_ctor
149	static int
150	d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
151	struct demangle_component *);
152
153	#define cplus_demangle_fill_dtor d_fill_dtor
154	static int
155	d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
156	struct demangle_component *);
157
158	#define cplus_demangle_mangled_name d_mangled_name
159	static struct demangle_component d_mangled_name (struct d_info , int);
160
161	#define cplus_demangle_type d_type
162	static struct demangle_component d_type (struct d_info );
163
164	#define cplus_demangle_print d_print
165	static char d_print (int, const struct demangle_component , int, size_t *);
166
167	#define cplus_demangle_print_callback d_print_callback
168	static int d_print_callback (int, const struct demangle_component *,
169	demangle_callbackref, void *);
170
171	#define cplus_demangle_init_info d_init_info
172	static void d_init_info (const char , int, size_t, struct d_info );
173
174	#else /* ! defined(IN_GLIBCPP_V3) */
175	#define CP_STATIC_IF_GLIBCPP_V3
176	#endif /* ! defined(IN_GLIBCPP_V3) */
177
178	/* See if the compiler supports dynamic arrays. */
179
180	#ifdef __GNUC__
181	#define CP_DYNAMIC_ARRAYS
182	#else
183	#ifdef __STDC__
184	#ifdef __STDC_VERSION__
185	#if __STDC_VERSION__ >= 199901L
186	#define CP_DYNAMIC_ARRAYS
187	#endif /* __STDC__VERSION >= 199901L */
188	#endif /* defined (__STDC_VERSION__) */
189	#endif /* defined (__STDC__) */
190	#endif /* ! defined (__GNUC__) */
191
192	/* We avoid pulling in the ctype tables, to prevent pulling in
193	additional unresolved symbols when this code is used in a library.
194	FIXME: Is this really a valid reason? This comes from the original
195	V3 demangler code.
196
197	As of this writing this file has the following undefined references
198	when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
199	strcat, strlen. */
200
201	#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
202	#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
203	#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
204
205	/* The prefix prepended by GCC to an identifier represnting the
206	anonymous namespace. */
207	#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
208	#define ANONYMOUS_NAMESPACE_PREFIX_LEN \
209	(sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
210
211	/* Information we keep for the standard substitutions. */
212
213	struct d_standard_sub_info
214	{
215	/* The code for this substitution. */
216	char code;
217	/* The simple string it expands to. */
218	const char *simple_expansion;
219	/* The length of the simple expansion. */
220	int simple_len;
221	/* The results of a full, verbose, expansion. This is used when
222	qualifying a constructor/destructor, or when in verbose mode. */
223	const char *full_expansion;
224	/* The length of the full expansion. */
225	int full_len;
226	/* What to set the last_name field of d_info to; NULL if we should
227	not set it. This is only relevant when qualifying a
228	constructor/destructor. */
229	const char *set_last_name;
230	/* The length of set_last_name. */
231	int set_last_name_len;
232	};
233
234	/* Accessors for subtrees of struct demangle_component. */
235
236	#define d_left(dc) ((dc)->u.s_binary.left)
237	#define d_right(dc) ((dc)->u.s_binary.right)
238
239	/* A list of templates. This is used while printing. */
240
241	struct d_print_template
242	{
243	/* Next template on the list. */
244	struct d_print_template *next;
245	/* This template. */
246	const struct demangle_component *template_decl;
247	};
248
249	/* A list of type modifiers. This is used while printing. */
250
251	struct d_print_mod
252	{
253	/* Next modifier on the list. These are in the reverse of the order
254	in which they appeared in the mangled string. */
255	struct d_print_mod *next;
256	/* The modifier. */
257	const struct demangle_component *mod;
258	/* Whether this modifier was printed. */
259	int printed;
260	/* The list of templates which applies to this modifier. */
261	struct d_print_template *templates;
262	};
263
264	/* We use these structures to hold information during printing. */
265
266	struct d_growable_string
267	{
268	/* Buffer holding the result. */
269	char *buf;
270	/* Current length of data in buffer. */
271	size_t len;
272	/* Allocated size of buffer. */
273	size_t alc;
274	/* Set to 1 if we had a memory allocation failure. */
275	int allocation_failure;
276	};
277
278	enum { D_PRINT_BUFFER_LENGTH = 256 };
279	struct d_print_info
280	{
281	/* The options passed to the demangler. */
282	int options;
283	/* Fixed-length allocated buffer for demangled data, flushed to the
284	callback with a NUL termination once full. */
285	char buf[D_PRINT_BUFFER_LENGTH];
286	/* Current length of data in buffer. */
287	size_t len;
288	/* The last character printed, saved individually so that it survives
289	any buffer flush. */
290	char last_char;
291	/* Callback function to handle demangled buffer flush. */
292	demangle_callbackref callback;
293	/* Opaque callback argument. */
294	void *opaque;
295	/* The current list of templates, if any. */
296	struct d_print_template *templates;
297	/* The current list of modifiers (e.g., pointer, reference, etc.),
298	if any. */
299	struct d_print_mod *modifiers;
300	/* Set to 1 if we saw a demangling error. */
301	int demangle_failure;
302	/* The current index into any template argument packs we are using
303	for printing. */
304	int pack_index;
305	};
306
307	#ifdef CP_DEMANGLE_DEBUG
308	static void d_dump (struct demangle_component *, int);
309	#endif
310
311	static struct demangle_component *
312	d_make_empty (struct d_info *);
313
314	static struct demangle_component *
315	d_make_comp (struct d_info *, enum demangle_component_type,
316	struct demangle_component *,
317	struct demangle_component *);
318
319	static struct demangle_component *
320	d_make_name (struct d_info , const char , int);
321
322	static struct demangle_component *
323	d_make_builtin_type (struct d_info *,
324	const struct demangle_builtin_type_info *);
325
326	static struct demangle_component *
327	d_make_operator (struct d_info *,
328	const struct demangle_operator_info *);
329
330	static struct demangle_component *
331	d_make_extended_operator (struct d_info *, int,
332	struct demangle_component *);
333
334	static struct demangle_component *
335	d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
336	struct demangle_component *);
337
338	static struct demangle_component *
339	d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
340	struct demangle_component *);
341
342	static struct demangle_component *
343	d_make_template_param (struct d_info *, long);
344
345	static struct demangle_component *
346	d_make_sub (struct d_info , const char , int);
347
348	static int
349	has_return_type (struct demangle_component *);
350
351	static int
352	is_ctor_dtor_or_conversion (struct demangle_component *);
353
354	static struct demangle_component d_encoding (struct d_info , int);
355
356	static struct demangle_component d_name (struct d_info );
357
358	static struct demangle_component d_nested_name (struct d_info );
359
360	static struct demangle_component d_prefix (struct d_info );
361
362	static struct demangle_component d_unqualified_name (struct d_info );
363
364	static struct demangle_component d_source_name (struct d_info );
365
366	static long d_number (struct d_info *);
367
368	static struct demangle_component d_identifier (struct d_info , int);
369
370	static struct demangle_component d_operator_name (struct d_info );
371
372	static struct demangle_component d_special_name (struct d_info );
373
374	static int d_call_offset (struct d_info *, int);
375
376	static struct demangle_component d_ctor_dtor_name (struct d_info );
377
378	static struct demangle_component **
379	d_cv_qualifiers (struct d_info , struct demangle_component *, int);
380
381	static struct demangle_component *
382	d_function_type (struct d_info *);
383
384	static struct demangle_component *
385	d_bare_function_type (struct d_info *, int);
386
387	static struct demangle_component *
388	d_class_enum_type (struct d_info *);
389
390	static struct demangle_component d_array_type (struct d_info );
391
392	static struct demangle_component *
393	d_pointer_to_member_type (struct d_info *);
394
395	static struct demangle_component *
396	d_template_param (struct d_info *);
397
398	static struct demangle_component d_template_args (struct d_info );
399
400	static struct demangle_component *
401	d_template_arg (struct d_info *);
402
403	static struct demangle_component d_expression (struct d_info );
404
405	static struct demangle_component d_expr_primary (struct d_info );
406
407	static struct demangle_component d_local_name (struct d_info );
408
409	static int d_discriminator (struct d_info *);
410
411	static int
412	d_add_substitution (struct d_info , struct demangle_component );
413
414	static struct demangle_component d_substitution (struct d_info , int);
415
416	static void d_growable_string_init (struct d_growable_string *, size_t);
417
418	static inline void
419	d_growable_string_resize (struct d_growable_string *, size_t);
420
421	static inline void
422	d_growable_string_append_buffer (struct d_growable_string *,
423	const char *, size_t);
424	static void
425	d_growable_string_callback_adapter (const char , size_t, void );
426
427	static void
428	d_print_init (struct d_print_info , int, demangle_callbackref, void );
429
430	static inline void d_print_error (struct d_print_info *);
431
432	static inline int d_print_saw_error (struct d_print_info *);
433
434	static inline void d_print_flush (struct d_print_info *);
435
436	static inline void d_append_char (struct d_print_info *, char);
437
438	static inline void d_append_buffer (struct d_print_info *,
439	const char *, size_t);
440
441	static inline void d_append_string (struct d_print_info , const char );
442
443	static inline char d_last_char (struct d_print_info *);
444
445	static void
446	d_print_comp (struct d_print_info , const struct demangle_component );
447
448	static void
449	d_print_java_identifier (struct d_print_info , const char , int);
450
451	static void
452	d_print_mod_list (struct d_print_info , struct d_print_mod , int);
453
454	static void
455	d_print_mod (struct d_print_info , const struct demangle_component );
456
457	static void
458	d_print_function_type (struct d_print_info *,
459	const struct demangle_component *,
460	struct d_print_mod *);
461
462	static void
463	d_print_array_type (struct d_print_info *,
464	const struct demangle_component *,
465	struct d_print_mod *);
466
467	static void
468	d_print_expr_op (struct d_print_info , const struct demangle_component );
469
470	static void
471	d_print_cast (struct d_print_info , const struct demangle_component );
472
473	static int d_demangle_callback (const char *, int,
474	demangle_callbackref, void *);
475	static char d_demangle (const char , int, size_t *);
476
477	#ifdef CP_DEMANGLE_DEBUG
478
479	static void
480	d_dump (struct demangle_component *dc, int indent)
481	{
482	int i;
483
484	if (dc == NULL)
485	{
486	if (indent == 0)
487	printf ("failed demangling\n");
488	return;
489	}
490
491	for (i = 0; i < indent; ++i)
492	putchar (' ');
493
494	switch (dc->type)
495	{
496	case DEMANGLE_COMPONENT_NAME:
497	printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
498	return;
499	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
500	printf ("template parameter %ld\n", dc->u.s_number.number);
501	return;
502	case DEMANGLE_COMPONENT_CTOR:
503	printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
504	d_dump (dc->u.s_ctor.name, indent + 2);
505	return;
506	case DEMANGLE_COMPONENT_DTOR:
507	printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
508	d_dump (dc->u.s_dtor.name, indent + 2);
509	return;
510	case DEMANGLE_COMPONENT_SUB_STD:
511	printf ("standard substitution %s\n", dc->u.s_string.string);
512	return;
513	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
514	printf ("builtin type %s\n", dc->u.s_builtin.type->name);
515	return;
516	case DEMANGLE_COMPONENT_OPERATOR:
517	printf ("operator %s\n", dc->u.s_operator.op->name);
518	return;
519	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
520	printf ("extended operator with %d args\n",
521	dc->u.s_extended_operator.args);
522	d_dump (dc->u.s_extended_operator.name, indent + 2);
523	return;
524
525	case DEMANGLE_COMPONENT_QUAL_NAME:
526	printf ("qualified name\n");
527	break;
528	case DEMANGLE_COMPONENT_LOCAL_NAME:
529	printf ("local name\n");
530	break;
531	case DEMANGLE_COMPONENT_TYPED_NAME:
532	printf ("typed name\n");
533	break;
534	case DEMANGLE_COMPONENT_TEMPLATE:
535	printf ("template\n");
536	break;
537	case DEMANGLE_COMPONENT_VTABLE:
538	printf ("vtable\n");
539	break;
540	case DEMANGLE_COMPONENT_VTT:
541	printf ("VTT\n");
542	break;
543	case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
544	printf ("construction vtable\n");
545	break;
546	case DEMANGLE_COMPONENT_TYPEINFO:
547	printf ("typeinfo\n");
548	break;
549	case DEMANGLE_COMPONENT_TYPEINFO_NAME:
550	printf ("typeinfo name\n");
551	break;
552	case DEMANGLE_COMPONENT_TYPEINFO_FN:
553	printf ("typeinfo function\n");
554	break;
555	case DEMANGLE_COMPONENT_THUNK:
556	printf ("thunk\n");
557	break;
558	case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
559	printf ("virtual thunk\n");
560	break;
561	case DEMANGLE_COMPONENT_COVARIANT_THUNK:
562	printf ("covariant thunk\n");
563	break;
564	case DEMANGLE_COMPONENT_JAVA_CLASS:
565	printf ("java class\n");
566	break;
567	case DEMANGLE_COMPONENT_GUARD:
568	printf ("guard\n");
569	break;
570	case DEMANGLE_COMPONENT_REFTEMP:
571	printf ("reference temporary\n");
572	break;
573	case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
574	printf ("hidden alias\n");
575	break;
576	case DEMANGLE_COMPONENT_RESTRICT:
577	printf ("restrict\n");
578	break;
579	case DEMANGLE_COMPONENT_VOLATILE:
580	printf ("volatile\n");
581	break;
582	case DEMANGLE_COMPONENT_CONST:
583	printf ("const\n");
584	break;
585	case DEMANGLE_COMPONENT_RESTRICT_THIS:
586	printf ("restrict this\n");
587	break;
588	case DEMANGLE_COMPONENT_VOLATILE_THIS:
589	printf ("volatile this\n");
590	break;
591	case DEMANGLE_COMPONENT_CONST_THIS:
592	printf ("const this\n");
593	break;
594	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
595	printf ("vendor type qualifier\n");
596	break;
597	case DEMANGLE_COMPONENT_POINTER:
598	printf ("pointer\n");
599	break;
600	case DEMANGLE_COMPONENT_REFERENCE:
601	printf ("reference\n");
602	break;
603	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
604	printf ("rvalue reference\n");
605	break;
606	case DEMANGLE_COMPONENT_COMPLEX:
607	printf ("complex\n");
608	break;
609	case DEMANGLE_COMPONENT_IMAGINARY:
610	printf ("imaginary\n");
611	break;
612	case DEMANGLE_COMPONENT_VENDOR_TYPE:
613	printf ("vendor type\n");
614	break;
615	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
616	printf ("function type\n");
617	break;
618	case DEMANGLE_COMPONENT_ARRAY_TYPE:
619	printf ("array type\n");
620	break;
621	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
622	printf ("pointer to member type\n");
623	break;
624	case DEMANGLE_COMPONENT_FIXED_TYPE:
625	printf ("fixed-point type\n");
626	break;
627	case DEMANGLE_COMPONENT_ARGLIST:
628	printf ("argument list\n");
629	break;
630	case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
631	printf ("template argument list\n");
632	break;
633	case DEMANGLE_COMPONENT_CAST:
634	printf ("cast\n");
635	break;
636	case DEMANGLE_COMPONENT_UNARY:
637	printf ("unary operator\n");
638	break;
639	case DEMANGLE_COMPONENT_BINARY:
640	printf ("binary operator\n");
641	break;
642	case DEMANGLE_COMPONENT_BINARY_ARGS:
643	printf ("binary operator arguments\n");
644	break;
645	case DEMANGLE_COMPONENT_TRINARY:
646	printf ("trinary operator\n");
647	break;
648	case DEMANGLE_COMPONENT_TRINARY_ARG1:
649	printf ("trinary operator arguments 1\n");
650	break;
651	case DEMANGLE_COMPONENT_TRINARY_ARG2:
652	printf ("trinary operator arguments 1\n");
653	break;
654	case DEMANGLE_COMPONENT_LITERAL:
655	printf ("literal\n");
656	break;
657	case DEMANGLE_COMPONENT_LITERAL_NEG:
658	printf ("negative literal\n");
659	break;
660	case DEMANGLE_COMPONENT_JAVA_RESOURCE:
661	printf ("java resource\n");
662	break;
663	case DEMANGLE_COMPONENT_COMPOUND_NAME:
664	printf ("compound name\n");
665	break;
666	case DEMANGLE_COMPONENT_CHARACTER:
667	printf ("character '%c'\n", dc->u.s_character.character);
668	return;
669	case DEMANGLE_COMPONENT_DECLTYPE:
670	printf ("decltype\n");
671	break;
672	case DEMANGLE_COMPONENT_PACK_EXPANSION:
673	printf ("pack expansion\n");
674	break;
675	}
676
677	d_dump (d_left (dc), indent + 2);
678	d_dump (d_right (dc), indent + 2);
679	}
680
681	#endif /* CP_DEMANGLE_DEBUG */
682
683	/* Fill in a DEMANGLE_COMPONENT_NAME. */
684
685	CP_STATIC_IF_GLIBCPP_V3
686	int
687	cplus_demangle_fill_name (struct demangle_component p, const char s, int len)
688	{
689	if (p == NULL \|\| s == NULL \|\| len == 0)
690	return 0;
691	p->type = DEMANGLE_COMPONENT_NAME;
692	p->u.s_name.s = s;
693	p->u.s_name.len = len;
694	return 1;
695	}
696
697	/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
698
699	CP_STATIC_IF_GLIBCPP_V3
700	int
701	cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
702	struct demangle_component *name)
703	{
704	if (p == NULL \|\| args < 0 \|\| name == NULL)
705	return 0;
706	p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
707	p->u.s_extended_operator.args = args;
708	p->u.s_extended_operator.name = name;
709	return 1;
710	}
711
712	/* Fill in a DEMANGLE_COMPONENT_CTOR. */
713
714	CP_STATIC_IF_GLIBCPP_V3
715	int
716	cplus_demangle_fill_ctor (struct demangle_component *p,
717	enum gnu_v3_ctor_kinds kind,
718	struct demangle_component *name)
719	{
720	if (p == NULL
721	\|\| name == NULL
722	\|\| (int) kind < gnu_v3_complete_object_ctor
723	\|\| (int) kind > gnu_v3_complete_object_allocating_ctor)
724	return 0;
725	p->type = DEMANGLE_COMPONENT_CTOR;
726	p->u.s_ctor.kind = kind;
727	p->u.s_ctor.name = name;
728	return 1;
729	}
730
731	/* Fill in a DEMANGLE_COMPONENT_DTOR. */
732
733	CP_STATIC_IF_GLIBCPP_V3
734	int
735	cplus_demangle_fill_dtor (struct demangle_component *p,
736	enum gnu_v3_dtor_kinds kind,
737	struct demangle_component *name)
738	{
739	if (p == NULL
740	\|\| name == NULL
741	\|\| (int) kind < gnu_v3_deleting_dtor
742	\|\| (int) kind > gnu_v3_base_object_dtor)
743	return 0;
744	p->type = DEMANGLE_COMPONENT_DTOR;
745	p->u.s_dtor.kind = kind;
746	p->u.s_dtor.name = name;
747	return 1;
748	}
749
750	/* Add a new component. */
751
752	static struct demangle_component *
753	d_make_empty (struct d_info *di)
754	{
755	struct demangle_component *p;
756
757	if (di->next_comp >= di->num_comps)
758	return NULL;
759	p = &di->comps[di->next_comp];
760	++di->next_comp;
761	return p;
762	}
763
764	/* Add a new generic component. */
765
766	static struct demangle_component *
767	d_make_comp (struct d_info *di, enum demangle_component_type type,
768	struct demangle_component *left,
769	struct demangle_component *right)
770	{
771	struct demangle_component *p;
772
773	/* We check for errors here. A typical error would be a NULL return
774	from a subroutine. We catch those here, and return NULL
775	upward. */
776	switch (type)
777	{
778	/* These types require two parameters. */
779	case DEMANGLE_COMPONENT_QUAL_NAME:
780	case DEMANGLE_COMPONENT_LOCAL_NAME:
781	case DEMANGLE_COMPONENT_TYPED_NAME:
782	case DEMANGLE_COMPONENT_TEMPLATE:
783	case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
784	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
785	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
786	case DEMANGLE_COMPONENT_UNARY:
787	case DEMANGLE_COMPONENT_BINARY:
788	case DEMANGLE_COMPONENT_BINARY_ARGS:
789	case DEMANGLE_COMPONENT_TRINARY:
790	case DEMANGLE_COMPONENT_TRINARY_ARG1:
791	case DEMANGLE_COMPONENT_TRINARY_ARG2:
792	case DEMANGLE_COMPONENT_LITERAL:
793	case DEMANGLE_COMPONENT_LITERAL_NEG:
794	case DEMANGLE_COMPONENT_COMPOUND_NAME:
795	if (left == NULL \|\| right == NULL)
796	return NULL;
797	break;
798
799	/* These types only require one parameter. */
800	case DEMANGLE_COMPONENT_VTABLE:
801	case DEMANGLE_COMPONENT_VTT:
802	case DEMANGLE_COMPONENT_TYPEINFO:
803	case DEMANGLE_COMPONENT_TYPEINFO_NAME:
804	case DEMANGLE_COMPONENT_TYPEINFO_FN:
805	case DEMANGLE_COMPONENT_THUNK:
806	case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
807	case DEMANGLE_COMPONENT_COVARIANT_THUNK:
808	case DEMANGLE_COMPONENT_JAVA_CLASS:
809	case DEMANGLE_COMPONENT_GUARD:
810	case DEMANGLE_COMPONENT_REFTEMP:
811	case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
812	case DEMANGLE_COMPONENT_POINTER:
813	case DEMANGLE_COMPONENT_REFERENCE:
814	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
815	case DEMANGLE_COMPONENT_COMPLEX:
816	case DEMANGLE_COMPONENT_IMAGINARY:
817	case DEMANGLE_COMPONENT_VENDOR_TYPE:
818	case DEMANGLE_COMPONENT_CAST:
819	case DEMANGLE_COMPONENT_JAVA_RESOURCE:
820	case DEMANGLE_COMPONENT_DECLTYPE:
821	case DEMANGLE_COMPONENT_PACK_EXPANSION:
822	case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
823	case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
824	if (left == NULL)
825	return NULL;
826	break;
827
828	/* This needs a right parameter, but the left parameter can be
829	empty. */
830	case DEMANGLE_COMPONENT_ARRAY_TYPE:
831	if (right == NULL)
832	return NULL;
833	break;
834
835	/* These are allowed to have no parameters--in some cases they
836	will be filled in later. */
837	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
838	case DEMANGLE_COMPONENT_RESTRICT:
839	case DEMANGLE_COMPONENT_VOLATILE:
840	case DEMANGLE_COMPONENT_CONST:
841	case DEMANGLE_COMPONENT_RESTRICT_THIS:
842	case DEMANGLE_COMPONENT_VOLATILE_THIS:
843	case DEMANGLE_COMPONENT_CONST_THIS:
844	case DEMANGLE_COMPONENT_ARGLIST:
845	case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
846	break;
847
848	/* Other types should not be seen here. */
849	default:
850	return NULL;
851	}
852
853	p = d_make_empty (di);
854	if (p != NULL)
855	{
856	p->type = type;
857	p->u.s_binary.left = left;
858	p->u.s_binary.right = right;
859	}
860	return p;
861	}
862
863	/* Add a new name component. */
864
865	static struct demangle_component *
866	d_make_name (struct d_info di, const char s, int len)
867	{
868	struct demangle_component *p;
869
870	p = d_make_empty (di);
871	if (! cplus_demangle_fill_name (p, s, len))
872	return NULL;
873	return p;
874	}
875
876	/* Add a new builtin type component. */
877
878	static struct demangle_component *
879	d_make_builtin_type (struct d_info *di,
880	const struct demangle_builtin_type_info *type)
881	{
882	struct demangle_component *p;
883
884	if (type == NULL)
885	return NULL;
886	p = d_make_empty (di);
887	if (p != NULL)
888	{
889	p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
890	p->u.s_builtin.type = type;
891	}
892	return p;
893	}
894
895	/* Add a new operator component. */
896
897	static struct demangle_component *
898	d_make_operator (struct d_info di, const struct demangle_operator_info op)
899	{
900	struct demangle_component *p;
901
902	p = d_make_empty (di);
903	if (p != NULL)
904	{
905	p->type = DEMANGLE_COMPONENT_OPERATOR;
906	p->u.s_operator.op = op;
907	}
908	return p;
909	}
910
911	/* Add a new extended operator component. */
912
913	static struct demangle_component *
914	d_make_extended_operator (struct d_info *di, int args,
915	struct demangle_component *name)
916	{
917	struct demangle_component *p;
918
919	p = d_make_empty (di);
920	if (! cplus_demangle_fill_extended_operator (p, args, name))
921	return NULL;
922	return p;
923	}
924
925	/* Add a new constructor component. */
926
927	static struct demangle_component *
928	d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
929	struct demangle_component *name)
930	{
931	struct demangle_component *p;
932
933	p = d_make_empty (di);
934	if (! cplus_demangle_fill_ctor (p, kind, name))
935	return NULL;
936	return p;
937	}
938
939	/* Add a new destructor component. */
940
941	static struct demangle_component *
942	d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
943	struct demangle_component *name)
944	{
945	struct demangle_component *p;
946
947	p = d_make_empty (di);
948	if (! cplus_demangle_fill_dtor (p, kind, name))
949	return NULL;
950	return p;
951	}
952
953	/* Add a new template parameter. */
954
955	static struct demangle_component *
956	d_make_template_param (struct d_info *di, long i)
957	{
958	struct demangle_component *p;
959
960	p = d_make_empty (di);
961	if (p != NULL)
962	{
963	p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
964	p->u.s_number.number = i;
965	}
966	return p;
967	}
968
969	/* Add a new function parameter. */
970
971	static struct demangle_component *
972	d_make_function_param (struct d_info *di, long i)
973	{
974	struct demangle_component *p;
975
976	p = d_make_empty (di);
977	if (p != NULL)
978	{
979	p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
980	p->u.s_number.number = i;
981	}
982	return p;
983	}
984
985	/* Add a new standard substitution component. */
986
987	static struct demangle_component *
988	d_make_sub (struct d_info di, const char name, int len)
989	{
990	struct demangle_component *p;
991
992	p = d_make_empty (di);
993	if (p != NULL)
994	{
995	p->type = DEMANGLE_COMPONENT_SUB_STD;
996	p->u.s_string.string = name;
997	p->u.s_string.len = len;
998	}
999	return p;
1000	}
1001
1002	/* <mangled-name> ::= _Z <encoding>
1003
1004	TOP_LEVEL is non-zero when called at the top level. */
1005
1006	CP_STATIC_IF_GLIBCPP_V3
1007	struct demangle_component *
1008	cplus_demangle_mangled_name (struct d_info *di, int top_level)
1009	{
1010	if (! d_check_char (di, '_')
1011	/* Allow missing _ if not at toplevel to work around a
1012	bug in G++ abi-version=2 mangling; see the comment in
1013	write_template_arg. */
1014	&& top_level)
1015	return NULL;
1016	if (! d_check_char (di, 'Z'))
1017	return NULL;
1018	return d_encoding (di, top_level);
1019	}
1020
1021	/* Return whether a function should have a return type. The argument
1022	is the function name, which may be qualified in various ways. The
1023	rules are that template functions have return types with some
1024	exceptions, function types which are not part of a function name
1025	mangling have return types with some exceptions, and non-template
1026	function names do not have return types. The exceptions are that
1027	constructors, destructors, and conversion operators do not have
1028	return types. */
1029
1030	static int
1031	has_return_type (struct demangle_component *dc)
1032	{
1033	if (dc == NULL)
1034	return 0;
1035	switch (dc->type)
1036	{
1037	default:
1038	return 0;
1039	case DEMANGLE_COMPONENT_TEMPLATE:
1040	return ! is_ctor_dtor_or_conversion (d_left (dc));
1041	case DEMANGLE_COMPONENT_RESTRICT_THIS:
1042	case DEMANGLE_COMPONENT_VOLATILE_THIS:
1043	case DEMANGLE_COMPONENT_CONST_THIS:
1044	return has_return_type (d_left (dc));
1045	}
1046	}
1047
1048	/* Return whether a name is a constructor, a destructor, or a
1049	conversion operator. */
1050
1051	static int
1052	is_ctor_dtor_or_conversion (struct demangle_component *dc)
1053	{
1054	if (dc == NULL)
1055	return 0;
1056	switch (dc->type)
1057	{
1058	default:
1059	return 0;
1060	case DEMANGLE_COMPONENT_QUAL_NAME:
1061	case DEMANGLE_COMPONENT_LOCAL_NAME:
1062	return is_ctor_dtor_or_conversion (d_right (dc));
1063	case DEMANGLE_COMPONENT_CTOR:
1064	case DEMANGLE_COMPONENT_DTOR:
1065	case DEMANGLE_COMPONENT_CAST:
1066	return 1;
1067	}
1068	}
1069
1070	/* <encoding> ::= <(function) name> <bare-function-type>
1071	::= <(data) name>
1072	::= <special-name>
1073
1074	TOP_LEVEL is non-zero when called at the top level, in which case
1075	if DMGL_PARAMS is not set we do not demangle the function
1076	parameters. We only set this at the top level, because otherwise
1077	we would not correctly demangle names in local scopes. */
1078
1079	static struct demangle_component *
1080	d_encoding (struct d_info *di, int top_level)
1081	{
1082	char peek = d_peek_char (di);
1083
1084	if (peek == 'G' \|\| peek == 'T')
1085	return d_special_name (di);
1086	else
1087	{
1088	struct demangle_component *dc;
1089
1090	dc = d_name (di);
1091
1092	if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1093	{
1094	/* Strip off any initial CV-qualifiers, as they really apply
1095	to the `this' parameter, and they were not output by the
1096	v2 demangler without DMGL_PARAMS. */
1097	while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1098	\|\| dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1099	\|\| dc->type == DEMANGLE_COMPONENT_CONST_THIS)
1100	dc = d_left (dc);
1101
1102	/* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1103	there may be CV-qualifiers on its right argument which
1104	really apply here; this happens when parsing a class
1105	which is local to a function. */
1106	if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1107	{
1108	struct demangle_component *dcr;
1109
1110	dcr = d_right (dc);
1111	while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1112	\|\| dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1113	\|\| dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
1114	dcr = d_left (dcr);
1115	dc->u.s_binary.right = dcr;
1116	}
1117
1118	return dc;
1119	}
1120
1121	peek = d_peek_char (di);
1122	if (dc == NULL \|\| peek == '\0' \|\| peek == 'E')
1123	return dc;
1124	return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1125	d_bare_function_type (di, has_return_type (dc)));
1126	}
1127	}
1128
1129	/* <name> ::= <nested-name>
1130	::= <unscoped-name>
1131	::= <unscoped-template-name> <template-args>
1132	::= <local-name>
1133
1134	<unscoped-name> ::= <unqualified-name>
1135	::= St <unqualified-name>
1136
1137	<unscoped-template-name> ::= <unscoped-name>
1138	::= <substitution>
1139	*/
1140
1141	static struct demangle_component *
1142	d_name (struct d_info *di)
1143	{
1144	char peek = d_peek_char (di);
1145	struct demangle_component *dc;
1146
1147	switch (peek)
1148	{
1149	case 'N':
1150	return d_nested_name (di);
1151
1152	case 'Z':
1153	return d_local_name (di);
1154
1155	case 'L':
1156	return d_unqualified_name (di);
1157
1158	case 'S':
1159	{
1160	int subst;
1161
1162	if (d_peek_next_char (di) != 't')
1163	{
1164	dc = d_substitution (di, 0);
1165	subst = 1;
1166	}
1167	else
1168	{
1169	d_advance (di, 2);
1170	dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1171	d_make_name (di, "std", 3),
1172	d_unqualified_name (di));
1173	di->expansion += 3;
1174	subst = 0;
1175	}
1176
1177	if (d_peek_char (di) != 'I')
1178	{
1179	/* The grammar does not permit this case to occur if we
1180	called d_substitution() above (i.e., subst == 1). We
1181	don't bother to check. */
1182	}
1183	else
1184	{
1185	/* This is <template-args>, which means that we just saw
1186	<unscoped-template-name>, which is a substitution
1187	candidate if we didn't just get it from a
1188	substitution. */
1189	if (! subst)
1190	{
1191	if (! d_add_substitution (di, dc))
1192	return NULL;
1193	}
1194	dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1195	d_template_args (di));
1196	}
1197
1198	return dc;
1199	}
1200
1201	default:
1202	dc = d_unqualified_name (di);
1203	if (d_peek_char (di) == 'I')
1204	{
1205	/* This is <template-args>, which means that we just saw
1206	<unscoped-template-name>, which is a substitution
1207	candidate. */
1208	if (! d_add_substitution (di, dc))
1209	return NULL;
1210	dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1211	d_template_args (di));
1212	}
1213	return dc;
1214	}
1215	}
1216
1217	/* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1218	::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1219	*/
1220
1221	static struct demangle_component *
1222	d_nested_name (struct d_info *di)
1223	{
1224	struct demangle_component *ret;
1225	struct demangle_component **pret;
1226
1227	if (! d_check_char (di, 'N'))
1228	return NULL;
1229
1230	pret = d_cv_qualifiers (di, &ret, 1);
1231	if (pret == NULL)
1232	return NULL;
1233
1234	*pret = d_prefix (di);
1235	if (*pret == NULL)
1236	return NULL;
1237
1238	if (! d_check_char (di, 'E'))
1239	return NULL;
1240
1241	return ret;
1242	}
1243
1244	/* <prefix> ::= <prefix> <unqualified-name>
1245	::= <template-prefix> <template-args>
1246	::= <template-param>
1247	::=
1248	::= <substitution>
1249
1250	<template-prefix> ::= <prefix> <(template) unqualified-name>
1251	::= <template-param>
1252	::= <substitution>
1253	*/
1254
1255	static struct demangle_component *
1256	d_prefix (struct d_info *di)
1257	{
1258	struct demangle_component *ret = NULL;
1259
1260	while (1)
1261	{
1262	char peek;
1263	enum demangle_component_type comb_type;
1264	struct demangle_component *dc;
1265
1266	peek = d_peek_char (di);
1267	if (peek == '\0')
1268	return NULL;
1269
1270	/* The older code accepts a <local-name> here, but I don't see
1271	that in the grammar. The older code does not accept a
1272	<template-param> here. */
1273
1274	comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1275	if (IS_DIGIT (peek)
1276	\|\| IS_LOWER (peek)
1277	\|\| peek == 'C'
1278	\|\| peek == 'D'
1279	\|\| peek == 'L')
1280	dc = d_unqualified_name (di);
1281	else if (peek == 'S')
1282	dc = d_substitution (di, 1);
1283	else if (peek == 'I')
1284	{
1285	if (ret == NULL)
1286	return NULL;
1287	comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1288	dc = d_template_args (di);
1289	}
1290	else if (peek == 'T')
1291	dc = d_template_param (di);
1292	else if (peek == 'E')
1293	return ret;
1294	else
1295	return NULL;
1296
1297	if (ret == NULL)
1298	ret = dc;
1299	else
1300	ret = d_make_comp (di, comb_type, ret, dc);
1301
1302	if (peek != 'S' && d_peek_char (di) != 'E')
1303	{
1304	if (! d_add_substitution (di, ret))
1305	return NULL;
1306	}
1307	}
1308	}
1309
1310	/* <unqualified-name> ::= <operator-name>
1311	::= <ctor-dtor-name>
1312	::= <source-name>
1313	::= <local-source-name>
1314
1315	<local-source-name> ::= L <source-name> <discriminator>
1316	*/
1317
1318	static struct demangle_component *
1319	d_unqualified_name (struct d_info *di)
1320	{
1321	char peek;
1322
1323	peek = d_peek_char (di);
1324	if (IS_DIGIT (peek))
1325	return d_source_name (di);
1326	else if (IS_LOWER (peek))
1327	{
1328	struct demangle_component *ret;
1329
1330	ret = d_operator_name (di);
1331	if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1332	di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1333	return ret;
1334	}
1335	else if (peek == 'C' \|\| peek == 'D')
1336	return d_ctor_dtor_name (di);
1337	else if (peek == 'L')
1338	{
1339	struct demangle_component * ret;
1340
1341	d_advance (di, 1);
1342
1343	ret = d_source_name (di);
1344	if (ret == NULL)
1345	return NULL;
1346	if (! d_discriminator (di))
1347	return NULL;
1348	return ret;
1349	}
1350	else
1351	return NULL;
1352	}
1353
1354	/* <source-name> ::= <(positive length) number> <identifier> */
1355
1356	static struct demangle_component *
1357	d_source_name (struct d_info *di)
1358	{
1359	long len;
1360	struct demangle_component *ret;
1361
1362	len = d_number (di);
1363	if (len <= 0)
1364	return NULL;
1365	ret = d_identifier (di, len);
1366	di->last_name = ret;
1367	return ret;
1368	}
1369
1370	/* number ::= [n] <(non-negative decimal integer)> */
1371
1372	static long
1373	d_number (struct d_info *di)
1374	{
1375	int negative;
1376	char peek;
1377	long ret;
1378
1379	negative = 0;
1380	peek = d_peek_char (di);
1381	if (peek == 'n')
1382	{
1383	negative = 1;
1384	d_advance (di, 1);
1385	peek = d_peek_char (di);
1386	}
1387
1388	ret = 0;
1389	while (1)
1390	{
1391	if (! IS_DIGIT (peek))
1392	{
1393	if (negative)
1394	ret = - ret;
1395	return ret;
1396	}
1397	ret = ret * 10 + peek - '0';
1398	d_advance (di, 1);
1399	peek = d_peek_char (di);
1400	}
1401	}
1402
1403	/* identifier ::= <(unqualified source code identifier)> */
1404
1405	static struct demangle_component *
1406	d_identifier (struct d_info *di, int len)
1407	{
1408	const char *name;
1409
1410	name = d_str (di);
1411
1412	if (di->send - name < len)
1413	return NULL;
1414
1415	d_advance (di, len);
1416
1417	/* A Java mangled name may have a trailing '$' if it is a C++
1418	keyword. This '$' is not included in the length count. We just
1419	ignore the '$'. */
1420	if ((di->options & DMGL_JAVA) != 0
1421	&& d_peek_char (di) == '$')
1422	d_advance (di, 1);
1423
1424	/* Look for something which looks like a gcc encoding of an
1425	anonymous namespace, and replace it with a more user friendly
1426	name. */
1427	if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1428	&& memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1429	ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1430	{
1431	const char *s;
1432
1433	s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1434	if ((s == '.' \|\| s == '_' \|\| *s == '$')
1435	&& s[1] == 'N')
1436	{
1437	di->expansion -= len - sizeof "(anonymous namespace)";
1438	return d_make_name (di, "(anonymous namespace)",
1439	sizeof "(anonymous namespace)" - 1);
1440	}
1441	}
1442
1443	return d_make_name (di, name, len);
1444	}
1445
1446	/* operator_name ::= many different two character encodings.
1447	::= cv <type>
1448	::= v <digit> <source-name>
1449	*/
1450
1451	#define NL(s) s, (sizeof s) - 1
1452
1453	CP_STATIC_IF_GLIBCPP_V3
1454	const struct demangle_operator_info cplus_demangle_operators[] =
1455	{
1456	{ "aN", NL ("&="), 2 },
1457	{ "aS", NL ("="), 2 },
1458	{ "aa", NL ("&&"), 2 },
1459	{ "ad", NL ("&"), 1 },
1460	{ "an", NL ("&"), 2 },
1461	{ "cl", NL ("()"), 2 },
1462	{ "cm", NL (","), 2 },
1463	{ "co", NL ("~"), 1 },
1464	{ "dV", NL ("/="), 2 },
1465	{ "da", NL ("delete[]"), 1 },
1466	{ "de", NL ("*"), 1 },
1467	{ "dl", NL ("delete"), 1 },
1468	{ "dt", NL ("."), 2 },
1469	{ "dv", NL ("/"), 2 },
1470	{ "eO", NL ("^="), 2 },
1471	{ "eo", NL ("^"), 2 },
1472	{ "eq", NL ("=="), 2 },
1473	{ "ge", NL (">="), 2 },
1474	{ "gt", NL (">"), 2 },
1475	{ "ix", NL ("[]"), 2 },
1476	{ "lS", NL ("<<="), 2 },
1477	{ "le", NL ("<="), 2 },
1478	{ "ls", NL ("<<"), 2 },
1479	{ "lt", NL ("<"), 2 },
1480	{ "mI", NL ("-="), 2 },
1481	{ "mL", NL ("*="), 2 },
1482	{ "mi", NL ("-"), 2 },
1483	{ "ml", NL ("*"), 2 },
1484	{ "mm", NL ("--"), 1 },
1485	{ "na", NL ("new[]"), 1 },
1486	{ "ne", NL ("!="), 2 },
1487	{ "ng", NL ("-"), 1 },
1488	{ "nt", NL ("!"), 1 },
1489	{ "nw", NL ("new"), 1 },
1490	{ "oR", NL ("\|="), 2 },
1491	{ "oo", NL ("\|\|"), 2 },
1492	{ "or", NL ("\|"), 2 },
1493	{ "pL", NL ("+="), 2 },
1494	{ "pl", NL ("+"), 2 },
1495	{ "pm", NL ("->*"), 2 },
1496	{ "pp", NL ("++"), 1 },
1497	{ "ps", NL ("+"), 1 },
1498	{ "pt", NL ("->"), 2 },
1499	{ "qu", NL ("?"), 3 },
1500	{ "rM", NL ("%="), 2 },
1501	{ "rS", NL (">>="), 2 },
1502	{ "rm", NL ("%"), 2 },
1503	{ "rs", NL (">>"), 2 },
1504	{ "st", NL ("sizeof "), 1 },
1505	{ "sz", NL ("sizeof "), 1 },
1506	{ "at", NL ("alignof "), 1 },
1507	{ "az", NL ("alignof "), 1 },
1508	{ NULL, NULL, 0, 0 }
1509	};
1510
1511	static struct demangle_component *
1512	d_operator_name (struct d_info *di)
1513	{
1514	char c1;
1515	char c2;
1516
1517	c1 = d_next_char (di);
1518	c2 = d_next_char (di);
1519	if (c1 == 'v' && IS_DIGIT (c2))
1520	return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1521	else if (c1 == 'c' && c2 == 'v')
1522	return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
1523	cplus_demangle_type (di), NULL);
1524	else
1525	{
1526	/* LOW is the inclusive lower bound. */
1527	int low = 0;
1528	/* HIGH is the exclusive upper bound. We subtract one to ignore
1529	the sentinel at the end of the array. */
1530	int high = ((sizeof (cplus_demangle_operators)
1531	/ sizeof (cplus_demangle_operators[0]))
1532	- 1);
1533
1534	while (1)
1535	{
1536	int i;
1537	const struct demangle_operator_info *p;
1538
1539	i = low + (high - low) / 2;
1540	p = cplus_demangle_operators + i;
1541
1542	if (c1 == p->code[0] && c2 == p->code[1])
1543	return d_make_operator (di, p);
1544
1545	if (c1 < p->code[0] \|\| (c1 == p->code[0] && c2 < p->code[1]))
1546	high = i;
1547	else
1548	low = i + 1;
1549	if (low == high)
1550	return NULL;
1551	}
1552	}
1553	}
1554
1555	static struct demangle_component *
1556	d_make_character (struct d_info *di, int c)
1557	{
1558	struct demangle_component *p;
1559	p = d_make_empty (di);
1560	if (p != NULL)
1561	{
1562	p->type = DEMANGLE_COMPONENT_CHARACTER;
1563	p->u.s_character.character = c;
1564	}
1565	return p;
1566	}
1567
1568	static struct demangle_component *
1569	d_java_resource (struct d_info *di)
1570	{
1571	struct demangle_component *p = NULL;
1572	struct demangle_component *next = NULL;
1573	long len, i;
1574	char c;
1575	const char *str;
1576
1577	len = d_number (di);
1578	if (len <= 1)
1579	return NULL;
1580
1581	/* Eat the leading '_'. */
1582	if (d_next_char (di) != '_')
1583	return NULL;
1584	len--;
1585
1586	str = d_str (di);
1587	i = 0;
1588
1589	while (len > 0)
1590	{
1591	c = str[i];
1592	if (!c)
1593	return NULL;
1594
1595	/* Each chunk is either a '$' escape... */
1596	if (c == '$')
1597	{
1598	i++;
1599	switch (str[i++])
1600	{
1601	case 'S':
1602	c = '/';
1603	break;
1604	case '_':
1605	c = '.';
1606	break;
1607	case '$':
1608	c = '$';
1609	break;
1610	default:
1611	return NULL;
1612	}
1613	next = d_make_character (di, c);
1614	d_advance (di, i);
1615	str = d_str (di);
1616	len -= i;
1617	i = 0;
1618	if (next == NULL)
1619	return NULL;
1620	}
1621	/* ... or a sequence of characters. */
1622	else
1623	{
1624	while (i < len && str[i] && str[i] != '$')
1625	i++;
1626
1627	next = d_make_name (di, str, i);
1628	d_advance (di, i);
1629	str = d_str (di);
1630	len -= i;
1631	i = 0;
1632	if (next == NULL)
1633	return NULL;
1634	}
1635
1636	if (p == NULL)
1637	p = next;
1638	else
1639	{
1640	p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
1641	if (p == NULL)
1642	return NULL;
1643	}
1644	}
1645
1646	p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
1647
1648	return p;
1649	}
1650
1651	/* <special-name> ::= TV <type>
1652	::= TT <type>
1653	::= TI <type>
1654	::= TS <type>
1655	::= GV <(object) name>
1656	::= T <call-offset> <(base) encoding>
1657	::= Tc <call-offset> <call-offset> <(base) encoding>
1658	Also g++ extensions:
1659	::= TC <type> <(offset) number> _ <(base) type>
1660	::= TF <type>
1661	::= TJ <type>
1662	::= GR <name>
1663	::= GA <encoding>
1664	::= Gr <resource name>
1665	*/
1666
1667	static struct demangle_component *
1668	d_special_name (struct d_info *di)
1669	{
1670	di->expansion += 20;
1671	if (d_check_char (di, 'T'))
1672	{
1673	switch (d_next_char (di))
1674	{
1675	case 'V':
1676	di->expansion -= 5;
1677	return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1678	cplus_demangle_type (di), NULL);
1679	case 'T':
1680	di->expansion -= 10;
1681	return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1682	cplus_demangle_type (di), NULL);
1683	case 'I':
1684	return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1685	cplus_demangle_type (di), NULL);
1686	case 'S':
1687	return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1688	cplus_demangle_type (di), NULL);
1689
1690	case 'h':
1691	if (! d_call_offset (di, 'h'))
1692	return NULL;
1693	return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1694	d_encoding (di, 0), NULL);
1695
1696	case 'v':
1697	if (! d_call_offset (di, 'v'))
1698	return NULL;
1699	return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1700	d_encoding (di, 0), NULL);
1701
1702	case 'c':
1703	if (! d_call_offset (di, '\0'))
1704	return NULL;
1705	if (! d_call_offset (di, '\0'))
1706	return NULL;
1707	return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1708	d_encoding (di, 0), NULL);
1709
1710	case 'C':
1711	{
1712	struct demangle_component *derived_type;
1713	long offset;
1714	struct demangle_component *base_type;
1715
1716	derived_type = cplus_demangle_type (di);
1717	offset = d_number (di);
1718	if (offset < 0)
1719	return NULL;
1720	if (! d_check_char (di, '_'))
1721	return NULL;
1722	base_type = cplus_demangle_type (di);
1723	/* We don't display the offset. FIXME: We should display
1724	it in verbose mode. */
1725	di->expansion += 5;
1726	return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1727	base_type, derived_type);
1728	}
1729
1730	case 'F':
1731	return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
1732	cplus_demangle_type (di), NULL);
1733	case 'J':
1734	return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
1735	cplus_demangle_type (di), NULL);
1736
1737	default:
1738	return NULL;
1739	}
1740	}
1741	else if (d_check_char (di, 'G'))
1742	{
1743	switch (d_next_char (di))
1744	{
1745	case 'V':
1746	return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
1747
1748	case 'R':
1749	return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
1750	NULL);
1751
1752	case 'A':
1753	return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
1754	d_encoding (di, 0), NULL);
1755
1756	case 'r':
1757	return d_java_resource (di);
1758
1759	default:
1760	return NULL;
1761	}
1762	}
1763	else
1764	return NULL;
1765	}
1766
1767	/* <call-offset> ::= h <nv-offset> _
1768	::= v <v-offset> _
1769
1770	<nv-offset> ::= <(offset) number>
1771
1772	<v-offset> ::= <(offset) number> _ <(virtual offset) number>
1773
1774	The C parameter, if not '\0', is a character we just read which is
1775	the start of the <call-offset>.
1776
1777	We don't display the offset information anywhere. FIXME: We should
1778	display it in verbose mode. */
1779
1780	static int
1781	d_call_offset (struct d_info *di, int c)
1782	{
1783	if (c == '\0')
1784	c = d_next_char (di);
1785
1786	if (c == 'h')
1787	d_number (di);
1788	else if (c == 'v')
1789	{
1790	d_number (di);
1791	if (! d_check_char (di, '_'))
1792	return 0;
1793	d_number (di);
1794	}
1795	else
1796	return 0;
1797
1798	if (! d_check_char (di, '_'))
1799	return 0;
1800
1801	return 1;
1802	}
1803
1804	/* <ctor-dtor-name> ::= C1
1805	::= C2
1806	::= C3
1807	::= D0
1808	::= D1
1809	::= D2
1810	*/
1811
1812	static struct demangle_component *
1813	d_ctor_dtor_name (struct d_info *di)
1814	{
1815	if (di->last_name != NULL)
1816	{
1817	if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
1818	di->expansion += di->last_name->u.s_name.len;
1819	else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
1820	di->expansion += di->last_name->u.s_string.len;
1821	}
1822	switch (d_peek_char (di))
1823	{
1824	case 'C':
1825	{
1826	enum gnu_v3_ctor_kinds kind;
1827
1828	switch (d_peek_next_char (di))
1829	{
1830	case '1':
1831	kind = gnu_v3_complete_object_ctor;
1832	break;
1833	case '2':
1834	kind = gnu_v3_base_object_ctor;
1835	break;
1836	case '3':
1837	kind = gnu_v3_complete_object_allocating_ctor;
1838	break;
1839	default:
1840	return NULL;
1841	}
1842	d_advance (di, 2);
1843	return d_make_ctor (di, kind, di->last_name);
1844	}
1845
1846	case 'D':
1847	{
1848	enum gnu_v3_dtor_kinds kind;
1849
1850	switch (d_peek_next_char (di))
1851	{
1852	case '0':
1853	kind = gnu_v3_deleting_dtor;
1854	break;
1855	case '1':
1856	kind = gnu_v3_complete_object_dtor;
1857	break;
1858	case '2':
1859	kind = gnu_v3_base_object_dtor;
1860	break;
1861	default:
1862	return NULL;
1863	}
1864	d_advance (di, 2);
1865	return d_make_dtor (di, kind, di->last_name);
1866	}
1867
1868	default:
1869	return NULL;
1870	}
1871	}
1872
1873	/* <type> ::= <builtin-type>
1874	::= <function-type>
1875	::= <class-enum-type>
1876	::= <array-type>
1877	::= <pointer-to-member-type>
1878	::= <template-param>
1879	::= <template-template-param> <template-args>
1880	::= <substitution>
1881	::= <CV-qualifiers> <type>
1882	::= P <type>
1883	::= R <type>
1884	::= O <type> (C++0x)
1885	::= C <type>
1886	::= G <type>
1887	::= U <source-name> <type>
1888
1889	<builtin-type> ::= various one letter codes
1890	::= u <source-name>
1891	*/
1892
1893	CP_STATIC_IF_GLIBCPP_V3
1894	const struct demangle_builtin_type_info
1895	cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
1896	{
1897	/* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
1898	/* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
1899	/* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
1900	/* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
1901	/* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
1902	/* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
1903	/* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
1904	/* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
1905	/* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
1906	/* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
1907	/* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1908	/* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
1909	/* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
1910	/* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
1911	/* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
1912	D_PRINT_DEFAULT },
1913	/* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1914	/* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1915	/* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1916	/* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
1917	/* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
1918	/* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1919	/* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
1920	/* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
1921	/* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
1922	/* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
1923	D_PRINT_UNSIGNED_LONG_LONG },
1924	/* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
1925	/* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
1926	/* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
1927	/* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
1928	/* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
1929	/* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
1930	/* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
1931	};
1932
1933	CP_STATIC_IF_GLIBCPP_V3
1934	struct demangle_component *
1935	cplus_demangle_type (struct d_info *di)
1936	{
1937	char peek;
1938	struct demangle_component *ret;
1939	int can_subst;
1940
1941	/* The ABI specifies that when CV-qualifiers are used, the base type
1942	is substitutable, and the fully qualified type is substitutable,
1943	but the base type with a strict subset of the CV-qualifiers is
1944	not substitutable. The natural recursive implementation of the
1945	CV-qualifiers would cause subsets to be substitutable, so instead
1946	we pull them all off now.
1947
1948	FIXME: The ABI says that order-insensitive vendor qualifiers
1949	should be handled in the same way, but we have no way to tell
1950	which vendor qualifiers are order-insensitive and which are
1951	order-sensitive. So we just assume that they are all
1952	order-sensitive. g++ 3.4 supports only one vendor qualifier,
1953	__vector, and it treats it as order-sensitive when mangling
1954	names. */
1955
1956	peek = d_peek_char (di);
1957	if (peek == 'r' \|\| peek == 'V' \|\| peek == 'K')
1958	{
1959	struct demangle_component **pret;
1960
1961	pret = d_cv_qualifiers (di, &ret, 0);
1962	if (pret == NULL)
1963	return NULL;
1964	*pret = cplus_demangle_type (di);
1965	if (! *pret \|\| ! d_add_substitution (di, ret))
1966	return NULL;
1967	return ret;
1968	}
1969
1970	can_subst = 1;
1971
1972	switch (peek)
1973	{
1974	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1975	case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
1976	case 'o': case 's': case 't':
1977	case 'v': case 'w': case 'x': case 'y': case 'z':
1978	ret = d_make_builtin_type (di,
1979	&cplus_demangle_builtin_types[peek - 'a']);
1980	di->expansion += ret->u.s_builtin.type->len;
1981	can_subst = 0;
1982	d_advance (di, 1);
1983	break;
1984
1985	case 'u':
1986	d_advance (di, 1);
1987	ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
1988	d_source_name (di), NULL);
1989	break;
1990
1991	case 'F':
1992	ret = d_function_type (di);
1993	break;
1994
1995	case '0': case '1': case '2': case '3': case '4':
1996	case '5': case '6': case '7': case '8': case '9':
1997	case 'N':
1998	case 'Z':
1999	ret = d_class_enum_type (di);
2000	break;
2001
2002	case 'A':
2003	ret = d_array_type (di);
2004	break;
2005
2006	case 'M':
2007	ret = d_pointer_to_member_type (di);
2008	break;
2009
2010	case 'T':
2011	ret = d_template_param (di);
2012	if (d_peek_char (di) == 'I')
2013	{
2014	/* This is <template-template-param> <template-args>. The
2015	<template-template-param> part is a substitution
2016	candidate. */
2017	if (! d_add_substitution (di, ret))
2018	return NULL;
2019	ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2020	d_template_args (di));
2021	}
2022	break;
2023
2024	case 'S':
2025	/* If this is a special substitution, then it is the start of
2026	<class-enum-type>. */
2027	{
2028	char peek_next;
2029
2030	peek_next = d_peek_next_char (di);
2031	if (IS_DIGIT (peek_next)
2032	\|\| peek_next == '_'
2033	\|\| IS_UPPER (peek_next))
2034	{
2035	ret = d_substitution (di, 0);
2036	/* The substituted name may have been a template name and
2037	may be followed by tepmlate args. */
2038	if (d_peek_char (di) == 'I')
2039	ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2040	d_template_args (di));
2041	else
2042	can_subst = 0;
2043	}
2044	else
2045	{
2046	ret = d_class_enum_type (di);
2047	/* If the substitution was a complete type, then it is not
2048	a new substitution candidate. However, if the
2049	substitution was followed by template arguments, then
2050	the whole thing is a substitution candidate. */
2051	if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2052	can_subst = 0;
2053	}
2054	}
2055	break;
2056
2057	case 'O':
2058	d_advance (di, 1);
2059	ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2060	cplus_demangle_type (di), NULL);
2061	break;
2062
2063	case 'P':
2064	d_advance (di, 1);
2065	ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2066	cplus_demangle_type (di), NULL);
2067	break;
2068
2069	case 'R':
2070	d_advance (di, 1);
2071	ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2072	cplus_demangle_type (di), NULL);
2073	break;
2074
2075	case 'C':
2076	d_advance (di, 1);
2077	ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2078	cplus_demangle_type (di), NULL);
2079	break;
2080
2081	case 'G':
2082	d_advance (di, 1);
2083	ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2084	cplus_demangle_type (di), NULL);
2085	break;
2086
2087	case 'U':
2088	d_advance (di, 1);
2089	ret = d_source_name (di);
2090	ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2091	cplus_demangle_type (di), ret);
2092	break;
2093
2094	case 'D':
2095	can_subst = 0;
2096	d_advance (di, 1);
2097	peek = d_next_char (di);
2098	switch (peek)
2099	{
2100	case 'T':
2101	case 't':
2102	/* decltype (expression) */
2103	ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2104	d_expression (di), NULL);
2105	if (ret && d_next_char (di) != 'E')
2106	ret = NULL;
2107	break;
2108
2109	case 'p':
2110	/* Pack expansion. */
2111	ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2112	cplus_demangle_type (di), NULL);
2113	break;
2114
2115	case 'f':
2116	/* 32-bit decimal floating point */
2117	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2118	di->expansion += ret->u.s_builtin.type->len;
2119	break;
2120	case 'd':
2121	/* 64-bit DFP */
2122	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2123	di->expansion += ret->u.s_builtin.type->len;
2124	break;
2125	case 'e':
2126	/* 128-bit DFP */
2127	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2128	di->expansion += ret->u.s_builtin.type->len;
2129	break;
2130	case 'h':
2131	/* 16-bit half-precision FP */
2132	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2133	di->expansion += ret->u.s_builtin.type->len;
2134	break;
2135	case 's':
2136	/* char16_t */
2137	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2138	di->expansion += ret->u.s_builtin.type->len;
2139	break;
2140	case 'i':
2141	/* char32_t */
2142	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2143	di->expansion += ret->u.s_builtin.type->len;
2144	break;
2145
2146	case 'F':
2147	/* Fixed point types. DF<int bits><length><fract bits><sat> */
2148	ret = d_make_empty (di);
2149	ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2150	if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2151	/* For demangling we don't care about the bits. */
2152	d_number (di);
2153	ret->u.s_fixed.length = cplus_demangle_type (di);
2154	d_number (di);
2155	peek = d_next_char (di);
2156	ret->u.s_fixed.sat = (peek == 's');
2157	break;
2158
2159	default:
2160	return NULL;
2161	}
2162	break;
2163
2164	default:
2165	return NULL;
2166	}
2167
2168	if (can_subst)
2169	{
2170	if (! d_add_substitution (di, ret))
2171	return NULL;
2172	}
2173
2174	return ret;
2175	}
2176
2177	/* <CV-qualifiers> ::= [r] [V] [K] */
2178
2179	static struct demangle_component **
2180	d_cv_qualifiers (struct d_info *di,
2181	struct demangle_component **pret, int member_fn)
2182	{
2183	char peek;
2184
2185	peek = d_peek_char (di);
2186	while (peek == 'r' \|\| peek == 'V' \|\| peek == 'K')
2187	{
2188	enum demangle_component_type t;
2189
2190	d_advance (di, 1);
2191	if (peek == 'r')
2192	{
2193	t = (member_fn
2194	? DEMANGLE_COMPONENT_RESTRICT_THIS
2195	: DEMANGLE_COMPONENT_RESTRICT);
2196	di->expansion += sizeof "restrict";
2197	}
2198	else if (peek == 'V')
2199	{
2200	t = (member_fn
2201	? DEMANGLE_COMPONENT_VOLATILE_THIS
2202	: DEMANGLE_COMPONENT_VOLATILE);
2203	di->expansion += sizeof "volatile";
2204	}
2205	else
2206	{
2207	t = (member_fn
2208	? DEMANGLE_COMPONENT_CONST_THIS
2209	: DEMANGLE_COMPONENT_CONST);
2210	di->expansion += sizeof "const";
2211	}
2212
2213	*pret = d_make_comp (di, t, NULL, NULL);
2214	if (*pret == NULL)
2215	return NULL;
2216	pret = &d_left (*pret);
2217
2218	peek = d_peek_char (di);
2219	}
2220
2221	return pret;
2222	}
2223
2224	/* <function-type> ::= F [Y] <bare-function-type> E */
2225
2226	static struct demangle_component *
2227	d_function_type (struct d_info *di)
2228	{
2229	struct demangle_component *ret;
2230
2231	if (! d_check_char (di, 'F'))
2232	return NULL;
2233	if (d_peek_char (di) == 'Y')
2234	{
2235	/* Function has C linkage. We don't print this information.
2236	FIXME: We should print it in verbose mode. */
2237	d_advance (di, 1);
2238	}
2239	ret = d_bare_function_type (di, 1);
2240	if (! d_check_char (di, 'E'))
2241	return NULL;
2242	return ret;
2243	}
2244
2245	/* <bare-function-type> ::= [J]<type>+ */
2246
2247	static struct demangle_component *
2248	d_bare_function_type (struct d_info *di, int has_return_type)
2249	{
2250	struct demangle_component *return_type;
2251	struct demangle_component *tl;
2252	struct demangle_component **ptl;
2253	char peek;
2254
2255	/* Detect special qualifier indicating that the first argument
2256	is the return type. */
2257	peek = d_peek_char (di);
2258	if (peek == 'J')
2259	{
2260	d_advance (di, 1);
2261	has_return_type = 1;
2262	}
2263
2264	return_type = NULL;
2265	tl = NULL;
2266	ptl = &tl;
2267	while (1)
2268	{
2269	struct demangle_component *type;
2270
2271	peek = d_peek_char (di);
2272	if (peek == '\0' \|\| peek == 'E')
2273	break;
2274	type = cplus_demangle_type (di);
2275	if (type == NULL)
2276	return NULL;
2277	if (has_return_type)
2278	{
2279	return_type = type;
2280	has_return_type = 0;
2281	}
2282	else
2283	{
2284	*ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2285	if (*ptl == NULL)
2286	return NULL;
2287	ptl = &d_right (*ptl);
2288	}
2289	}
2290
2291	/* There should be at least one parameter type besides the optional
2292	return type. A function which takes no arguments will have a
2293	single parameter type void. */
2294	if (tl == NULL)
2295	return NULL;
2296
2297	/* If we have a single parameter type void, omit it. */
2298	if (d_right (tl) == NULL
2299	&& d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2300	&& d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2301	{
2302	di->expansion -= d_left (tl)->u.s_builtin.type->len;
2303	tl = NULL;
2304	}
2305
2306	return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
2307	}
2308
2309	/* <class-enum-type> ::= <name> */
2310
2311	static struct demangle_component *
2312	d_class_enum_type (struct d_info *di)
2313	{
2314	return d_name (di);
2315	}
2316
2317	/* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2318	::= A [<(dimension) expression>] _ <(element) type>
2319	*/
2320
2321	static struct demangle_component *
2322	d_array_type (struct d_info *di)
2323	{
2324	char peek;
2325	struct demangle_component *dim;
2326
2327	if (! d_check_char (di, 'A'))
2328	return NULL;
2329
2330	peek = d_peek_char (di);
2331	if (peek == '_')
2332	dim = NULL;
2333	else if (IS_DIGIT (peek))
2334	{
2335	const char *s;
2336
2337	s = d_str (di);
2338	do
2339	{
2340	d_advance (di, 1);
2341	peek = d_peek_char (di);
2342	}
2343	while (IS_DIGIT (peek));
2344	dim = d_make_name (di, s, d_str (di) - s);
2345	if (dim == NULL)
2346	return NULL;
2347	}
2348	else
2349	{
2350	dim = d_expression (di);
2351	if (dim == NULL)
2352	return NULL;
2353	}
2354
2355	if (! d_check_char (di, '_'))
2356	return NULL;
2357
2358	return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2359	cplus_demangle_type (di));
2360	}
2361
2362	/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2363
2364	static struct demangle_component *
2365	d_pointer_to_member_type (struct d_info *di)
2366	{
2367	struct demangle_component *cl;
2368	struct demangle_component *mem;
2369	struct demangle_component **pmem;
2370
2371	if (! d_check_char (di, 'M'))
2372	return NULL;
2373
2374	cl = cplus_demangle_type (di);
2375
2376	/* The ABI specifies that any type can be a substitution source, and
2377	that M is followed by two types, and that when a CV-qualified
2378	type is seen both the base type and the CV-qualified types are
2379	substitution sources. The ABI also specifies that for a pointer
2380	to a CV-qualified member function, the qualifiers are attached to
2381	the second type. Given the grammar, a plain reading of the ABI
2382	suggests that both the CV-qualified member function and the
2383	non-qualified member function are substitution sources. However,
2384	g++ does not work that way. g++ treats only the CV-qualified
2385	member function as a substitution source. FIXME. So to work
2386	with g++, we need to pull off the CV-qualifiers here, in order to
2387	avoid calling add_substitution() in cplus_demangle_type(). But
2388	for a CV-qualified member which is not a function, g++ does
2389	follow the ABI, so we need to handle that case here by calling
2390	d_add_substitution ourselves. */
2391
2392	pmem = d_cv_qualifiers (di, &mem, 1);
2393	if (pmem == NULL)
2394	return NULL;
2395	*pmem = cplus_demangle_type (di);
2396	if (*pmem == NULL)
2397	return NULL;
2398
2399	if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
2400	{
2401	if (! d_add_substitution (di, mem))
2402	return NULL;
2403	}
2404
2405	return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2406	}
2407
2408	/* <template-param> ::= T_
2409	::= T <(parameter-2 non-negative) number> _
2410	*/
2411
2412	static struct demangle_component *
2413	d_template_param (struct d_info *di)
2414	{
2415	long param;
2416
2417	if (! d_check_char (di, 'T'))
2418	return NULL;
2419
2420	if (d_peek_char (di) == '_')
2421	param = 0;
2422	else
2423	{
2424	param = d_number (di);
2425	if (param < 0)
2426	return NULL;
2427	param += 1;
2428	}
2429
2430	if (! d_check_char (di, '_'))
2431	return NULL;
2432
2433	++di->did_subs;
2434
2435	return d_make_template_param (di, param);
2436	}
2437
2438	/* <template-args> ::= I <template-arg>+ E */
2439
2440	static struct demangle_component *
2441	d_template_args (struct d_info *di)
2442	{
2443	struct demangle_component *hold_last_name;
2444	struct demangle_component *al;
2445	struct demangle_component **pal;
2446
2447	/* Preserve the last name we saw--don't let the template arguments
2448	clobber it, as that would give us the wrong name for a subsequent
2449	constructor or destructor. */
2450	hold_last_name = di->last_name;
2451
2452	if (! d_check_char (di, 'I'))
2453	return NULL;
2454
2455	if (d_peek_char (di) == 'E')
2456	{
2457	/* An argument pack can be empty. */
2458	d_advance (di, 1);
2459	return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2460	}
2461
2462	al = NULL;
2463	pal = &al;
2464	while (1)
2465	{
2466	struct demangle_component *a;
2467
2468	a = d_template_arg (di);
2469	if (a == NULL)
2470	return NULL;
2471
2472	*pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2473	if (*pal == NULL)
2474	return NULL;
2475	pal = &d_right (*pal);
2476
2477	if (d_peek_char (di) == 'E')
2478	{
2479	d_advance (di, 1);
2480	break;
2481	}
2482	}
2483
2484	di->last_name = hold_last_name;
2485
2486	return al;
2487	}
2488
2489	/* <template-arg> ::= <type>
2490	::= X <expression> E
2491	::= <expr-primary>
2492	*/
2493
2494	static struct demangle_component *
2495	d_template_arg (struct d_info *di)
2496	{
2497	struct demangle_component *ret;
2498
2499	switch (d_peek_char (di))
2500	{
2501	case 'X':
2502	d_advance (di, 1);
2503	ret = d_expression (di);
2504	if (! d_check_char (di, 'E'))
2505	return NULL;
2506	return ret;
2507
2508	case 'L':
2509	return d_expr_primary (di);
2510
2511	case 'I':
2512	/* An argument pack. */
2513	return d_template_args (di);
2514
2515	default:
2516	return cplus_demangle_type (di);
2517	}
2518	}
2519
2520	/* Subroutine of <expression> ::= cl <expression>+ E */
2521
2522	static struct demangle_component *
2523	d_exprlist (struct d_info *di)
2524	{
2525	struct demangle_component *list = NULL;
2526	struct demangle_component **p = &list;
2527
2528	if (d_peek_char (di) == 'E')
2529	{
2530	d_advance (di, 1);
2531	return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
2532	}
2533
2534	while (1)
2535	{
2536	struct demangle_component *arg = d_expression (di);
2537	if (arg == NULL)
2538	return NULL;
2539
2540	*p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
2541	if (*p == NULL)
2542	return NULL;
2543	p = &d_right (*p);
2544
2545	if (d_peek_char (di) == 'E')
2546	{
2547	d_advance (di, 1);
2548	break;
2549	}
2550	}
2551
2552	return list;
2553	}
2554
2555	/* <expression> ::= <(unary) operator-name> <expression>
2556	::= <(binary) operator-name> <expression> <expression>
2557	::= <(trinary) operator-name> <expression> <expression> <expression>
2558	::= cl <expression>+ E
2559	::= st <type>
2560	::= <template-param>
2561	::= sr <type> <unqualified-name>
2562	::= sr <type> <unqualified-name> <template-args>
2563	::= <expr-primary>
2564	*/
2565
2566	static struct demangle_component *
2567	d_expression (struct d_info *di)
2568	{
2569	char peek;
2570
2571	peek = d_peek_char (di);
2572	if (peek == 'L')
2573	return d_expr_primary (di);
2574	else if (peek == 'T')
2575	return d_template_param (di);
2576	else if (peek == 's' && d_peek_next_char (di) == 'r')
2577	{
2578	struct demangle_component *type;
2579	struct demangle_component *name;
2580
2581	d_advance (di, 2);
2582	type = cplus_demangle_type (di);
2583	name = d_unqualified_name (di);
2584	if (d_peek_char (di) != 'I')
2585	return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2586	else
2587	return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2588	d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2589	d_template_args (di)));
2590	}
2591	else if (peek == 's' && d_peek_next_char (di) == 'p')
2592	{
2593	d_advance (di, 2);
2594	return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2595	d_expression (di), NULL);
2596	}
2597	else if (peek == 'f' && d_peek_next_char (di) == 'p')
2598	{
2599	/* Function parameter used in a late-specified return type. */
2600	int index;
2601	d_advance (di, 2);
2602	if (d_peek_char (di) == '_')
2603	index = 1;
2604	else
2605	{
2606	index = d_number (di);
2607	if (index < 0)
2608	return NULL;
2609	index += 2;
2610	}
2611
2612	if (! d_check_char (di, '_'))
2613	return NULL;
2614
2615	return d_make_function_param (di, index);
2616	}
2617	else if (IS_DIGIT (peek))
2618	{
2619	/* We can get an unqualified name as an expression in the case of
2620	a dependent member access, i.e. decltype(T().i). */
2621	struct demangle_component *name = d_unqualified_name (di);
2622	if (name == NULL)
2623	return NULL;
2624	if (d_peek_char (di) == 'I')
2625	return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2626	d_template_args (di));
2627	else
2628	return name;
2629	}
2630	else
2631	{
2632	struct demangle_component *op;
2633	int args;
2634
2635	op = d_operator_name (di);
2636	if (op == NULL)
2637	return NULL;
2638
2639	if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2640	di->expansion += op->u.s_operator.op->len - 2;
2641
2642	if (op->type == DEMANGLE_COMPONENT_OPERATOR
2643	&& strcmp (op->u.s_operator.op->code, "st") == 0)
2644	return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2645	cplus_demangle_type (di));
2646
2647	switch (op->type)
2648	{
2649	default:
2650	return NULL;
2651	case DEMANGLE_COMPONENT_OPERATOR:
2652	args = op->u.s_operator.op->args;
2653	break;
2654	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2655	args = op->u.s_extended_operator.args;
2656	break;
2657	case DEMANGLE_COMPONENT_CAST:
2658	args = 1;
2659	break;
2660	}
2661
2662	switch (args)
2663	{
2664	case 1:
2665	{
2666	struct demangle_component *operand;
2667	if (op->type == DEMANGLE_COMPONENT_CAST
2668	&& d_check_char (di, '_'))
2669	operand = d_exprlist (di);
2670	else
2671	operand = d_expression (di);
2672	return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2673	operand);
2674	}
2675	case 2:
2676	{
2677	struct demangle_component *left;
2678	struct demangle_component *right;
2679
2680	left = d_expression (di);
2681	if (!strcmp (op->u.s_operator.op->code, "cl"))
2682	right = d_exprlist (di);
2683	else
2684	right = d_expression (di);
2685
2686	return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2687	d_make_comp (di,
2688	DEMANGLE_COMPONENT_BINARY_ARGS,
2689	left, right));
2690	}
2691	case 3:
2692	{
2693	struct demangle_component *first;
2694	struct demangle_component *second;
2695
2696	first = d_expression (di);
2697	second = d_expression (di);
2698	return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2699	d_make_comp (di,
2700	DEMANGLE_COMPONENT_TRINARY_ARG1,
2701	first,
2702	d_make_comp (di,
2703	DEMANGLE_COMPONENT_TRINARY_ARG2,
2704	second,
2705	d_expression (di))));
2706	}
2707	default:
2708	return NULL;
2709	}
2710	}
2711	}
2712
2713	/* <expr-primary> ::= L <type> <(value) number> E
2714	::= L <type> <(value) float> E
2715	::= L <mangled-name> E
2716	*/
2717
2718	static struct demangle_component *
2719	d_expr_primary (struct d_info *di)
2720	{
2721	struct demangle_component *ret;
2722
2723	if (! d_check_char (di, 'L'))
2724	return NULL;
2725	if (d_peek_char (di) == '_'
2726	/* Workaround for G++ bug; see comment in write_template_arg. */
2727	\|\| d_peek_char (di) == 'Z')
2728	ret = cplus_demangle_mangled_name (di, 0);
2729	else
2730	{
2731	struct demangle_component *type;
2732	enum demangle_component_type t;
2733	const char *s;
2734
2735	type = cplus_demangle_type (di);
2736	if (type == NULL)
2737	return NULL;
2738
2739	/* If we have a type we know how to print, we aren't going to
2740	print the type name itself. */
2741	if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2742	&& type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2743	di->expansion -= type->u.s_builtin.type->len;
2744
2745	/* Rather than try to interpret the literal value, we just
2746	collect it as a string. Note that it's possible to have a
2747	floating point literal here. The ABI specifies that the
2748	format of such literals is machine independent. That's fine,
2749	but what's not fine is that versions of g++ up to 3.2 with
2750	-fabi-version=1 used upper case letters in the hex constant,
2751	and dumped out gcc's internal representation. That makes it
2752	hard to tell where the constant ends, and hard to dump the
2753	constant in any readable form anyhow. We don't attempt to
2754	handle these cases. */
2755
2756	t = DEMANGLE_COMPONENT_LITERAL;
2757	if (d_peek_char (di) == 'n')
2758	{
2759	t = DEMANGLE_COMPONENT_LITERAL_NEG;
2760	d_advance (di, 1);
2761	}
2762	s = d_str (di);
2763	while (d_peek_char (di) != 'E')
2764	{
2765	if (d_peek_char (di) == '\0')
2766	return NULL;
2767	d_advance (di, 1);
2768	}
2769	ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2770	}
2771	if (! d_check_char (di, 'E'))
2772	return NULL;
2773	return ret;
2774	}
2775
2776	/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2777	::= Z <(function) encoding> E s [<discriminator>]
2778	*/
2779
2780	static struct demangle_component *
2781	d_local_name (struct d_info *di)
2782	{
2783	struct demangle_component *function;
2784
2785	if (! d_check_char (di, 'Z'))
2786	return NULL;
2787
2788	function = d_encoding (di, 0);
2789
2790	if (! d_check_char (di, 'E'))
2791	return NULL;
2792
2793	if (d_peek_char (di) == 's')
2794	{
2795	d_advance (di, 1);
2796	if (! d_discriminator (di))
2797	return NULL;
2798	return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2799	d_make_name (di, "string literal",
2800	sizeof "string literal" - 1));
2801	}
2802	else
2803	{
2804	struct demangle_component *name;
2805
2806	name = d_name (di);
2807	if (! d_discriminator (di))
2808	return NULL;
2809	return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2810	}
2811	}
2812
2813	/* <discriminator> ::= _ <(non-negative) number>
2814
2815	We demangle the discriminator, but we don't print it out. FIXME:
2816	We should print it out in verbose mode. */
2817
2818	static int
2819	d_discriminator (struct d_info *di)
2820	{
2821	long discrim;
2822
2823	if (d_peek_char (di) != '_')
2824	return 1;
2825	d_advance (di, 1);
2826	discrim = d_number (di);
2827	if (discrim < 0)
2828	return 0;
2829	return 1;
2830	}
2831
2832	/* Add a new substitution. */
2833
2834	static int
2835	d_add_substitution (struct d_info di, struct demangle_component dc)
2836	{
2837	if (dc == NULL)
2838	return 0;
2839	if (di->next_sub >= di->num_subs)
2840	return 0;
2841	di->subs[di->next_sub] = dc;
2842	++di->next_sub;
2843	return 1;
2844	}
2845
2846	/* <substitution> ::= S <seq-id> _
2847	::= S_
2848	::= St
2849	::= Sa
2850	::= Sb
2851	::= Ss
2852	::= Si
2853	::= So
2854	::= Sd
2855
2856	If PREFIX is non-zero, then this type is being used as a prefix in
2857	a qualified name. In this case, for the standard substitutions, we
2858	need to check whether we are being used as a prefix for a
2859	constructor or destructor, and return a full template name.
2860	Otherwise we will get something like std::iostream::~iostream()
2861	which does not correspond particularly well to any function which
2862	actually appears in the source.
2863	*/
2864
2865	static const struct d_standard_sub_info standard_subs[] =
2866	{
2867	{ 't', NL ("std"),
2868	NL ("std"),
2869	NULL, 0 },
2870	{ 'a', NL ("std::allocator"),
2871	NL ("std::allocator"),
2872	NL ("allocator") },
2873	{ 'b', NL ("std::basic_string"),
2874	NL ("std::basic_string"),
2875	NL ("basic_string") },
2876	{ 's', NL ("std::string"),
2877	NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
2878	NL ("basic_string") },
2879	{ 'i', NL ("std::istream"),
2880	NL ("std::basic_istream<char, std::char_traits<char> >"),
2881	NL ("basic_istream") },
2882	{ 'o', NL ("std::ostream"),
2883	NL ("std::basic_ostream<char, std::char_traits<char> >"),
2884	NL ("basic_ostream") },
2885	{ 'd', NL ("std::iostream"),
2886	NL ("std::basic_iostream<char, std::char_traits<char> >"),
2887	NL ("basic_iostream") }
2888	};
2889
2890	static struct demangle_component *
2891	d_substitution (struct d_info *di, int prefix)
2892	{
2893	char c;
2894
2895	if (! d_check_char (di, 'S'))
2896	return NULL;
2897
2898	c = d_next_char (di);
2899	if (c == '_' \|\| IS_DIGIT (c) \|\| IS_UPPER (c))
2900	{
2901	unsigned int id;
2902
2903	id = 0;
2904	if (c != '_')
2905	{
2906	do
2907	{
2908	unsigned int new_id;
2909
2910	if (IS_DIGIT (c))
2911	new_id = id * 36 + c - '0';
2912	else if (IS_UPPER (c))
2913	new_id = id * 36 + c - 'A' + 10;
2914	else
2915	return NULL;
2916	if (new_id < id)
2917	return NULL;
2918	id = new_id;
2919	c = d_next_char (di);
2920	}
2921	while (c != '_');
2922
2923	++id;
2924	}
2925
2926	if (id >= (unsigned int) di->next_sub)
2927	return NULL;
2928
2929	++di->did_subs;
2930
2931	return di->subs[id];
2932	}
2933	else
2934	{
2935	int verbose;
2936	const struct d_standard_sub_info *p;
2937	const struct d_standard_sub_info *pend;
2938
2939	verbose = (di->options & DMGL_VERBOSE) != 0;
2940	if (! verbose && prefix)
2941	{
2942	char peek;
2943
2944	peek = d_peek_char (di);
2945	if (peek == 'C' \|\| peek == 'D')
2946	verbose = 1;
2947	}
2948
2949	pend = (&standard_subs[0]
2950	+ sizeof standard_subs / sizeof standard_subs[0]);
2951	for (p = &standard_subs[0]; p < pend; ++p)
2952	{
2953	if (c == p->code)
2954	{
2955	const char *s;
2956	int len;
2957
2958	if (p->set_last_name != NULL)
2959	di->last_name = d_make_sub (di, p->set_last_name,
2960	p->set_last_name_len);
2961	if (verbose)
2962	{
2963	s = p->full_expansion;
2964	len = p->full_len;
2965	}
2966	else
2967	{
2968	s = p->simple_expansion;
2969	len = p->simple_len;
2970	}
2971	di->expansion += len;
2972	return d_make_sub (di, s, len);
2973	}
2974	}
2975
2976	return NULL;
2977	}
2978	}
2979
2980	/* Initialize a growable string. */
2981
2982	static void
2983	d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
2984	{
2985	dgs->buf = NULL;
2986	dgs->len = 0;
2987	dgs->alc = 0;
2988	dgs->allocation_failure = 0;
2989
2990	if (estimate > 0)
2991	d_growable_string_resize (dgs, estimate);
2992	}
2993
2994	/* Grow a growable string to a given size. */
2995
2996	static inline void
2997	d_growable_string_resize (struct d_growable_string *dgs, size_t need)
2998	{
2999	size_t newalc;
3000	char *newbuf;
3001
3002	if (dgs->allocation_failure)
3003	return;
3004
3005	/* Start allocation at two bytes to avoid any possibility of confusion
3006	with the special value of 1 used as a return in *palc to indicate
3007	allocation failures. */
3008	newalc = dgs->alc > 0 ? dgs->alc : 2;
3009	while (newalc < need)
3010	newalc <<= 1;
3011
3012	newbuf = (char *) realloc (dgs->buf, newalc);
3013	if (newbuf == NULL)
3014	{
3015	free (dgs->buf);
3016	dgs->buf = NULL;
3017	dgs->len = 0;
3018	dgs->alc = 0;
3019	dgs->allocation_failure = 1;
3020	return;
3021	}
3022	dgs->buf = newbuf;
3023	dgs->alc = newalc;
3024	}
3025
3026	/* Append a buffer to a growable string. */
3027
3028	static inline void
3029	d_growable_string_append_buffer (struct d_growable_string *dgs,
3030	const char *s, size_t l)
3031	{
3032	size_t need;
3033
3034	need = dgs->len + l + 1;
3035	if (need > dgs->alc)
3036	d_growable_string_resize (dgs, need);
3037
3038	if (dgs->allocation_failure)
3039	return;
3040
3041	memcpy (dgs->buf + dgs->len, s, l);
3042	dgs->buf[dgs->len + l] = '\0';
3043	dgs->len += l;
3044	}
3045
3046	/* Bridge growable strings to the callback mechanism. */
3047
3048	static void
3049	d_growable_string_callback_adapter (const char s, size_t l, void opaque)
3050	{
3051	struct d_growable_string dgs = (struct d_growable_string) opaque;
3052
3053	d_growable_string_append_buffer (dgs, s, l);
3054	}
3055
3056	/* Initialize a print information structure. */
3057
3058	static void
3059	d_print_init (struct d_print_info *dpi, int options,
3060	demangle_callbackref callback, void *opaque)
3061	{
3062	dpi->options = options;
3063	dpi->len = 0;
3064	dpi->last_char = '\0';
3065	dpi->templates = NULL;
3066	dpi->modifiers = NULL;
3067
3068	dpi->callback = callback;
3069	dpi->opaque = opaque;
3070
3071	dpi->demangle_failure = 0;
3072	}
3073
3074	/* Indicate that an error occurred during printing, and test for error. */
3075
3076	static inline void
3077	d_print_error (struct d_print_info *dpi)
3078	{
3079	dpi->demangle_failure = 1;
3080	}
3081
3082	static inline int
3083	d_print_saw_error (struct d_print_info *dpi)
3084	{
3085	return dpi->demangle_failure != 0;
3086	}
3087
3088	/* Flush buffered characters to the callback. */
3089
3090	static inline void
3091	d_print_flush (struct d_print_info *dpi)
3092	{
3093	dpi->buf[dpi->len] = '\0';
3094	dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3095	dpi->len = 0;
3096	}
3097
3098	/* Append characters and buffers for printing. */
3099
3100	static inline void
3101	d_append_char (struct d_print_info *dpi, char c)
3102	{
3103	if (dpi->len == sizeof (dpi->buf) - 1)
3104	d_print_flush (dpi);
3105
3106	dpi->buf[dpi->len++] = c;
3107	dpi->last_char = c;
3108	}
3109
3110	static inline void
3111	d_append_buffer (struct d_print_info dpi, const char s, size_t l)
3112	{
3113	size_t i;
3114
3115	for (i = 0; i < l; i++)
3116	d_append_char (dpi, s[i]);
3117	}
3118
3119	static inline void
3120	d_append_string (struct d_print_info dpi, const char s)
3121	{
3122	d_append_buffer (dpi, s, strlen (s));
3123	}
3124
3125	static inline char
3126	d_last_char (struct d_print_info *dpi)
3127	{
3128	return dpi->last_char;
3129	}
3130
3131	/* Turn components into a human readable string. OPTIONS is the
3132	options bits passed to the demangler. DC is the tree to print.
3133	CALLBACK is a function to call to flush demangled string segments
3134	as they fill the intermediate buffer, and OPAQUE is a generalized
3135	callback argument. On success, this returns 1. On failure,
3136	it returns 0, indicating a bad parse. It does not use heap
3137	memory to build an output string, so cannot encounter memory
3138	allocation failure. */
3139
3140	CP_STATIC_IF_GLIBCPP_V3
3141	int
3142	cplus_demangle_print_callback (int options,
3143	const struct demangle_component *dc,
3144	demangle_callbackref callback, void *opaque)
3145	{
3146	struct d_print_info dpi;
3147
3148	d_print_init (&dpi, options, callback, opaque);
3149
3150	d_print_comp (&dpi, dc);
3151
3152	d_print_flush (&dpi);
3153
3154	return ! d_print_saw_error (&dpi);
3155	}
3156
3157	/* Turn components into a human readable string. OPTIONS is the
3158	options bits passed to the demangler. DC is the tree to print.
3159	ESTIMATE is a guess at the length of the result. This returns a
3160	string allocated by malloc, or NULL on error. On success, this
3161	sets *PALC to the size of the allocated buffer. On failure, this
3162	sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3163	failure. */
3164
3165	CP_STATIC_IF_GLIBCPP_V3
3166	char *
3167	cplus_demangle_print (int options, const struct demangle_component *dc,
3168	int estimate, size_t *palc)
3169	{
3170	struct d_growable_string dgs;
3171
3172	d_growable_string_init (&dgs, estimate);
3173
3174	if (! cplus_demangle_print_callback (options, dc,
3175	d_growable_string_callback_adapter,
3176	&dgs))
3177	{
3178	free (dgs.buf);
3179	*palc = 0;
3180	return NULL;
3181	}
3182
3183	*palc = dgs.allocation_failure ? 1 : dgs.alc;
3184	return dgs.buf;
3185	}
3186
3187	/* Returns the I'th element of the template arglist ARGS, or NULL on
3188	failure. */
3189
3190	static struct demangle_component *
3191	d_index_template_argument (struct demangle_component *args, int i)
3192	{
3193	struct demangle_component *a;
3194
3195	for (a = args;
3196	a != NULL;
3197	a = d_right (a))
3198	{
3199	if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3200	return NULL;
3201	if (i <= 0)
3202	break;
3203	--i;
3204	}
3205	if (i != 0 \|\| a == NULL)
3206	return NULL;
3207
3208	return d_left (a);
3209	}
3210
3211	/* Returns the template argument from the current context indicated by DC,
3212	which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
3213
3214	static struct demangle_component *
3215	d_lookup_template_argument (struct d_print_info *dpi,
3216	const struct demangle_component *dc)
3217	{
3218	if (dpi->templates == NULL)
3219	{
3220	d_print_error (dpi);
3221	return NULL;
3222	}
3223
3224	return d_index_template_argument
3225	(d_right (dpi->templates->template_decl),
3226	dc->u.s_number.number);
3227	}
3228
3229	/* Returns a template argument pack used in DC (any will do), or NULL. */
3230
3231	static struct demangle_component *
3232	d_find_pack (struct d_print_info *dpi,
3233	const struct demangle_component *dc)
3234	{
3235	struct demangle_component *a;
3236	if (dc == NULL)
3237	return NULL;
3238
3239	switch (dc->type)
3240	{
3241	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3242	a = d_lookup_template_argument (dpi, dc);
3243	if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3244	return a;
3245	return NULL;
3246
3247	case DEMANGLE_COMPONENT_PACK_EXPANSION:
3248	return NULL;
3249
3250	case DEMANGLE_COMPONENT_NAME:
3251	case DEMANGLE_COMPONENT_OPERATOR:
3252	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3253	case DEMANGLE_COMPONENT_SUB_STD:
3254	case DEMANGLE_COMPONENT_CHARACTER:
3255	case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3256	return NULL;
3257
3258	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3259	return d_find_pack (dpi, dc->u.s_extended_operator.name);
3260	case DEMANGLE_COMPONENT_CTOR:
3261	return d_find_pack (dpi, dc->u.s_ctor.name);
3262	case DEMANGLE_COMPONENT_DTOR:
3263	return d_find_pack (dpi, dc->u.s_dtor.name);
3264
3265	default:
3266	a = d_find_pack (dpi, d_left (dc));
3267	if (a)
3268	return a;
3269	return d_find_pack (dpi, d_right (dc));
3270	}
3271	}
3272
3273	/* Returns the length of the template argument pack DC. */
3274
3275	static int
3276	d_pack_length (const struct demangle_component *dc)
3277	{
3278	int count = 0;
3279	while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3280	&& d_left (dc) != NULL)
3281	{
3282	++count;
3283	dc = d_right (dc);
3284	}
3285	return count;
3286	}
3287
3288	/* DC is a component of a mangled expression. Print it, wrapped in parens
3289	if needed. */
3290
3291	static void
3292	d_print_subexpr (struct d_print_info *dpi,
3293	const struct demangle_component *dc)
3294	{
3295	int simple = 0;
3296	if (dc->type == DEMANGLE_COMPONENT_NAME
3297	\|\| dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3298	simple = 1;
3299	if (!simple)
3300	d_append_char (dpi, '(');
3301	d_print_comp (dpi, dc);
3302	if (!simple)
3303	d_append_char (dpi, ')');
3304	}
3305
3306	/* Subroutine to handle components. */
3307
3308	static void
3309	d_print_comp (struct d_print_info *dpi,
3310	const struct demangle_component *dc)
3311	{
3312	if (dc == NULL)
3313	{
3314	d_print_error (dpi);
3315	return;
3316	}
3317	if (d_print_saw_error (dpi))
3318	return;
3319
3320	switch (dc->type)
3321	{
3322	case DEMANGLE_COMPONENT_NAME:
3323	if ((dpi->options & DMGL_JAVA) == 0)
3324	d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3325	else
3326	d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3327	return;
3328
3329	case DEMANGLE_COMPONENT_QUAL_NAME:
3330	case DEMANGLE_COMPONENT_LOCAL_NAME:
3331	d_print_comp (dpi, d_left (dc));
3332	if ((dpi->options & DMGL_JAVA) == 0)
3333	d_append_string (dpi, "::");
3334	else
3335	d_append_char (dpi, '.');
3336	d_print_comp (dpi, d_right (dc));
3337	return;
3338
3339	case DEMANGLE_COMPONENT_TYPED_NAME:
3340	{
3341	struct d_print_mod *hold_modifiers;
3342	struct demangle_component *typed_name;
3343	struct d_print_mod adpm[4];
3344	unsigned int i;
3345	struct d_print_template dpt;
3346
3347	/* Pass the name down to the type so that it can be printed in
3348	the right place for the type. We also have to pass down
3349	any CV-qualifiers, which apply to the this parameter. */
3350	hold_modifiers = dpi->modifiers;
3351	dpi->modifiers = 0;
3352	i = 0;
3353	typed_name = d_left (dc);
3354	while (typed_name != NULL)
3355	{
3356	if (i >= sizeof adpm / sizeof adpm[0])
3357	{
3358	d_print_error (dpi);
3359	return;
3360	}
3361
3362	adpm[i].next = dpi->modifiers;
3363	dpi->modifiers = &adpm[i];
3364	adpm[i].mod = typed_name;
3365	adpm[i].printed = 0;
3366	adpm[i].templates = dpi->templates;
3367	++i;
3368
3369	if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3370	&& typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3371	&& typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3372	break;
3373
3374	typed_name = d_left (typed_name);
3375	}
3376
3377	if (typed_name == NULL)
3378	{
3379	d_print_error (dpi);
3380	return;
3381	}
3382
3383	/* If typed_name is a template, then it applies to the
3384	function type as well. */
3385	if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3386	{
3387	dpt.next = dpi->templates;
3388	dpi->templates = &dpt;
3389	dpt.template_decl = typed_name;
3390	}
3391
3392	/* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3393	there may be CV-qualifiers on its right argument which
3394	really apply here; this happens when parsing a class which
3395	is local to a function. */
3396	if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3397	{
3398	struct demangle_component *local_name;
3399
3400	local_name = d_right (typed_name);
3401	while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3402	\|\| local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3403	\|\| local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3404	{
3405	if (i >= sizeof adpm / sizeof adpm[0])
3406	{
3407	d_print_error (dpi);
3408	return;
3409	}
3410
3411	adpm[i] = adpm[i - 1];
3412	adpm[i].next = &adpm[i - 1];
3413	dpi->modifiers = &adpm[i];
3414
3415	adpm[i - 1].mod = local_name;
3416	adpm[i - 1].printed = 0;
3417	adpm[i - 1].templates = dpi->templates;
3418	++i;
3419
3420	local_name = d_left (local_name);
3421	}
3422	}
3423
3424	d_print_comp (dpi, d_right (dc));
3425
3426	if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3427	dpi->templates = dpt.next;
3428
3429	/* If the modifiers didn't get printed by the type, print them
3430	now. */
3431	while (i > 0)
3432	{
3433	--i;
3434	if (! adpm[i].printed)
3435	{
3436	d_append_char (dpi, ' ');
3437	d_print_mod (dpi, adpm[i].mod);
3438	}
3439	}
3440
3441	dpi->modifiers = hold_modifiers;
3442
3443	return;
3444	}
3445
3446	case DEMANGLE_COMPONENT_TEMPLATE:
3447	{
3448	struct d_print_mod *hold_dpm;
3449	struct demangle_component *dcl;
3450
3451	/* Don't push modifiers into a template definition. Doing so
3452	could give the wrong definition for a template argument.
3453	Instead, treat the template essentially as a name. */
3454
3455	hold_dpm = dpi->modifiers;
3456	dpi->modifiers = NULL;
3457
3458	dcl = d_left (dc);
3459
3460	if ((dpi->options & DMGL_JAVA) != 0
3461	&& dcl->type == DEMANGLE_COMPONENT_NAME
3462	&& dcl->u.s_name.len == 6
3463	&& strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3464	{
3465	/* Special-case Java arrays, so that JArray<TYPE> appears
3466	instead as TYPE[]. */
3467
3468	d_print_comp (dpi, d_right (dc));
3469	d_append_string (dpi, "[]");
3470	}
3471	else
3472	{
3473	d_print_comp (dpi, dcl);
3474	if (d_last_char (dpi) == '<')
3475	d_append_char (dpi, ' ');
3476	d_append_char (dpi, '<');
3477	d_print_comp (dpi, d_right (dc));
3478	/* Avoid generating two consecutive '>' characters, to avoid
3479	the C++ syntactic ambiguity. */
3480	if (d_last_char (dpi) == '>')
3481	d_append_char (dpi, ' ');
3482	d_append_char (dpi, '>');
3483	}
3484
3485	dpi->modifiers = hold_dpm;
3486
3487	return;
3488	}
3489
3490	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3491	{
3492	struct d_print_template *hold_dpt;
3493	struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3494
3495	if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3496	a = d_index_template_argument (a, dpi->pack_index);
3497
3498	if (a == NULL)
3499	{
3500	d_print_error (dpi);
3501	return;
3502	}
3503
3504	/* While processing this parameter, we need to pop the list of
3505	templates. This is because the template parameter may
3506	itself be a reference to a parameter of an outer
3507	template. */
3508
3509	hold_dpt = dpi->templates;
3510	dpi->templates = hold_dpt->next;
3511
3512	d_print_comp (dpi, a);
3513
3514	dpi->templates = hold_dpt;
3515
3516	return;
3517	}
3518
3519	case DEMANGLE_COMPONENT_CTOR:
3520	d_print_comp (dpi, dc->u.s_ctor.name);
3521	return;
3522
3523	case DEMANGLE_COMPONENT_DTOR:
3524	d_append_char (dpi, '~');
3525	d_print_comp (dpi, dc->u.s_dtor.name);
3526	return;
3527
3528	case DEMANGLE_COMPONENT_VTABLE:
3529	d_append_string (dpi, "vtable for ");
3530	d_print_comp (dpi, d_left (dc));
3531	return;
3532
3533	case DEMANGLE_COMPONENT_VTT:
3534	d_append_string (dpi, "VTT for ");
3535	d_print_comp (dpi, d_left (dc));
3536	return;
3537
3538	case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3539	d_append_string (dpi, "construction vtable for ");
3540	d_print_comp (dpi, d_left (dc));
3541	d_append_string (dpi, "-in-");
3542	d_print_comp (dpi, d_right (dc));
3543	return;
3544
3545	case DEMANGLE_COMPONENT_TYPEINFO:
3546	d_append_string (dpi, "typeinfo for ");
3547	d_print_comp (dpi, d_left (dc));
3548	return;
3549
3550	case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3551	d_append_string (dpi, "typeinfo name for ");
3552	d_print_comp (dpi, d_left (dc));
3553	return;
3554
3555	case DEMANGLE_COMPONENT_TYPEINFO_FN:
3556	d_append_string (dpi, "typeinfo fn for ");
3557	d_print_comp (dpi, d_left (dc));
3558	return;
3559
3560	case DEMANGLE_COMPONENT_THUNK:
3561	d_append_string (dpi, "non-virtual thunk to ");
3562	d_print_comp (dpi, d_left (dc));
3563	return;
3564
3565	case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3566	d_append_string (dpi, "virtual thunk to ");
3567	d_print_comp (dpi, d_left (dc));
3568	return;
3569
3570	case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3571	d_append_string (dpi, "covariant return thunk to ");
3572	d_print_comp (dpi, d_left (dc));
3573	return;
3574
3575	case DEMANGLE_COMPONENT_JAVA_CLASS:
3576	d_append_string (dpi, "java Class for ");
3577	d_print_comp (dpi, d_left (dc));
3578	return;
3579
3580	case DEMANGLE_COMPONENT_GUARD:
3581	d_append_string (dpi, "guard variable for ");
3582	d_print_comp (dpi, d_left (dc));
3583	return;
3584
3585	case DEMANGLE_COMPONENT_REFTEMP:
3586	d_append_string (dpi, "reference temporary for ");
3587	d_print_comp (dpi, d_left (dc));
3588	return;
3589
3590	case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3591	d_append_string (dpi, "hidden alias for ");
3592	d_print_comp (dpi, d_left (dc));
3593	return;
3594
3595	case DEMANGLE_COMPONENT_SUB_STD:
3596	d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3597	return;
3598
3599	case DEMANGLE_COMPONENT_RESTRICT:
3600	case DEMANGLE_COMPONENT_VOLATILE:
3601	case DEMANGLE_COMPONENT_CONST:
3602	{
3603	struct d_print_mod *pdpm;
3604
3605	/* When printing arrays, it's possible to have cases where the
3606	same CV-qualifier gets pushed on the stack multiple times.
3607	We only need to print it once. */
3608
3609	for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3610	{
3611	if (! pdpm->printed)
3612	{
3613	if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3614	&& pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3615	&& pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3616	break;
3617	if (pdpm->mod->type == dc->type)
3618	{
3619	d_print_comp (dpi, d_left (dc));
3620	return;
3621	}
3622	}
3623	}
3624	}
3625	/* Fall through. */
3626	case DEMANGLE_COMPONENT_RESTRICT_THIS:
3627	case DEMANGLE_COMPONENT_VOLATILE_THIS:
3628	case DEMANGLE_COMPONENT_CONST_THIS:
3629	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3630	case DEMANGLE_COMPONENT_POINTER:
3631	case DEMANGLE_COMPONENT_REFERENCE:
3632	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3633	case DEMANGLE_COMPONENT_COMPLEX:
3634	case DEMANGLE_COMPONENT_IMAGINARY:
3635	{
3636	/* We keep a list of modifiers on the stack. */
3637	struct d_print_mod dpm;
3638
3639	dpm.next = dpi->modifiers;
3640	dpi->modifiers = &dpm;
3641	dpm.mod = dc;
3642	dpm.printed = 0;
3643	dpm.templates = dpi->templates;
3644
3645	d_print_comp (dpi, d_left (dc));
3646
3647	/* If the modifier didn't get printed by the type, print it
3648	now. */
3649	if (! dpm.printed)
3650	d_print_mod (dpi, dc);
3651
3652	dpi->modifiers = dpm.next;
3653
3654	return;
3655	}
3656
3657	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3658	if ((dpi->options & DMGL_JAVA) == 0)
3659	d_append_buffer (dpi, dc->u.s_builtin.type->name,
3660	dc->u.s_builtin.type->len);
3661	else
3662	d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3663	dc->u.s_builtin.type->java_len);
3664	return;
3665
3666	case DEMANGLE_COMPONENT_VENDOR_TYPE:
3667	d_print_comp (dpi, d_left (dc));
3668	return;
3669
3670	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3671	{
3672	if ((dpi->options & DMGL_RET_POSTFIX) != 0)
3673	d_print_function_type (dpi, dc, dpi->modifiers);
3674
3675	/* Print return type if present */
3676	if (d_left (dc) != NULL)
3677	{
3678	struct d_print_mod dpm;
3679
3680	/* We must pass this type down as a modifier in order to
3681	print it in the right location. */
3682	dpm.next = dpi->modifiers;
3683	dpi->modifiers = &dpm;
3684	dpm.mod = dc;
3685	dpm.printed = 0;
3686	dpm.templates = dpi->templates;
3687
3688	d_print_comp (dpi, d_left (dc));
3689
3690	dpi->modifiers = dpm.next;
3691
3692	if (dpm.printed)
3693	return;
3694
3695	/* In standard prefix notation, there is a space between the
3696	return type and the function signature. */
3697	if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3698	d_append_char (dpi, ' ');
3699	}
3700
3701	if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3702	d_print_function_type (dpi, dc, dpi->modifiers);
3703
3704	return;
3705	}
3706
3707	case DEMANGLE_COMPONENT_ARRAY_TYPE:
3708	{
3709	struct d_print_mod *hold_modifiers;
3710	struct d_print_mod adpm[4];
3711	unsigned int i;
3712	struct d_print_mod *pdpm;
3713
3714	/* We must pass this type down as a modifier in order to print
3715	multi-dimensional arrays correctly. If the array itself is
3716	CV-qualified, we act as though the element type were
3717	CV-qualified. We do this by copying the modifiers down
3718	rather than fiddling pointers, so that we don't wind up
3719	with a d_print_mod higher on the stack pointing into our
3720	stack frame after we return. */
3721
3722	hold_modifiers = dpi->modifiers;
3723
3724	adpm[0].next = hold_modifiers;
3725	dpi->modifiers = &adpm[0];
3726	adpm[0].mod = dc;
3727	adpm[0].printed = 0;
3728	adpm[0].templates = dpi->templates;
3729
3730	i = 1;
3731	pdpm = hold_modifiers;
3732	while (pdpm != NULL
3733	&& (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3734	\|\| pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3735	\|\| pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3736	{
3737	if (! pdpm->printed)
3738	{
3739	if (i >= sizeof adpm / sizeof adpm[0])
3740	{
3741	d_print_error (dpi);
3742	return;
3743	}
3744
3745	adpm[i] = *pdpm;
3746	adpm[i].next = dpi->modifiers;
3747	dpi->modifiers = &adpm[i];
3748	pdpm->printed = 1;
3749	++i;
3750	}
3751
3752	pdpm = pdpm->next;
3753	}
3754
3755	d_print_comp (dpi, d_right (dc));
3756
3757	dpi->modifiers = hold_modifiers;
3758
3759	if (adpm[0].printed)
3760	return;
3761
3762	while (i > 1)
3763	{
3764	--i;
3765	d_print_mod (dpi, adpm[i].mod);
3766	}
3767
3768	d_print_array_type (dpi, dc, dpi->modifiers);
3769
3770	return;
3771	}
3772
3773	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3774	{
3775	struct d_print_mod dpm;
3776
3777	dpm.next = dpi->modifiers;
3778	dpi->modifiers = &dpm;
3779	dpm.mod = dc;
3780	dpm.printed = 0;
3781	dpm.templates = dpi->templates;
3782
3783	d_print_comp (dpi, d_right (dc));
3784
3785	/* If the modifier didn't get printed by the type, print it
3786	now. */
3787	if (! dpm.printed)
3788	{
3789	d_append_char (dpi, ' ');
3790	d_print_comp (dpi, d_left (dc));
3791	d_append_string (dpi, "::*");
3792	}
3793
3794	dpi->modifiers = dpm.next;
3795
3796	return;
3797	}
3798
3799	case DEMANGLE_COMPONENT_FIXED_TYPE:
3800	if (dc->u.s_fixed.sat)
3801	d_append_string (dpi, "_Sat ");
3802	/* Don't print "int _Accum". */
3803	if (dc->u.s_fixed.length->u.s_builtin.type
3804	!= &cplus_demangle_builtin_types['i'-'a'])
3805	{
3806	d_print_comp (dpi, dc->u.s_fixed.length);
3807	d_append_char (dpi, ' ');
3808	}
3809	if (dc->u.s_fixed.accum)
3810	d_append_string (dpi, "_Accum");
3811	else
3812	d_append_string (dpi, "_Fract");
3813	return;
3814
3815	case DEMANGLE_COMPONENT_ARGLIST:
3816	case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
3817	if (d_left (dc) != NULL)
3818	d_print_comp (dpi, d_left (dc));
3819	if (d_right (dc) != NULL)
3820	{
3821	size_t len;
3822	d_append_string (dpi, ", ");
3823	len = dpi->len;
3824	d_print_comp (dpi, d_right (dc));
3825	/* If that didn't print anything (which can happen with empty
3826	template argument packs), remove the comma and space. */
3827	if (dpi->len == len)
3828	dpi->len -= 2;
3829	}
3830	return;
3831
3832	case DEMANGLE_COMPONENT_OPERATOR:
3833	{
3834	char c;
3835
3836	d_append_string (dpi, "operator");
3837	c = dc->u.s_operator.op->name[0];
3838	if (IS_LOWER (c))
3839	d_append_char (dpi, ' ');
3840	d_append_buffer (dpi, dc->u.s_operator.op->name,
3841	dc->u.s_operator.op->len);
3842	return;
3843	}
3844
3845	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3846	d_append_string (dpi, "operator ");
3847	d_print_comp (dpi, dc->u.s_extended_operator.name);
3848	return;
3849
3850	case DEMANGLE_COMPONENT_CAST:
3851	d_append_string (dpi, "operator ");
3852	d_print_cast (dpi, dc);
3853	return;
3854
3855	case DEMANGLE_COMPONENT_UNARY:
3856	if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
3857	d_print_expr_op (dpi, d_left (dc));
3858	else
3859	{
3860	d_append_char (dpi, '(');
3861	d_print_cast (dpi, d_left (dc));
3862	d_append_char (dpi, ')');
3863	}
3864	d_print_subexpr (dpi, d_right (dc));
3865	return;
3866
3867	case DEMANGLE_COMPONENT_BINARY:
3868	if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
3869	{
3870	d_print_error (dpi);
3871	return;
3872	}
3873
3874	/* We wrap an expression which uses the greater-than operator in
3875	an extra layer of parens so that it does not get confused
3876	with the '>' which ends the template parameters. */
3877	if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3878	&& d_left (dc)->u.s_operator.op->len == 1
3879	&& d_left (dc)->u.s_operator.op->name[0] == '>')
3880	d_append_char (dpi, '(');
3881
3882	d_print_subexpr (dpi, d_left (d_right (dc)));
3883	if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
3884	d_print_expr_op (dpi, d_left (dc));
3885	d_print_subexpr (dpi, d_right (d_right (dc)));
3886
3887	if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3888	&& d_left (dc)->u.s_operator.op->len == 1
3889	&& d_left (dc)->u.s_operator.op->name[0] == '>')
3890	d_append_char (dpi, ')');
3891
3892	return;
3893
3894	case DEMANGLE_COMPONENT_BINARY_ARGS:
3895	/* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
3896	d_print_error (dpi);
3897	return;
3898
3899	case DEMANGLE_COMPONENT_TRINARY:
3900	if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
3901	\|\| d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
3902	{
3903	d_print_error (dpi);
3904	return;
3905	}
3906	d_print_subexpr (dpi, d_left (d_right (dc)));
3907	d_print_expr_op (dpi, d_left (dc));
3908	d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
3909	d_append_string (dpi, " : ");
3910	d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
3911	return;
3912
3913	case DEMANGLE_COMPONENT_TRINARY_ARG1:
3914	case DEMANGLE_COMPONENT_TRINARY_ARG2:
3915	/* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
3916	d_print_error (dpi);
3917	return;
3918
3919	case DEMANGLE_COMPONENT_LITERAL:
3920	case DEMANGLE_COMPONENT_LITERAL_NEG:
3921	{
3922	enum d_builtin_type_print tp;
3923
3924	/* For some builtin types, produce simpler output. */
3925	tp = D_PRINT_DEFAULT;
3926	if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
3927	{
3928	tp = d_left (dc)->u.s_builtin.type->print;
3929	switch (tp)
3930	{
3931	case D_PRINT_INT:
3932	case D_PRINT_UNSIGNED:
3933	case D_PRINT_LONG:
3934	case D_PRINT_UNSIGNED_LONG:
3935	case D_PRINT_LONG_LONG:
3936	case D_PRINT_UNSIGNED_LONG_LONG:
3937	if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
3938	{
3939	if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3940	d_append_char (dpi, '-');
3941	d_print_comp (dpi, d_right (dc));
3942	switch (tp)
3943	{
3944	default:
3945	break;
3946	case D_PRINT_UNSIGNED:
3947	d_append_char (dpi, 'u');
3948	break;
3949	case D_PRINT_LONG:
3950	d_append_char (dpi, 'l');
3951	break;
3952	case D_PRINT_UNSIGNED_LONG:
3953	d_append_string (dpi, "ul");
3954	break;
3955	case D_PRINT_LONG_LONG:
3956	d_append_string (dpi, "ll");
3957	break;
3958	case D_PRINT_UNSIGNED_LONG_LONG:
3959	d_append_string (dpi, "ull");
3960	break;
3961	}
3962	return;
3963	}
3964	break;
3965
3966	case D_PRINT_BOOL:
3967	if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
3968	&& d_right (dc)->u.s_name.len == 1
3969	&& dc->type == DEMANGLE_COMPONENT_LITERAL)
3970	{
3971	switch (d_right (dc)->u.s_name.s[0])
3972	{
3973	case '0':
3974	d_append_string (dpi, "false");
3975	return;
3976	case '1':
3977	d_append_string (dpi, "true");
3978	return;
3979	default:
3980	break;
3981	}
3982	}
3983	break;
3984
3985	default:
3986	break;
3987	}
3988	}
3989
3990	d_append_char (dpi, '(');
3991	d_print_comp (dpi, d_left (dc));
3992	d_append_char (dpi, ')');
3993	if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3994	d_append_char (dpi, '-');
3995	if (tp == D_PRINT_FLOAT)
3996	d_append_char (dpi, '[');
3997	d_print_comp (dpi, d_right (dc));
3998	if (tp == D_PRINT_FLOAT)
3999	d_append_char (dpi, ']');
4000	}
4001	return;
4002
4003	case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4004	d_append_string (dpi, "java resource ");
4005	d_print_comp (dpi, d_left (dc));
4006	return;
4007
4008	case DEMANGLE_COMPONENT_COMPOUND_NAME:
4009	d_print_comp (dpi, d_left (dc));
4010	d_print_comp (dpi, d_right (dc));
4011	return;
4012
4013	case DEMANGLE_COMPONENT_CHARACTER:
4014	d_append_char (dpi, dc->u.s_character.character);
4015	return;
4016
4017	case DEMANGLE_COMPONENT_DECLTYPE:
4018	d_append_string (dpi, "decltype (");
4019	d_print_comp (dpi, d_left (dc));
4020	d_append_char (dpi, ')');
4021	return;
4022
4023	case DEMANGLE_COMPONENT_PACK_EXPANSION:
4024	{
4025	int len;
4026	int i;
4027	struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4028	if (a == NULL)
4029	{
4030	/* d_find_pack won't find anything if the only packs involved
4031	in this expansion are function parameter packs; in that
4032	case, just print the pattern and "...". */
4033	d_print_subexpr (dpi, d_left (dc));
4034	d_append_string (dpi, "...");
4035	return;
4036	}
4037
4038	len = d_pack_length (a);
4039	dc = d_left (dc);
4040	for (i = 0; i < len; ++i)
4041	{
4042	dpi->pack_index = i;
4043	d_print_comp (dpi, dc);
4044	if (i < len-1)
4045	d_append_string (dpi, ", ");
4046	}
4047	}
4048	return;
4049
4050	case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4051	{
4052	char buf[25];
4053	d_append_string (dpi, "parm#");
4054	sprintf(buf,"%ld", dc->u.s_number.number);
4055	d_append_string (dpi, buf);
4056	return;
4057	}
4058
4059	case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4060	d_append_string (dpi, "global constructors keyed to ");
4061	d_print_comp (dpi, dc->u.s_binary.left);
4062	return;
4063
4064	case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4065	d_append_string (dpi, "global destructors keyed to ");
4066	d_print_comp (dpi, dc->u.s_binary.left);
4067	return;
4068
4069	default:
4070	d_print_error (dpi);
4071	return;
4072	}
4073	}
4074
4075	/* Print a Java dentifier. For Java we try to handle encoded extended
4076	Unicode characters. The C++ ABI doesn't mention Unicode encoding,
4077	so we don't it for C++. Characters are encoded as
4078	__U<hex-char>+_. */
4079
4080	static void
4081	d_print_java_identifier (struct d_print_info dpi, const char name, int len)
4082	{
4083	const char *p;
4084	const char *end;
4085
4086	end = name + len;
4087	for (p = name; p < end; ++p)
4088	{
4089	if (end - p > 3
4090	&& p[0] == '_'
4091	&& p[1] == '_'
4092	&& p[2] == 'U')
4093	{
4094	unsigned long c;
4095	const char *q;
4096
4097	c = 0;
4098	for (q = p + 3; q < end; ++q)
4099	{
4100	int dig;
4101
4102	if (IS_DIGIT (*q))
4103	dig = *q - '0';
4104	else if (q >= 'A' && q <= 'F')
4105	dig = *q - 'A' + 10;
4106	else if (q >= 'a' && q <= 'f')
4107	dig = *q - 'a' + 10;
4108	else
4109	break;
4110
4111	c = c * 16 + dig;
4112	}
4113	/* If the Unicode character is larger than 256, we don't try
4114	to deal with it here. FIXME. */
4115	if (q < end && *q == '_' && c < 256)
4116	{
4117	d_append_char (dpi, c);
4118	p = q;
4119	continue;
4120	}
4121	}
4122
4123	d_append_char (dpi, *p);
4124	}
4125	}
4126
4127	/* Print a list of modifiers. SUFFIX is 1 if we are printing
4128	qualifiers on this after printing a function. */
4129
4130	static void
4131	d_print_mod_list (struct d_print_info *dpi,
4132	struct d_print_mod *mods, int suffix)
4133	{
4134	struct d_print_template *hold_dpt;
4135
4136	if (mods == NULL \|\| d_print_saw_error (dpi))
4137	return;
4138
4139	if (mods->printed
4140	\|\| (! suffix
4141	&& (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4142	\|\| mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4143	\|\| mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4144	{
4145	d_print_mod_list (dpi, mods->next, suffix);
4146	return;
4147	}
4148
4149	mods->printed = 1;
4150
4151	hold_dpt = dpi->templates;
4152	dpi->templates = mods->templates;
4153
4154	if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4155	{
4156	d_print_function_type (dpi, mods->mod, mods->next);
4157	dpi->templates = hold_dpt;
4158	return;
4159	}
4160	else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4161	{
4162	d_print_array_type (dpi, mods->mod, mods->next);
4163	dpi->templates = hold_dpt;
4164	return;
4165	}
4166	else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4167	{
4168	struct d_print_mod *hold_modifiers;
4169	struct demangle_component *dc;
4170
4171	/* When this is on the modifier stack, we have pulled any
4172	qualifiers off the right argument already. Otherwise, we
4173	print it as usual, but don't let the left argument see any
4174	modifiers. */
4175
4176	hold_modifiers = dpi->modifiers;
4177	dpi->modifiers = NULL;
4178	d_print_comp (dpi, d_left (mods->mod));
4179	dpi->modifiers = hold_modifiers;
4180
4181	if ((dpi->options & DMGL_JAVA) == 0)
4182	d_append_string (dpi, "::");
4183	else
4184	d_append_char (dpi, '.');
4185
4186	dc = d_right (mods->mod);
4187	while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4188	\|\| dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4189	\|\| dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4190	dc = d_left (dc);
4191
4192	d_print_comp (dpi, dc);
4193
4194	dpi->templates = hold_dpt;
4195	return;
4196	}
4197
4198	d_print_mod (dpi, mods->mod);
4199
4200	dpi->templates = hold_dpt;
4201
4202	d_print_mod_list (dpi, mods->next, suffix);
4203	}
4204
4205	/* Print a modifier. */
4206
4207	static void
4208	d_print_mod (struct d_print_info *dpi,
4209	const struct demangle_component *mod)
4210	{
4211	switch (mod->type)
4212	{
4213	case DEMANGLE_COMPONENT_RESTRICT:
4214	case DEMANGLE_COMPONENT_RESTRICT_THIS:
4215	d_append_string (dpi, " restrict");
4216	return;
4217	case DEMANGLE_COMPONENT_VOLATILE:
4218	case DEMANGLE_COMPONENT_VOLATILE_THIS:
4219	d_append_string (dpi, " volatile");
4220	return;
4221	case DEMANGLE_COMPONENT_CONST:
4222	case DEMANGLE_COMPONENT_CONST_THIS:
4223	d_append_string (dpi, " const");
4224	return;
4225	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4226	d_append_char (dpi, ' ');
4227	d_print_comp (dpi, d_right (mod));
4228	return;
4229	case DEMANGLE_COMPONENT_POINTER:
4230	/* There is no pointer symbol in Java. */
4231	if ((dpi->options & DMGL_JAVA) == 0)
4232	d_append_char (dpi, '*');
4233	return;
4234	case DEMANGLE_COMPONENT_REFERENCE:
4235	d_append_char (dpi, '&');
4236	return;
4237	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4238	d_append_string (dpi, "&&");
4239	return;
4240	case DEMANGLE_COMPONENT_COMPLEX:
4241	d_append_string (dpi, "complex ");
4242	return;
4243	case DEMANGLE_COMPONENT_IMAGINARY:
4244	d_append_string (dpi, "imaginary ");
4245	return;
4246	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4247	if (d_last_char (dpi) != '(')
4248	d_append_char (dpi, ' ');
4249	d_print_comp (dpi, d_left (mod));
4250	d_append_string (dpi, "::*");
4251	return;
4252	case DEMANGLE_COMPONENT_TYPED_NAME:
4253	d_print_comp (dpi, d_left (mod));
4254	return;
4255	default:
4256	/* Otherwise, we have something that won't go back on the
4257	modifier stack, so we can just print it. */
4258	d_print_comp (dpi, mod);
4259	return;
4260	}
4261	}
4262
4263	/* Print a function type, except for the return type. */
4264
4265	static void
4266	d_print_function_type (struct d_print_info *dpi,
4267	const struct demangle_component *dc,
4268	struct d_print_mod *mods)
4269	{
4270	int need_paren;
4271	int saw_mod;
4272	int need_space;
4273	struct d_print_mod *p;
4274	struct d_print_mod *hold_modifiers;
4275
4276	need_paren = 0;
4277	saw_mod = 0;
4278	need_space = 0;
4279	for (p = mods; p != NULL; p = p->next)
4280	{
4281	if (p->printed)
4282	break;
4283
4284	saw_mod = 1;
4285	switch (p->mod->type)
4286	{
4287	case DEMANGLE_COMPONENT_POINTER:
4288	case DEMANGLE_COMPONENT_REFERENCE:
4289	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4290	need_paren = 1;
4291	break;
4292	case DEMANGLE_COMPONENT_RESTRICT:
4293	case DEMANGLE_COMPONENT_VOLATILE:
4294	case DEMANGLE_COMPONENT_CONST:
4295	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4296	case DEMANGLE_COMPONENT_COMPLEX:
4297	case DEMANGLE_COMPONENT_IMAGINARY:
4298	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4299	need_space = 1;
4300	need_paren = 1;
4301	break;
4302	case DEMANGLE_COMPONENT_RESTRICT_THIS:
4303	case DEMANGLE_COMPONENT_VOLATILE_THIS:
4304	case DEMANGLE_COMPONENT_CONST_THIS:
4305	break;
4306	default:
4307	break;
4308	}
4309	if (need_paren)
4310	break;
4311	}
4312
4313	if (d_left (dc) != NULL && ! saw_mod)
4314	need_paren = 1;
4315
4316	if (need_paren)
4317	{
4318	if (! need_space)
4319	{
4320	if (d_last_char (dpi) != '('
4321	&& d_last_char (dpi) != '*')
4322	need_space = 1;
4323	}
4324	if (need_space && d_last_char (dpi) != ' ')
4325	d_append_char (dpi, ' ');
4326	d_append_char (dpi, '(');
4327	}
4328
4329	hold_modifiers = dpi->modifiers;
4330	dpi->modifiers = NULL;
4331
4332	d_print_mod_list (dpi, mods, 0);
4333
4334	if (need_paren)
4335	d_append_char (dpi, ')');
4336
4337	d_append_char (dpi, '(');
4338
4339	if (d_right (dc) != NULL)
4340	d_print_comp (dpi, d_right (dc));
4341
4342	d_append_char (dpi, ')');
4343
4344	d_print_mod_list (dpi, mods, 1);
4345
4346	dpi->modifiers = hold_modifiers;
4347	}
4348
4349	/* Print an array type, except for the element type. */
4350
4351	static void
4352	d_print_array_type (struct d_print_info *dpi,
4353	const struct demangle_component *dc,
4354	struct d_print_mod *mods)
4355	{
4356	int need_space;
4357
4358	need_space = 1;
4359	if (mods != NULL)
4360	{
4361	int need_paren;
4362	struct d_print_mod *p;
4363
4364	need_paren = 0;
4365	for (p = mods; p != NULL; p = p->next)
4366	{
4367	if (! p->printed)
4368	{
4369	if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4370	{
4371	need_space = 0;
4372	break;
4373	}
4374	else
4375	{
4376	need_paren = 1;
4377	need_space = 1;
4378	break;
4379	}
4380	}
4381	}
4382
4383	if (need_paren)
4384	d_append_string (dpi, " (");
4385
4386	d_print_mod_list (dpi, mods, 0);
4387
4388	if (need_paren)
4389	d_append_char (dpi, ')');
4390	}
4391
4392	if (need_space)
4393	d_append_char (dpi, ' ');
4394
4395	d_append_char (dpi, '[');
4396
4397	if (d_left (dc) != NULL)
4398	d_print_comp (dpi, d_left (dc));
4399
4400	d_append_char (dpi, ']');
4401	}
4402
4403	/* Print an operator in an expression. */
4404
4405	static void
4406	d_print_expr_op (struct d_print_info *dpi,
4407	const struct demangle_component *dc)
4408	{
4409	if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
4410	d_append_buffer (dpi, dc->u.s_operator.op->name,
4411	dc->u.s_operator.op->len);
4412	else
4413	d_print_comp (dpi, dc);
4414	}
4415
4416	/* Print a cast. */
4417
4418	static void
4419	d_print_cast (struct d_print_info *dpi,
4420	const struct demangle_component *dc)
4421	{
4422	if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
4423	d_print_comp (dpi, d_left (dc));
4424	else
4425	{
4426	struct d_print_mod *hold_dpm;
4427	struct d_print_template dpt;
4428
4429	/* It appears that for a templated cast operator, we need to put
4430	the template parameters in scope for the operator name, but
4431	not for the parameters. The effect is that we need to handle
4432	the template printing here. */
4433
4434	hold_dpm = dpi->modifiers;
4435	dpi->modifiers = NULL;
4436
4437	dpt.next = dpi->templates;
4438	dpi->templates = &dpt;
4439	dpt.template_decl = d_left (dc);
4440
4441	d_print_comp (dpi, d_left (d_left (dc)));
4442
4443	dpi->templates = dpt.next;
4444
4445	if (d_last_char (dpi) == '<')
4446	d_append_char (dpi, ' ');
4447	d_append_char (dpi, '<');
4448	d_print_comp (dpi, d_right (d_left (dc)));
4449	/* Avoid generating two consecutive '>' characters, to avoid
4450	the C++ syntactic ambiguity. */
4451	if (d_last_char (dpi) == '>')
4452	d_append_char (dpi, ' ');
4453	d_append_char (dpi, '>');
4454
4455	dpi->modifiers = hold_dpm;
4456	}
4457	}
4458
4459	/* Initialize the information structure we use to pass around
4460	information. */
4461
4462	CP_STATIC_IF_GLIBCPP_V3
4463	void
4464	cplus_demangle_init_info (const char *mangled, int options, size_t len,
4465	struct d_info *di)
4466	{
4467	di->s = mangled;
4468	di->send = mangled + len;
4469	di->options = options;
4470
4471	di->n = mangled;
4472
4473	/* We can not need more components than twice the number of chars in
4474	the mangled string. Most components correspond directly to
4475	chars, but the ARGLIST types are exceptions. */
4476	di->num_comps = 2 * len;
4477	di->next_comp = 0;
4478
4479	/* Similarly, we can not need more substitutions than there are
4480	chars in the mangled string. */
4481	di->num_subs = len;
4482	di->next_sub = 0;
4483	di->did_subs = 0;
4484
4485	di->last_name = NULL;
4486
4487	di->expansion = 0;
4488	}
4489
4490	/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
4491	mangled name, return strings in repeated callback giving the demangled
4492	name. OPTIONS is the usual libiberty demangler options. On success,
4493	this returns 1. On failure, returns 0. */
4494
4495	static int
4496	d_demangle_callback (const char *mangled, int options,
4497	demangle_callbackref callback, void *opaque)
4498	{
4499	enum
4500	{
4501	DCT_TYPE,
4502	DCT_MANGLED,
4503	DCT_GLOBAL_CTORS,
4504	DCT_GLOBAL_DTORS
4505	}
4506	type;
4507	struct d_info di;
4508	struct demangle_component *dc = NULL;
4509	int status;
4510
4511	if (mangled[0] == '_' && mangled[1] == 'Z')
4512	type = DCT_MANGLED;
4513	else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4514	&& (mangled[8] == '.' \|\| mangled[8] == '_' \|\| mangled[8] == '$')
4515	&& (mangled[9] == 'D' \|\| mangled[9] == 'I')
4516	&& mangled[10] == '_')
4517	type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
4518	else
4519	{
4520	if ((options & DMGL_TYPES) == 0)
4521	return 0;
4522	type = DCT_TYPE;
4523	}
4524
4525	cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4526
4527	{
4528	#ifdef CP_DYNAMIC_ARRAYS
4529	__extension__ struct demangle_component comps[di.num_comps];
4530	__extension__ struct demangle_component *subs[di.num_subs];
4531
4532	di.comps = comps;
4533	di.subs = subs;
4534	#else
4535	di.comps = alloca (di.num_comps * sizeof (*di.comps));
4536	di.subs = alloca (di.num_subs * sizeof (*di.subs));
4537	#endif
4538
4539	switch (type)
4540	{
4541	case DCT_TYPE:
4542	dc = cplus_demangle_type (&di);
4543	break;
4544	case DCT_MANGLED:
4545	dc = cplus_demangle_mangled_name (&di, 1);
4546	break;
4547	case DCT_GLOBAL_CTORS:
4548	case DCT_GLOBAL_DTORS:
4549	d_advance (&di, 11);
4550	dc = d_make_comp (&di,
4551	(type == DCT_GLOBAL_CTORS
4552	? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
4553	: DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
4554	d_make_name (&di, d_str (&di), strlen (d_str (&di))),
4555	NULL);
4556	d_advance (&di, strlen (d_str (&di)));
4557	break;
4558	}
4559
4560	/* If DMGL_PARAMS is set, then if we didn't consume the entire
4561	mangled string, then we didn't successfully demangle it. If
4562	DMGL_PARAMS is not set, we didn't look at the trailing
4563	parameters. */
4564	if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
4565	dc = NULL;
4566
4567	#ifdef CP_DEMANGLE_DEBUG
4568	d_dump (dc, 0);
4569	#endif
4570
4571	status = (dc != NULL)
4572	? cplus_demangle_print_callback (options, dc, callback, opaque)
4573	: 0;
4574	}
4575
4576	return status;
4577	}
4578
4579	/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
4580	name, return a buffer allocated with malloc holding the demangled
4581	name. OPTIONS is the usual libiberty demangler options. On
4582	success, this sets *PALC to the allocated size of the returned
4583	buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
4584	a memory allocation failure, and returns NULL. */
4585
4586	static char *
4587	d_demangle (const char mangled, int options, size_t palc)
4588	{
4589	struct d_growable_string dgs;
4590	int status;
4591
4592	d_growable_string_init (&dgs, 0);
4593
4594	status = d_demangle_callback (mangled, options,
4595	d_growable_string_callback_adapter, &dgs);
4596	if (status == 0)
4597	{
4598	free (dgs.buf);
4599	*palc = 0;
4600	return NULL;
4601	}
4602
4603	*palc = dgs.allocation_failure ? 1 : 0;
4604	return dgs.buf;
4605	}
4606
4607	#if defined(IN_LIBGCC2) \|\| defined(IN_GLIBCPP_V3)
4608
4609	extern char __cxa_demangle (const char , char , size_t , int *);
4610
4611	/* ia64 ABI-mandated entry point in the C++ runtime library for
4612	performing demangling. MANGLED_NAME is a NUL-terminated character
4613	string containing the name to be demangled.
4614
4615	OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4616	*LENGTH bytes, into which the demangled name is stored. If
4617	OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4618	OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4619	is placed in a region of memory allocated with malloc.
4620
4621	If LENGTH is non-NULL, the length of the buffer containing the
4622	demangled name, is placed in *LENGTH.
4623
4624	The return value is a pointer to the start of the NUL-terminated
4625	demangled name, or NULL if the demangling fails. The caller is
4626	responsible for deallocating this memory using free.
4627
4628	*STATUS is set to one of the following values:
4629	0: The demangling operation succeeded.
4630	-1: A memory allocation failure occurred.
4631	-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4632	-3: One of the arguments is invalid.
4633
4634	The demangling is performed using the C++ ABI mangling rules, with
4635	GNU extensions. */
4636
4637	char *
4638	__cxa_demangle (const char mangled_name, char output_buffer,
4639	size_t length, int status)
4640	{
4641	char *demangled;
4642	size_t alc;
4643
4644	if (mangled_name == NULL)
4645	{
4646	if (status != NULL)
4647	*status = -3;
4648	return NULL;
4649	}
4650
4651	if (output_buffer != NULL && length == NULL)
4652	{
4653	if (status != NULL)
4654	*status = -3;
4655	return NULL;
4656	}
4657
4658	demangled = d_demangle (mangled_name, DMGL_PARAMS \| DMGL_TYPES, &alc);
4659
4660	if (demangled == NULL)
4661	{
4662	if (status != NULL)
4663	{
4664	if (alc == 1)
4665	*status = -1;
4666	else
4667	*status = -2;
4668	}
4669	return NULL;
4670	}
4671
4672	if (output_buffer == NULL)
4673	{
4674	if (length != NULL)
4675	*length = alc;
4676	}
4677	else
4678	{
4679	if (strlen (demangled) < *length)
4680	{
4681	strcpy (output_buffer, demangled);
4682	free (demangled);
4683	demangled = output_buffer;
4684	}
4685	else
4686	{
4687	free (output_buffer);
4688	*length = alc;
4689	}
4690	}
4691
4692	if (status != NULL)
4693	*status = 0;
4694
4695	return demangled;
4696	}
4697
4698	extern int __gcclibcxx_demangle_callback (const char *,
4699	void (*)
4700	(const char , size_t, void ),
4701	void *);
4702
4703	/* Alternative, allocationless entry point in the C++ runtime library
4704	for performing demangling. MANGLED_NAME is a NUL-terminated character
4705	string containing the name to be demangled.
4706
4707	CALLBACK is a callback function, called with demangled string
4708	segments as demangling progresses; it is called at least once,
4709	but may be called more than once. OPAQUE is a generalized pointer
4710	used as a callback argument.
4711
4712	The return code is one of the following values, equivalent to
4713	the STATUS values of __cxa_demangle() (excluding -1, since this
4714	function performs no memory allocations):
4715	0: The demangling operation succeeded.
4716	-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4717	-3: One of the arguments is invalid.
4718
4719	The demangling is performed using the C++ ABI mangling rules, with
4720	GNU extensions. */
4721
4722	int
4723	__gcclibcxx_demangle_callback (const char *mangled_name,
4724	void (callback) (const char , size_t, void *),
4725	void *opaque)
4726	{
4727	int status;
4728
4729	if (mangled_name == NULL \|\| callback == NULL)
4730	return -3;
4731
4732	status = d_demangle_callback (mangled_name, DMGL_PARAMS \| DMGL_TYPES,
4733	callback, opaque);
4734	if (status == 0)
4735	return -2;
4736
4737	return 0;
4738	}
4739
4740	#else /* ! (IN_LIBGCC2 \|\| IN_GLIBCPP_V3) */
4741
4742	/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
4743	mangled name, return a buffer allocated with malloc holding the
4744	demangled name. Otherwise, return NULL. */
4745
4746	char *
4747	cplus_demangle_v3 (const char *mangled, int options)
4748	{
4749	size_t alc;
4750
4751	return d_demangle (mangled, options, &alc);
4752	}
4753
4754	int
4755	cplus_demangle_v3_callback (const char *mangled, int options,
4756	demangle_callbackref callback, void *opaque)
4757	{
4758	return d_demangle_callback (mangled, options, callback, opaque);
4759	}
4760
4761	/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
4762	conventions, but the output formatting is a little different.
4763	This instructs the C++ demangler not to emit pointer characters ("*"), to
4764	use Java's namespace separator symbol ("." instead of "::"), and to output
4765	JArray<TYPE> as TYPE[]. */
4766
4767	char *
4768	java_demangle_v3 (const char *mangled)
4769	{
4770	size_t alc;
4771
4772	return d_demangle (mangled, DMGL_JAVA \| DMGL_PARAMS \| DMGL_RET_POSTFIX, &alc);
4773	}
4774
4775	int
4776	java_demangle_v3_callback (const char *mangled,
4777	demangle_callbackref callback, void *opaque)
4778	{
4779	return d_demangle_callback (mangled,
4780	DMGL_JAVA \| DMGL_PARAMS \| DMGL_RET_POSTFIX,
4781	callback, opaque);
4782	}
4783
4784	#endif /* IN_LIBGCC2 \|\| IN_GLIBCPP_V3 */
4785
4786	#ifndef IN_GLIBCPP_V3
4787
4788	/* Demangle a string in order to find out whether it is a constructor
4789	or destructor. Return non-zero on success. Set *CTOR_KIND and
4790	DTOR_KIND appropriately. /
4791
4792	static int
4793	is_ctor_or_dtor (const char *mangled,
4794	enum gnu_v3_ctor_kinds *ctor_kind,
4795	enum gnu_v3_dtor_kinds *dtor_kind)
4796	{
4797	struct d_info di;
4798	struct demangle_component *dc;
4799	int ret;
4800
4801	*ctor_kind = (enum gnu_v3_ctor_kinds) 0;
4802	*dtor_kind = (enum gnu_v3_dtor_kinds) 0;
4803
4804	cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
4805
4806	{
4807	#ifdef CP_DYNAMIC_ARRAYS
4808	__extension__ struct demangle_component comps[di.num_comps];
4809	__extension__ struct demangle_component *subs[di.num_subs];
4810
4811	di.comps = comps;
4812	di.subs = subs;
4813	#else
4814	di.comps = alloca (di.num_comps * sizeof (*di.comps));
4815	di.subs = alloca (di.num_subs * sizeof (*di.subs));
4816	#endif
4817
4818	dc = cplus_demangle_mangled_name (&di, 1);
4819
4820	/* Note that because we did not pass DMGL_PARAMS, we don't expect
4821	to demangle the entire string. */
4822
4823	ret = 0;
4824	while (dc != NULL)
4825	{
4826	switch (dc->type)
4827	{
4828	default:
4829	dc = NULL;
4830	break;
4831	case DEMANGLE_COMPONENT_TYPED_NAME:
4832	case DEMANGLE_COMPONENT_TEMPLATE:
4833	case DEMANGLE_COMPONENT_RESTRICT_THIS:
4834	case DEMANGLE_COMPONENT_VOLATILE_THIS:
4835	case DEMANGLE_COMPONENT_CONST_THIS:
4836	dc = d_left (dc);
4837	break;
4838	case DEMANGLE_COMPONENT_QUAL_NAME:
4839	case DEMANGLE_COMPONENT_LOCAL_NAME:
4840	dc = d_right (dc);
4841	break;
4842	case DEMANGLE_COMPONENT_CTOR:
4843	*ctor_kind = dc->u.s_ctor.kind;
4844	ret = 1;
4845	dc = NULL;
4846	break;
4847	case DEMANGLE_COMPONENT_DTOR:
4848	*dtor_kind = dc->u.s_dtor.kind;
4849	ret = 1;
4850	dc = NULL;
4851	break;
4852	}
4853	}
4854	}
4855
4856	return ret;
4857	}
4858
4859	/* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4860	name. A non-zero return indicates the type of constructor. */
4861
4862	enum gnu_v3_ctor_kinds
4863	is_gnu_v3_mangled_ctor (const char *name)
4864	{
4865	enum gnu_v3_ctor_kinds ctor_kind;
4866	enum gnu_v3_dtor_kinds dtor_kind;
4867
4868	if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4869	return (enum gnu_v3_ctor_kinds) 0;
4870	return ctor_kind;
4871	}
4872
4873
4874	/* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4875	name. A non-zero return indicates the type of destructor. */
4876
4877	enum gnu_v3_dtor_kinds
4878	is_gnu_v3_mangled_dtor (const char *name)
4879	{
4880	enum gnu_v3_ctor_kinds ctor_kind;
4881	enum gnu_v3_dtor_kinds dtor_kind;
4882
4883	if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4884	return (enum gnu_v3_dtor_kinds) 0;
4885	return dtor_kind;
4886	}
4887
4888	#endif /* IN_GLIBCPP_V3 */
4889
4890	#ifdef STANDALONE_DEMANGLER
4891
4892	#include "getopt.h"
4893	#include "dyn-string.h"
4894
4895	static void print_usage (FILE* fp, int exit_value);
4896
4897	#define IS_ALPHA(CHAR) \
4898	(((CHAR) >= 'a' && (CHAR) <= 'z') \
4899	\|\| ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4900
4901	/* Non-zero if CHAR is a character than can occur in a mangled name. */
4902	#define is_mangled_char(CHAR) \
4903	(IS_ALPHA (CHAR) \|\| IS_DIGIT (CHAR) \
4904	\|\| (CHAR) == '_' \|\| (CHAR) == '.' \|\| (CHAR) == '$')
4905
4906	/* The name of this program, as invoked. */
4907	const char* program_name;
4908
4909	/* Prints usage summary to FP and then exits with EXIT_VALUE. */
4910
4911	static void
4912	print_usage (FILE* fp, int exit_value)
4913	{
4914	fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
4915	fprintf (fp, "Options:\n");
4916	fprintf (fp, " -h,--help Display this message.\n");
4917	fprintf (fp, " -p,--no-params Don't display function parameters\n");
4918	fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
4919	fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
4920
4921	exit (exit_value);
4922	}
4923
4924	/* Option specification for getopt_long. */
4925	static const struct option long_options[] =
4926	{
4927	{ "help", no_argument, NULL, 'h' },
4928	{ "no-params", no_argument, NULL, 'p' },
4929	{ "verbose", no_argument, NULL, 'v' },
4930	{ NULL, no_argument, NULL, 0 },
4931	};
4932
4933	/* Main entry for a demangling filter executable. It will demangle
4934	its command line arguments, if any. If none are provided, it will
4935	filter stdin to stdout, replacing any recognized mangled C++ names
4936	with their demangled equivalents. */
4937
4938	int
4939	main (int argc, char *argv[])
4940	{
4941	int i;
4942	int opt_char;
4943	int options = DMGL_PARAMS \| DMGL_ANSI \| DMGL_TYPES;
4944
4945	/* Use the program name of this program, as invoked. */
4946	program_name = argv[0];
4947
4948	/* Parse options. */
4949	do
4950	{
4951	opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
4952	switch (opt_char)
4953	{
4954	case '?': /* Unrecognized option. */
4955	print_usage (stderr, 1);
4956	break;
4957
4958	case 'h':
4959	print_usage (stdout, 0);
4960	break;
4961
4962	case 'p':
4963	options &= ~ DMGL_PARAMS;
4964	break;
4965
4966	case 'v':
4967	options \|= DMGL_VERBOSE;
4968	break;
4969	}
4970	}
4971	while (opt_char != -1);
4972
4973	if (optind == argc)
4974	/* No command line arguments were provided. Filter stdin. */
4975	{
4976	dyn_string_t mangled = dyn_string_new (3);
4977	char *s;
4978
4979	/* Read all of input. */
4980	while (!feof (stdin))
4981	{
4982	char c;
4983
4984	/* Pile characters into mangled until we hit one that can't
4985	occur in a mangled name. */
4986	c = getchar ();
4987	while (!feof (stdin) && is_mangled_char (c))
4988	{
4989	dyn_string_append_char (mangled, c);
4990	if (feof (stdin))
4991	break;
4992	c = getchar ();
4993	}
4994
4995	if (dyn_string_length (mangled) > 0)
4996	{
4997	#ifdef IN_GLIBCPP_V3
4998	s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
4999	#else
5000	s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5001	#endif
5002
5003	if (s != NULL)
5004	{
5005	fputs (s, stdout);
5006	free (s);
5007	}
5008	else
5009	{
5010	/* It might not have been a mangled name. Print the
5011	original text. */
5012	fputs (dyn_string_buf (mangled), stdout);
5013	}
5014
5015	dyn_string_clear (mangled);
5016	}
5017
5018	/* If we haven't hit EOF yet, we've read one character that
5019	can't occur in a mangled name, so print it out. */
5020	if (!feof (stdin))
5021	putchar (c);
5022	}
5023
5024	dyn_string_delete (mangled);
5025	}
5026	else
5027	/* Demangle command line arguments. */
5028	{
5029	/* Loop over command line arguments. */
5030	for (i = optind; i < argc; ++i)
5031	{
5032	char *s;
5033	#ifdef IN_GLIBCPP_V3
5034	int status;
5035	#endif
5036
5037	/* Attempt to demangle. */
5038	#ifdef IN_GLIBCPP_V3
5039	s = __cxa_demangle (argv[i], NULL, NULL, &status);
5040	#else
5041	s = cplus_demangle_v3 (argv[i], options);
5042	#endif
5043
5044	/* If it worked, print the demangled name. */
5045	if (s != NULL)
5046	{
5047	printf ("%s\n", s);
5048	free (s);
5049	}
5050	else
5051	{
5052	#ifdef IN_GLIBCPP_V3
5053	fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5054	#else
5055	fprintf (stderr, "Failed: %s\n", argv[i]);
5056	#endif
5057	}
5058	}
5059	}
5060
5061	return 0;
5062	}
5063
5064	#endif /* STANDALONE_DEMANGLER */

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

Download in other formats: